0 else 0\r\n for f in results:\r\n if isinstance(f, pygrep.FileRecord):\r\n self.non_match_record += 1\r\n self.file_info = f.info\r\n self.create_file_entry = True\r\n count2 += 1\r\n self.last_line = None\r\n else:\r\n if self.create_file_entry:\r\n self.m_result_file_panel.set_item_map(\r\n count, basename(self.file_info.name), float(self.file_info.size.strip(\"KB\")), 1,\r\n dirname(self.file_info.name), self.file_info.encoding, self.file_info.modified,\r\n self.file_info.created, f.lineno, f.colno\r\n )\r\n count += 1\r\n self.create_file_entry = False\r\n else:\r\n self.m_result_file_panel.increment_match_count(count - 1)\r\n\r\n if self.args.count_only or self.args.boolean:\r\n count2 += 1\r\n self.content_table_offset += 1\r\n continue\r\n\r\n lineno = f.lineno\r\n if self.last_line is not None and lineno == self.last_line:\r\n self.m_result_content_panel.increment_match_count(\r\n count2 - self.content_table_offset - self.non_match_record - 1\r\n )\r\n self.content_table_offset += 1\r\n count2 += 1\r\n else:\r\n self.m_result_content_panel.set_item_map(\r\n count2 - self.content_table_offset - self.non_match_record,\r\n (basename(self.file_info.name), dirname(self.file_info.name)),\r\n lineno, 1,\r\n f.lines.replace(\"\\r\", \"\").split(\"\\n\")[0],\r\n count - 1, f.colno, self.file_info.encoding\r\n )\r\n self.last_line = lineno\r\n count2 += 1\r\n\r\n if p_range != total:\r\n self.m_progressbar.SetRange(total)\r\n if p_value != done:\r\n self.m_progressbar.SetValue(actually_done)\r\n self.m_statusbar.set_status(\r\n _(\"Searching: %d/%d %d%% Matches: %d\") % (\r\n actually_done, total,\r\n int(float(actually_done)/float(total) * 100),\r\n (count2 - self.non_match_record)\r\n ) if total != 0 else (0, 0, 0)\r\n )\r\n wx.GetApp().Yield()\r\n return count, count2","def mergeResults(self, job, colname, tablemodel): \n if job==None:\n return \n matrices = job.data.allMatrices()\n if not colname:\n return\n nf={'Total':colname}\n for m in matrices:\n matrix = matrices[m]\n if matrix == None: continue\n M = self.mergeMatrix(matrix, tablemodel, fields=['Total'], newfields=nf) \n return","def collect_rows():\n return ((x, y) for x in range(80) for y in range(x + 1, 9 + (x//9)*9))","def clear(self):\n self.filled = 0\n self.used = 0\n self.table = []\n # Initialize the table to a clean slate of entries.\n for i in range(self.size):\n self.table.append(Entry())","def clear_rows(self):\n ### Previous version had a bug, in that it assumed the set of ###\n ### indices of full rows had to be a contiguous sequence! ###\n full_rows = [j for j in range(ROWS) if all(\n (i, j) in self.locked_squares for i in range(COLS))]\n if not full_rows: return\n ### Calculate how for to drop each other row, and do it ###\n drop = {j: len([k for k in full_rows if k > j]) for j in range(ROWS)}\n self.locked_squares = {(i, j+drop[j]): color for (i, j), color in\n self.locked_squares.items() if j not in full_rows}\n ### Now just update score, etc. ###\n d = len(full_rows)\n self.increment_lines(d)\n self.increment_score(self.level*{1: 40, 2: 100, 3: 300, 4: 1200}[d])\n if self.level < self.lines // 10 + 1:\n self.increment_level()","def append_table(self, table):\n if not table:\n return\n\n indexes = []\n for idx in table.index:\n index = self.size + idx\n indexes.append(index)\n\n self.set(indexes=indexes, columns=table.columns, values=table.data)","def print_rows():\n do_four(print_row)","def print_rows():\n do_four(print_row)","def populate_board(self):\n for row in range(10):\n for col in range(10):\n coord = Coordinate(row, col)\n coord_attack = Coordinate(row, col)\n self.player_table.setItem(row, col, coord)\n self.attack_table.setItem(row, col, coord_attack)","def table(self):\n\n param=self.x_param\n\n device=self.device\n\n base_params=device.get_params()\n\n data_tot=DataFrame()\n\n for i in range(len(param)):\n\n print_index=1\n\n for name in param.names:\n\n device._set_params(param(i))\n\n device.draw()\n\n df=device.export_all()\n\n if self.labels_bottom is not None:\n\n index=self.labels_bottom[i]\n\n else:\n\n index=str(i)\n\n print(\"Generating table, item {} of {}\\r\".format(print_index,len(param)),end=\"\")\n\n data_tot=data_tot.append(Series(df,name=index))\n\n device._set_params(base_params)\n\n return data_tot","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def run_all(rows):\n\n print \"start row1\"\n result = generate_1st_column(rows)\n print \"start row 2 - 10\"\n second_10th = generate_2nd_10th_column(rows)\n print \"add row 2 - 10\"\n result = generate_column(second_10th, result)\n print \"start row 11 - 19\"\n eleventh_19th = generate_11th_19th_column(rows)\n print \"add row 11 - 19\"\n result = generate_column(eleventh_19th, result)\n print \"start row 20\"\n twentiesth = generate_20th_column(rows)\n print \"add row 20\"\n result = generate_column(twentiesth, result)\n print \"adding row 20 completed.\"\n\n return result","def _load_table(self, field_list):\n for i, patterns in enumerate(field_list):\n self.ui.tableFields.insertRow(i)\n for j, item in enumerate(patterns):\n self.ui.tableFields.setItem(i, j, QTableWidgetItem(item))","def reset_q_table(self):\n for i in range(len(self.qtable)):\n for j in range(len(self.qtable[0])):\n self.qtable[i][j] = 0\n self.epsilon = 1 # Reset espilon as well.","def result_table(fmt='latex_booktabs'):\n \n names = [\n \"ETF EW.\",\n \"Antonacci ETF\",\n \"Antonacci ETF Inv. Vol.\",\n \"Futures EW.\",\n \"Antonacci Futures\",\n \"Antonacci Futures Inv. Vol.\",\n \"TSMOM Futures Low Vol.\",\n \"TSMOM Futures High Vol.\"\n ]\n\n # Get stats for each strategy\n s1 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=7, target_vol=40, periods=6, vol_weight=False)\n s2 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=2, target_vol=40, periods=6, vol_weight=False)\n s3 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=2, target_vol=40, periods=6, vol_weight=True)\n s4 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=47, target_vol=40, periods=6, vol_weight=False)\n s5 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=False)\n s6 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=True)\n s7 = calculate.stats_from_parameters(name='TSMOM', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=False)\n s8 = calculate.stats_from_parameters(name='TSMOM', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=100, periods=6, vol_weight=False)\n\n # The relevant columns from the summary data\n cols = [3, 4, 5, 6]\n num_assets = [7, 2, 2, 47, 10, 10, 47, 47]\n stats = [s1, s2, s3, s4, s5, s6, s7, s8]\n table = [names]\n \n # Collecting the results\n for i, col in enumerate(cols):\n col_list = [round(stat['summary'][col], 2) for stat in stats]\n table.append(col_list)\n\n table.append(num_assets)\n table = list(map(list, zip(*table))) # Transpose\n \n # Creating table headers\n headers = ['Strategy Name', 'Annual Return', 'Annual Vol.', 'Sharpe', 'Max. Drawdown', '# Assets']\n \n # Returning latex table\n tbl = tabulate(table, headers, tablefmt=fmt)\n print(tbl)\n \n return tbl","def refillCodeTable(self):\n\n tableSQL = \"\"\n sortDirection = self.pushButton_sortDirection.text()\n sortField = self.pushButton_sort.text()\n if sortDirection == \"Ascending\":\n if sortField == \"Sorted by code\":\n tableSQL = self.orderByCodeAscendSQL\n else:\n tableSQL = self.orderByCategoryAscendSQL\n else: # sort descending\n if sortField == \"Sorted by code\":\n tableSQL = self.orderByCodeDescendSQL\n else:\n tableSQL = self.orderByCategoryDescendSQL\n\n for row in self.codes:\n self.tableWidget.removeRow(0)\n self.codes = []\n cur = self.settings['conn'].cursor()\n cur.execute(tableSQL)\n result = cur.fetchall()\n for row in result:\n self.codes.append({'name':row[0], 'category':row[1], 'id':row[2], 'color':row[3]})\n self.fillTableWidget()","def display(self):\n covtable = self.covtable\n covtable.clearContents()\n covtable.setRowCount(0)\n for entry in self.config['table']:\n row_position = covtable.rowCount()\n covtable.insertRow(row_position)\n covtable.setItem(row_position, 0, sit.PercentWidgetItem(entry[0]))\n covtable.setItem(row_position, 1, sit.QTableWidgetItem(entry[1]))\n covtable.setItem(row_position, 2, sit.HexWidgetItem(entry[2]))\n covtable.setItem(row_position, 3, sit.RatioWidgetItem(entry[3]))\n covtable.setItem(row_position, 4, sit.centered_text(entry[4]))","def append_rows(self, rows):\n for row in rows:\n self.append_row(row)","def make_summary_tables( res ):\n\n # transform second table to csv and read this as a dataFrame\n result_fit_df = pd.read_csv(StringIO( res.tables[1].as_csv() ), sep=\",\",index_col=0)\n result_fit_df.columns = [i.strip() for i in result_fit_df.columns]\n result_fit_df.index = [i.strip() for i in result_fit_df.index]\n\n # first table is trickier because the data is spread on to columns, and there is title line\n L = res.tables[0].as_html().split('\\n')\n L.pop(1) # get rid of the title\n tmp = pd.read_html('\\n'.join(L) , header=None)[0] # read as a dataframe, but with 4 columns \n\n names = list(tmp[0]) + list(tmp[2])[:-2] # columns 0 and 2 are metric names\n values = list(tmp[1]) + list(tmp[3])[:-2] # columns 1 and 3 are the corresponding values\n # NB : I exclude the last 2 elements which are empty \n \n result_general_df = pd.DataFrame( {'Name': names , 'Value' : values}, index = names , columns=['Value'] )\n \n return result_general_df , result_fit_df","def _makeTable(self, rowIter, resultTableDef, queryMeta):\n\t\trows = list(rowIter)\n\t\tisOverflowed = len(rows)>queryMeta.get(\"dbLimit\", 1e10)\n\t\tif isOverflowed:\n\t\t\tdel rows[-1]\n\t\tqueryMeta[\"Matched\"] = len(rows)\n\t\tres = rsc.TableForDef(resultTableDef, rows=rows)\n\t\tif isOverflowed:\n\t\t\tqueryMeta[\"Overflow\"] = True\n\t\t\tres.addMeta(\"_warning\", \"The query limit was reached. Increase it\"\n\t\t\t\t\" to retrieve more matches. Note that unsorted truncated queries\"\n\t\t\t\t\" are not reproducible (i.e., might return a different result set\"\n\t\t\t\t\" at a later time).\")\n\t\t\tres.addMeta(\"_queryStatus\", \"Overflowed\")\n\t\telse:\n\t\t\tres.addMeta(\"_queryStatus\", \"Ok\")\n\t\treturn res","def format_result(result):\n nbdiff = 0\n errloc = 0\n i = 0\n total_diff = len(result)\n for result_row in result:\n i = i + 1\n logging.info(f\"\"\"search row {i}/{len(result)}\"\"\")\n if nbdiff >= int(maxdiff):\n logging.warning(\n f\"\"\"line {id}:reach max diff {maxdiff} for {table1.schema}.{table1.tableName} total diff:{total_diff}\"\"\")\n errloc = nbdiff\n self.total_nbdiff = nbdiff\n break\n list_fields = ''\n fields1 = table1.concatened_fields\n fields2 = table2.concatened_fields\n qry1_fields = f\"\"\"select {fields1} from\n {table1.schema}.{table1.viewName}\n where\n 1 = 1 \"\"\"\n qry2_fields = f\"\"\"select {fields2} from\n {table2.schema}.{table2.viewName}\n where\n 1 = 1 \"\"\"\n\n qry1 = qry1_fields + build_where(table1,result_row)\n qry2 = qry2_fields + build_where(table2,result_row)\n # list_fields = '|'\n # list_fields = list_fields.join(result_row)\n\n for result_col in result_row:\n test = \"{}\"\n list_fields = list_fields + '|' + test.format(result_col)\n # if type(result_col) is str:\n # list_fields = ''.join(list_fields,'|',result_col)\n # else:\n # list_fields = ''.join(list_fields,'|',result_col)\n\n # .encode\n # ('utf-8').strip()\n # list_fields = list_fields + '|' + result_col.encode('utf-8')\n\n list_fields = list_fields.lstrip('|')\n quotedsql = qry1.replace(\"'\",\"''\")\n\n qry_thread_1 = ExecQry(\n table1.getengine() + '_dtsDiff',table1,qry1)\n qry_thread_2 = ExecQry(\n table2.getengine() + '_dtsDiff',table2,qry2)\n\n \"\"\"\n start the threads on server1 and server2\n \"\"\"\n qry_thread_1.start()\n qry_thread_2.start()\n\n \"\"\"\n wait for the 2 thread to terminate\n \"\"\"\n try:\n \"\"\"\n wait for the qry being executed\n \"\"\"\n row1detail = qry_thread_1.join()\n except Exception as exc:\n error, = exc.args\n logging.error(f\"\"\"error executing thread:\n {error.code}\"\"\")\n try:\n \"\"\"\n wait for the qry being executed\n \"\"\"\n row2detail = qry_thread_2.join()\n except Exception as exc:\n error, = exc.args\n logging.error(f\"\"\"error executing thread:\n {error.code}\"\"\")\n\n if (row1detail is not None) and (len(row1detail) != 0):\n nbrows1 = 1\n fieldst1 = row1detail[0][0]\n fieldst1 = fieldst1.replace(\"\\x00\",\"\")\n fieldst1 = fieldst1.replace(\"\\r\\n\",\"\\n\")\n fieldst1 = fieldst1.replace(\" \\n\",\"\\n\")\n fieldst1 = fieldst1.replace(\"\\t\",\"\")\n if fieldst1 != row1detail[0][0]:\n self.set_comments(id,'x00 or other found')\n else:\n nbrows1 = 0\n\n if (row2detail is not None) and len(row2detail) != 0:\n nbrows2 = 1\n fieldst2 = row2detail[0][0]\n fieldst2 = fieldst2.replace(\"\\x00\",\"\")\n fieldst2 = fieldst2.replace(\"\\r\\n\",\"\\n\")\n fieldst2 = fieldst2.replace(\"\\t\",\"\")\n fieldst2 = fieldst2.replace(\" \\n\",\"\\n\")\n if fieldst2 != row2detail[0][0]:\n self.set_comments(id,'x00 or other found')\n else:\n nbrows2 = 0\n\n desc = \"ok\"\n if nbrows1 == 1 and nbrows2 == 1:\n if fieldst1 != fieldst2:\n desc = f\"\"\"( <> in server1 {table1.getengine()} and server2 {table2.getengine()})\n server1 {fieldst1}\n server2 {fieldst2}\"\"\"\n # logging.info(f\"\"\"delta in {table1.tableName}:\\n {desc}\n # \"\"\")\n elif nbrows1 == 1 and nbrows2 == 0:\n desc = f\"\"\"(+ in server1 {table1.getengine()}) {fieldst1} ; (- in server2 {table2.getengine()}) \"\"\"\n elif nbrows1 == 0 and nbrows2 == 1:\n desc = f\"\"\"(- in server1 {table1.getengine()}) ; (+ in server2 {table2.getengine()}) {fieldst2}\"\"\"\n\n quoteddesc = desc.replace(\"'\",\"''\")\n quotedlist_fields = list_fields.replace(\"'\",\"''\")\n quotedtableName = table1.tableName.replace(\"'\",\"''\")\n sql = f\"\"\"insert into {schemaRepo}.rowdiff (idtable,table_name,\n comments,fields,qry) select '{id}','{quotedtableName}','\n {quoteddesc}','{quotedlist_fields}','{quotedsql}'\n where not exists\n (select 1 from {schemaRepo}.rowdiff where (idtable,lower\n (table_name),\n comments,qry) =\n ({id},lower('{quotedtableName}'),'{quoteddesc}','{quotedsql}'))\"\"\"\n\n if desc != 'ok':\n errloc = errloc + 1\n nbdiff = nbdiff + 1\n logging.info(\n f\"\"\"diffrowset nok {table1.tableName} for id = {id}\"\"\")\n logging.error(f\"\"\"{desc}\"\"\")\n conn = self.connect(cxRepo)\n with conn.cursor() as curs:\n try:\n curs.execute(sql)\n except Exception as exc:\n error, = exc.args\n logging.error(f\"\"\"error executing {sql}:\n {error.code}\"\"\")\n return errloc","def mix_iterator(self):\n self.job = OrderedDict()\n for list_i in self.grid_iterator():\n # Pick the values to be used in this run\n for (k, i) in zip(self.table.keys(), list_i):\n self.job[k] = self.table[k][i]\n # Do the string replace operations on the values themselves\n self.expand_values()\n yield self.job","def generate_table(start_int=0, end_int=10, table_type='Addition'):\n lines = [r'\\documentclass{article}',\n r'\\usepackage{geometry}',\n r'\\geometry{landscape,a4paper,total={170mm,257mm},left=10mm,right=10mm,top=10mm}',\n r'\\usepackage{amsmath}',\n r'\\usepackage{amsfonts}',\n r'\\usepackage{amssymb}',\n r'\\usepackage{dcolumn}',\n r'\\newcolumntype{2}{D{.}{}{2.0}}',\n r'\\begin{document}',\n r'\\begin{large}',\n r'\\begin{center}',\n r'{\\Large ' + table_type + r' Table version 0.1\\par}',\n r'\\vspace*{25px}',\n r'\\renewcommand\\arraystretch{1.3}',\n r'\\setlength\\doublerulesep{0pt}',\n r'\\pagenumbering{gobble}',\n r'\\begin{tabular}{r||*{' + str(end_int - start_int + 1) + '}{3|}}']\n\n operator = {'Addition': r'$+$',\n 'Subtraction': r'$-$',\n 'Multiplication': r'$\\times$'}\n\n lines.append(operator[table_type] + ''.join([' & {} '.format(x) for x in range(start_int, end_int + 1)]) + r'\\\\')\n lines.append('\\hline\\hline')\n for i in range(start_int, end_int + 1):\n if table_type == 'Addition':\n lines.append(str(i) + ''.join([' & {} '.format(x + i) for x in range(start_int, end_int + 1)]) + r'\\\\')\n if table_type == 'Subtraction':\n lines.append(str(i) + ''.join([' & {} '.format(x - i) for x in range(start_int, end_int + 1)]) + r'\\\\')\n if table_type == 'Multiplication':\n lines.append(str(i) + ''.join([' & {} '.format(x * i) for x in range(start_int, end_int + 1)]) + r'\\\\')\n lines.append('\\hline')\n\n lines.append(r'\\end{tabular}')\n lines.append(r'\\end{center}')\n lines.append(r'\\end{large}')\n lines.append(r'\\end{document}')\n\n return '\\n'.join(lines)","def append_data(start_col, end_col, rows, func_for_content):\n\n result = [generate_header(start_col, end_col, \"\")]\n\n while len(result) < rows + 1:\n item = []\n while len(item) < end_col - start_col + 1:\n to_append = func_for_content()\n item.append(to_append)\n result.append(item)\n\n display_indicator(ROWS, len(result), \\\n str(len(result)) + \" data processed for \" + str(func_for_content)[10:-1])\n\n return result","def prepare_table(self):\n i = 0\n for item in ['DN[-]', 'd_out[mm]', 'tl_trub[mm]', 'roztec_trub[mm]', 'delka[mm]', 'roztec_prep[mm]', 'vyska_prep[mm]']:\n self.table.insertColumn(i)\n self.table.setHorizontalHeaderItem(i, QTableWidgetItem(item))\n i += 1\n for item in ['tl_prep[mm]','pocet_prep[-]', 'pocet_trub[-]', 'TP[m/s]', 'MZP[m/s]', 'vykon [W]',\n 'tlak_ztraty[Pa]', 'hmotnost[kg]']:\n self.table.insertColumn(i)\n self.table.setHorizontalHeaderItem(i, QTableWidgetItem(item))\n i += 1","def _format_data(self) -> None:\n for row in self._db_data:\n if row['age_start'] is None:\n continue\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\n elif row['age_start'] == 95:\n entry = {'x': f\"{int(row['age_start'])}+\", 'y': int(row['count'])}\n else:\n entry = {'x': f\"{int(row['age_start'])}-{int(row['age_start'])+4}\", 'y': int(row['count'])}\n self.return_data['data'].append(entry)","def _store_rows(self):\n\n for value in self.values:\n self.counters.append(value['counter'])\n self.timestamps.append(value['timestamp'])\n self.acceleration.append(value['acceleration'])","def initialize(self) -> None:\n all_queries: List[Union[DataQueryInfo, MeasureQueryInfo]] = []\n entity_cells: List[DataCell] = []\n current_row_group = None\n\n # Loop over rows, columns\n for row_index, row in enumerate(self.rows):\n if isinstance(row, RowSeparator):\n current_row_group = row.name\n continue\n entity: Entity = row.entity\n if isinstance(entity, Entity):\n self.entity_map[entity.get_marquee_id()] = entity\n else:\n self.entity_map[''] = entity\n cells: List[DataCell] = []\n row_overrides = row.overrides\n\n for column_index, column in enumerate(self.columns):\n column_name = column.name\n column_processor = column.processor\n\n # Get all the data coordinate overrides and apply the processor override if it exists\n data_overrides, value_override, processor_override = _get_overrides(row_overrides, column_name)\n\n # Create the cell\n cell: DataCell = DataCell(column_name,\n column_processor,\n entity,\n data_overrides,\n column_index,\n row_index,\n current_row_group)\n\n if processor_override:\n # Check if there is a processor override and apply if so\n cell.processor = processor_override\n if value_override:\n cell.value = ProcessorResult(True, value_override.value)\n cell.updated_time = get_utc_now()\n elif isinstance(column_processor, EntityProcessor):\n # store these cells to fetch entity data during poll\n entity_cells.append(cell)\n elif isinstance(column_processor, CoordinateProcessor):\n # store these cells to fetch entity data during poll\n if len(data_overrides):\n # Get the last in the list if more than 1 override is given\n cell.processor.children['a'].set_dimensions(data_overrides[-1].dimensions)\n\n self._coord_processor_cells.append(cell)\n elif column_processor.measure_processor:\n all_queries.append(MeasureQueryInfo(attr='', entity=entity, processor=column_processor))\n else:\n # append the required queries to the map\n cell.build_cell_graph(all_queries, self.rdate_entity_map)\n\n cells.append(cell)\n\n self._cells.extend(cells)\n self.results.append(cells)\n\n self._data_queries = all_queries\n self._entity_cells = entity_cells\n self.is_initialized = True","def UpdateResults(self, data, row = None):\n if not self.active:\n return\n\n if row is None:\n row = self.active_row\n\n self.SetValueRaw(row, 0, row) #set FileID\n\n #take only values from fit with match column labels\n for species, fitpars in data.iteritems():\n\n #clear fit parameter entries for species TODO: always\n #cleared, even if fitpars not valid (Note: NoFit says\n #invalid\n for rawcol in self.fitparcols[species]:\n self.SetValueRaw(row, rawcol, None)\n\n if fitpars.valid:\n for key, val in fitpars.valuedict().iteritems():\n try:\n rawcol = self.colLabels.tolist().index(key+' '+species)\n self.SetValueRaw(row, rawcol, val)\n except ValueError:\n pass\n\n self.update_dynamic_cols()\n self.update_variable_cols()\n\n #uncomment this to change row selection to the newly added row\n #self.GetView().MakeCellVisible(row, 0)\n self.GetView().Refresh()","def startmeup():\r\n global iteration\r\n\r\n #The readout function is called...\r\n thetime, T_BL100, MF_BL100, Rho_BL100, T_Cori, MF_Cori, Rho_Cori, DP = readout()\r\n #... and the results are added to the dataframe.\r\n df.loc[iteration]= [thetime, T_BL100, MF_BL100, Rho_BL100, T_Cori, MF_Cori, Rho_Cori, DP]\r\n iteration = iteration + 1 #Moving on to the next entry.\r","def merge_rows(self, rows):\n for row in rows:\n yield tuple(self.merge_one_row(row, combine_measurements))","def rows(self):\n out = []\n for row in self.a:\n new = self.new(1, len(row), fake=False)\n new.a[0] = row\n out.append(new)\n return out","def startTableRow(self):\r\n self.text += \"<tr>\""],"string":"[\n \"def start_table(self):\\n self.col_widths = []\\n self.result = \\\"\\\"\",\n \"def generate_table(self, rows):\\n ...\",\n \"def fill_table(self, executer, tree, cursor, table):\\n counter = 0\\n table_content = executer.lots_of_eggs(cursor, table)\\n for line in table_content:\\n tree.insert('', 'end', text=counter, values=line)\\n counter += 1\",\n \"def populate_table(self, table: Table, name=None) -> None:\\n new_table = Table()\\n\\n if name is None:\\n name = self.returns_tms.name\\n\\n new_table.set_column_names([\\\"Statistic\\\", name])\\n for item in self._get_results_list():\\n row_name = item[1] + \\\" [\\\" + item[3] + \\\"]\\\"\\n if item[3] == '':\\n row_name = item[1]\\n\\n new_table.add_row([row_name, Table.Cell(item[2])])\\n\\n if len(table.rows) != 0:\\n new_table = table.combine(new_table)\\n\\n table.set_column_names(new_table.get_column_names())\\n table.rows = new_table.rows\",\n \"def start_table(self):\\n self.result = \\\"<table>\\\\n\\\"\",\n \"def __format_results__(self, result_rows):\\n for row in result_rows:\\n self.return_dict['results']['items'].append(row)\",\n \"def places_process_rows(self):\\n\\n for index in range(len(self.table)):\\n row_rdf = self.places_map_row_to_rdf(self.table.iloc[index])\\n if row_rdf is not None:\\n self.data += row_rdf\",\n \"def _populate_output(self):\\n self._store_query_percentiles_table()\",\n \"def add_rows(self):\\n for row in self.rows:\\n self.table.add_row(row)\",\n \"def flush(self):\\n self.table = []\",\n \"def add_to_table(self):\\n if len(self.result) == 0:\\n self.result = {self.title: [self.accuracy, self.f1, self.precision]}\\n self.result = pd.DataFrame(self.result, index=['Accuracy', 'F-score', 'Precision'])\\n return self.result\\n else:\\n conact = {self.title: [self.accuracy, self.f1, self.precision]}\\n conact = pd.DataFrame(conact, index=['Accuracy', 'F-score', 'Precision'])\\n self.result = pd.concat([self.result, conact], axis=1)\\n return self.result\",\n \"def i_fill_page_data_table(self):\\n raise NotImplemented('method not implemented yet!')\",\n \"def _generate_rows(self):\\n logger.debug(\\\"Generating pre-genealogical coherence data for %s\\\", self.w1)\\n if not self.rows:\\n for w2 in self.all_mss:\\n if self.w1 == w2:\\n continue\\n self._add_row(w2)\\n\\n self._sort()\\n logger.debug(\\\"Generated pre-genealogical coherence data for %s\\\", self.w1)\",\n \"def fill_table(self, data):\\r\\n if len(data) > 0:\\r\\n if isinstance(data, np.ndarray):\\r\\n data = data.tolist()\\r\\n data_rows = len(data)\\r\\n data_columns = len(data[0])\\r\\n if data_columns > 0:\\r\\n self.setRowCount(data_rows)\\r\\n # We hide the imag part of the complex impedance\\r\\n self.setColumnCount(data_columns - 1)\\r\\n for r in range(0, data_rows):\\r\\n # Update real columns\\r\\n for c, realc in [(0, 0), (1, 1), (3, 4)]:\\r\\n item = QTableWidgetItem() \\r\\n item.setText(str(data[r][realc])) \\r\\n self.setItem(r, c, item)\\r\\n # Earth resistance has a hidden column which can have an imaginary number\\r\\n if data[r][3] != 0.0:\\r\\n # show complex impedance\\r\\n item = QTableWidgetItem() \\r\\n item.setText(str(np.complex(data[r][2], data[r][3])))\\r\\n self.setItem(r, 2, item)\\r\\n else:\\r\\n # show real impedance\\r\\n item = QTableWidgetItem()\\r\\n item.setText(str(data[r][2])) \\r\\n self.setItem(r, 2, item)\\r\\n # Last Column is a QComboBox to select phasing\\r\\n phasing = QComboBox()\\r\\n phasing.addItems([\\\"Normal\\\",\\\"120 degree shift\\\", \\\"240 degree shift\\\"])\\r\\n phasing.setCurrentIndex(np.real(data[r][5]))\\r\\n phasing.currentIndexChanged.connect(self.phasing_signal(phasing, r, 5))\\r\\n self.setCellWidget(r, 4, phasing)\",\n \"def append_table(lines, table):\\n tabulate(table)\\n for row in table:\\n lines.append('|' + '|'.join(row).rstrip() + '\\\\n')\",\n \"def __update_table(self):\\n\\n headlines = [\\\"\\\", ]\\n headlines += range(1, + 1)\\n headlines = [\\\" \\\"] + [str(x) for x in range(1, self.find_table_length() + 1)]\\n self.__main_display_table.config(columns=headlines)\\n\\n for headline in headlines:\\n self.__main_display_table.heading(headline, text=headline)\\n self.__main_display_table.column(headline, anchor=\\\"center\\\", width=35)\\n\\n data = self.__display_buses_location()\\n\\n for i in self.__main_display_table.get_children():\\n # deletes all the data in the chart\\n self.__main_display_table.delete(i)\\n for line in data:\\n # inserts new data into the chart, goes line by line\\n self.__main_display_table.insert(\\\"\\\", END, values=line)\",\n \"def fill_row(row, x):\\n row.append(x)\\n return row\",\n \"def PopulatePointToPointDistancesResultsTable(self, markups, table):\\n headerList = [markups.GetNthFiducialLabel(i) for i in range(markups.GetNumberOfFiducials())]\\n table.setRowCount(len(headerList))\\n table.setColumnCount(len(headerList))\\n table.setHorizontalHeaderLabels(headerList)\\n table.setVerticalHeaderLabels(headerList)\\n\\n for point1 in range(markups.GetNumberOfFiducials()):\\n for point2 in range(point1 + 1, markups.GetNumberOfFiducials()):\\n point1_RAS = [0, 0, 0]\\n point2_RAS = [0, 0, 0]\\n markups.GetNthFiducialPosition(point1, point1_RAS)\\n markups.GetNthFiducialPosition(point2, point2_RAS)\\n distance = round(self.GetPointToPointDistance(point1_RAS, point2_RAS), 1)\\n table.setItem(point1, point2, qt.QTableWidgetItem(str(distance)))\\n\\n table.show()\\n table.resizeColumnsToContents()\\n table.resizeRowsToContents()\",\n \"def fill_table(table, shape, nrows):\\n # Reuse already computed data if possible.\\n tdata = table_data.get((shape, nrows))\\n if tdata is not None:\\n table.append(tdata)\\n table.flush()\\n return\\n\\n heavy = common.heavy\\n size = int(np.prod(shape, dtype=tb.utils.SizeType))\\n\\n row, value = table.row, 0\\n for nrow in range(nrows):\\n data = np.arange(value, value + size).reshape(shape)\\n for (type_, sctype) in sctype_from_type.items():\\n if not heavy and type_ in heavy_types:\\n continue # skip heavy type in non-heavy mode\\n colname = 'c_%s' % type_\\n ncolname = 'c_nested/%s' % colname\\n if type_ == 'bool':\\n coldata = data > (row_period // 2)\\n elif type_ == 'string':\\n sdata = [str_format % x for x in range(value, value + size)]\\n coldata = np.array(sdata, dtype=sctype).reshape(shape)\\n else:\\n coldata = np.asarray(data, dtype=sctype)\\n row[ncolname] = row[colname] = coldata\\n row['c_extra'] = data - (row_period // 2)\\n row['c_idxextra'] = data - (row_period // 2)\\n row.append()\\n value += 1\\n if value == row_period:\\n value = 0\\n table.flush()\\n\\n # Make computed data reusable.\\n tdata = table.read()\\n table_data[(shape, nrows)] = tdata\",\n \"def initrows(self):\\n #~ self.initrows2()\\n self.rows=[]\\n for yy in range(self.height):\\n row=[]\\n for xx in range(self.width):\\n if (xx,yy) in self.allsqs:\\n row.append(0)\\n #~ elif p in self.gatesqs:\\n #~ row.append(0)\\n else:\\n row.append(1)\\n self.rows.append(row)\",\n \"def MakeTableData(\\n visible_results, starred_items, lower_columns, lower_group_by,\\n users_by_id, cell_factories, id_accessor, related_issues,\\n viewable_iids_set, config, context_for_all_issues=None):\\n table_data = []\\n\\n group_cell_factories = [\\n ChooseCellFactory(group.strip('-'), cell_factories, config)\\n for group in lower_group_by]\\n\\n # Make a list of cell factories, one for each column.\\n factories_to_use = [\\n ChooseCellFactory(col, cell_factories, config) for col in lower_columns]\\n\\n current_group = None\\n for idx, art in enumerate(visible_results):\\n row = MakeRowData(\\n art, lower_columns, users_by_id, factories_to_use, related_issues,\\n viewable_iids_set, config, context_for_all_issues)\\n row.starred = ezt.boolean(id_accessor(art) in starred_items)\\n row.idx = idx # EZT does not have loop counters, so add idx.\\n table_data.append(row)\\n row.group = None\\n\\n # Also include group information for the first row in each group.\\n # TODO(jrobbins): This seems like more overhead than we need for the\\n # common case where no new group heading row is to be inserted.\\n group = MakeRowData(\\n art, [group_name.strip('-') for group_name in lower_group_by],\\n users_by_id, group_cell_factories, related_issues, viewable_iids_set,\\n config, context_for_all_issues)\\n for cell, group_name in zip(group.cells, lower_group_by):\\n cell.group_name = group_name\\n if group == current_group:\\n current_group.rows_in_group += 1\\n else:\\n row.group = group\\n current_group = group\\n current_group.rows_in_group = 1\\n\\n return table_data\",\n \"def end_table(self):\\n self.result += \\\"</table>\\\\n\\\"\",\n \"def disp_line(table, value1 = '', value2 = '', value3 = ''):\\n row = webproc.table_row()\\n item = webproc.table_item(value1)\\n row.items.append(item)\\n if value2 != '':\\n item = webproc.table_item(value2)\\n row.items.append(item)\\n if value3 != '':\\n item = webproc.table_item(value3)\\n row.items.append(item)\\n table.rows.append(row)\\n return\",\n \"def fill_table(info):\\n # extrac attributes from info struct\\n data = info[\\\"data\\\"]\\n table = info[\\\"table\\\"]\\n header = info[\\\"header\\\"]\\n row_num = info[\\\"row_num\\\"]\\n\\n currency_type_num = row_num - 1\\n row_index = 0\\n col_index = 0\\n i = 0\\n while i < len(data):\\n if data[i].find(\\\"%\\\") > 0:\\n # stat data\\n while i < len(data) and row_index < currency_type_num:\\n table[row_index+1].append(data[i])\\n row_index += 1\\n i += 1\\n # Reset row_index\\n row_index = 0\\n else:\\n if i < row_num - 1:\\n # currency Type\\n table[i+1].append(data[i])\\n else:\\n # time marker\\n if data[i] != header:\\n table[0].append(data[i])\\n i += 1\\n\\n # End loop\\n return None\",\n \"def prepare_table(table):\\n n = len(table)\\n for i, row in enumerate(table):\\n assert len(row) == n, f\\\"len(row) = {len(row)} != {n} = n\\\"\\n for j, _ in enumerate(row):\\n if i == j:\\n table[i][i] = 0.0\\n elif i > j:\\n table[i][j] = 1 - table[j][i]\\n return table\",\n \"def _gen_table_rows(self):\\n row_labels = self._get_padded_row_labels()\\n column_labels = self._get_padded_column_labels()\\n for row in zip(*column_labels):\\n yield ''.join('<td>%s</td>' % c for c in row)\\n for label, row_string in zip(row_labels, HeatMap._gen_table_rows(self)):\\n yield ''.join('<td>%s</td>' % c for c in label) + row_string\",\n \"def populate_dyn(self, table):\\n myrow = table.row\\n myrow[\\\"sample_time\\\"] = int(time.time() - glob.base_time)\\n myrow[\\\"available_bike_stands\\\"] = self.available_bike_stands\\n myrow[\\\"available_bikes\\\"] = self.available_bikes\\n myrow[\\\"last_update\\\"] = self.last_update\\n myrow[\\\"status\\\"] = self.status\\n myrow.append()\\n table.flush()\",\n \"def flush(self):\\r\\n lines = []\\r\\n\\r\\n # Append new buffer to last stored line\\r\\n total_buffer = self.lines[-1] + self.buffer\\r\\n\\r\\n width = self.size[COLS]\\r\\n for block in total_buffer.split('\\\\n'):\\r\\n # If the line fits, just add it as is. Otherwise use the textwrap\\r\\n # tool to wrap. We don't use textwrap on every line because it will strip trailing spaces\\r\\n if len(block) < width:\\r\\n lines.append(block)\\r\\n else:\\r\\n for line in textwrap.wrap(block,width-1): # Formatting works better with a 1-character buffer on right\\r\\n lines.append(line)\\r\\n\\r\\n first_line=True\\r\\n for line in lines:\\r\\n if not first_line:\\r\\n self._add_row()\\r\\n first_line=False\\r\\n self.lines[self.cursor_row] = line\\r\\n \\r\\n if total_buffer.endswith('\\\\n') and first_line:\\r\\n self.add_row()\\r\\n self.buffer=''\\r\\n self.draw()\",\n \"def clearRows(self):\\n self.data['rows'] = []\",\n \"def clear_rows(self):\\n ...\",\n \"def newrow(self):\\n maxlen = 0\\n for colbuf in self.colbufs:\\n maxlen = max(maxlen, len(colbuf))\\n\\n for i in range(maxlen):\\n first = True\\n for colbuf in self.colbufs:\\n if first:\\n first = False\\n else:\\n sys.stdout.write(self.sepstr)\\n if i < len(colbuf):\\n sys.stdout.write(colbuf[i])\\n else:\\n sys.stdout.write(\\\" \\\"*self.colwidth)\\n sys.stdout.write(\\\"\\\\n\\\")\\n\\n self.colbufs = []\\n for i in range(self.ncolumns):\\n self.colbufs.append([])\",\n \"def _populate_output(self):\\n self._store_atomic_queries_table()\\n self._store_composite_queries_table()\",\n \"def repeat_tables(primer, table, dependencies, ignore_header=True):\\n knowledge_map = learn(primer, dependencies)\\n completed = []\\n for row in table:\\n # copy everything over\\n completed_row = row\\n for dvcol, ivcol in dependencies.items():\\n iv = row[ivcol]\\n # if the value is empty and we know what to put\\n if row[dvcol] == \\\"\\\" and iv in knowledge_map[dvcol]:\\n # fill in what we learned\\n completed_row[dvcol] = knowledge_map[dvcol][iv]\\n completed.append(completed_row)\\n return completed\",\n \"def test_toTable(self):\\r\\n # Empty results.\\r\\n out_f = StringIO()\\r\\n self.res1.toTable(out_f)\\r\\n self.assertEqual(out_f.getvalue(),\\r\\n \\\"SampleID\\\\tSize\\\\tEstimate\\\\tStd Err\\\\tCI (lower)\\\\tCI (upper)\\\\n\\\")\\r\\n out_f.close()\\r\\n\\r\\n # Results with multiple samples.\\r\\n exp = \\\"\\\"\\\"SampleID\\\\tSize\\\\tEstimate\\\\tStd Err\\\\tCI (lower)\\\\tCI (upper)\\r\\nS1\\\\t5\\\\t21\\\\t1.5\\\\t2.5\\\\t3.5\\r\\nS1\\\\t10\\\\t20\\\\t2.5\\\\t2.5\\\\t3.5\\r\\nS1\\\\t20\\\\t30\\\\t3.5\\\\t2.5\\\\t3.5\\r\\nS2\\\\t1\\\\t3\\\\t0.4\\\\t2.5\\\\t3.5\\r\\n\\\"\\\"\\\"\\r\\n out_f = StringIO()\\r\\n self.res2.toTable(out_f)\\r\\n self.assertEqual(out_f.getvalue(), exp)\\r\\n out_f.close()\\r\\n\\r\\n # Custom header.\\r\\n exp = \\\"\\\"\\\"foo\\\\tbar\\\\tbaz\\\\tbazaar\\\\tbazaaar\\\\tbazaaaar\\r\\nS1\\\\t5\\\\t21\\\\t1.5\\\\t2.5\\\\t3.5\\r\\n\\\"\\\"\\\"\\r\\n out_f = StringIO()\\r\\n self.res1.addSample('S1', 42)\\r\\n self.res1.addSampleEstimate('S1', 5, 21, 1.5, 2.5, 3.5)\\r\\n self.res1.toTable(out_f,\\r\\n header=['foo', 'bar', 'baz', 'bazaar', 'bazaaar', 'bazaaaar'])\\r\\n self.assertEqual(out_f.getvalue(), exp)\\r\\n out_f.close()\\r\\n\\r\\n # Invalid header.\\r\\n with self.assertRaises(ValueError):\\r\\n out_f = StringIO()\\r\\n self.res1.toTable(out_f, header=['foo'])\\r\\n\\r\\n # Cells with None as their value.\\r\\n exp = \\\"\\\"\\\"SampleID\\\\tSize\\\\tEstimate\\\\tStd Err\\\\tCI (lower)\\\\tCI (upper)\\r\\nS1\\\\t43\\\\tN/A\\\\tN/A\\\\tN/A\\\\tN/A\\r\\n\\\"\\\"\\\"\\r\\n out_f = StringIO()\\r\\n res = RichnessEstimatesResults()\\r\\n res.addSample('S1', 42)\\r\\n res.addSampleEstimate('S1', 43, None, None, None, None)\\r\\n res.toTable(out_f)\\r\\n self.assertEqual(out_f.getvalue(), exp)\\r\\n out_f.close()\",\n \"def insertLines(data):\\n data = pd.DataFrame(data)\\n for _,row in data.iterrows():\\n insertLine(row)\",\n \"def _fillinSheet(self,sheet,data,startrow=2):\\n i = startrow-1\\n for r in data:\\n j = 0\\n for c in r:\\n sheet.write(i,j,c)\\n j+=1\\n i += 1\",\n \"def _tabulate_data(\\n self, headers, tabular_data, column_spacing=2, divider='-'\\n ):\\n max_lengths = [len(str(header)) for header in headers]\\n for data_row in tabular_data:\\n for column_index, item in enumerate(data_row):\\n item = str(item).replace(self.color_package, '')\\n item = str(item).replace(self.color_foreground, '')\\n if len(str(item)) > max_lengths[column_index]:\\n max_lengths[column_index] = len(str(item))\\n\\n dividers = [divider * length for length in max_lengths]\\n\\n def tabulate_row(items):\\n row = ''\\n item_template = '{item}{spacing}'\\n for i, row_item in enumerate(items):\\n\\n # clear colors before calculating\\n colorless_item = (\\n str(row_item).replace(self.color_package, '')\\n )\\n colorless_item = colorless_item.replace(\\n self.color_foreground, '')\\n\\n item_spacing = ' ' * (\\n max_lengths[i] +\\n column_spacing -\\n len(str(colorless_item))\\n )\\n row += item_template.format(\\n item=row_item, spacing=item_spacing)\\n return row.strip() + '\\\\n'\\n\\n result = tabulate_row(items=headers)\\n result += tabulate_row(items=dividers)\\n for data_row in tabular_data:\\n result += tabulate_row(items=data_row)\\n\\n return result.rstrip()\",\n \"def _set_rows(self, start, end):\\n if start <= end <= self.height:\\n self._write(ST7789_RASET, _encode_pos(\\n start+self.ystart, end+self.ystart))\",\n \"def set_results(self, results, unique_keys):\\n self._results = results\\n self._compute_logic()\\n\\n for _, query in enumerate(self._results):\\n\\n flat = query.flatten_results(unique_keys)\\n filename = 'flattened_{0}.csv'.format('_'.join(sorted(query.in_sets)))\\n flat.to_csv(\\n os.path.join(\\n Configuration().csv.output_directory,\\n '{0}'.format(filename)\\n ),\\n sep='\\\\t'\\n )\",\n \"def add_to_table(self, values_to_report, table_headers):\\n row = Series(dict(zip(\\n table_headers,\\n values_to_report\\n )))\\n self.configuration.results = self.configuration.results.append(\\n row, ignore_index=True)\",\n \"def updateTableOutcomes(self):\\n if not self.data or not self.predictors or not self.outvar:\\n return\\n\\n classification = self.outvar.varType == orange.VarTypes.Discrete\\n\\n # sindx is the column where these start\\n sindx = len(self.data.domain.variables)\\n col = sindx\\n showprob = self.showProb and len(self.selectedClasses)\\n fmt = \\\"%%1.%df\\\" % self.precision\\n if self.showClass or (classification and showprob):\\n for (cid, c) in enumerate(self.predictors.values()):\\n if classification:\\n for (i, d) in enumerate(self.data):\\n (cl, p) = c(d, orange.GetBoth)\\n\\n self.classifications[i].append(cl)\\n s = \\\"\\\"\\n if showprob:\\n s = \\\" : \\\".join([fmt % p[k] for k in self.selectedClasses])\\n if self.showClass: s += \\\" -> \\\"\\n if self.showClass: s += \\\"%s\\\" % str(cl)\\n self.table.setItem(self.rindx[i], col, QTableWidgetItem(s))\\n print s, self.rindx[i], col\\n else:\\n # regression\\n for (i, d) in enumerate(self.data):\\n cl = c(d)\\n self.classifications[i].append(cl)\\n self.table.setItem(self.rindx[i], col, QTableWidgetItem(str(cl)))\\n col += 1\\n else:\\n for i in range(len(self.data)):\\n for c in range(len(self.predictors)):\\n self.table.setItem(self.rindx[i], col+c, QTableWidgetItem(''))\\n col += len(self.predictors)\\n\\n for i in range(sindx, col):\\n if self.showClass or (classification and self.showProb):\\n self.table.showColumn(i)\\n## self.table.adjustColumn(i)\\n else:\\n self.table.hideColumn(i)\",\n \"def update_ui(self):\\n if self.results:\\n self.table.setRowCount(len(self.results))\\n for idx, item in enumerate(self.results):\\n char, latex, description, user_description = item\\n char_item = QTableWidgetItem(char)\\n char_item.setFlags(char_item.flags() & ~Qt.ItemIsEditable)\\n latex_item = QTableWidgetItem(latex)\\n latex_item.setFlags(latex_item.flags() & ~Qt.ItemIsEditable)\\n user_desc = \\\" [{}]\\\".format(user_description) if user_description else \\\"\\\"\\n description_item = QTableWidgetItem(\\\"{}{}\\\".format(description, user_desc))\\n description_item.setFlags(description_item.flags() & ~Qt.ItemIsEditable)\\n self.table.setItem(idx, 0, char_item)\\n self.table.setItem(idx, 1, latex_item)\\n self.table.setItem(idx, 2, description_item)\\n self.table.setCurrentCell(0, 0)\\n else:\\n self.table.setRowCount(0)\",\n \"def _postprocess_arena(self):\\n # Create tables\\n for i, (offset, rot, half_size, friction, legs) in enumerate(\\n zip(self.table_offsets, self.table_rots, self.table_half_sizes, self.table_frictions, self.has_legs)\\n ):\\n self._add_table(\\n name=f\\\"table{i}\\\",\\n offset=offset,\\n rot=rot,\\n half_size=half_size,\\n friction=friction,\\n has_legs=legs,\\n )\",\n \"def reset_row(self):\\n\\n self.line = [0] * LINE_LENGTH\\n self.current_index = 0\",\n \"def __init__(self, rows, columns, fillValue = None):\\n self.data = []\\n for row in range(rows):\\n dataInRow = []\\n for column in range(columns):\\n dataInRow.append(fillValue)\\n self.data.append(dataInRow)\",\n \"def rosterRowData(self):\",\n \"def start_next_row(self) -> None:\\n\\n if self._is_ringing_rounds:\\n self._row = self._rounds\\n else:\\n self._row = self.row_generator.next_row(self.stroke)\\n if len(self._row) < len(self._rounds):\\n # Add cover bells if needed\\n self._row.extend(self._rounds[len(self._row):])\\n\\n for (index, bell) in enumerate(self._row):\\n self.expect_bell(index, bell)\",\n \"def generate_table(results):\\n keyslist = list(results[0].keys())\\n table = PrettyTable(keyslist)\\n for dct in results:\\n table.add_row([dct.get(c, \\\"\\\") for c in keyslist])\\n return table\",\n \"def get_table(self):\\n result_table = [row[:] for row in self.table] # Clone the result table\\n\\n # Htmlise all columns containing images\\n for col_num in self.image_column_nums():\\n for row_num in range(1, len(result_table)):\\n result_table[row_num][col_num] = self.htmlise(result_table[row_num][col_num])\\n\\n # Append images\\n for ((col,row), image_list) in self.images.items():\\n for image in image_list:\\n try:\\n result_table[row][col] += \\\"<br>\\\" + image\\n except IndexError:\\n pass # Testing must have aborted so discard image\\n\\n return result_table\",\n \"def Table(self, line):\\n if line is None:\\n # TODO(user): Use resource_printer.TablePrinter() when it lands.\\n if self._rows:\\n cols = len(self._rows[0])\\n width = [0 for _ in range(cols)]\\n for row in self._rows:\\n for i in range(cols - 1):\\n w = len(row[i])\\n if width[i] <= w:\\n width[i] = w + 1\\n for row in self._rows:\\n self._out.write(' ' * (self._indent[self._level] + 2))\\n for i in range(cols - 1):\\n self._out.write(row[i].ljust(width[i]))\\n self._out.write(row[-1] + '\\\\n')\\n self._rows = []\\n self._table = False\\n self._out.write('\\\\n')\\n elif not self._table:\\n self._table = True\\n self.Line()\\n else:\\n self._rows.append(line.split(','))\",\n \"def _gen_table_rows(self):\\n for row in self.row_major_matrix:\\n arr = []\\n for value in row:\\n css_class = self.legend.value_to_css_class(value)\\n arr.append('<td class=\\\"%s\\\"> </td>' % css_class)\\n yield ''.join(arr)\",\n \"def expand(table):\\n t = []\\n for r in table:\\n for _ in range(r[1]):\\n try:\\n t.append((r[0], r[2]))\\n except IndexError:\\n t.append((r[0], None))\\n return t\",\n \"def refresh_data(self):\\r\\n self.tableWidget.setRowCount(globals.no_sections)\\r\\n self.le.setText(str(globals.no_sections))\\r\\n self.tableWidget.fill_table(globals.sections)\",\n \"def _append_results(self) -> None:\\n self._t_mps.compute_traces(self._step, self._process_tensors)\\n time = self.time(self._step)\\n norm = self._t_mps.get_norm()\\n bond_dimensions = self._t_mps.get_bond_dimensions()\\n self._results['time'].append(time)\\n self._results['norm'].append(norm)\\n self._results['bond_dimensions'].append(bond_dimensions)\\n for sites, dynamics in self._results['dynamics'].items():\\n if isinstance(sites, int):\\n sites_list = [sites]\\n else:\\n sites_list = list(sites)\\n dynamics.add(\\n time,\\n self._t_mps.get_density_matrix(sites_list))\\n self._t_mps.clear_traces()\",\n \"def reset(self):\\n self.rows = deepcopy(self.empty_rows)\\n self._update_max_row_info()\",\n \"def fill_missing(self) -> None:\\n\\n self.fill_missing_rows()\\n self.fill_missing_source_parameters()\\n return\",\n \"def tabulate(self):\\n for test_name, test in self.test_types.items():\\n for ivs_name, ivs in self.ivs.items():\\n if self.verbose:\\n print(\\\"{0}: {1}\\\".format(ivs_name, test_name))\\n tree = test(ivs)\\n if not tree:\\n continue\\n score = tree.score(True)\\n if self.verbose > 1:\\n tree.print_structure()\\n\\n self.result_matrix['ivs name'][ivs_name][test_name] = score\\n self.result_matrix['test type'][test_name][ivs_name] = score\",\n \"def endTableRow(self):\\r\\n self.text += \\\"</tr>\\\"\\r\\n if self.verbosity >= 1 : print \\\" \\\"\",\n \"def fill_missing_rows(self) -> None:\\n\\n row_dict = {row.kind: row for row in self.hints}\\n out_rows = []\\n\\n for kind in HintKind:\\n if kind in row_dict:\\n row_dict[kind].fill_missing(self.sources)\\n out_rows.append(row_dict[kind])\\n else:\\n new_row = HintRowFactory(kind)\\n new_row.fill_missing(self.sources)\\n out_rows.append(new_row)\\n\\n self.hints = out_rows\\n return\",\n \"def fill_board(self):\\n slope = 0\\n for i in range(0, len(self.row_map.keys())):\\n for j in range(0, len(self.row_map.keys())):\\n key = self.row_map[i + 1] + str(j + 1)\\n value = int(self.raw_data[j + (8 * i + slope)])\\n self.sudoku_board.update({key: value})\\n slope += 1\",\n \"def add_blank_data_row(self):\\n last_row_count = self.csv_data_table.rowCount()\\n column_count = self.csv_data_table.columnCount()\\n self.csv_data_table.insertRow(last_row_count)\\n for empty_col in range(0, column_count):\\n item = QTableWidgetItem('')\\n self.csv_data_table.setItem(last_row_count, empty_col, item)\",\n \"def fill_table(self):\\n\\n rows = self.ui.tableWidget.rowCount()\\n for r in range(0, rows):\\n self.ui.tableWidget.removeRow(0)\\n self.ui.tableWidget.setColumnCount(len(self.header_labels))\\n self.ui.tableWidget.setHorizontalHeaderLabels(self.header_labels)\\n\\n for row, f in enumerate(self.allfiles):\\n self.ui.tableWidget.insertRow(row)\\n item = QtWidgets.QTableWidgetItem(str(f[0]))\\n item.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)\\n self.ui.tableWidget.setItem(row, 0, item)\\n item = QtWidgets.QTableWidgetItem(f[1])\\n item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)\\n self.ui.tableWidget.setItem(row, 1, item)\\n # Mark Yes if assigned\\n assigned = \\\"\\\"\\n for i in self.casefiles:\\n if f[0] == i[0]:\\n assigned = _(\\\"Yes\\\")\\n item = QtWidgets.QTableWidgetItem(assigned)\\n item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)\\n self.ui.tableWidget.setItem(row, 2, item)\\n for a in self.attributes:\\n for col, header in enumerate(self.header_labels):\\n if f[0] == a[2] and a[0] == header:\\n string_value = ''\\n if a[1] is not None:\\n string_value = str(a[1])\\n if header == \\\"Ref_Authors\\\":\\n string_value = string_value.replace(\\\";\\\", \\\"\\\\n\\\")\\n item = QtWidgets.QTableWidgetItem(string_value)\\n if header in (\\\"Ref_Authors\\\", \\\"Ref_Title\\\", \\\"Ref_Type\\\", \\\"Ref_Year\\\"):\\n item.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)\\n self.ui.tableWidget.setItem(row, col, item)\\n\\n self.ui.tableWidget.hideColumn(0)\\n if self.app.settings['showids']:\\n self.ui.tableWidget.showColumn(0)\\n self.ui.tableWidget.resizeColumnsToContents()\",\n \"def populateTable(self):\\n\\n output_list = self.output_ports.split(', ')\\n\\n for i in output_list:\\n values = i.split('-')\\n nextHopPort = values[0]\\n linkCost = values[1]\\n destId = values[2]\\n learnedFrom = 0 # As it was learned from ConfigFile\\n row = routing_row.RoutingRow(nextHopPort, destId, linkCost, destId, learnedFrom)\\n self.addToRoutingTable(row)\",\n \"def prepare_lines_data(self):\\n for l_hd in self.hour_data:\\n if not self.node_from or not self.node_to:\\n print('ERROR! line %i-%i has no node(s)' % (self.node_from_code, self.node_to_code))\\n if l_hd.state and self.node_from.get_node_hour_state(l_hd.hour) \\\\\\n and self.node_to.get_node_hour_state(l_hd.hour):\\n if not self.type:\\n node_start = self.node_from_code\\n node_finish = self.node_to_code\\n base_coeff = 0\\n k_pu = 0\\n else:\\n node_start = self.node_to_code\\n node_finish = self.node_from_code\\n base_coeff = self.node_to.voltage_class / self.node_from.voltage_class\\n k_pu = math.sqrt(math.pow(self.kt_re, 2) + math.pow(self.kt_im, 2))\\n lag = math.atan(self.kt_im / self.kt_re) if self.kt_re else 0\\n\\n self.eq_db_lines_data.append((\\n l_hd.hour, node_start, node_finish, self.parallel_num, self.type,\\n max(self.node_from.voltage_class, self.node_to.voltage_class), base_coeff,\\n l_hd.r, l_hd.x, l_hd.g, -l_hd.b, k_pu, lag, -l_hd.b_from, -l_hd.b_to\\n ))\",\n \"def __init__(self):\\n\\n self.reset_row()\",\n \"def end_table(self):\\n pass\",\n \"def rows(self, row):\\n self.row += row\",\n \"def convert_rows(start, end, progress_tracker):\\n rows = end - start\\n results = []\\n process_start = time.process_time()\\n for row in range(start, end, reducer):\\n col_results = []\\n currentRow = row * scale\\n for col in range(0, cols, reducer):\\n val = int(img[row, col] / div)\\n col_results.append((col * scale, chars[val]))\\n results.append((currentRow, col_results))\\n with progress_tracker.get_lock():\\n progress_tracker.value += progress_step\\n if logs : print (\\\"Progress: %.4f%%\\\" % progress_tracker.value, end=\\\"\\\\r\\\")\\n final_results.append(results)\",\n \"def update_table(self, count, count2, done, total, *results):\\r\\n\\r\\n p_range = self.m_progressbar.GetRange()\\r\\n p_value = self.m_progressbar.GetValue()\\r\\n actually_done = done - 1 if done > 0 else 0\\r\\n for f in results:\\r\\n if isinstance(f, pygrep.FileRecord):\\r\\n self.non_match_record += 1\\r\\n self.file_info = f.info\\r\\n self.create_file_entry = True\\r\\n count2 += 1\\r\\n self.last_line = None\\r\\n else:\\r\\n if self.create_file_entry:\\r\\n self.m_result_file_panel.set_item_map(\\r\\n count, basename(self.file_info.name), float(self.file_info.size.strip(\\\"KB\\\")), 1,\\r\\n dirname(self.file_info.name), self.file_info.encoding, self.file_info.modified,\\r\\n self.file_info.created, f.lineno, f.colno\\r\\n )\\r\\n count += 1\\r\\n self.create_file_entry = False\\r\\n else:\\r\\n self.m_result_file_panel.increment_match_count(count - 1)\\r\\n\\r\\n if self.args.count_only or self.args.boolean:\\r\\n count2 += 1\\r\\n self.content_table_offset += 1\\r\\n continue\\r\\n\\r\\n lineno = f.lineno\\r\\n if self.last_line is not None and lineno == self.last_line:\\r\\n self.m_result_content_panel.increment_match_count(\\r\\n count2 - self.content_table_offset - self.non_match_record - 1\\r\\n )\\r\\n self.content_table_offset += 1\\r\\n count2 += 1\\r\\n else:\\r\\n self.m_result_content_panel.set_item_map(\\r\\n count2 - self.content_table_offset - self.non_match_record,\\r\\n (basename(self.file_info.name), dirname(self.file_info.name)),\\r\\n lineno, 1,\\r\\n f.lines.replace(\\\"\\\\r\\\", \\\"\\\").split(\\\"\\\\n\\\")[0],\\r\\n count - 1, f.colno, self.file_info.encoding\\r\\n )\\r\\n self.last_line = lineno\\r\\n count2 += 1\\r\\n\\r\\n if p_range != total:\\r\\n self.m_progressbar.SetRange(total)\\r\\n if p_value != done:\\r\\n self.m_progressbar.SetValue(actually_done)\\r\\n self.m_statusbar.set_status(\\r\\n _(\\\"Searching: %d/%d %d%% Matches: %d\\\") % (\\r\\n actually_done, total,\\r\\n int(float(actually_done)/float(total) * 100),\\r\\n (count2 - self.non_match_record)\\r\\n ) if total != 0 else (0, 0, 0)\\r\\n )\\r\\n wx.GetApp().Yield()\\r\\n return count, count2\",\n \"def mergeResults(self, job, colname, tablemodel): \\n if job==None:\\n return \\n matrices = job.data.allMatrices()\\n if not colname:\\n return\\n nf={'Total':colname}\\n for m in matrices:\\n matrix = matrices[m]\\n if matrix == None: continue\\n M = self.mergeMatrix(matrix, tablemodel, fields=['Total'], newfields=nf) \\n return\",\n \"def collect_rows():\\n return ((x, y) for x in range(80) for y in range(x + 1, 9 + (x//9)*9))\",\n \"def clear(self):\\n self.filled = 0\\n self.used = 0\\n self.table = []\\n # Initialize the table to a clean slate of entries.\\n for i in range(self.size):\\n self.table.append(Entry())\",\n \"def clear_rows(self):\\n ### Previous version had a bug, in that it assumed the set of ###\\n ### indices of full rows had to be a contiguous sequence! ###\\n full_rows = [j for j in range(ROWS) if all(\\n (i, j) in self.locked_squares for i in range(COLS))]\\n if not full_rows: return\\n ### Calculate how for to drop each other row, and do it ###\\n drop = {j: len([k for k in full_rows if k > j]) for j in range(ROWS)}\\n self.locked_squares = {(i, j+drop[j]): color for (i, j), color in\\n self.locked_squares.items() if j not in full_rows}\\n ### Now just update score, etc. ###\\n d = len(full_rows)\\n self.increment_lines(d)\\n self.increment_score(self.level*{1: 40, 2: 100, 3: 300, 4: 1200}[d])\\n if self.level < self.lines // 10 + 1:\\n self.increment_level()\",\n \"def append_table(self, table):\\n if not table:\\n return\\n\\n indexes = []\\n for idx in table.index:\\n index = self.size + idx\\n indexes.append(index)\\n\\n self.set(indexes=indexes, columns=table.columns, values=table.data)\",\n \"def print_rows():\\n do_four(print_row)\",\n \"def print_rows():\\n do_four(print_row)\",\n \"def populate_board(self):\\n for row in range(10):\\n for col in range(10):\\n coord = Coordinate(row, col)\\n coord_attack = Coordinate(row, col)\\n self.player_table.setItem(row, col, coord)\\n self.attack_table.setItem(row, col, coord_attack)\",\n \"def table(self):\\n\\n param=self.x_param\\n\\n device=self.device\\n\\n base_params=device.get_params()\\n\\n data_tot=DataFrame()\\n\\n for i in range(len(param)):\\n\\n print_index=1\\n\\n for name in param.names:\\n\\n device._set_params(param(i))\\n\\n device.draw()\\n\\n df=device.export_all()\\n\\n if self.labels_bottom is not None:\\n\\n index=self.labels_bottom[i]\\n\\n else:\\n\\n index=str(i)\\n\\n print(\\\"Generating table, item {} of {}\\\\r\\\".format(print_index,len(param)),end=\\\"\\\")\\n\\n data_tot=data_tot.append(Series(df,name=index))\\n\\n device._set_params(base_params)\\n\\n return data_tot\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def run_all(rows):\\n\\n print \\\"start row1\\\"\\n result = generate_1st_column(rows)\\n print \\\"start row 2 - 10\\\"\\n second_10th = generate_2nd_10th_column(rows)\\n print \\\"add row 2 - 10\\\"\\n result = generate_column(second_10th, result)\\n print \\\"start row 11 - 19\\\"\\n eleventh_19th = generate_11th_19th_column(rows)\\n print \\\"add row 11 - 19\\\"\\n result = generate_column(eleventh_19th, result)\\n print \\\"start row 20\\\"\\n twentiesth = generate_20th_column(rows)\\n print \\\"add row 20\\\"\\n result = generate_column(twentiesth, result)\\n print \\\"adding row 20 completed.\\\"\\n\\n return result\",\n \"def _load_table(self, field_list):\\n for i, patterns in enumerate(field_list):\\n self.ui.tableFields.insertRow(i)\\n for j, item in enumerate(patterns):\\n self.ui.tableFields.setItem(i, j, QTableWidgetItem(item))\",\n \"def reset_q_table(self):\\n for i in range(len(self.qtable)):\\n for j in range(len(self.qtable[0])):\\n self.qtable[i][j] = 0\\n self.epsilon = 1 # Reset espilon as well.\",\n \"def result_table(fmt='latex_booktabs'):\\n \\n names = [\\n \\\"ETF EW.\\\",\\n \\\"Antonacci ETF\\\",\\n \\\"Antonacci ETF Inv. Vol.\\\",\\n \\\"Futures EW.\\\",\\n \\\"Antonacci Futures\\\",\\n \\\"Antonacci Futures Inv. Vol.\\\",\\n \\\"TSMOM Futures Low Vol.\\\",\\n \\\"TSMOM Futures High Vol.\\\"\\n ]\\n\\n # Get stats for each strategy\\n s1 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=7, target_vol=40, periods=6, vol_weight=False)\\n s2 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=2, target_vol=40, periods=6, vol_weight=False)\\n s3 = calculate.stats_from_parameters(name='Antonacci', price_set='ETF', fee_rate_bps=10, get_top=2, target_vol=40, periods=6, vol_weight=True)\\n s4 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=47, target_vol=40, periods=6, vol_weight=False)\\n s5 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=False)\\n s6 = calculate.stats_from_parameters(name='Antonacci', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=True)\\n s7 = calculate.stats_from_parameters(name='TSMOM', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=40, periods=6, vol_weight=False)\\n s8 = calculate.stats_from_parameters(name='TSMOM', price_set='Futures', fee_rate_bps=10, get_top=10, target_vol=100, periods=6, vol_weight=False)\\n\\n # The relevant columns from the summary data\\n cols = [3, 4, 5, 6]\\n num_assets = [7, 2, 2, 47, 10, 10, 47, 47]\\n stats = [s1, s2, s3, s4, s5, s6, s7, s8]\\n table = [names]\\n \\n # Collecting the results\\n for i, col in enumerate(cols):\\n col_list = [round(stat['summary'][col], 2) for stat in stats]\\n table.append(col_list)\\n\\n table.append(num_assets)\\n table = list(map(list, zip(*table))) # Transpose\\n \\n # Creating table headers\\n headers = ['Strategy Name', 'Annual Return', 'Annual Vol.', 'Sharpe', 'Max. Drawdown', '# Assets']\\n \\n # Returning latex table\\n tbl = tabulate(table, headers, tablefmt=fmt)\\n print(tbl)\\n \\n return tbl\",\n \"def refillCodeTable(self):\\n\\n tableSQL = \\\"\\\"\\n sortDirection = self.pushButton_sortDirection.text()\\n sortField = self.pushButton_sort.text()\\n if sortDirection == \\\"Ascending\\\":\\n if sortField == \\\"Sorted by code\\\":\\n tableSQL = self.orderByCodeAscendSQL\\n else:\\n tableSQL = self.orderByCategoryAscendSQL\\n else: # sort descending\\n if sortField == \\\"Sorted by code\\\":\\n tableSQL = self.orderByCodeDescendSQL\\n else:\\n tableSQL = self.orderByCategoryDescendSQL\\n\\n for row in self.codes:\\n self.tableWidget.removeRow(0)\\n self.codes = []\\n cur = self.settings['conn'].cursor()\\n cur.execute(tableSQL)\\n result = cur.fetchall()\\n for row in result:\\n self.codes.append({'name':row[0], 'category':row[1], 'id':row[2], 'color':row[3]})\\n self.fillTableWidget()\",\n \"def display(self):\\n covtable = self.covtable\\n covtable.clearContents()\\n covtable.setRowCount(0)\\n for entry in self.config['table']:\\n row_position = covtable.rowCount()\\n covtable.insertRow(row_position)\\n covtable.setItem(row_position, 0, sit.PercentWidgetItem(entry[0]))\\n covtable.setItem(row_position, 1, sit.QTableWidgetItem(entry[1]))\\n covtable.setItem(row_position, 2, sit.HexWidgetItem(entry[2]))\\n covtable.setItem(row_position, 3, sit.RatioWidgetItem(entry[3]))\\n covtable.setItem(row_position, 4, sit.centered_text(entry[4]))\",\n \"def append_rows(self, rows):\\n for row in rows:\\n self.append_row(row)\",\n \"def make_summary_tables( res ):\\n\\n # transform second table to csv and read this as a dataFrame\\n result_fit_df = pd.read_csv(StringIO( res.tables[1].as_csv() ), sep=\\\",\\\",index_col=0)\\n result_fit_df.columns = [i.strip() for i in result_fit_df.columns]\\n result_fit_df.index = [i.strip() for i in result_fit_df.index]\\n\\n # first table is trickier because the data is spread on to columns, and there is title line\\n L = res.tables[0].as_html().split('\\\\n')\\n L.pop(1) # get rid of the title\\n tmp = pd.read_html('\\\\n'.join(L) , header=None)[0] # read as a dataframe, but with 4 columns \\n\\n names = list(tmp[0]) + list(tmp[2])[:-2] # columns 0 and 2 are metric names\\n values = list(tmp[1]) + list(tmp[3])[:-2] # columns 1 and 3 are the corresponding values\\n # NB : I exclude the last 2 elements which are empty \\n \\n result_general_df = pd.DataFrame( {'Name': names , 'Value' : values}, index = names , columns=['Value'] )\\n \\n return result_general_df , result_fit_df\",\n \"def _makeTable(self, rowIter, resultTableDef, queryMeta):\\n\\t\\trows = list(rowIter)\\n\\t\\tisOverflowed = len(rows)>queryMeta.get(\\\"dbLimit\\\", 1e10)\\n\\t\\tif isOverflowed:\\n\\t\\t\\tdel rows[-1]\\n\\t\\tqueryMeta[\\\"Matched\\\"] = len(rows)\\n\\t\\tres = rsc.TableForDef(resultTableDef, rows=rows)\\n\\t\\tif isOverflowed:\\n\\t\\t\\tqueryMeta[\\\"Overflow\\\"] = True\\n\\t\\t\\tres.addMeta(\\\"_warning\\\", \\\"The query limit was reached. Increase it\\\"\\n\\t\\t\\t\\t\\\" to retrieve more matches. Note that unsorted truncated queries\\\"\\n\\t\\t\\t\\t\\\" are not reproducible (i.e., might return a different result set\\\"\\n\\t\\t\\t\\t\\\" at a later time).\\\")\\n\\t\\t\\tres.addMeta(\\\"_queryStatus\\\", \\\"Overflowed\\\")\\n\\t\\telse:\\n\\t\\t\\tres.addMeta(\\\"_queryStatus\\\", \\\"Ok\\\")\\n\\t\\treturn res\",\n \"def format_result(result):\\n nbdiff = 0\\n errloc = 0\\n i = 0\\n total_diff = len(result)\\n for result_row in result:\\n i = i + 1\\n logging.info(f\\\"\\\"\\\"search row {i}/{len(result)}\\\"\\\"\\\")\\n if nbdiff >= int(maxdiff):\\n logging.warning(\\n f\\\"\\\"\\\"line {id}:reach max diff {maxdiff} for {table1.schema}.{table1.tableName} total diff:{total_diff}\\\"\\\"\\\")\\n errloc = nbdiff\\n self.total_nbdiff = nbdiff\\n break\\n list_fields = ''\\n fields1 = table1.concatened_fields\\n fields2 = table2.concatened_fields\\n qry1_fields = f\\\"\\\"\\\"select {fields1} from\\n {table1.schema}.{table1.viewName}\\n where\\n 1 = 1 \\\"\\\"\\\"\\n qry2_fields = f\\\"\\\"\\\"select {fields2} from\\n {table2.schema}.{table2.viewName}\\n where\\n 1 = 1 \\\"\\\"\\\"\\n\\n qry1 = qry1_fields + build_where(table1,result_row)\\n qry2 = qry2_fields + build_where(table2,result_row)\\n # list_fields = '|'\\n # list_fields = list_fields.join(result_row)\\n\\n for result_col in result_row:\\n test = \\\"{}\\\"\\n list_fields = list_fields + '|' + test.format(result_col)\\n # if type(result_col) is str:\\n # list_fields = ''.join(list_fields,'|',result_col)\\n # else:\\n # list_fields = ''.join(list_fields,'|',result_col)\\n\\n # .encode\\n # ('utf-8').strip()\\n # list_fields = list_fields + '|' + result_col.encode('utf-8')\\n\\n list_fields = list_fields.lstrip('|')\\n quotedsql = qry1.replace(\\\"'\\\",\\\"''\\\")\\n\\n qry_thread_1 = ExecQry(\\n table1.getengine() + '_dtsDiff',table1,qry1)\\n qry_thread_2 = ExecQry(\\n table2.getengine() + '_dtsDiff',table2,qry2)\\n\\n \\\"\\\"\\\"\\n start the threads on server1 and server2\\n \\\"\\\"\\\"\\n qry_thread_1.start()\\n qry_thread_2.start()\\n\\n \\\"\\\"\\\"\\n wait for the 2 thread to terminate\\n \\\"\\\"\\\"\\n try:\\n \\\"\\\"\\\"\\n wait for the qry being executed\\n \\\"\\\"\\\"\\n row1detail = qry_thread_1.join()\\n except Exception as exc:\\n error, = exc.args\\n logging.error(f\\\"\\\"\\\"error executing thread:\\n {error.code}\\\"\\\"\\\")\\n try:\\n \\\"\\\"\\\"\\n wait for the qry being executed\\n \\\"\\\"\\\"\\n row2detail = qry_thread_2.join()\\n except Exception as exc:\\n error, = exc.args\\n logging.error(f\\\"\\\"\\\"error executing thread:\\n {error.code}\\\"\\\"\\\")\\n\\n if (row1detail is not None) and (len(row1detail) != 0):\\n nbrows1 = 1\\n fieldst1 = row1detail[0][0]\\n fieldst1 = fieldst1.replace(\\\"\\\\x00\\\",\\\"\\\")\\n fieldst1 = fieldst1.replace(\\\"\\\\r\\\\n\\\",\\\"\\\\n\\\")\\n fieldst1 = fieldst1.replace(\\\" \\\\n\\\",\\\"\\\\n\\\")\\n fieldst1 = fieldst1.replace(\\\"\\\\t\\\",\\\"\\\")\\n if fieldst1 != row1detail[0][0]:\\n self.set_comments(id,'x00 or other found')\\n else:\\n nbrows1 = 0\\n\\n if (row2detail is not None) and len(row2detail) != 0:\\n nbrows2 = 1\\n fieldst2 = row2detail[0][0]\\n fieldst2 = fieldst2.replace(\\\"\\\\x00\\\",\\\"\\\")\\n fieldst2 = fieldst2.replace(\\\"\\\\r\\\\n\\\",\\\"\\\\n\\\")\\n fieldst2 = fieldst2.replace(\\\"\\\\t\\\",\\\"\\\")\\n fieldst2 = fieldst2.replace(\\\" \\\\n\\\",\\\"\\\\n\\\")\\n if fieldst2 != row2detail[0][0]:\\n self.set_comments(id,'x00 or other found')\\n else:\\n nbrows2 = 0\\n\\n desc = \\\"ok\\\"\\n if nbrows1 == 1 and nbrows2 == 1:\\n if fieldst1 != fieldst2:\\n desc = f\\\"\\\"\\\"( <> in server1 {table1.getengine()} and server2 {table2.getengine()})\\n server1 {fieldst1}\\n server2 {fieldst2}\\\"\\\"\\\"\\n # logging.info(f\\\"\\\"\\\"delta in {table1.tableName}:\\\\n {desc}\\n # \\\"\\\"\\\")\\n elif nbrows1 == 1 and nbrows2 == 0:\\n desc = f\\\"\\\"\\\"(+ in server1 {table1.getengine()}) {fieldst1} ; (- in server2 {table2.getengine()}) \\\"\\\"\\\"\\n elif nbrows1 == 0 and nbrows2 == 1:\\n desc = f\\\"\\\"\\\"(- in server1 {table1.getengine()}) ; (+ in server2 {table2.getengine()}) {fieldst2}\\\"\\\"\\\"\\n\\n quoteddesc = desc.replace(\\\"'\\\",\\\"''\\\")\\n quotedlist_fields = list_fields.replace(\\\"'\\\",\\\"''\\\")\\n quotedtableName = table1.tableName.replace(\\\"'\\\",\\\"''\\\")\\n sql = f\\\"\\\"\\\"insert into {schemaRepo}.rowdiff (idtable,table_name,\\n comments,fields,qry) select '{id}','{quotedtableName}','\\n {quoteddesc}','{quotedlist_fields}','{quotedsql}'\\n where not exists\\n (select 1 from {schemaRepo}.rowdiff where (idtable,lower\\n (table_name),\\n comments,qry) =\\n ({id},lower('{quotedtableName}'),'{quoteddesc}','{quotedsql}'))\\\"\\\"\\\"\\n\\n if desc != 'ok':\\n errloc = errloc + 1\\n nbdiff = nbdiff + 1\\n logging.info(\\n f\\\"\\\"\\\"diffrowset nok {table1.tableName} for id = {id}\\\"\\\"\\\")\\n logging.error(f\\\"\\\"\\\"{desc}\\\"\\\"\\\")\\n conn = self.connect(cxRepo)\\n with conn.cursor() as curs:\\n try:\\n curs.execute(sql)\\n except Exception as exc:\\n error, = exc.args\\n logging.error(f\\\"\\\"\\\"error executing {sql}:\\n {error.code}\\\"\\\"\\\")\\n return errloc\",\n \"def mix_iterator(self):\\n self.job = OrderedDict()\\n for list_i in self.grid_iterator():\\n # Pick the values to be used in this run\\n for (k, i) in zip(self.table.keys(), list_i):\\n self.job[k] = self.table[k][i]\\n # Do the string replace operations on the values themselves\\n self.expand_values()\\n yield self.job\",\n \"def generate_table(start_int=0, end_int=10, table_type='Addition'):\\n lines = [r'\\\\documentclass{article}',\\n r'\\\\usepackage{geometry}',\\n r'\\\\geometry{landscape,a4paper,total={170mm,257mm},left=10mm,right=10mm,top=10mm}',\\n r'\\\\usepackage{amsmath}',\\n r'\\\\usepackage{amsfonts}',\\n r'\\\\usepackage{amssymb}',\\n r'\\\\usepackage{dcolumn}',\\n r'\\\\newcolumntype{2}{D{.}{}{2.0}}',\\n r'\\\\begin{document}',\\n r'\\\\begin{large}',\\n r'\\\\begin{center}',\\n r'{\\\\Large ' + table_type + r' Table version 0.1\\\\par}',\\n r'\\\\vspace*{25px}',\\n r'\\\\renewcommand\\\\arraystretch{1.3}',\\n r'\\\\setlength\\\\doublerulesep{0pt}',\\n r'\\\\pagenumbering{gobble}',\\n r'\\\\begin{tabular}{r||*{' + str(end_int - start_int + 1) + '}{3|}}']\\n\\n operator = {'Addition': r'$+$',\\n 'Subtraction': r'$-$',\\n 'Multiplication': r'$\\\\times$'}\\n\\n lines.append(operator[table_type] + ''.join([' & {} '.format(x) for x in range(start_int, end_int + 1)]) + r'\\\\\\\\')\\n lines.append('\\\\hline\\\\hline')\\n for i in range(start_int, end_int + 1):\\n if table_type == 'Addition':\\n lines.append(str(i) + ''.join([' & {} '.format(x + i) for x in range(start_int, end_int + 1)]) + r'\\\\\\\\')\\n if table_type == 'Subtraction':\\n lines.append(str(i) + ''.join([' & {} '.format(x - i) for x in range(start_int, end_int + 1)]) + r'\\\\\\\\')\\n if table_type == 'Multiplication':\\n lines.append(str(i) + ''.join([' & {} '.format(x * i) for x in range(start_int, end_int + 1)]) + r'\\\\\\\\')\\n lines.append('\\\\hline')\\n\\n lines.append(r'\\\\end{tabular}')\\n lines.append(r'\\\\end{center}')\\n lines.append(r'\\\\end{large}')\\n lines.append(r'\\\\end{document}')\\n\\n return '\\\\n'.join(lines)\",\n \"def append_data(start_col, end_col, rows, func_for_content):\\n\\n result = [generate_header(start_col, end_col, \\\"\\\")]\\n\\n while len(result) < rows + 1:\\n item = []\\n while len(item) < end_col - start_col + 1:\\n to_append = func_for_content()\\n item.append(to_append)\\n result.append(item)\\n\\n display_indicator(ROWS, len(result), \\\\\\n str(len(result)) + \\\" data processed for \\\" + str(func_for_content)[10:-1])\\n\\n return result\",\n \"def prepare_table(self):\\n i = 0\\n for item in ['DN[-]', 'd_out[mm]', 'tl_trub[mm]', 'roztec_trub[mm]', 'delka[mm]', 'roztec_prep[mm]', 'vyska_prep[mm]']:\\n self.table.insertColumn(i)\\n self.table.setHorizontalHeaderItem(i, QTableWidgetItem(item))\\n i += 1\\n for item in ['tl_prep[mm]','pocet_prep[-]', 'pocet_trub[-]', 'TP[m/s]', 'MZP[m/s]', 'vykon [W]',\\n 'tlak_ztraty[Pa]', 'hmotnost[kg]']:\\n self.table.insertColumn(i)\\n self.table.setHorizontalHeaderItem(i, QTableWidgetItem(item))\\n i += 1\",\n \"def _format_data(self) -> None:\\n for row in self._db_data:\\n if row['age_start'] is None:\\n continue\\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\\n elif row['age_start'] == 95:\\n entry = {'x': f\\\"{int(row['age_start'])}+\\\", 'y': int(row['count'])}\\n else:\\n entry = {'x': f\\\"{int(row['age_start'])}-{int(row['age_start'])+4}\\\", 'y': int(row['count'])}\\n self.return_data['data'].append(entry)\",\n \"def _store_rows(self):\\n\\n for value in self.values:\\n self.counters.append(value['counter'])\\n self.timestamps.append(value['timestamp'])\\n self.acceleration.append(value['acceleration'])\",\n \"def initialize(self) -> None:\\n all_queries: List[Union[DataQueryInfo, MeasureQueryInfo]] = []\\n entity_cells: List[DataCell] = []\\n current_row_group = None\\n\\n # Loop over rows, columns\\n for row_index, row in enumerate(self.rows):\\n if isinstance(row, RowSeparator):\\n current_row_group = row.name\\n continue\\n entity: Entity = row.entity\\n if isinstance(entity, Entity):\\n self.entity_map[entity.get_marquee_id()] = entity\\n else:\\n self.entity_map[''] = entity\\n cells: List[DataCell] = []\\n row_overrides = row.overrides\\n\\n for column_index, column in enumerate(self.columns):\\n column_name = column.name\\n column_processor = column.processor\\n\\n # Get all the data coordinate overrides and apply the processor override if it exists\\n data_overrides, value_override, processor_override = _get_overrides(row_overrides, column_name)\\n\\n # Create the cell\\n cell: DataCell = DataCell(column_name,\\n column_processor,\\n entity,\\n data_overrides,\\n column_index,\\n row_index,\\n current_row_group)\\n\\n if processor_override:\\n # Check if there is a processor override and apply if so\\n cell.processor = processor_override\\n if value_override:\\n cell.value = ProcessorResult(True, value_override.value)\\n cell.updated_time = get_utc_now()\\n elif isinstance(column_processor, EntityProcessor):\\n # store these cells to fetch entity data during poll\\n entity_cells.append(cell)\\n elif isinstance(column_processor, CoordinateProcessor):\\n # store these cells to fetch entity data during poll\\n if len(data_overrides):\\n # Get the last in the list if more than 1 override is given\\n cell.processor.children['a'].set_dimensions(data_overrides[-1].dimensions)\\n\\n self._coord_processor_cells.append(cell)\\n elif column_processor.measure_processor:\\n all_queries.append(MeasureQueryInfo(attr='', entity=entity, processor=column_processor))\\n else:\\n # append the required queries to the map\\n cell.build_cell_graph(all_queries, self.rdate_entity_map)\\n\\n cells.append(cell)\\n\\n self._cells.extend(cells)\\n self.results.append(cells)\\n\\n self._data_queries = all_queries\\n self._entity_cells = entity_cells\\n self.is_initialized = True\",\n \"def UpdateResults(self, data, row = None):\\n if not self.active:\\n return\\n\\n if row is None:\\n row = self.active_row\\n\\n self.SetValueRaw(row, 0, row) #set FileID\\n\\n #take only values from fit with match column labels\\n for species, fitpars in data.iteritems():\\n\\n #clear fit parameter entries for species TODO: always\\n #cleared, even if fitpars not valid (Note: NoFit says\\n #invalid\\n for rawcol in self.fitparcols[species]:\\n self.SetValueRaw(row, rawcol, None)\\n\\n if fitpars.valid:\\n for key, val in fitpars.valuedict().iteritems():\\n try:\\n rawcol = self.colLabels.tolist().index(key+' '+species)\\n self.SetValueRaw(row, rawcol, val)\\n except ValueError:\\n pass\\n\\n self.update_dynamic_cols()\\n self.update_variable_cols()\\n\\n #uncomment this to change row selection to the newly added row\\n #self.GetView().MakeCellVisible(row, 0)\\n self.GetView().Refresh()\",\n \"def startmeup():\\r\\n global iteration\\r\\n\\r\\n #The readout function is called...\\r\\n thetime, T_BL100, MF_BL100, Rho_BL100, T_Cori, MF_Cori, Rho_Cori, DP = readout()\\r\\n #... and the results are added to the dataframe.\\r\\n df.loc[iteration]= [thetime, T_BL100, MF_BL100, Rho_BL100, T_Cori, MF_Cori, Rho_Cori, DP]\\r\\n iteration = iteration + 1 #Moving on to the next entry.\\r\",\n \"def merge_rows(self, rows):\\n for row in rows:\\n yield tuple(self.merge_one_row(row, combine_measurements))\",\n \"def rows(self):\\n out = []\\n for row in self.a:\\n new = self.new(1, len(row), fake=False)\\n new.a[0] = row\\n out.append(new)\\n return out\",\n \"def startTableRow(self):\\r\\n self.text += \\\"<tr>\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65478563","0.6272289","0.62374914","0.6087662","0.5902959","0.58083314","0.57289517","0.5723789","0.5701637","0.56659144","0.56502664","0.563632","0.5613999","0.5606675","0.55917966","0.5551868","0.5539367","0.55313087","0.5485055","0.5482998","0.54741925","0.5410293","0.5402534","0.53996265","0.53984606","0.5383273","0.536428","0.53353596","0.53330046","0.53285533","0.5327293","0.5319462","0.53165936","0.5306885","0.53025675","0.52996886","0.5279001","0.5274608","0.5262352","0.5256924","0.5249502","0.52360916","0.5217746","0.5214477","0.5213191","0.5191564","0.518687","0.5185689","0.5184821","0.51804054","0.51794314","0.51719344","0.5163616","0.51569057","0.51562965","0.5153983","0.5146685","0.512216","0.51161885","0.5111366","0.5109309","0.5101987","0.5054431","0.50538504","0.5047185","0.50437975","0.5039665","0.5039542","0.50244623","0.50236094","0.50117695","0.50093704","0.500679","0.4996973","0.49927613","0.49927613","0.49890292","0.49879152","0.49843198","0.49800143","0.49790636","0.4971437","0.497015","0.49700555","0.4966374","0.49597242","0.49595186","0.49549052","0.49538785","0.4952051","0.49518874","0.49430862","0.49419525","0.49415883","0.4940125","0.4937838","0.493465","0.49178177","0.4912786","0.49114716","0.49090964"],"string":"[\n \"0.65478563\",\n \"0.6272289\",\n \"0.62374914\",\n \"0.6087662\",\n \"0.5902959\",\n \"0.58083314\",\n \"0.57289517\",\n \"0.5723789\",\n \"0.5701637\",\n \"0.56659144\",\n \"0.56502664\",\n \"0.563632\",\n \"0.5613999\",\n \"0.5606675\",\n \"0.55917966\",\n \"0.5551868\",\n \"0.5539367\",\n \"0.55313087\",\n \"0.5485055\",\n \"0.5482998\",\n \"0.54741925\",\n \"0.5410293\",\n \"0.5402534\",\n \"0.53996265\",\n \"0.53984606\",\n \"0.5383273\",\n \"0.536428\",\n \"0.53353596\",\n \"0.53330046\",\n \"0.53285533\",\n \"0.5327293\",\n \"0.5319462\",\n \"0.53165936\",\n \"0.5306885\",\n \"0.53025675\",\n \"0.52996886\",\n \"0.5279001\",\n \"0.5274608\",\n \"0.5262352\",\n \"0.5256924\",\n \"0.5249502\",\n \"0.52360916\",\n \"0.5217746\",\n \"0.5214477\",\n \"0.5213191\",\n \"0.5191564\",\n \"0.518687\",\n \"0.5185689\",\n \"0.5184821\",\n \"0.51804054\",\n \"0.51794314\",\n \"0.51719344\",\n \"0.5163616\",\n \"0.51569057\",\n \"0.51562965\",\n \"0.5153983\",\n \"0.5146685\",\n \"0.512216\",\n \"0.51161885\",\n \"0.5111366\",\n \"0.5109309\",\n \"0.5101987\",\n \"0.5054431\",\n \"0.50538504\",\n \"0.5047185\",\n \"0.50437975\",\n \"0.5039665\",\n \"0.5039542\",\n \"0.50244623\",\n \"0.50236094\",\n \"0.50117695\",\n \"0.50093704\",\n \"0.500679\",\n \"0.4996973\",\n \"0.49927613\",\n \"0.49927613\",\n \"0.49890292\",\n \"0.49879152\",\n \"0.49843198\",\n \"0.49800143\",\n \"0.49790636\",\n \"0.4971437\",\n \"0.497015\",\n \"0.49700555\",\n \"0.4966374\",\n \"0.49597242\",\n \"0.49595186\",\n \"0.49549052\",\n \"0.49538785\",\n \"0.4952051\",\n \"0.49518874\",\n \"0.49430862\",\n \"0.49419525\",\n \"0.49415883\",\n \"0.4940125\",\n \"0.4937838\",\n \"0.493465\",\n \"0.49178177\",\n \"0.4912786\",\n \"0.49114716\",\n \"0.49090964\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9282,"cells":{"query":{"kind":"string","value":"Plots the free energy change computed using the equilibrated snapshots between the proper target time frames (f_ts and r_ts) in both forward (data points are stored in F_df and F_ddf) and reverse (data points are stored in R_df and R_ddf) directions."},"document":{"kind":"string","value":"def plotdFvsTime(f_ts, r_ts, F_df, R_df, F_ddf, R_ddf):\n fig = pl.figure(figsize=(8,6))\n ax = fig.add_subplot(111)\n pl.setp(ax.spines['bottom'], color='#D2B9D3', lw=3, zorder=-2)\n pl.setp(ax.spines['left'], color='#D2B9D3', lw=3, zorder=-2)\n for dire in ['top', 'right']:\n ax.spines[dire].set_color('none')\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n\n max_fts = max(f_ts)\n rr_ts = [aa/max_fts for aa in f_ts[::-1]]\n f_ts = [aa/max_fts for aa in f_ts]\n r_ts = [aa/max_fts for aa in r_ts]\n\n line0 = pl.fill_between([r_ts[0], f_ts[-1]], R_df[0]-R_ddf[0], R_df[0]+R_ddf[0], color='#D2B9D3', zorder=-5)\n for i in range(len(f_ts)):\n line1 = pl.plot([f_ts[i]]*2, [F_df[i]-F_ddf[i], F_df[i]+F_ddf[i]], color='#736AFF', ls='-', lw=3, solid_capstyle='round', zorder=1)\n line11 = pl.plot(f_ts, F_df, color='#736AFF', ls='-', lw=3, marker='o', mfc='w', mew=2.5, mec='#736AFF', ms=12, zorder=2)\n\n for i in range(len(rr_ts)):\n line2 = pl.plot([rr_ts[i]]*2, [R_df[i]-R_ddf[i], R_df[i]+R_ddf[i]], color='#C11B17', ls='-', lw=3, solid_capstyle='round', zorder=3)\n line22 = pl.plot(rr_ts, R_df, color='#C11B17', ls='-', lw=3, marker='o', mfc='w', mew=2.5, mec='#C11B17', ms=12, zorder=4)\n\n pl.xlim(r_ts[0], f_ts[-1])\n\n pl.xticks(r_ts[::2] + f_ts[-1:], fontsize=10)\n pl.yticks(fontsize=10)\n\n leg = pl.legend((line1[0], line2[0]), (r'$Forward$', r'$Reverse$'), loc=1, prop=FP(size=18), frameon=False)\n pl.xlabel(r'$\\mathrm{Fraction\\/of\\/the\\/simulation\\/step}$', fontsize=16, color='#151B54')\n pl.ylabel(r'$\\mathrm{\\Delta G\\/%s}$' % P.units, fontsize=16, color='#151B54')\n pl.xticks(f_ts, ['%.2f' % i for i in f_ts])\n pl.tick_params(axis='x', color='#D2B9D3')\n pl.tick_params(axis='y', color='#D2B9D3')\n pl.savefig(os.path.join(P.output_directory, 'dF_t.pdf'))\n pl.close(fig)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def sysPLQF(mirror, blkFlag=True):\n import matplotlib.pyplot as plt\n import numpy as np # to ndarray.flatten ax\n\n mir = mirror\n xend = max(mir.r_t)\n\n fig, ax = plt.subplots(nrows=2, ncols=2,)\n ax = np.ndarray.flatten(ax)\n ax[0].set_title('Real Power Generated')\n for mach in mir.Machines:\n ax[0].plot(mir.r_t, mach.r_Pe, \n marker = 10,\n fillstyle='none',\n #linestyle = ':',\n label = 'Pe Gen '+ mach.Busnam)\n ax[0].set_xlabel('Time [sec]')\n ax[0].set_ylabel('MW')\n\n ax[2].set_title('Reactive Power Generated')\n for mach in mir.Machines:\n ax[2].plot(mir.r_t, mach.r_Q, \n marker = 10,\n fillstyle='none',\n #linestyle = ':',\n label = 'Q Gen '+ mach.Busnam)\n ax[2].set_xlabel('Time [sec]')\n ax[2].set_ylabel('MVAR')\n\n ax[1].set_title('Total System P Loading')\n ax[1].plot(mir.r_t, mir.r_ss_Pload, \n marker = 11,\n #fillstyle='none',\n #linestyle = ':',\n label = 'Pload')\n ax[1].set_xlabel('Time [sec]')\n ax[1].set_ylabel('MW')\n\n ax[3].set_title('System Mean Frequency')\n ax[3].plot(mir.r_t, mir.r_f,\n marker = '.',\n #linestyle = ':',\n label = r'System Frequency')\n ax[3].set_xlabel('Time [sec]')\n ax[3].set_ylabel('Frequency [PU]')\n\n # Global Plot settings\n for x in np.ndarray.flatten(ax):\n x.set_xlim(0,xend)\n x.legend()\n x.grid(True)\n\n fig.tight_layout()\n\n plt.show(block = blkFlag)","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def plot_fvc_distances(\n configuration: BaseConfiguration,\n fibre_data_F: pandas.DataFrame,\n path: str | pathlib.Path | None = None,\n):\n\n data = configuration.assignment_data.fibre_table.copy()\n data = data.reset_index().set_index([\"positioner_id\", \"fibre_type\"])\n\n data_F = fibre_data_F.copy()\n data_F = data_F.reset_index().set_index([\"positioner_id\", \"fibre_type\"])\n\n is_dither = configuration.is_dither\n\n data = data.loc[data_F.index, :]\n\n data_F[\"xwok_distance\"] = data.xwok - data_F.xwok\n data_F[\"ywok_distance\"] = data.ywok - data_F.ywok\n data_F[\"wok_distance\"] = numpy.hypot(data_F.xwok_distance, data_F.ywok_distance)\n\n deccen = configuration.assignment_data.boresight[0][1]\n cos_dec = numpy.cos(numpy.deg2rad(float(deccen)))\n\n data_F[\"ra_distance\"] = (data.ra_epoch - data_F.ra_epoch) * cos_dec * 3600.0\n data_F[\"dec_distance\"] = (data.dec_epoch - data_F.dec_epoch) * 3600.0\n data_F[\"sky_distance\"] = numpy.hypot(data_F.ra_distance, data_F.dec_distance)\n\n if not is_dither:\n data_F[\"racat_distance\"] = (data_F.ra_icrs - data_F.ra_epoch) * cos_dec * 3600.0\n data_F[\"deccat_distance\"] = (data_F.dec_icrs - data_F.dec_epoch) * 3600.0\n data_F[\"skycat_distance\"] = numpy.hypot(\n data_F.racat_distance, data_F.deccat_distance\n )\n\n with plt.ioff(): # type: ignore\n seaborn.set_theme()\n\n fig, axes = plt.subplots(1, 3, figsize=(30, 10))\n\n if not is_dither:\n data_F = data_F.groupby(\"positioner_id\").filter(\n lambda g: g.assigned.any() & g.on_target.any() & g.valid.all()\n )\n\n assert isinstance(axes, numpy.ndarray)\n\n _plot_wok_distance(data_F, axes[0])\n\n _plot_sky_distance(\n data_F,\n axes[1],\n \"sky_distance\",\n is_dither=is_dither,\n plot_metrology=True,\n title=\"Sky distance (ra/dec vs ra/dec)\",\n )\n\n # if not is_dither:\n # _plot_sky_distance(\n # data_F,\n # axes[1, 0],\n # \"skycat_distance\",\n # is_dither=is_dither,\n # plot_metrology=False,\n # title=\"Sky distance (ra/dec vs racat/deccat)\",\n # )\n\n _plot_sky_quiver(data_F, axes[2], is_dither=is_dither)\n\n fig.suptitle(\n f\"Configuration ID: {configuration.configuration_id}\"\n + (\" (dithered)\" if is_dither else \"\")\n )\n\n plt.tight_layout()\n\n if path:\n fig.savefig(str(path))\n plt.close(fig)\n\n seaborn.reset_defaults()\n\n return fig","def plot_delta(fname, temp, delta_ts_list, delta_rxn_list, labels, var='G'):\n max_y_lines = 5\n x_axis = np.array([0, 1, 3, 4, 6, 7])\n y_axis = []\n y_labels = []\n # y_min = np.floor(np.array(g_rxn_list).min())\n # y_max = np.ceil(np.array(g_ts_list).max())\n for index in range(max_y_lines):\n try:\n y_axis.append(np.array([0.0, 0.0, delta_ts_list[index], delta_ts_list[index],\n delta_rxn_list[index], delta_rxn_list[index]]))\n except IndexError:\n y_axis.append(None)\n try:\n y_labels.append(labels[index])\n except IndexError:\n y_labels.append(None)\n\n make_fig(fname, x_axis, y_axis[0],\n x_label='reaction coordinate', y_label='\\u0394' + var + ' at {} K (kcal/mol)'.format(temp),\n y1_label=y_labels[0], y2_label=y_labels[1], y3_label=y_labels[2], y4_label=y_labels[3],\n y5_label=y_labels[4], y2_array=y_axis[1], y3_array=y_axis[2], y4_array=y_axis[3], y5_array=y_axis[4],\n ls2='-', ls3='-', ls4='-', ls5='-',\n # y_lima=y_min, y_limb=y_max,\n hide_x=True,\n )","def plot(self):\n\t\t\n\t\ttf=tfData(self.shotno,tStart=None,tStop=None)\n\t\t\n\t\t_plt.figure()\n\t\tax1 = _plt.subplot2grid((3,2), (0,1), rowspan=3) #tf\n\t\tax2 = _plt.subplot2grid((3,2), (0,0)) #vf\n\t\tax3 = _plt.subplot2grid((3,2), (1,0),sharex=ax2) #oh\n\t\tax4 = _plt.subplot2grid((3,2), (2, 0),sharex=ax2) #sh\n\t\tfig=_plt.gcf()\n\t\tfig.set_size_inches(10,5)\n\t\t\t\t\n\t\ttStart=-2\n\t\ttStop=20\n\t\t\n\t\tax1.plot(tf.time*1e3,tf.tfBankField)\n\t\tax1.axvspan(tStart,tStop,color='r',alpha=0.3)\n\t\t_plot.finalizeSubplot(ax1,xlabel='Time (s)',xlim=[-150,450],ylabel='TF Field (T)')#,title=self.title\n\t\t\n\t\tax2.plot(self.vfTime*1e3,self.vfBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax2,ylabel='VF Current\\n(kA)')\n\t\t\n\t\tax3.plot(self.ohTime*1e3,self.ohBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax3,ylim=[-20,30],ylabel='OH Current\\n(kA)')\n\t\t\n\t\tax4.plot(self.shTime*1e3,self.shBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax4,ylim=[tStart,tStop],xlabel='Time (s)',ylabel='SH Current\\n(kA)')\n\t\t\n\t\t_plot.finalizeFigure(fig,title=self.title)\n#\t\tfig.set_tight_layout(True)\n\t\t\n\t\treturn fig","def show_dcr_results(dg):\n cycle = dg.fileDB['cycle'].values[0]\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\n # print(df_dsp.describe()) \n\n # compare DCR and A/E distributions\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\n \n elo, ehi, epb = 0, 25000, 100\n \n # aoe distribution\n # ylo, yhi, ypb = -1, 2, 0.1\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\n p0.set_ylabel('A/E', ha='right', y=1)\n\n # dcr distribution\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\n # ylo, yhi, ypb = -3, 2, 0.1\n ylo, yhi, ypb = 0.9, 1.08, 0.001\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\n p1.set_ylabel('DCR', ha='right', y=1)\n \n # plt.show()\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\n plt.cla()","def show_derivative(self):\n for trace in self.plotWidget.plotDataItems:\n dt = float(trace.attrs['dt'])\n dtrace = np.diff(trace.data)\n x = pgplot.make_xvector(dtrace, dt)\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))","def plot_rfs(self):\n self.xe = self.data['XE']\n self.ye = self.data['YE']\n# self.IE = self.data['IE']\n self.Var = self.data['Var']\n std = np.sqrt(np.mean(self.Var))\n fig = plt.gcf()\n ax = plt.gca()\n ax.set_xlim((np.min(self.xe), np.max(self.xe)))\n ax.set_ylim((np.min(self.ye), np.max(self.ye)))\n for xe, ye in zip(self.xe, self.ye):\n circ = plt.Circle((xe, ye), std, color='b', alpha=0.4)\n fig.gca().add_artist(circ)","def volatility_factor_plot(prices: list, dates: list, vf_data: VFStopsResultType,\n green_zone_x_values: List[list], red_zone_x_values: List[list],\n yellow_zone_x_values: List[list], y_range: float, minimum: float,\n text_str: str = \"\", str_color: str = \"\", **kwargs):\n # pylint: disable=too-many-locals,too-many-branches,too-many-statements\n register_matplotlib_converters()\n\n title = kwargs.get('title', '')\n save_fig = kwargs.get('save_fig', False)\n filename = kwargs.get('filename', 'temp_candlestick.png')\n\n stop_loss_objects = vf_data.data_sets\n\n shown_stop_loss = f\"VF: {np.round(vf_data.vf.curated, 3)}\\n\"\n if vf_data.current_status.status.value != 'stopped_out':\n shown_stop_loss += f\"Stop Loss: ${np.round(vf_data.stop_loss.curated, 2)}\"\n else:\n shown_stop_loss += \"Stop Loss: n/a\"\n\n fig, ax_handle = plt.subplots()\n\n date_indexes = [datetime.strptime(date, '%Y-%m-%d').date() for date in dates]\n ax_handle.plot(date_indexes, prices, color='black')\n\n # Set the tick spacing (this is because dates crowd easily)\n mid_tick_size = int(len(date_indexes) / 4)\n ax_handle.xaxis.set_ticks([\n date_indexes[0], date_indexes[mid_tick_size], date_indexes[mid_tick_size * 2],\n date_indexes[mid_tick_size * 3], date_indexes[-1]\n ])\n\n y_start = minimum - (y_range * 0.05)\n height = y_range * 0.02\n\n for stop in stop_loss_objects:\n sub_dates = [date_indexes[index] for index in stop.time_index_list]\n ax_handle.plot(sub_dates, stop.caution_line, color='gold')\n ax_handle.plot(sub_dates, stop.stop_loss_line, color='red')\n\n for green_zone in green_zone_x_values:\n start = mdates.date2num(date_indexes[green_zone[0]])\n end = mdates.date2num(date_indexes[green_zone[-1]])\n width = end - start\n ax_handle.add_patch(\n Rectangle(\n (start, y_start),\n width,\n height,\n edgecolor='green',\n facecolor='green',\n fill=True\n )\n )\n\n for red_zone in red_zone_x_values:\n start = mdates.date2num(date_indexes[red_zone[0]])\n end = mdates.date2num(date_indexes[red_zone[-1]])\n width = end - start\n ax_handle.add_patch(\n Rectangle(\n (start, y_start),\n width,\n height,\n edgecolor='red',\n facecolor='red',\n fill=True\n )\n )\n\n for yellow_zone in yellow_zone_x_values:\n start = mdates.date2num(date_indexes[yellow_zone[0]])\n end = mdates.date2num(date_indexes[yellow_zone[-1]])\n width = end - start\n ax_handle.add_patch(\n Rectangle(\n (start, y_start),\n width,\n height,\n edgecolor='yellow',\n facecolor='yellow',\n fill=True\n )\n )\n\n ax_handle.set_title(title)\n\n if len(text_str) > 0 and len(str_color) > 0:\n new_start = minimum - (y_range * 0.2)\n new_end = minimum + (y_range * 1.02)\n ax_handle.set_ylim(new_start, new_end)\n props = dict(boxstyle='round', facecolor='white', alpha=0.25)\n ax_handle.text(\n 0.02,\n 0.02,\n text_str,\n color=str_color,\n transform=ax_handle.transAxes,\n bbox=props\n )\n\n if len(shown_stop_loss) > 0:\n props = dict(boxstyle='round', facecolor='white', alpha=0.25)\n ax_handle.text(\n 0.02,\n 0.90,\n shown_stop_loss,\n transform=ax_handle.transAxes,\n bbox=props\n )\n\n try:\n if save_fig:\n temp_path = os.path.join(\"output\", \"temp\")\n if not os.path.exists(temp_path):\n # For functions, this directory may not exist.\n plt.close(fig)\n plt.clf()\n return\n\n filename = os.path.join(temp_path, filename)\n if os.path.exists(filename):\n os.remove(filename)\n plt.savefig(filename)\n\n else:\n plt.show()\n\n except: # pylint: disable=bare-except\n print(\n f\"{utils.WARNING}Warning: plot failed to render in 'volatility factor plot' of \" +\n f\"title: {title}{utils.NORMAL}\")\n\n plt.close('all')\n plt.clf()","def v_positions_history(self, end=yesterdaydash(), rendered=True):\n start = self.totcftable.iloc[0].date\n times = pd.date_range(start, end)\n tdata = []\n for date in times:\n sdata = sorted(\n [\n (\n date,\n fob.briefdailyreport(date).get(\"currentvalue\", 0),\n fob.name,\n )\n for fob in self.fundtradeobj\n ],\n key=lambda x: x[1],\n reverse=True,\n )\n tdata.extend(sdata)\n\n tr = ThemeRiver()\n tr.add(\n series_name=[foj.name for foj in self.fundtradeobj],\n data=tdata,\n label_opts=opts.LabelOpts(is_show=False),\n singleaxis_opts=opts.SingleAxisOpts(type_=\"time\", pos_bottom=\"10%\"),\n )\n if rendered:\n return tr.render_notebook()\n else:\n return tr","def show(self, fig=None):\n i = 0\n # for t = 0:obj.step_size:obj.duration\n # TODO: make a generator?\n iterator = np.linspace(0, self.duration(), num=math.ceil(self.duration() / self.step_precision) + 1)\n tfInterp_l = np.zeros((4, 4, len(iterator)))\n tfInterp_r = np.zeros((4, 4, len(iterator)))\n for t in iterator:\n [lfp, rfp] = self.footPosition(t)\n tfInterp_l[:, :, i] = lfp\n tfInterp_r[:, :, i] = rfp\n i = i + 1\n\n self.show_tf(fig, tfInterp_l, len(iterator))\n self.show_tf(fig, tfInterp_r, len(iterator))","def plot_fits_and_residuals(all_fits_df, dfs_list, expt_name, **kwargs):\n\n colors = cm.rainbow(np.linspace(0, 1, len(dfs_list)))\n fig = plt.figure(figsize=(5, 5), tight_layout=True)\n fig.set_dpi(300)\n\n filename = f'{expt_name}_fits_and_residuals'\n fileformat = '.png'\n \n # Set parameters for decay traces plot\n xlabel_traces = kwargs.get('xlabel_traces', 'Time after Chase (Hrs.)')\n ylabel_traces = kwargs.get('ylabel_traces', 'YFP(t)/YFP(0)')\n ylim_traces = kwargs.get('ylim_traces', (0, 1.2))\n xticks_traces = kwargs.get('xticks_traces', make_ticks(all_fits_df.x_input, decimals=0))\n yticks_traces = kwargs.get('y_ticks_traces', make_ticks((0, 1), decimals=1, n_ticks=7))\n xlim_traces = kwargs.get('xlim_traces', (xticks_traces.min(), xticks_traces.max())) \n # Set parameters for decay fit residuals plot\n xlabel_resids = kwargs.get('xlabel_resids', xlabel_traces)\n ylabel_resids = kwargs.get('ylabel_resids', 'Residuals')\n xlim_resids = kwargs.get('xlim_resids', xlim_traces)\n xticks_resids = xticks_traces\n yticks_resids = kwargs.get('yticks_resids', make_yticks_0cent(all_fits_df.residual))\n ylim_resids = kwargs.get('ylim_resids', (yticks_resids.min(), yticks_resids.max()))\n \n # Set parameters for decay fit residuals kernel density estimate\n # plot \n xlabel_kde = kwargs.get('xlabel_kde', ylabel_resids)\n ylabel_kde = kwargs.get('ylabel_kde', 'Density')\n xlim_kde = kwargs.get('xlim_kde', ylim_resids)\n ylim_kde = kwargs.get('ylim_kde', None)\n xticks_kde = yticks_resids\n # yticks_kde will get set below during \n # density calcuation\n \n # Set parameters used across all plots\n hidden_spines = kwargs.get('hidden_spine', ['top', 'right'])\n labelfontsize = kwargs.get('labelfontsize', 12)\n linewidth = kwargs.get('linewidth', 1)\n linealpha = kwargs.get('linealpha', 1)\n scatteralpha = kwargs.get('scatteralpha', 0.8)\n scattersize = kwargs.get('scattersize', 5)\n \n # Make the residuals scatter plot\n ax = fig.add_subplot(222)\n for cell_index in all_fits_df.cell_index.unique()[:]:\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\n ax.scatter(cell_df.x_input, cell_df.residual,\n s=scattersize, alpha=scatteralpha,\n facecolor='white', edgecolor=colors[cell_index])\n\n ax.axhline(0, linewidth=linewidth, alpha=linealpha, color='black')\n for spine in [ax.spines[hidden_spine] for hidden_spine in hidden_spines]:\n spine.set_visible(False)\n try:\n ax.set_xticks(xticks_resids)\n except:\n pass\n try:\n ax.set_yticks(yticks_resids)\n except:\n pass\n try:\n ax.set_ylim(ylim_resids)\n except:\n pass\n if xlabel_resids:\n ax.set_xlabel(xlabel_resids, fontsize=labelfontsize)\n if ylabel_resids:\n ax.set_ylabel(ylabel_resids, fontsize=labelfontsize) \n\n ax.set_aspect(1.0/ax.get_data_ratio(), adjustable='box')\n\n # Scatter plot of traces and line plot of fitted decays\n ax2 = fig.add_subplot(221)\n\n for cell_index in all_fits_df.cell_index.unique()[:]:\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\n ax2.plot(cell_df.x_input, cell_df.y_pred_norm/cell_df.y_pred_norm.max(),\n linewidth=linewidth, alpha=linealpha, color=colors[cell_index])\n ax2.scatter(cell_df.x_input, cell_df.y_input_norm/cell_df.y_input_norm.max(),\n s=scattersize, alpha=scatteralpha, color=colors[cell_index])\n\n if ylim_traces:\n ax2.set_ylim(ylim_traces)\n if xlim_traces:\n ax2.set_xlim(xlim_traces) \n try:\n ax2.set_xticks(xticks_traces)\n except:\n pass\n try:\n ax2.set_yticks(yticks_traces)\n except:\n pass \n if xlabel_traces:\n ax2.set_xlabel(xlabel_traces, fontsize=labelfontsize)\n if ylabel_traces:\n ax2.set_ylabel(ylabel_traces, fontsize=labelfontsize) \n\n ax2.set_aspect(1.0/ax2.get_data_ratio(), adjustable='box')\n for spine in [ax2.spines[hidden_spine] for hidden_spine in hidden_spines]:\n spine.set_visible(False)\n\n # Smoothed hist of residuals for each cell (KDE plot)\n ax3 = fig.add_subplot(223)\n \n densities = []\n for cell_index in all_fits_df.cell_index.unique()[:]:\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\n density = gaussian_kde(cell_df.residual)\n xs = np.linspace(all_fits_df.residual.min(),all_fits_df.residual.max(),200)\n ax3.plot(xs,density(xs), color=colors[cell_index],\n alpha=linealpha, linewidth=linewidth)\n densities.append(density(xs))\n\n # Also plot total residuals\n density = gaussian_kde(all_fits_df.residual)\n xs = np.linspace(all_fits_df.residual.min(),all_fits_df.residual.max(),200)\n ax3.plot(xs,density(xs), color='black',\n alpha=linealpha*2, linewidth=linewidth)\n densities.append(density(xs))\n \n # Figure out whech density outuput array has the highest y value and\n # set the yticks of the plot using that density array\n max_dens = np.array([np.max(arr) for arr in densities])\n longest_range_den = densities[max_dens.argmax()]\n yticks_kde = make_ticks(longest_range_den)\n\n if ylim_kde:\n ax3.set_ylim(ylim)\n if xlim_kde:\n ax3.set_xlim(xlim_kde)\n if xlabel_kde:\n ax3.set_xlabel(xlabel_kde, fontsize=labelfontsize)\n if ylabel_kde:\n ax3.set_ylabel(ylabel_kde, fontsize=labelfontsize)\n try:\n ax3.set_yticks(yticks_kde)\n except:\n pass\n try:\n ax3.set_xticks(xticks_kde)\n except:\n pass\n\n ax3.set_aspect(1.0/ax3.get_data_ratio(), adjustable='box')\n for spine in [ax3.spines[hidden_spine] for hidden_spine in hidden_spines]:\n spine.set_visible(False)\n\n if filename and fileformat:\n fig.savefig(f'{filename}{fileformat}', transparent=True)\n print(f'Saved plot at {filename}{fileformat}')","def plot_image_and_rfs(self, fig=None, ax=None, legend=True, q=None,\n alpha_rf=0.5, cmap=plt.cm.gray_r):\n if fig is None:\n fig, ax = plt.subplots(1, 1)\n\n if q is None:\n dx, dy = 0., 0.\n xr, yr = self.xr, self.yr\n\n else:\n dx = self.xr[q]\n dy = self.yr[q]\n xr, yr = self.xr[0:q], self.yr[0:q]\n\n m = max(max(self.data['XE']), max(self.data['YE']))\n ax.set_xlim([-m, m])\n ax.set_ylim([-m, m])\n\n if self.s_range == 'sym':\n ax.imshow(np.zeros((1, 1)), cmap=cmap, vmin=-0.5, vmax=0.5,\n extent=[-m, m, -m, m])\n\n self.plot_base_image(\n fig, ax, colorbar=False, alpha=1., cmap=cmap, dx=dx, dy=dy)\n\n _plot_rfs(\n ax, self.data['XE'], self.data['YE'], self.data['de'],\n legend, alpha=alpha_rf)\n\n ax.plot(-xr, yr, label='Eye path', c='g')","def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\n plt.figure()\n\n #legacy beamprofile data is a 1-D array of the peak negative pressure\n if len(self.hydoutput.shape)<2:\n pnp = self.hydoutput\n else:\n sensitivity = hyd_calibration(self.cfreq)\n pnp = -1*np.min(self.hydoutput,1)/sensitivity\n\n if dbdown:\n pnp = 20.0*np.log10(pnp/np.max(pnp))\n else:\n pnp = pnp*1e-6\n\n figure1 = plt.plot(self.depth, pnp)\n #the latest beamprofile data should be a 2-D array of the hydrophone output\n plt.xlabel('Depth (mm)')\n if dbdown:\n plt.ylabel('Peak Negative Pressure (dB Max)')\n else:\n plt.ylabel('Peak Negative Pressure (MPa)')\n plt.title(self.txdr)\n if displayplt:\n plt.show()\n if saveplt:\n if savepath=='':\n #prompt for a save path using a default filename\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_depthprofile.png'\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\n plt.savefig(savepath)\n return figure1, savepath","def plot_snapshot(snap):\n\n q = snap['q'][:]\n phi = snap['phi'][:]\n t = snap['t'][()]\n\n fig = plt.figure(figsize=(10.5,5))\n cv = np.linspace(-.2,.2,30)\n cphi = np.linspace(0,4.,30)\n Ew = epsilon_w/muw/2\n Q = (2*np.pi)**-2 * epsilon/(mu**2 / kf**2)\n PHI = np.sqrt(epsilon_w/muw)\n PHI2 = PHI**2\n\n ax = fig.add_subplot(121,aspect=1)\n im1 = plt.contourf(x[:nmax,:nmax]/Lf,y[:nmax,:nmax]/Lf,q[:nmax,:nmax]/Q,cv,\\\n cmin=-0.2,cmax=0.2,extend='both',cmap=cmocean.cm.curl)\n plt.xlabel(r'$x\\, k_f$')\n plt.ylabel(r'$y\\, k_f$')\n\n plt.text(25.25,25.5,r\"$t\\,\\,\\gamma = %3.2f$\" % (t*muw))\n\n cbaxes = fig.add_axes([0.15, 1., 0.3, 0.025]) \n plt.colorbar(im1, cax = cbaxes, ticks=[-.2,-.1,0,.1,.2],orientation='horizontal',label=r'Potential vorticity $[q/Q]$')\n\n ax = fig.add_subplot(122,aspect=1)\n im2 = plt.contourf(x[:nmax,:nmax]/Lf,y[:nmax,:nmax]/Lf,np.abs(phi[:nmax,:nmax])**2/PHI2,cphi,\\\n cmin=0,cmax=4,extend='max',cmap=cmocean.cm.ice_r)\n\n plt.xlabel(r'$x\\, k_f$')\n plt.yticks([])\n\n cbaxes = fig.add_axes([0.575, 1., 0.3, 0.025]) \n plt.colorbar(im2,cax=cbaxes,ticks=[0,1,2,3,4],orientation='horizontal',label=r'Wave action density $[\\mathcal{A}/A]$')\n\n figname = \"figs2movie/qgniw/\"+ fni[-18:-3]+\".png\"\n\n plt.savefig(figname, dpi=80, pad_inces=0, bbox_inches='tight')\n\n plt.close(\"all\")","def plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def show(self):\n fixed_cols = [\"Recovered\", \"Actual\"]\n # Predict the future with curve fitting\n df_list = [\n self.curve_fit(df, num).drop(fixed_cols, axis=1)\n for (num, df) in enumerate(self.subsets)\n ]\n pred_df = pd.concat(df_list, axis=1)\n pred_df[fixed_cols] = self.all_df[fixed_cols]\n if \"1st_phase\" in pred_df.columns:\n phase0_name = \"Initial_phase\"\n else:\n phase0_name = \"Regression\"\n pred_df = pred_df.rename({\"0th_phase\": phase0_name}, axis=1)\n # The list of change points\n day_list = [df.index.min() for df in df_list]\n # Show figure and the list of change points in string\n str_dates = self._show_figure(pred_df, day_list)\n return str_dates","def SA_data_display(opt_df, all_df):\n fig, axs = plt.subplots(2, 3)\n\n axs[0,0].set_title(\"Optimal rewire attempts for circularity\")\n axs[0,0].set_ylabel(\"Percent waste %\")\n axs[0,0].set_xlabel(\"Time (s)\")\n axs[0,0].plot(opt_df[\"Time (s)\"], opt_df[\"Percent waste (%)\"])\n\n axs[0,1].set_title(\"Optimal rewire attempts acceptance probability\")\n axs[0,1].set_ylabel(\"Acceptance Probability\")\n axs[0,1].set_xlabel(\"Time (s)\") # time??\n axs[0,1].scatter(opt_df[\"Time (s)\"], opt_df[\"Probability\"])\n\n axs[0,2].set_title(\"Optimal rewire attempts temperature decrease\")\n axs[0,2].set_ylabel(\"Temperature\")\n axs[0,2].set_xlabel(\"Time (s)\") # time??\n axs[0,2].plot(opt_df[\"Time (s)\"], opt_df[\"Temperature\"])\n\n axs[1,0].set_title(\"All rewire attempts for circularity\")\n axs[1,0].set_ylabel(\"Percent waste %\")\n axs[1,0].set_xlabel(\"Time (s)\")\n axs[1,0].plot(all_df[\"Time (s)\"], all_df[\"Percent waste (%)\"])\n\n axs[1,1].set_title(\"All rewire attempts acceptance probability\")\n axs[1,1].set_ylabel(\"Acceptance Probability\")\n axs[1,1].set_xlabel(\"Time (s)\") # time??\n axs[1,1].scatter(all_df[\"Time (s)\"], all_df[\"Probability\"])\n\n axs[1,2].set_title(\"All rewire attempts temperature decrease\")\n axs[1,2].set_ylabel(\"Temperature\")\n axs[1,2].set_xlabel(\"Time (s)\") # time??\n axs[1,2].plot(all_df[\"Time (s)\"], all_df[\"Temperature\"])\n\n return plt.show()","def plot_derivatives(self, show=False):\n\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(0,self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].set_xscale('log')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[1, 0].set_xscale('log')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 0].set_title('Upper - lower input data: train sample');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 0].set_title('Numerical derivative: train sample');\n ax[3, 0].set_xlabel(r'$\\ell$')\n ax[3, 0].set_ylabel(r'$\\Delta C_\\ell / 2\\Delta \\theta$')\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 0].set_xscale('log')\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n ax[0, 1].set_xscale('log')\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n ax[1, 1].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 1].set_title('Upper - lower input data: test sample');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 1].set_title('Numerical derivative: train sample');\n ax[3, 1].set_xlabel(r'$\\ell$')\n ax[3, 1].set_ylabel(r'$\\Delta C_\\ell / \\Delta \\theta $')\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 1].set_xscale('log')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def _create_velocity_figure(dataframe, color_key, title, color_mapper,\n legend_loc='top_right', plot_width=None, plot_height=None):\n \n # these markers are nearly indistinguishble\n markers = [marker for marker in MarkerType if marker not in ['circle_cross', 'circle_x']]\n fig = figure(title=title)\n _set_plot_wh(fig, plot_width, plot_height)\n\n for i, (marker, (path, df)) in enumerate(zip(markers, dataframe.iterrows())):\n ds = dict(df)\n source = ColumnDataSource(ds)\n fig.scatter('dpt', 'expr', source=source, color={'field': color_key, 'transform': color_mapper},\n marker=marker, size=10, legend=f'{path}', muted_alpha=0)\n\n fig.xaxis.axis_label = 'dpt'\n fig.yaxis.axis_label = 'expression'\n if legend_loc is not None:\n fig.legend.location = legend_loc\n\n if ds.get('x_test') is not None:\n if ds.get('x_mean') is not None:\n fig.line('x_test', 'x_mean', source=source, muted_alpha=0, legend=path)\n if all(map(lambda val: val is not None, ds.get('x_cov', [None]))):\n x_mean = ds['x_mean']\n x_cov = ds['x_cov']\n band_x = np.append(ds['x_test'][::-1], ds['x_test'])\n # black magic, known only to the most illustrious of wizards\n band_y = np.append((x_mean - np.sqrt(np.diag(x_cov)))[::-1], (x_mean + np.sqrt(np.diag(x_cov))))\n fig.patch(band_x, band_y, alpha=0.1, line_color='black', fill_color='black',\n legend=path, line_dash='dotdash', muted_alpha=0)\n\n if ds.get('x_grad') is not None:\n fig.line('x_test', 'x_grad', source=source, muted_alpha=0)\n\n\n fig.legend.click_policy = 'mute'\n\n return fig","def plot(self):\n\t\tself.plotOfLoopVoltage()","def plot_frenet_serret(self, fig, ax, frame_number=5, frame_scale=0.10):\n\n # Compute the tangent, normal and binormal unitary vectors\n h = 1e-12\n u = np.linspace(0+h, 1-h, frame_number)\n position = np.real(self.get_value(u))\n tangent = np.real(self.get_tangent(u))\n normal = np.real(self.get_normal(u))\n binormal = np.real(self.get_binormal(u))\n\n # Two dimensions (plane curve)\n if self.ndim == 2:\n\n # Plot the frames of reference\n for k in range(frame_number):\n\n # Plot the tangent vector\n x, y = position[:, k]\n u, v = tangent[:, k]\n ax.quiver(x, y, u, v, color='red', scale=7.5)\n\n # Plot the normal vector\n x, y = position[:, k]\n u, v = normal[:, k]\n ax.quiver(x, y, u, v, color='blue', scale=7.5)\n\n # Plot the origin of the vectors\n x, y = position\n points, = ax.plot(x, y)\n points.set_linestyle(' ')\n points.set_marker('o')\n points.set_markersize(5)\n points.set_markeredgewidth(1.25)\n points.set_markeredgecolor('k')\n points.set_markerfacecolor('w')\n points.set_zorder(4)\n # points.set_label(' ')\n\n # Three dimensions (space curve)\n elif self.ndim == 3:\n\n # Compute a length scale (fraction of the curve arc length)\n scale = frame_scale * self.get_arclength(0, 1)\n\n # Plot the frames of reference\n for k in range(frame_number):\n\n # Plot the tangent vector\n x, y, z = position[:, k]\n u, v, w = tangent[:, k]\n ax.quiver(x, y, z, u, v, w, color='red', length=scale, normalize=True)\n\n # Plot the norma vector\n x, y, z = position[:, k]\n u, v, w = normal[:, k]\n ax.quiver(x, y, z, u, v, w, color='blue', length=scale, normalize=True)\n\n # Plot the binormal vector\n x, y, z = position[:, k]\n u, v, w = binormal[:, k]\n ax.quiver(x, y, z, u, v, w, color='green', length=scale, normalize=True)\n\n # Plot the origin of the vectors\n x, y, z = position\n points, = ax.plot(x, y, z)\n points.set_linestyle(' ')\n points.set_marker('o')\n points.set_markersize(5)\n points.set_markeredgewidth(1.25)\n points.set_markeredgecolor('k')\n points.set_markerfacecolor('w')\n points.set_zorder(4)\n # points.set_label(' ')\n\n\n else: raise Exception('The number of dimensions must be 2 or 3')\n\n return fig, ax","def parameter_forecast_plot(model_obj,time_index,start,end,num_samples = 100,cached_samples=None,col_labels = ['P','PET','Lag-1 Q','Lag-1 P','Seasonal','P$^2$','Constant']):\n \n f = plt.figure(figsize = (8,10))\n num_components = len(col_labels)\n gs = gridspec.GridSpec(8+2*num_components,6)\n ax0 = plt.subplot(gs[-8:-6,:])\n ax1 = plt.subplot(gs[-6::,:])\n col_labels = ['P','PET','Lag-1 Q','Lag-1 P','Seasonal','P$^2$','Constant']\n ffbs = model_obj # 120 is French Broad River at Blantyre, NC\n if cached_samples is None:\n samples = ffbs.backward_sample(num_samples=num_samples)\n else: \n samples = cached_samples\n for i in range(7):\n ax_new = plt.subplot(gs[2*i:2*i+2,:])\n\n upper = np.percentile(samples[start:end,i,:],75,axis = 1)\n mid = np.percentile(samples[start:end,i,:],50,axis = 1)\n lower = np.percentile(samples[start:end,i,:],25,axis = 1)\n\n ax_new.plot(time_index[start:end],mid,color='k')\n ax_new.fill_between(time_index[start:end],upper,lower,color='0.8')\n ax_new.tick_params(labelbottom=False,direction='in')\n ax_new.text(0.02, 0.82,col_labels[i],\n horizontalalignment='left',\n verticalalignment='center',transform=ax_new.transAxes)\n\n ax1.plot(time_index[start:end],ffbs.f[start:end],color='k',label='1-step forecast')\n ax1.plot(time_index[start:end],ffbs.Y[start:end],color='k',linestyle='',marker='+',\n markersize = 10,label='Observed streamflow')\n\n ax1.fill_between(time_index[start:end],\n np.squeeze(ffbs.f[start:end] + 2*ffbs.Q[start:end,0]),\n np.squeeze(ffbs.f[start:end] - 2*ffbs.Q[start:end,0]),color='0.8',\n label = 'Forecast $\\pm 2V_t$')\n ax1.tick_params(direction='in')\n ax1.legend(loc='upper right',ncol=1,frameon=True)\n #ax1.set_ylabel('Standardized streamflow')\n ax1.set_xlabel('Date',fontsize=16)\n ax1.get_yaxis().set_label_coords(-0.1,0.5)\n ax1.text(0.02, 0.92,'Standardized streamflow',\n horizontalalignment='left',\n verticalalignment='center',transform=ax1.transAxes,)\n ax0.plot(time_index[start:end],ffbs.s[start:end],color='k')\n ax0.text(0.02, 0.82,'$E[V_t]$',\n horizontalalignment='left',\n verticalalignment='center',transform=ax0.transAxes,)\n ax0.get_yaxis().set_label_coords(-0.1,0.5)\n return f,samples","def _plot_rfs(ax, xe, ye, de, legend, alpha=0.5):\n # ax = plt.axes()\n ax.set_aspect('equal')\n # FIXME: HARD CODED 2x\n r = 0.203 * de\n for i, (x, y) in enumerate(zip(xe, ye)):\n if i == 0:\n label = None # 'One SDev of Neuron RF'\n else:\n label = None\n ax.add_patch(plt.Circle((x, -y), r, color='red', fill=True,\n alpha=alpha, label=label))\n\n if legend:\n plt.legend()\n ax.set_xlabel('x (arcmin)')\n ax.set_ylabel('y (arcmin)')","def plot_ef2(self,er,cov,n_points):\n \n if er.shape[0] != 2:\n raise ValueError('Plot ef2 can only plot two asset efficient frontier')\n \n \n weights = [np.array([w, 1-w]) for w in np.linspace(0,1,n_points)]\n \n rets = [self.portfolio_returns(w,er) for w in weights]\n \n vols = [self.portfolio_vol(w,cov) for w in weights]\n \n ef = pd.DataFrame({\n 'Returns':rets,\n 'Volatility':vols\n })\n \n return ef.plot.line(x='Volatility',y='Returns',style='.-')","def get_temp():\n epts = [\"cage_coldPlate_temp\", \"cage_pressure\"]\n # t_earlier_aug = '2019-10-02T00:00'\n # t_later_aug = datetime.utcnow().isoformat()\n t_earlier_aug = '2019-09-27T13:00'\n t_later_aug = '2019-09-28T19:49'\n dfs = pandas_db_query(epts, t_earlier_aug, t_later_aug)\n print(dfs[epts[0]].tail())\n\n exit()\n\n xv = dfs[epts[0]][\"timestamp\"]\n yv = dfs[epts[0]][epts[0]]\n plt.plot(xv, yv, '-b')\n plt.ylabel(epts[0], ha='right', y=1)\n\n p1a = plt.gca().twinx()\n xv = dfs[epts[1]][\"timestamp\"]\n yv = dfs[epts[1]][epts[1]]\n p1a.set_ylabel(epts[1], color='r', ha='right', y=1)\n p1a.tick_params('y', colors='r')\n p1a.semilogy(xv, yv, '-r')\n\n plt.gcf().autofmt_xdate()\n plt.tight_layout()\n plt.show()","def plotData(BX,BY,xi,yi,expArr,t,savepath_dir):\r\n \r\n #Find the current channel data\r\n Jz=newCurrent(BX,BY,xi,yi,expArr,t)\r\n\r\n #Find the dipole vector components\r\n BxTime=np.real(BX*expArr[t])\r\n ByTime=np.real(BY*expArr[t])\r\n\r\n #Plot the current density contour and dipole vector grid\r\n #Create the figure\r\n p1=plt.figure(figsize=(9,8))\r\n \r\n #Plot the data\r\n p1=plt.contourf(xi,yi,Jz,levels=100,vmin=-0.1,vmax=0.1)\r\n qv1=plt.quiver(xi,yi,BxTime,ByTime,width=0.004,scale=3)\r\n \r\n #Add axes labels and title\r\n p1=plt.xlabel('X [cm]',fontsize=20)\r\n p1=plt.ylabel('Y [cm]',fontsize=20)\r\n # p1=plt.title('Alfven Wave Dipole; Frequency='+str(freq)+r'KHz; $\\nu_{ei}$='+str(col)+'KHz',fontsize=19,y=1.02)\r\n p1=plt.title('E Field; Frequency='+str(freq)+r'KHz; $\\nu_{ei}$='+str(col)+'KHz',fontsize=19,y=1.02)\r\n \r\n #Set axes parameters\r\n p1=plt.xticks(np.arange(-50,51,5))\r\n p1=plt.yticks(np.arange(-50,51,5))\r\n p1=plt.xlim(-xAxisLim,xAxisLim)\r\n p1=plt.ylim(-yAxisLim,yAxisLim)\r\n \r\n #Add colorbar\r\n cbar=plt.colorbar()\r\n cbar.set_label('Normalized Current Density',rotation=270,labelpad=15)\r\n cbar=plt.clim(-1,1)\r\n \r\n #Add vector label\r\n plt.quiverkey(qv1,-0.1,-0.1,0.2,label=r'$(B_x,B_y)$')\r\n \r\n #Miscellaneous\r\n p1=plt.tick_params(axis='both', which='major', labelsize=18)\r\n p1=plt.grid(True)\r\n p1=plt.gcf().subplots_adjust(left=0.15)\r\n\r\n #Save the plot\r\n savepath_frame=savepath_dir+'frame'+str(t+1)+'.png'\r\n p1=plt.savefig(savepath_frame,dpi=100,bbox_to_anchor='tight')\r\n p1=plt.close()\r\n\r\n #Let me know which frame we just saved\r\n print('Saved frame '+str(t+1)+' of '+str(len(expArr)))\r\n \r\n return","def plot_ef(self,er,cov,n_points):\n \n weights = self.optimal_weights(n_points,er,cov)\n \n rets = [self.portfolio_returns(w,er) for w in weights]\n \n vols = [self.portfolio_vol(w,cov) for w in weights]\n \n ef = pd.DataFrame({\n 'Returns':rets,\n 'Volatility':vols\n })\n \n return ef.plot.line(x='Volatility',y='Returns',style='.-')","def show_observables(rf, logical_pops_file='qubit_pop.dat',\n beta_pops_file='beta_pop.dat', exc_file='cavity_excitation.dat',\n pulse1_file='pulse1.dat', pulse2_file='pulse2.dat'):\n fig = plt.figure(figsize=(16,3.5), dpi=70)\n\n qubit_pop = np.genfromtxt(join(rf, logical_pops_file)).transpose()\n beta_pop = np.genfromtxt(join(rf, beta_pops_file)).transpose()\n exc = np.genfromtxt(join(rf, exc_file)).transpose()\n p1 = QDYN.pulse.Pulse.read(join(rf, pulse1_file))\n p2 = QDYN.pulse.Pulse.read(join(rf, pulse2_file))\n\n ax = fig.add_subplot(131)\n tgrid = qubit_pop[0] # microsecond\n ax.plot(tgrid, qubit_pop[1], label=r'00')\n ax.plot(tgrid, qubit_pop[2], label=r'01')\n ax.plot(tgrid, qubit_pop[3], label=r'10')\n ax.plot(tgrid, qubit_pop[4], label=r'11')\n ax.plot(tgrid, beta_pop[1], label=r'0010')\n ax.plot(tgrid, beta_pop[2], label=r'0001')\n analytical_pop = qubit_pop[1] + qubit_pop[2] + qubit_pop[3] \\\n + beta_pop[1] + beta_pop[2]\n ax.plot(tgrid, analytical_pop, label=r'ana. subsp.')\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\n ax.set_xlabel(\"time (microsecond)\")\n ax.set_ylabel(\"population\")\n\n ax = fig.add_subplot(132)\n ax.plot(tgrid, exc[1], label=r'<n> (cav 1)')\n ax.plot(tgrid, exc[2], label=r'<n> (cav 2)')\n ax.plot(tgrid, exc[3], label=r'<L>')\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\n ax.set_xlabel(\"time (microsecond)\")\n ax.set_ylabel(\"cavity excitation\")\n\n ax = fig.add_subplot(133)\n p1.render_pulse(ax, label='pulse 1')\n p2.render_pulse(ax, label='pulse 2')\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\n\n #ax.set_xlim(-4, -1)","def visualize(dcf_prices, current_share_prices, regress = True):\n # TODO: implement\n return NotImplementedError","def plotAll(fx,tfarray,tlst,flst,fignum=1,starttime=0,timeinc='hrs',\r\n dt=1.0,title=None,vmm=None,cmap=None,aspect=None,interpolation=None,\r\n cbori=None,cbshrink=None,cbaspect=None,cbpad=None,normalize='n',\r\n scale='log'):\r\n \r\n #time increment\r\n if timeinc=='hrs':\r\n tinc=3600/dt\r\n elif timeinc=='min':\r\n tinc=60/dt\r\n elif timeinc=='sec':\r\n tinc=1/dt\r\n else:\r\n raise ValueError(timeinc+'is not defined')\r\n #colormap\r\n if cmap==None:\r\n cmap='jet'\r\n else:\r\n cmap=cmap\r\n #aspect ratio\r\n if aspect==None:\r\n aspect='auto'\r\n else:\r\n aspect=aspect\r\n #interpolation\r\n if interpolation==None:\r\n interpolation='gaussian'\r\n else:\r\n interpolation=interpolation\r\n #colorbar orientation\r\n if cbori==None:\r\n cbori='vertical'\r\n else:\r\n cbori=cbori\r\n #colorbar shinkage\r\n if cbshrink==None:\r\n cbshrink=.99\r\n else:\r\n cbshrink=cbshrink\r\n #colorbar aspect\r\n if cbaspect==None:\r\n cbaspect=20\r\n else:\r\n cbaspect=cbaspect\r\n #colorbar pad\r\n if cbpad==None:\r\n cbpad=.1\r\n else:\r\n cbpad=cbpad\r\n \r\n #scale\r\n if scale=='log':\r\n zerofind=np.where(abs(tfarray)==0)\r\n tfarray[zerofind]=1.0\r\n if normalize=='y':\r\n plottfarray=20*np.log10(abs(tfarray/np.max(abs(tfarray))))\r\n else:\r\n plottfarray=20*np.log10(abs(tfarray))\r\n elif scale=='linear':\r\n if normalize=='y':\r\n plottfarray=abs(plottfarray/np.max(abs(plottfarray)))**2\r\n else:\r\n plottfarray=abs(tfarray)**2\r\n \r\n t=np.arange(len(fx))*dt+starttime*dt\r\n FX=np.fft.fft(padzeros(fx))\r\n FXfreq=np.fft.fftfreq(len(FX),dt)\r\n \r\n #set some plot parameters\r\n plt.rcParams['font.size']=10\r\n plt.rcParams['figure.subplot.left']=.13\r\n plt.rcParams['figure.subplot.right']=.98\r\n plt.rcParams['figure.subplot.bottom']=.07\r\n plt.rcParams['figure.subplot.top']=.96\r\n plt.rcParams['figure.subplot.wspace']=.25\r\n plt.rcParams['figure.subplot.hspace']=.20\r\n #plt.rcParams['font.family']='helvetica'\r\n \r\n fig=plt.figure(fignum)\r\n \r\n #plot FFT of fx\r\n fax=fig.add_axes([.05,.25,.1,.7])\r\n plt.plot(abs(FX[0:len(FX)/2]/max(abs(FX)))**2,FXfreq[0:len(FX)/2],'-k')\r\n plt.xlim(0,1)\r\n plt.ylim(0,FXfreq[len(FX)/2-1])\r\n fax.xaxis.set_major_locator(MultipleLocator(.5))\r\n \r\n #plot TFD\r\n pax=fig.add_axes([.25,.25,.75,.7])\r\n if vmm!=None:\r\n vmin=vmm[0]\r\n vmax=vmm[1]\r\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\r\n flst[0],flst[-1]),aspect=aspect,vmin=vmin,vmax=vmax,cmap=cmap,\r\n interpolation=interpolation)\r\n else:\r\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\r\n flst[0],flst[-1]),aspect=aspect,cmap=cmap,\r\n interpolation=interpolation)\r\n plt.xlabel('Time('+timeinc+')',fontsize=12,fontweight='bold')\r\n plt.ylabel('Frequency (Hz)',fontsize=12,fontweight='bold')\r\n if title!=None:\r\n plt.title(title,fontsize=14,fontweight='bold')\r\n plt.colorbar(orientation=cbori,shrink=cbshrink,pad=cbpad,aspect=cbaspect)\r\n \r\n #plot timeseries\r\n tax=fig.add_axes([.25,.05,.60,.1])\r\n plt.plot(t,fx,'-k')\r\n plt.axis('tight')\r\n plt.show()","def ecdf_plot(ecdf_q1, ecdf_q2, ecdf_q3, ecdf_q4, performance_measure, ecdf_parameter):\n from plotly.offline import iplot\n import plotly.graph_objs as go\n\n performance_measure = performance_measure.replace('_', ' ').capitalize()\n ecdf_parameter = ecdf_parameter.replace('_', ' ').capitalize()\n\n ecdf_1 = go.Scatter(x=ecdf_q1.x,\n y=ecdf_q1.y,\n name='0 to 25',\n mode='lines+markers',\n marker=dict(size='7', color='#0C3383'))\n ecdf_2 = go.Scatter(x=ecdf_q2.x,\n y=ecdf_q2.y,\n name='25 to 50',\n mode='lines+markers',\n marker=dict(size='7', color='#57A18F'))\n ecdf_3 = go.Scatter(x=ecdf_q3.x,\n y=ecdf_q3.y,\n name='50 to 75',\n mode='lines+markers',\n marker=dict(size='7', color='#F2A638'))\n ecdf_4 = go.Scatter(x=ecdf_q4.x,\n y=ecdf_q4.y,\n name='75 to 100 (best wells)',\n mode='lines+markers',\n marker=dict(size='7', color='#D91E1E'))\n\n data = [ecdf_1, ecdf_2, ecdf_3, ecdf_4]\n\n layout = go.Layout(height=650,\n width=650,\n title='ECDF ' + ecdf_parameter,\n titlefont=dict(size=18),\n\n xaxis=dict(title=ecdf_parameter,\n titlefont=dict(size=16),\n type=None,\n zeroline=False,\n showgrid=True,\n showline=False,\n autorange=True),\n\n yaxis=dict(title='Cumulative Probability',\n titlefont=dict(size=16),\n showgrid=True,\n showline=False,\n zeroline=False,\n tickvals=[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1],\n range=[-0.03, 1.03]),\n\n legend=dict(x=0.65, y=0.1, font=dict(size=14)),\n margin={'l': 50, 'r': 10, 'b': 50, 't': 85})\n\n layout.update(dict(annotations=[go.Annotation(text='Quantiles: ' + performance_measure,\n x=np.max(ecdf_q4.x),\n y=0.3,\n showarrow=False,\n bgcolor='#FFFFFF',\n font=dict(size=16))]))\n\n plot = go.Figure(data=data, layout=layout)\n\n iplot(plot, show_link=False)","def view(self, lo_en: Quantity = Quantity(0.0, \"keV\"), hi_en: Quantity = Quantity(30.0, \"keV\"),\n figsize: Tuple = (8, 6)):\n if lo_en > hi_en:\n raise ValueError(\"hi_en cannot be greater than lo_en\")\n else:\n lo_en = lo_en.to(\"keV\").value\n hi_en = hi_en.to(\"keV\").value\n\n if len(self._plot_data.keys()) != 0:\n # Create figure object\n plt.figure(figsize=figsize)\n\n # Set the plot up to look nice and professional.\n ax = plt.gca()\n ax.minorticks_on()\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\n\n # Set the title with all relevant information about the spectrum object in it\n plt.title(\"{n} - {o}{i} Spectrum\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\n for mod_ind, mod in enumerate(self._plot_data):\n x = self._plot_data[mod][\"x\"]\n # If the defaults are left, just update them to the min and max of the dataset\n # to avoid unsightly gaps at the sides of the plot\n if lo_en == 0.:\n lo_en = x.min()\n if hi_en == 30.0:\n hi_en = x.max()\n\n # Cut the x dataset to just the energy range we want\n plot_x = x[(x > lo_en) & (x < hi_en)]\n\n if mod_ind == 0:\n # Read out the data just for line length reasons\n # Make the cuts based on energy values supplied to the view method\n plot_y = self._plot_data[mod][\"y\"][(x > lo_en) & (x < hi_en)]\n plot_xerr = self._plot_data[mod][\"x_err\"][(x > lo_en) & (x < hi_en)]\n plot_yerr = self._plot_data[mod][\"y_err\"][(x > lo_en) & (x < hi_en)]\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\"k+\", label=\"data\", zorder=1)\n else:\n # Don't want to re-plot data points as they should be identical, so if there is another model\n # only it will be plotted\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n # The model line is put on\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\n\n # Generate the legend for the data and model(s)\n plt.legend(loc=\"best\")\n\n # Ensure axis is limited to the chosen energy range\n plt.xlim(lo_en, hi_en)\n\n plt.xlabel(\"Energy [keV]\")\n plt.ylabel(\"Normalised Counts s$^{-1}$ keV$^{-1}$\")\n\n ax.set_xscale(\"log\")\n ax.xaxis.set_major_formatter(ScalarFormatter())\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n\n plt.tight_layout()\n # Display the spectrum\n plt.show()\n\n # Wipe the figure\n plt.close(\"all\")\n\n else:\n warnings.warn(\"There are no XSPEC fits associated with this Spectrum, you can't view it.\")","def plot_fppy_equation(self,LAXIS,xbl,xbr,ybu,ybd,ilg): \n\t\t\n # load x GRID\n grd1 = self.xzn0\n\n lhs0 = self.minus_dt_fppy\n lhs1 = self.minus_fht_ux_gradx_fppy\n\t\t\n rhs0 = self.minus_div_fppyx\n rhs1 = self.minus_fppx_gradx_uy\n rhs2 = self.plus_eht_uyf_uxff_gradx_pp\n rhs3 = self.plus_gamma1_eht_uyf_pp_divu\n rhs4 = self.plus_gamma3_minus_one_eht_uyf_dd_enuc\n rhs5 = self.plus_eht_ppf_uyff_divuff\n rhs6 = self.minus_eht_ppf_GtM_o_dd\n rhs7 = self.minus_eht_ppf_grady_pp_o_ddrr\n\t \n res = self.minus_resPPfluxEquation\n\t\n # create FIGURE\n plt.figure(figsize=(7,6))\n\t\t\n # format AXIS, make sure it is exponential\n plt.gca().yaxis.get_major_formatter().set_powerlimits((0,0))\t\t\n\n # set plot boundaries \n to_plot = [lhs0,lhs1,rhs0,rhs1,rhs2,rhs3,rhs4,rhs5,rhs6,rhs7,res]\t\t\n self.set_plt_axis(LAXIS,xbl,xbr,ybu,ybd,to_plot)\t\t\n\t\t\n # plot DATA \n plt.title('acoustic flux y equation')\n plt.plot(grd1,lhs0,color='#FF6EB4',label = r\"$-\\partial_t f_{py}$\")\n plt.plot(grd1,lhs1,color='k',label = r\"$-\\widetilde{u}_r \\partial_r f_{py}$)\")\t\n\t\t\n plt.plot(grd1,rhs0,color='#FF8C00',label = r\"$-\\nabla_r f_p^r $\") \n plt.plot(grd1,rhs1,color='#802A2A',label = r\"$-f_{py} \\partial_r \\overline{u}_r$\") \n plt.plot(grd1,rhs2,color='r',label = r\"$+\\overline{u'_\\theta u''_r} \\partial_r \\overline{P}$\") \n plt.plot(grd1,rhs3,color='firebrick',label = r\"$+\\Gamma_1 \\overline{u'_\\theta P d}$\") \n plt.plot(grd1,rhs4,color='c',label = r\"$+(\\Gamma_3-1)\\overline{u'_\\theta \\rho \\epsilon_{nuc}}$\")\n plt.plot(grd1,rhs5,color='mediumseagreen',label = r\"$+\\overline{P'u''_\\theta d''}$\")\n plt.plot(grd1,rhs6,color='b',label = r\"$+\\overline{P' G_\\theta^M/ \\rho}$\")\n plt.plot(grd1,rhs7,color='m',label = r\"$+\\overline{P'\\partial_\\theta P/ \\rho r}$\")\n\t\t\n plt.plot(grd1,res,color='k',linestyle='--',label=r\"res $\\sim N_p$\")\n \n # define and show x/y LABELS\n setxlabel = r\"r (cm)\"\n setylabel = r\"erg cm$^{-2}$ s$^{-2}$\"\n plt.xlabel(setxlabel)\n plt.ylabel(setylabel)\n\t\t\n # show LEGEND\n plt.legend(loc=ilg,prop={'size':8})\n\n # display PLOT\n plt.show(block=False)\n\n # save PLOT\n plt.savefig('RESULTS/'+self.data_prefix+'fppy_eq.png')\t\n plt.savefig('RESULTS/'+self.data_prefix+'fppy_eq.eps')","def surface_plot(name: str = 'start_date_analysis1.pkl'):\n df = pd.read_pickle(name)\n\n # set up a figure twice as wide as it is tall\n fig = plt.figure(figsize=plt.figaspect(0.5))\n # ===============\n # First subplot\n # ===============\n # set up the axes for the first plot\n ax = fig.add_subplot(1, 2, 1, projection='3d')\n ax.set_title('Modifications per File')\n ax.set_xlabel('Date (Months)')\n ax.set_ylabel('Threshold Individual')\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\n data = df[df['threshold_pairs'] == row]\n label = 'Threshold pairs ' + str(row)\n # Plot the surface.\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['mpf'], alpha=0.7,\n linewidth=0, antialiased=False, label=label)\n surf._facecolors2d = surf._facecolors3d\n surf._edgecolors2d = surf._edgecolors3d\n # ===============\n # Second subplot\n # ===============\n # set up the axes for the second plot\n ax = fig.add_subplot(1, 2, 2, projection='3d')\n ax.set_title('Transitions per Test')\n ax.set_xlabel('Date (Months)')\n ax.set_ylabel('Threshold Individual')\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\n data = df[df['threshold_pairs'] == row]\n label = 'Threshold pairs ' + str(row)\n # Plot the surface.\n\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['tpt'], alpha=0.7,\n linewidth=0, antialiased=False, label=label)\n\n surf._facecolors2d = surf._facecolors3d\n surf._edgecolors2d = surf._edgecolors3d\n\n # cbar = fig.colorbar(surf)\n # cbar.locator = LinearLocator(numticks=10)\n # cbar.update_ticks()\n\n plt.suptitle('Threshold Start Date Analysis 3D', fontsize=14)\n plt.legend()\n plt.show()","def plot_diff(self):\n if not(self.is_attribute(\"time\") & self.is_attribute(\"intensity_up\") & \n self.is_attribute(\"intensity_up_sigma\") &\n self.is_attribute(\"intensity_down\") & \n self.is_attribute(\"intensity_down_sigma\") &\n self.is_attribute(\"intensity_up_total\") &\n self.is_attribute(\"intensity_down_total\")):\n return\n fig, ax = plt.subplots()\n ax.set_title(\"Polarized intensity: I_up - I_down\")\n ax.set_xlabel(\"Time (microseconds)\")\n ax.set_ylabel('Intensity')\n \n np_time = numpy.array(self.time, dtype=float)\n np_up = numpy.array(self.intensity_up, dtype=float)\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\n np_down = numpy.array(self.intensity_down, dtype=float)\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\n np_diff = np_up - np_down\n np_diff_mod = np_up_mod - np_down_mod\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\n\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \"b:\")\n ax.plot(np_time, np_diff_mod, \"k-\",\n label=\"model\")\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\"ko\", alpha=0.2,\n label=\"experiment\")\n\n y_min_d, y_max_d = ax.get_ylim()\n param = y_min_d-(np_diff-np_diff_mod).max()\n\n ax.plot([np_time.min(), np_time.max()], [param, param], \"k:\")\n ax.plot(np_time, np_diff-np_diff_mod+param, \"r-\", alpha=0.7,\n label=\"difference\")\n ax.legend(loc='upper right')\n fig.tight_layout()\n return (fig, ax)","def DETCurve(fps, fns):\n axis_min = min(fps[0], fns[-1])\n fig, ax = plt.subplots()\n plt.xlabel(\"FAR\")\n plt.ylabel(\"FRR\")\n plt.plot(fps, fns, '-|')\n plt.yscale('log')\n plt.xscale('log')\n ax.get_xaxis().set_major_formatter(\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\n ax.get_yaxis().set_major_formatter(\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\n ticks_to_use = [0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1]\n ax.set_xticks(ticks_to_use)\n ax.set_yticks(ticks_to_use)\n plt.axis([0.01, 1, 0.01, 1])\n # plt.show()","def plot(frame, clipped, auto, lag, threshold, freq, save):\n fig, axes = plt.subplots(4, constrained_layout=True)\n fig.set_size_inches(8.0, 8.0)\n fig.canvas.set_window_title('Excercise 4')\n\n ax_frame, ax_clipped, ax_auto, ax_freq = axes\n\n time = np.linspace(0, frame.size / SAMPLE_RATE, num=frame.size)\n for ax in axes:\n ax.set_xlabel('time [s]')\n ax.set_ylabel('y')\n\n\n ax_frame.plot(time, frame)\n ax_clipped.plot(time, clipped)\n\n ax_auto.plot(auto)\n ax_auto.axvline(threshold, color='black', label='Threshold')\n ax_auto.stem([lag[0]], [lag[1]], linefmt='r-', basefmt=None, label='Lag')\n\n ax_freq.plot(freq[0], 'g-', label='mask-on')\n ax_freq.plot(freq[1], 'r-', label='mask-off')\n\n ax_auto.legend(loc=1)\n ax_freq.legend(loc=0)\n\n ax_frame.set_title('Maskon frame')\n ax_clipped.set_title('Central clipping with 70%')\n ax_auto.set_title('Autocorrelation')\n ax_freq.set_title('Primary frequencies of frames')\n\n ax_auto.set_xlabel('frames')\n ax_freq.set_xlabel('frames')\n\n ax_freq.set_ylabel('f0')\n\n if save:\n save_figure(fig, 'ex4')\n else:\n plt.show()","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def PMTandPiezoPlot(datadir,run,event,gain): \n en = event\n mu = gain\n e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)\n print(e[\"fastDAQ\"].keys())\n cgate = e[\"fastDAQ\"][\"CAMgate\"]\n dcam = np.diff(cgate)\n \n p0=e[\"fastDAQ\"][\"Piezo1\"]\n p1 = e[\"fastDAQ\"][\"Piezo2\"]\n fdt = e[\"fastDAQ\"][\"time\"]\n runreconpath = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\"%run\n pmtdiffs = []\n diffs = []\n \n camOnTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] < -0.5]\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\n print(len(camOnTimes))\n print(len(camOffTimes))\n \n acousticfilename = runreconpath+\"AcousticAnalysis_%s.bin\"%run\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\n bubt0 = a[\"bubble_t0\"]\n \n pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n tracetimes = pmttracetime - pmtalign\n at0 = bubt0[en,0]\n at0_1 = bubt0[en,1]\n \n allxyzfname = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\"\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\n indices = [i for i,x in enumerate(xyzf[\"runid\"]) if str(x[0])+\"_\"+str(x[1]) == run]\n xyz_reconstructed = True\n if len(indices) > 0:\n runposreco = {\"ev\":[xyzf[\"ev\"][indices]],\"x\":[xyzf[\"bubX\"][indices]],\n \"y\":[xyzf[\"bubY\"][indices]],\"z\":[xyzf[\"bubZ\"][indices]]}\n z = runposreco[\"z\"][0][int(int(en))]\n else:\n print(\"no handscan?\")\n z = 1.5\n xyz_reconstructed = False\n lag_expected = (-23.387649*z - 261.020495)*1e-6 # fit from other analysis\n t0_expected_p0 = at0 + lag_expected\n t0_expected_p1 = at0_1 + lag_expected\n \n i=0\n candidates = []\n candidate_times=[]\n for t in (tracetimes-at0):\n \n if t<0.2 and t>-0.2:\n lastCamOff = 0\n for k in range(len(camOffTimes)):\n if t+at0 > camOffTimes[k]:\n lastCamOff = camOffTimes[k]\n elif t+at0 < camOffTimes[k]:\n break\n if t+at0-lastCamOff > 25e-6:\n \n pmtdiffs.append(t)\n trace = np.fabs(e[\"PMTtraces\"][\"traces\"][i][0])\n if max(trace) == 128:\n trace = pi.stitchTraces(trace,np.fabs(e[\"PMTtraces\"][\"traces\"][i][1]))\n dt = e[\"PMTtraces\"][\"dt\"][i][0]\n #baseline = np.mean(trace[0:50])\n #trace = trace - baseline\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt)\n \n if phe != None:\n phe /= mu\n candidates.append(phe)\n candidate_times.append(t)\n i+=1\n candidate_phe = 0\n the_index = 0\n i=0\n near_trace_indices = []\n for t in candidate_times:\n if t > -500e-6 and t <0:\n near_trace_indices.append(list(tracetimes-at0).index(t))\n if candidates[i]>candidate_phe:\n candidate_phe = candidates[i]\n the_index = i\n i+=1\n \n if len(candidates) != 0:\n if max(candidates)>0:\n diffs.append(candidate_times[candidates.index(max(candidates))])\n fig,ax1 = plt.subplots()\n ax2 = ax1.twinx()\n ax1.plot(fdt,p0,'b',alpha=0.6, label = 'piezo 0')\n ax1.plot(fdt,p1,'k',alpha=0.2, label= 'piezo 1')\n for i in range(len(candidates)):\n if i == the_index:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'r',lw=4)\n else:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'y',lw=4)\n #ax2.plot([min(candidate_times),max(candidate_times)],[0,0],linewidth=2)\n ax1.plot([at0,at0],[-0.5,0.5],'b',linewidth=2, label = 'acoustic t0, p0')\n ax1.plot([at0_1,at0_1],[-0.5,0.5],'k',linewidth=2, label = 'acoustic t0, p1')\n \"\"\"\n if xyz_reconstructed:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1')\n else:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0, center of chamber')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1, center of chamber')\n \"\"\"\n ax1.plot(fdt,cgate,'c')\n ax1.plot(fdt[:-1],dcam,'m')\n ax2.set_ylabel('pmt signal (phe)',fontsize=20)\n ax1.set_xlabel('time (s)',fontsize=20)\n ax1.set_ylabel('Acoustic signa(V)',fontsize=20)\n ax1.set_ylim([min(p1),max(p1)])\n ax2.set_xlim([-0.1,0.1])\n #ax2.set_ylim([0,5])\n ax1.legend()\n plt.show\n \n for j in near_trace_indices:\n trace = e[\"PMTtraces\"][\"traces\"][j][0]\n dt = e[\"PMTtraces\"][\"dt\"]\n dt_tr = dt[j][0]\n tPMT = np.arange(len(trace))*dt_tr\n plt.figure()\n plt.plot(tPMT,trace)\n plt.xlabel(\"t (s)\")\n plt.ylabel(\"PMT signal\")\n plt.show\n \n plt.figure()\n plt.plot(e[\"fastDAQ\"][\"time\"],e[\"fastDAQ\"][\"VetoCoinc\"])\n plt.ylabel(\"Veto Coincidence signal\",fontsize=18)\n plt.xlabel(\"time (s)\")\n plt.show","def plot(self):\n\n\t\tprint('lcrPicker.plot()')\n\t\tif self.dr.dfSparkMaster is None:\n\t\t\tprint(' error: new_plotSparkMaster() did not find self.dr.dfSparkMaster')\n\n\t\t#print(self.dfSparkMaster.head)\n\t\tprint(' sm columns:', self.dr.dfSparkMaster.columns)\n\n\t\ttifFirstFrameSeconds = self.dr.abfTif.tifHeader['firstFrameSeconds']\n\t\ttifSecondsPerLine = self.dr.abfTif.tifHeader['secondsPerLine']\n\t\ttifTotalSeconds = self.dr.abfTif.tifHeader['totalSeconds']\n\t\tprint(' first frame of the image wrt pClamp abf as at', tifFirstFrameSeconds)\n\n\t\txLineScanSum = self.dr.abfTif.sweepX + tifFirstFrameSeconds\n\t\tyLineScanSum = self.dr.abfTif.sweepY\n\n\t\t# now stripping leading spaces in SparkMaster columns (see loadSparkMaster)\n\t\t# remember: when traversing rows, t-pos is out of order w.r.t. time\n\t\txSmStatStr = 't-pos' # t-pos is in seconds?\n\t\txSmStat = self.dr.dfSparkMaster[xSmStatStr]\n\t\t# shift wrt tifFirstFrameSeconds\n\t\txSmStatSec = [x+tifFirstFrameSeconds for x in xSmStat]\n\n\t\tyDoThisSmStat = 'FWHM' # 'Ampl.' # or 'FWHM'\n\t\tySmStatStr = yDoThisSmStat\n\t\tySmStat = self.dr.dfSparkMaster[ySmStatStr]\n\n\t\tyDoThisSmStat2 = 'Ampl.' # 'Ampl.' # or 'FWHM'\n\t\tySmStatStr2 = yDoThisSmStat2\n\t\tySmStat2 = self.dr.dfSparkMaster[ySmStatStr2]\n\n\t\ttPos_orig = self.dr.dfSparkMaster['t-pos']\n\t\ttPos_offset = tPos_orig + tifFirstFrameSeconds\n\t\ttPos_bin = [round(x/tifSecondsPerLine) for x in tPos_orig] # t-pos of each LCR as bin # (into tif)\n\t\t#print('tPos_bin:', tPos_bin)\n\n\t\txPos = self.dr.dfSparkMaster['x-pos'] # pixel along line scan???\n\n\t\t#\n\t\t# bin sparkmaster time and count the number of LCR ROIs in a bin\n\t\t#print(' self.tifBins_ms:', self.tifBins_ms)\n\t\ttifBins_sec = self.tifBins_ms / 1000\n\t\t# important to consider wrt tifBins_sec\n\t\txNumBins = math.floor(tifTotalSeconds / tifBins_sec)\n\t\tprint('tifBins_sec:', tifBins_sec, 'xNumBins:', xNumBins, 'tifSecondsPerLine:', tifSecondsPerLine)\n\t\t# make new x-axis with bins\n\t\txBins = [tifFirstFrameSeconds+(x*tifBins_sec) for x in range(xNumBins)]\n\n\t\t# if weights is None, will count LCR in each bin\n\t\t# if weight=ampl, will sum ampl for each LCRR in each bin\n\t\tweights = None\n\t\tweights = self.dr.dfSparkMaster['Ampl.']\n\n\t\t# plotted below\n\t\t#myHist,myBins = np.histogram(tPos_offset, weights=weights,\n\t\t#\t\t\t\t\t\t\tbins=xBins)\n\n\t\t#\n\t\t# plot\n\t\tnumPanels = 5\n\t\tfig, axs = plt.subplots(numPanels, 1, sharex=True)\n\t\tif numPanels == 1:\n\t\t\taxs = [axs]\n\t\tfig.canvas.mpl_connect('key_press_event', self.key_press_event)\n\t\tfig.canvas.mpl_connect('key_release_event', self.key_release_event)\n\t\tfig.canvas.mpl_connect('button_press_event', self.on_button_press_event)\n\t\tfig.canvas.mpl_connect('pick_event', self.onpick)\n\n\t\ttitleStr = str(self.region)\n\t\ttitleStr += ' ' + os.path.split(self.dr.abfTif.tifHeader['tif'])[1]\n\t\ttitleStr += ' self.tifBins_ms:' + str(self.tifBins_ms)\n\t\tfig.suptitle(titleStr)\n\n\t\t# ephys Vm\n\t\txVm = self.dr.abf.sweepX\n\t\tyVm = self.dr.abf.sweepY\n\t\taxs[0].plot(xVm, yVm, 'k')\n\t\taxs[0].set_ylabel('Vm (mV)')\n\n\t\t# sparkmaster over Vm\n\t\taxRight1 = axs[0].twinx() # instantiate a second axes that shares the same x-axis\n\t\taxRight1.plot(xSmStatSec, ySmStat, '.b')\n\t\t#axRight1.set_xlabel(xStatStr)\n\t\taxRight1.set_ylabel('SM ' + ySmStatStr)\n\n\t\t#\n\t\t# sum of each line scan\n\t\txLineScan = self.dr.abfTif.sweepX\n\t\tyLineScan = self.dr.abfTif.sweepY\n\t\taxs[1].plot(xLineScanSum, yLineScan, 'r')\n\t\taxs[1].set_ylabel('Ca Line Scan Sum')\n\n\t\t# sparkmaster over Ca Line Scan Sum\n\t\taxRight1 = axs[1].twinx() # instantiate a second axes that shares the same x-axis\n\t\taxRight1.plot(xSmStatSec, ySmStat2, '.b')\n\t\t#axRight1.set_xlabel(xStatStr)\n\t\taxRight1.set_ylabel('SM ' + ySmStatStr2)\n\n\t\t#\n\t\taxs[2].plot(xVm, yVm, '-k')\n\t\taxs[2].set_ylabel('Vm (mV)')\n\n\t\tself.axRight2 = axs[2].twinx() # instantiate a second axes that shares the same x-axis\n\t\t#axRight2.plot(xLineScanSum, yLineScanSum, '-r')\n\t\tn, bins, patches = self.axRight2.hist(tPos_offset, weights=weights,\n\t\t\t\t\t\t\t\t\tbins=xBins,\n\t\t\t\t\t\t\t\t\tfacecolor='k', histtype='step')\n\t\tif weights is None:\n\t\t\tself.axRight2.set_ylabel('SM LCR Count')\n\t\telse:\n\t\t\tself.axRight2.set_ylabel('SM LCR Weight (amp)')\n\t\t# once we mask out Ca++ in response to spikes\n\t\t# we do not need log plot !!!\n\t\t#axRight2.set_yscale('log')\n\n\t\t#\n\t\t# plot tif image overlaid with position of LCRs\n\t\tif 1:\n\t\t\tfirstFrameSeconds = self.dr.abfTif.tifHeader['firstFrameSeconds']\n\t\t\txMin = firstFrameSeconds\n\t\t\txMax = firstFrameSeconds + self.dr.abfTif.sweepX[-1]\n\t\t\tyMin = 0\n\t\t\tyMax = self.dr.abfTif.tifHeader['umLength'] #57.176\n\t\t\t#extent = [xMin, xMaxImage, yMax, yMin] # flipped y\n\t\t\textent = [xMin, xMax, yMin, yMax] # flipped y\n\t\t\taxs[3].imshow(self.dr.abfTif.tif, extent=extent, aspect='auto')\n\t\t\taxs[3].spines['right'].set_visible(False)\n\t\t\taxs[3].spines['top'].set_visible(False)\n\n\t\t\taxRight3 = axs[3].twinx() # instantiate a second axes that shares the same x-axis\n\t\t\taxRight3.plot(tPos_offset, xPos, '.r')\n\n\t\t#\n\t\t# plot analysis results, both (picked lcr) and (picked vm)\n\n\t\taxsLcrAnalysisLeft = axs[4]\n\t\tself.vmAnalysisLine2D, = axs[4].plot([], [], 'ob')\n\n\t\taxsLcrAnalysisRight = axs[4].twinx() # instantiate a second axes that shares the same x-axis\n\t\tself.lcrAnalysisLine2D, = axsLcrAnalysisRight.plot(self.dfAnalysis['lcrSec'],\n\t\t\t\t\t\t\t\tself.dfAnalysis['lcrSum'],\n\t\t\t\t\t\t\t\t'or',\n\t\t\t\t\t\t\t\tpicker=5)\n\t\tself.lcrAnalysisSelectionLine2D, = axsLcrAnalysisRight.plot([],\n\t\t\t\t\t\t\t\t[],\n\t\t\t\t\t\t\t\t'oy')\n\n\t\treturn fig, axs, tPos_offset, n, bins, axsLcrAnalysisLeft, axsLcrAnalysisRight","def plot_derivatives_divided(self, show=False):\n\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\n ax[2, 0].set_title('Difference between upper and lower training examples');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n ax[2, 0].legend(frameon=False)\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\n ax[2, 1].set_title('Difference between upper and lower test samples');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def changeFridge(self,*args):\n self.selectedADR = self.adrSelect.get()\n # clear temps plot\n self.stage60K.set_xdata([])\n self.stage60K.set_ydata([])\n self.stage03K.set_xdata([])\n self.stage03K.set_ydata([])\n self.stageGGG.set_xdata([])\n self.stageGGG.set_ydata([])\n self.stageFAA.set_xdata([])\n self.stageFAA.set_ydata([])\n # load saved temp data\n # We have to sleep for 0.5s here because it seems like it takes\n # a moment for the connected server to register in self.cxn, even\n # though all this starts because a message is received saying it\n # is connected :\\\n time.sleep(0.5)\n startDateTime = yield self.cxn[self.selectedADR].get_start_datetime()\n try:\n reg = self.cxn.registry\n yield reg.cd(ADR_SETTINGS_BASE_PATH + [self.selectedADR])\n logPath = yield reg.get('Log Path')\n tempDataChest = dataChest(logPath)\n ds = dateStamp()\n dset = '%s_temperatures'%ds.dateStamp(startDateTime.isoformat())\n tempDataChest.openDataset(dset)\n\n n = tempDataChest.getNumRows()\n # load approximately the last 6 hours of data\n pastTempData = tempDataChest.getData(max(0,n-6*60*60),None )\n for newRow in pastTempData:\n # change utc time to local\n utc = newRow[0] # (float)\n utc = datetime.datetime.utcfromtimestamp(utc)\n utc = utc.replace(tzinfo=tz.tzutc())\n newRow[0] = mpl.dates.date2num(utc)\n # add old data from file into plot\n self.stage60K.set_xdata(numpy.append(self.stage60K.get_xdata(),newRow[0]))\n self.stage60K.set_ydata(numpy.append(self.stage60K.get_ydata(),newRow[1]))\n self.stage03K.set_xdata(numpy.append(self.stage03K.get_xdata(),newRow[0]))\n self.stage03K.set_ydata(numpy.append(self.stage03K.get_ydata(),newRow[2]))\n self.stageGGG.set_xdata(numpy.append(self.stageGGG.get_xdata(),newRow[0]))\n self.stageGGG.set_ydata(numpy.append(self.stageGGG.get_ydata(),newRow[3]))\n self.stageFAA.set_xdata(numpy.append(self.stageFAA.get_xdata(),newRow[0]))\n self.stageFAA.set_ydata(numpy.append(self.stageFAA.get_ydata(),newRow[4]))\n except IOError:\n # file not created yet if adr server just opened\n print( 'temp file not created yet?' )\n self.updatePlot()\n # clear and reload last 20 messages of log\n self.log.clear()\n logMessages = yield self.cxn[self.selectedADR].get_log(20)\n for (t,m,a) in logMessages:\n self.updateLog(t,m,a)\n # update instrument status stuff: delete old, create new\n for widget in self.instrumentStatusFrame.winfo_children():\n widget.destroy()\n returnStatus = yield self.cxn[self.selectedADR].get_instrument_state()\n self.instrumentStatuses = {}\n for name,status in returnStatus:\n self.instrumentStatuses[name] = Tkinter.Label(self.instrumentStatusFrame,\n text=name,\n relief=Tkinter.RIDGE,\n bg='gray70')\n self.instrumentStatuses[name].pack(side=Tkinter.LEFT,\n expand=True,\n fill=Tkinter.X)\n # update field limits and button statuses\n self.setFieldLimits()\n self.magUpButton.configure(state=Tkinter.NORMAL)\n self.regulateButton.configure(state=Tkinter.NORMAL)\n self.compressorButton.configure(state=Tkinter.DISABLED)\n mUp = yield self.cxn[self.selectedADR].get_state_var('maggingUp')\n reg = yield self.cxn[self.selectedADR].get_state_var('regulating')\n if mUp:\n self.magUpButton.configure(text='Stop Magging Up',\n command=self.cancelMagUp)\n self.regulateButton.configure(state=Tkinter.DISABLED)\n if reg:\n self.regulateButton.configure(text='Stop Regulating',\n command=self.cancelRegulate)\n self.magUpButton.configure(state=Tkinter.DISABLED)\n # update heat switch buttons\n HSAvailable = yield self.cxn[self.selectedADR].get_instrument_state(['Heat Switch'])\n if HSAvailable[0][1][0]:\n self.HSCloseButton.configure(state=Tkinter.NORMAL)\n self.HSOpenButton.configure(state=Tkinter.NORMAL)\n else:\n self.HSCloseButton.configure(state=Tkinter.DISABLED)\n self.HSOpenButton.configure(state=Tkinter.DISABLED)\n # refresh interface\n self.updateInterface()","def update_plot(click, contents, filename, start_date, end_date, freq, window_length, mean_diff,\n max_diff, upper_ll, lower_ll, vardiff, slopedev):\n if click < 1:\n return\n\n # params = pd.read_json(params)\n # params = params.apply(pd.to_numeric)\n # params = params.sort_values('Run')\n\n window_length = int(window_length)\n mean_diff = float(mean_diff)\n max_diff = float(max_diff)\n upper_ll = float(upper_ll)\n lower_ll = float(lower_ll)\n slopedev = float(slopedev)\n vardiff = float(vardiff)\n\n\n df = utils.read_df(contents, filename)\n df = df[(df.index >= start_date) & (df.index <= end_date)]\n df = df[df.index.minute % freq == 0]\n is_clear, components, alpha = \\\n cs_utils.detect_clearsky(df['GHI'], df['GHIcs'], df.index,\n window_length=window_length, mean_diff=mean_diff,\n max_diff=max_diff, upper_line_length=upper_ll, lower_line_length=lower_ll,\n slope_dev=slopedev, var_diff=vardiff, return_components=True)\n\n df['GHIcs'] = df['GHIcs'] * alpha\n fig = tls.make_subplots(rows=2, cols=1, shared_xaxes=True)\n\n plots = []\n plots.append(go.Scatter(x=df.index, y=df['GHI'], name='GHI'))\n plots.append(go.Scatter(x=df.index, y=df['GHIcs'], name='GHIcs'))\n plots.append(go.Scatter(x=df[is_clear].index, y=df[is_clear]['GHI'], name='PVLib clear', mode='markers'))\n plots.append(go.Scatter(x=df.index, y=components['mean_diff'],\n name='Mean diff.', visible='legendonly'))\n plots.append(go.Scatter(x=df.index, y=components['max_diff'],\n name='Max diff.', visible='legendonly'))\n plots.append(go.Scatter(x=df.index, y=components['line_length'],\n name='Line length', visible='legendonly'))\n plots.append(go.Scatter(x=df.index, y=components['slope_nstd'],\n name='Slope std. dev.', visible='legendonly'))\n plots.append(go.Scatter(x=df.index, y=components['slope_max'],\n name='Max slope diff.', visible='legendonly'))\n\n for p in plots:\n fig.append_trace(p, 1, 1)\n\n plots2 = []\n passes = pd.DataFrame(components)\n for i, test in enumerate(['mean_diff_pass', 'max_diff_pass', 'line_length_pass',\n 'slope_nstd_pass', 'slope_max_pass']):\n slice = passes[test].astype(int)\n ii = i / 4\n yval = [ii] * len(slice.astype(bool) & passes['non_zero'].astype(bool))\n plots2.append(\n go.Scatter(x=df.index[:len(slice)][slice.astype(bool) & passes['non_zero'].astype(bool)],\n y=yval, name='', mode='markers', showlegend=False)\n )\n\n for p in plots2:\n fig.append_trace(p, 2, 1)\n\n fig['layout']['yaxis2'].update(tickmode='text', tickvals=[0, .25, .5, .75, 1],\n ticktext=['Mean diff.', 'Max diff.', 'Line length',\n 'Slope std. dev.', 'Max slope diff.'])\n fig['layout']['xaxis2'].update(title='Date')\n fig['layout']['yaxis2'].update(domain=[0, 0.2])\n fig['layout']['yaxis1'].update(title='GHI / W/m2')\n fig['layout']['yaxis1'].update(domain=[.25, 1])\n fig['layout'].update(height=500, margin={'l': 100})\n fig['layout'].update(title='Window length: {}, mean diff: {}, max diff: {}, upper line length: {}, '\n 'lower line length: {}, max slope difference: {}, std slope differece: {}'\n .format(window_length, mean_diff, max_diff, upper_ll, lower_ll, slopedev, vardiff))\n\n plots = fig\n\n layout = go.Layout(xaxis={'title': 'Date'}, # yaxis={'title': 'W/m2'},\n title='Window length: {}, mean diff: {}, max diff: {}, upper line length: {}, '\n 'lower line length: {}, max slope difference: {}, std slope differece: {}'\n .format(window_length, mean_diff, max_diff, upper_ll, lower_ll, slopedev, vardiff),\n )\n ts_plot = dcc.Graph(id='cs-plot', figure={'data': plots, 'layout': layout})\n\n # scores = [go.Scatter(x=list(range(len(params))),\n # y=params['F-score'],\n # text=utils.df_to_text(params), hoverinfo='text')]\n # scores_layout = go.Layout(xaxis={'title': 'Run', 'tickvals': [i for i in range(1, len(params))],\n # 'ticktext': [str(i + 1) for i in range(1, len(params))],\n # 'range': [0, len(params)]}, yaxis={'title': 'F-score'})\n # scores_plot = dcc.Graph(id='cs-scores', figure={'data': scores, 'layout': scores_layout})\n #\n # table = dt.DataTable(\n # rows=params[['Run', 'Window length', 'Mean difference', 'Max difference',\n # 'Upper line length', 'Lower line length', 'Variance of slopes',\n # 'Max difference of slopes', 'F-score']].round(3).to_dict('records'),\n # columns=['Run', 'Window length', 'Mean difference', 'Max difference',\n # 'Upper line length', 'Lower line length', 'Variance of slopes',\n # 'Max difference of slopes', 'F-score'],\n # selected_row_indices=[],\n # sortable=True,\n # filterable=True,\n # editable=False,\n # id='cs-param_table'\n # )\n\n final = html.Div([\n html.Div(ts_plot)\n ], style={'width': '98%', 'float': 'center', 'pad': {'l': 40}})\n\n return final","def plot(self,displayplt = True,saveplt = False,savepath=''):\n figure1 = plt.figure()\n axa = figure1.add_subplot(2, 1, 1)\n sensitivity =hyd_calibration_multiple_freq(self.cfreq)\n pnp = -1e-6 * np.min(self.hydoutput, axis=1) / sensitivity\n figure2 = axa.plot(self.cfreq, pnp, 'x')\n axa.set_title('Frequency Sweep')\n plt.xlabel('Frequency (MHz)')\n plt.ylabel('Peak Negative Pressure (MPa)')\n axb = figure1.add_subplot(2, 1, 2)\n mi_fs = pnp / np.sqrt(self.cfreq)\n figure4 = axb.plot(self.cfreq, mi_fs, 'x')\n plt.xlabel('Frequency (MHz)')\n plt.ylabel('MI')\n if displayplt:\n plt.show()\n if saveplt:\n if savepath == '':\n # prompt for a save path using a default filename\n defaultfn = self.txdr + '_' + self.collectiondate + '_' + self.collectiontime + '_freqsweep.png'\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\n plt.savefig(savepath)\n return figure1, savepath","def plot_step_details(df1, df2, rxn, detail):\n a1, a2 = df1.align(df2, join='outer', axis=0)\n x_list = [row[detail] for row in a1[rxn]]\n y_list = [row[detail] for row in a2[rxn]]\n comparison_plot(x_list, y_list, f'{rxn} {detail}')","def test_2d_plot(self):\n db = pd.HDFStore('test.h5')\n df_iv = db['iv']\n dates = df_iv[df_iv['dte'] == 30]['date']\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\n db.close()\n\n print df_iv.sort_values('impl_vol').head()\n\n plt.plot(dates, impl_vols)\n plt.xlabel('date')\n plt.ylabel('impl_vols')\n plt.show()","def _rfigure(self, legend=True, fig=None, ax=None):\n if fig is None and ax is None:\n fig, ax = plt.subplots()\n suptitle = True\n elif fig is None:\n fig = ax.get_figure()\n suptitle = False\n elif ax is None:\n ax = fig.gca()\n suptitle = False\n\n ax.grid(True)\n\n line_rstr = None\n line_rrls = None\n line_lstr = None\n line_lrls = None\n line_minima = None\n line_maxima = None\n t = self.timevector\n for axis, trace in zip('xy', ['positionX', 'positionY']):\n s = self.get_data(traces=trace) * 1e6 # m -> µm\n r_str_rls = self.stress_release_pairs(axis=axis, direction='right')\n l_str_rls = self.stress_release_pairs(axis=axis, direction='left')\n rstr = r_str_rls['stress']['idx']\n lstr = l_str_rls['stress']['idx']\n rrls = r_str_rls['release']['idx']\n lrls = l_str_rls['release']['idx']\n\n ax.plot(t, s, lw=0.1, ms=2, color='k', alpha=1.0)\n\n # line_rstr = None\n # line_rrls = None\n # line_lstr = None\n # line_lrls = None\n for rstr, rrls in zip(rstr, rrls):\n line_rstr, = ax.plot(t[rstr], s[rstr], lw=0.4, ms=2, color='m')\n line_rrls, = ax.plot(t[rrls], s[rrls], lw=0.4, ms=2, color='c')\n for lstr, lrls in zip(lstr, lrls):\n line_lstr, = ax.plot(t[lstr], s[lstr], lw=0.4, ms=2, color='g')\n line_lrls, = ax.plot(t[lrls], s[lrls], lw=0.4, ms=2, color='y')\n\n # line_minima = None\n # line_maxima = None\n for segment in self._sf.sections[axis]:\n minima = self.undecimate_and_limit(segment['minima'])\n maxima = self.undecimate_and_limit(segment['maxima'])\n line_minima, = ax.plot(t[minima], s[minima], '.', ms=5,\n color='b')\n line_maxima, = ax.plot(t[maxima], s[maxima], '.', ms=5,\n color='r')\n\n line_excited_x = None\n for x_c in (self.undecimate_and_limit(self._sf.excited['x'])\n / self.resolution):\n line_excited_x = ax.hlines(0.0, x_c[0], x_c[1], alpha=1,\n colors='b', linestyle='solid', lw=1)\n # ax.plot(x_c[0], 0.5, '.k', alpha=1, ms=3)\n # ax.plot(x_c[1], 0.5, '.k', alpha=1, ms=3)\n ax.vlines(x_c[0], -0.01, 0.01, alpha=1, colors='b',\n linestyle='solid', lw=1)\n ax.vlines(x_c[1], -0.01, 0.01, alpha=1, colors='b',\n linestyle='solid', lw=1)\n\n line_excited_y = None\n for y_c in (self.undecimate_and_limit(self._sf.excited['y'])\n / self.resolution):\n line_excited_y = ax.hlines(0.0, y_c[0], y_c[1], alpha=1,\n colors='r', linestyle='solid', lw=1)\n # ax.plot(y_c[0], -0.5, '.k', alpha=1, ms=3)\n # ax.plot(y_c[1], -0.5, '.k', alpha=1, ms=3)\n ax.vlines(y_c[0], -0.01, 0.01, alpha=1, colors='r',\n linestyle='solid', lw=1)\n ax.vlines(y_c[1], -0.01, 0.01, alpha=1, colors='r',\n linestyle='solid', lw=1)\n\n ax.set_xlim((t[0], t[-1]))\n\n ax.set_xlabel(\"Time (s)\")\n ax.set_ylabel(\"Signal positionX and Y (µm)\")\n if suptitle:\n fig.suptitle(\"Automatically detected excited axis, minima, \"\n \"maxima, and sections.\")\n\n if legend:\n if line_minima is not None:\n line_minima.set_label('minima')\n if line_maxima is not None:\n line_maxima.set_label('maxima')\n if line_rstr is not None:\n line_rstr.set_label('rightstress')\n if line_rrls is not None:\n line_rrls.set_label('rightrelease')\n if line_lstr is not None:\n line_lstr.set_label('leftstress')\n if line_lrls is not None:\n line_lrls.set_label('leftrelease')\n if line_excited_x is not None:\n line_excited_x.set_label('excited x')\n if line_excited_y is not None:\n line_excited_y.set_label('excited y')\n\n ax.legend(loc='upper right')\n\n return fig","def plot_figure3(df, left_colNames, right_colNames, dvmin=-100, dvmax=101, step=20, show=False, write_to=None):\n\t#select left values and right values\n\tleft = df[left_colNames]\n\tright = df[right_colNames]\n\t# 'diff' column: sum(left) - sum(right)\n\tlr_diff = pd.DataFrame({'diff': left.sum(axis=1)-right.sum(axis=1)})\n\t# 'side_chosen': 0 left, 1 right \n\t# 'choice': 1 chose left, 0 chose right. Flipped 'side_chosen' column, b/c we will count the frequency of choosing left\n\tlr_diff['choice'] = np.logical_xor(df['side_chosen'],1).astype(int)\n\t# sort diff from lowest to highest, and group into buckets\n\tlr_diff = lr_diff.sort_values(by=['diff'], ascending=True)\n\t#array of prob(choosing left) for each bucket\n\tgrouped = group(lr_diff, dvmin, dvmax, step)\n\n\t#plot data\n\ty = np.array(grouped)\n\tx = np.array([x for x in range(dvmin, dvmax, step)])\n\tif show:\n\t\tfig = go.Figure()\n\t\tfig.add_trace(go.Scatter(x=x, y=y, name=\"linear\", line_shape='linear'))\n\t\tfig.show()\n\tif write_to is not None:\n\t\tfig.write_image(write_to)\n\treturn x, y","def SavingAndPlottingAfterRecursive(self):\n\n\n #Starting points of events in sec.\n startpoints=self.AnalysisResults[self.sig]['StartPoints']\n\n #Ending points of events in sec.\n endpoints=self.AnalysisResults[self.sig]['EndPoints']\n\n #Total number of events\n numberofevents=self.AnalysisResults[self.sig]['NumberOfEvents']\n\n #Current drop in nA\n deli=self.AnalysisResults[self.sig]['DeltaI']\n\n #end[i] - start[i] in sec.\n dwell=self.AnalysisResults[self.sig]['DwellTime']\n\n #current drop / current at start \n frac=self.AnalysisResults[self.sig]['FractionalCurrentDrop']\n\n #start[i+1] - start[i] in sec.\n dt=self.AnalysisResults[self.sig]['Frequency']\n\n #start[i+1] - start[i] in sec.\n localBaseline=self.AnalysisResults[self.sig]['LocalBaseline']\n\n # If plotting takes too much time: \"Don_t_plot...\" the graph will be deleted\n if not self.ui.actionDon_t_Plot_if_slow.isChecked():\n #clear signal plot\n self.p1.clear()\n # Event detection plot, Signal Plot\n self.p1.plot(self.t, self.data[self.sig], pen='b')\n # Draw green circles indicating start of event\n self.p1.plot(self.t[startpoints], self.data[self.sig][startpoints], pen=None, symbol='o', symbolBrush='g', symbolSize=10)\n # Draw red circles indicating end of event\n self.p1.plot(self.t[endpoints], self.data[self.sig][endpoints], pen=None, symbol='o', symbolBrush='r', symbolSize=10)\n #self.p1.plot(self.t[startpoints-10], localBaseline, pen=None, symbol='x', symbolBrush='y', symbolSize=10)\n \n # choice only data for current file name\n try:\n self.p2.data = self.p2.data[np.where(np.array(self.sdf.fn) != self.matfilename)]\n except:\n IndexError\n #Data frame for event info storage\n self.sdf = self.sdf[self.sdf.fn != self.matfilename]\n \n #Panda series with file name of data loaded (without ending .dat or some other) \n #repeated numberofevents times\n fn = pd.Series([self.matfilename, ] * numberofevents)\n \n #Same color identification repeated numberofevents\n color = pd.Series([self.cb.color(), ] * numberofevents)\n \n self.sdf = self.sdf.append(pd.DataFrame({'fn': fn, 'color': color, 'deli': deli,\n 'frac': frac, 'dwell': dwell,\n 'dt': dt, 'startpoints': startpoints,\n 'endpoints': endpoints, 'baseline': localBaseline}), ignore_index=True)\n \n # Create Scatter plot with\n # x = log10(dwell)\n # y = current drop / current at start\n #self.p2.addPoints(x=np.log10(dwell), y=frac, symbol='o', brush=(self.cb.color()), pen=None, size=10)\n self.p2.addPoints(x=dwell, y=frac,\n symbol='o', brush=(self.cb.color()), pen=None, size=10)\n self.w1.addItem(self.p2)\n self.w1.setLogMode(x=False, y=False)\n self.p1.autoRange()\n self.w1.autoRange()\n self.ui.scatterplot.update() # Replot Scatter plot\n # Set y - axis range\n self.w1.setRange(yRange=[0, 1])\n \n # Pandas series of colors. \n colors = self.sdf.color\n # If we have data from different experiments and different analyte\n # we can change the color for them \n for i, x in enumerate(colors):\n\n # Preparation for distribution histogram of fraction. Different color\n # Corresponds to different experiments\n # For better undarstanding see Feng et. al Indentification of single nucliotides\n # in MoS2 nanopores - different nucliotides for different colors \n # frac = current drop / current at start \n fracy, fracx = np.histogram(self.sdf.frac[self.sdf.color == x],\n bins=np.linspace(0, 1, int(self.ui.fracbins.text())))\n # Create pyqtgraph hist of Fraction data\n hist = pg.PlotCurveItem(fracx, fracy , stepMode = True, \n fillLevel=0, brush = x, pen = 'k') \n #Plot Frac histogram \n self.w2.addItem(hist) \n \n\n # Preparation for distribution histogram of Current drop in nA.\n # Idea of color choice is the same as in histogram above.\n deliy, delix = np.histogram(self.sdf.deli[self.sdf.color == x], \n bins=np.linspace(float(self.ui.delirange0.text()) *1e-9, \n float(self.ui.delirange1.text()) * 1e-9, \n int(self.ui.delibins.text())))\n # Create pyqtgraph hist of Deli data\n #hist = pg.BarGraphItem(height=deliy, x0=delix[:-1], x1=delix[1:], brush=x)\n hist = pg.PlotCurveItem(delix, deliy , stepMode = True, \n fillLevel=0, brush = x, pen = 'k')\n self.w3.addItem(hist) #Deli histogram plot\n self.w3.setRange(xRange=[float(self.ui.delirange0.text()) * 10 ** -9,\n float(self.ui.delirange1.text()) * 10 ** -9])\n \n # Preparation for distribution histogram of length of events expressed as\n # end[i] - start[i] in sec..\n # Idea of color choice is the same as in histogram above.\n #linspace for bins\n print('dwell = ' + str(self.sdf.dwell))\n bins_dwell = np.linspace(float(self.ui.dwellrange0.text()) * 1e-6, \n float(self.ui.dwellrange1.text()) * 1e-6, \n int(self.ui.dwellbins.text()))\n\n dwelly, dwellx = np.histogram((self.sdf.dwell[self.sdf.color == x]),\n bins=bins_dwell,range=(bins_dwell.min(),\n bins_dwell.max()))\n hist = pg.PlotCurveItem(dwellx, dwelly , stepMode = True, \n fillLevel=0, brush = x, pen = 'k')\n self.w4.addItem(hist)\n\n \n # Preparation for distribution histogram of start[i+1] - start[i] in sec. \n # \"Frequency\" of events expressed as\n # Idea of color choice is the same as in histogram above.\n\n dty, dtx = np.histogram(self.sdf.dt[self.sdf.color == x],\n bins=np.linspace(float(self.ui.dtrange0.text()), \n float(self.ui.dtrange1.text()),\n int(self.ui.dtbins.text())))\n hist = pg.PlotCurveItem(dtx, dty , stepMode = True, \n fillLevel=0, brush = x, pen = 'k')\n self.w5.addItem(hist) #Dt histogram plot","def plotting(dataframe, prod_num):\n fig, axs = plt.subplots(2, sharex=True)\n axs[0].plot(dataframe['STU'])\n axs[1].plot(dataframe['STU'].diff().dropna())\n axs[0].set_title(\"Time Series of Product\" + f\"_{prod_num}\")\n axs[1].set_title(\"Differenced Time Series of Product\" + f\"_{prod_num}\")\n plt.savefig(\"Time Series of Product\" + f\"_{prod_num}\" + \".pdf\")","def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\n plt.figure()\n\n #legacy beamprofile data is a 1-D array of the peak negative pressure\n pnp = self.pnp\n\n if dbdown:\n pnp = 20.0*np.log10(pnp/np.max(pnp))\n else:\n pnp = pnp*1e-6\n\n if polarplt:\n figure1 = plt.polar(self.angle * np.pi / 180.0, pnp)\n else:\n figure1 = plt.plot(self.angle, pnp)\n #the latest beamprofile data should be a 2-D array of the hydrophone output\n plt.xlabel('Angle (degrees)')\n if dbdown:\n plt.ylabel('Peak Negative Pressure (dB Max)')\n else:\n plt.ylabel('Peak Negative Pressure (MPa)')\n plt.title(self.txdr)\n if displayplt:\n plt.show()\n if saveplt:\n if savepath=='':\n #prompt for a save path using a default filename\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_beamprofile.png'\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\n plt.savefig(savepath)\n return figure1, savepath","def plot(\n self,\n group_delay=False,\n slce=None,\n flim=None,\n dblim=None,\n tlim=None,\n grpdlim=None,\n dbref=1,\n show=False,\n use_fig=None,\n label=None,\n unwrap_phase=False,\n logf=True,\n third_oct_f=True,\n plot_kw={},\n **fig_kw,\n ):\n if use_fig is None:\n fig_kw = {**{\"figsize\": (10, 10)}, **fig_kw}\n fig, axes = plt.subplots(nrows=3, constrained_layout=True, **fig_kw)\n else:\n fig = use_fig\n axes = fig.axes\n\n self.plot_magnitude(\n use_ax=axes[0],\n slce=slce,\n dblim=dblim,\n flim=flim,\n dbref=dbref,\n label=label,\n plot_kw=plot_kw,\n logf=logf,\n third_oct_f=third_oct_f,\n )\n if group_delay:\n self.plot_group_delay(\n use_ax=axes[1],\n slce=slce,\n flim=flim,\n ylim=grpdlim,\n plot_kw=plot_kw,\n logf=logf,\n third_oct_f=third_oct_f,\n )\n else:\n self.plot_phase(\n use_ax=axes[1],\n slce=slce,\n flim=flim,\n plot_kw=plot_kw,\n unwrap=unwrap_phase,\n logf=logf,\n third_oct_f=third_oct_f,\n )\n self.plot_time(\n use_ax=axes[2], tlim=tlim, slce=slce, plot_kw=plot_kw\n )\n\n if show:\n plt.show()\n\n return fig","def fig_TF(f, day_trfs, day_list, sta_trfs, sta_list, skey=''):\n\n import matplotlib.ticker as mtick\n\n # Extract only positive frequencies\n faxis = f > 0\n\n # Get max number of TFs to plot\n ntf = max(sum(day_list.values()), sum(sta_list.values()))\n\n # Define all possible compbinations\n tf_list = {'ZP': True, 'Z1': True, 'Z2-1': True,\n 'ZP-21': True, 'ZH': True, 'ZP-H': True}\n\n if ntf == 1:\n fig = plt.figure(figsize=(6, 1.75))\n else:\n fig = plt.figure(figsize=(6, 1.33333333*ntf))\n\n j = 1\n for key in tf_list:\n\n if not day_list[key] and not sta_list[key]:\n continue\n\n ax = fig.add_subplot(ntf, 1, j)\n\n if day_list[key]:\n for i in range(len(day_trfs)):\n ax.loglog(\n f[faxis],\n np.abs(day_trfs[i][key]['TF_'+key][faxis]),\n 'gray', lw=0.5)\n if sta_list[key]:\n ax.loglog(\n f[faxis],\n np.abs(sta_trfs[key]['TF_'+key][faxis]),\n 'k', lw=0.5)\n if key == 'ZP':\n ax.set_ylim(1.e-20, 1.e0)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: ZP',\n fontdict={'fontsize': 8})\n elif key == 'Z1':\n ax.set_ylim(1.e-5, 1.e5)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: Z1',\n fontdict={'fontsize': 8})\n elif key == 'Z2-1':\n ax.set_ylim(1.e-5, 1.e5)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: Z2-1',\n fontdict={'fontsize': 8})\n elif key == 'ZP-21':\n ax.set_ylim(1.e-20, 1.e0)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: ZP-21',\n fontdict={'fontsize': 8})\n elif key == 'ZH':\n ax.set_ylim(1.e-10, 1.e10)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: ZH',\n fontdict={'fontsize': 8})\n elif key == 'ZP-H':\n ax.set_ylim(1.e-20, 1.e0)\n ax.set_xlim(1.e-4, 2.5)\n ax.set_title(skey+' Transfer Function: ZP-H',\n fontdict={'fontsize': 8})\n\n j += 1\n\n ax.set_xlabel('Frequency (Hz)')\n plt.tight_layout()\n\n return plt","def show(self, show_figure=True, filename=None):\n # Create phase dictionary\n phase_series = self._create_phases()\n if not show_figure:\n return phase_series\n phase_dict = phase_series.to_dict()\n # Curve fitting\n nested = [\n self._curve_fitting(phase, info)\n for (phase, info) in phase_dict.items()\n ]\n df_list, vlines = zip(*nested)\n comp_df = pd.concat([self.sr_df, *df_list], axis=1)\n comp_df = comp_df.rename({self.S: f\"{self.S}{self.A}\"}, axis=1)\n comp_df = comp_df.apply(\n lambda x: pd.to_numeric(x, errors=\"coerce\", downcast=\"integer\"),\n axis=0\n )\n # Show figure\n pred_cols = [\n col for col in comp_df.columns if col.endswith(self.P)\n ]\n if len(pred_cols) == 1:\n title = f\"{self.area}: S-R trend without change points\"\n else:\n _list = self._change_dates[:]\n strings = [\n \", \".join(_list[i: i + 6]) for i in range(0, len(_list), 6)\n ]\n change_str = \",\\n\".join(strings)\n title = f\"{self.area}: S-R trend changed on\\n{change_str}\"\n Trend.show_with_many(\n result_df=comp_df,\n predicted_cols=pred_cols,\n title=title,\n vlines=vlines[1:],\n filename=filename\n )\n return phase_series","def display_feds(list1, list2):\n if len(list1) != len(list2):\n print(\"In display_feds: lists must be of the same length\")\n return \n fig = plt.figure(dpi=128, figsize=(10, 6))\n fed_list_answer = fed_list(list1, list2)\n plt.plot(range(len(fed_list_answer)), fed_list_answer, c='red', alpha=0.5)\n \n plt.title(\"Feature edit distances between corresponding pairs\", fontsize = 24)\n plt.xlabel('', fontsize =16)\n #fig.autofmt_xdate()\n plt.ylabel(\"Distance\", fontsize =16)\n plt.tick_params(axis='both', which = 'major', labelsize=16)\n\n plt.show()","def figure_2():\n from matplotlib.animation import FuncAnimation\n from collections import OrderedDict\n\n plt.rc(\"font\", **{\n \"family\": \"sans-serif\",\n \"sans-serif\": [\"Helvetica\"],\n })\n plt.rc(\"text\", usetex=True)\n plt.rc(\"lines\", linewidth=1)\n plt.rc(\"axes\", grid=True)\n plt.rc(\"grid\", linestyle=\"--\", alpha=0.8)\n\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n exp_list.remove(\"mrac-nullagent\")\n\n data = {exp: get_data(exp) for exp in exp_list}\n\n fig, ax = plt.subplots(figsize=[16, 9])\n plt.xlabel(\"Time, sec\")\n\n linekw = dict(linewidth=1, alpha=0.3)\n\n def make_line(label, *args):\n ln, = plt.plot([], [], label=label, *args, **linekw)\n return ln\n\n time_list = [data[exp][\"time\"] for exp in exp_list]\n time = time_list[np.argmin(list(map(len, time_list)))]\n lines = [\n (\n make_line(\"Command\", \"k--\"),\n data[\"fecmrac-nullagent\"][\"cmd\"]\n ),\n (\n make_line(r\"$x_{r,1}$\", \"k\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"reference_system\"][:, 0]\n ),\n (\n make_line(r\"$x_{r,2}$\", \"k\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"reference_system\"][:, 1]\n ),\n (\n make_line(r\"FE-CMRAC $x_{1}$\", \"r-.\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(r\"FE-CMRAC $x_{2}$\", \"r-.\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"main_system\"][:, 1],\n ),\n (\n make_line(r\"RL-CMRAC $x_{1}$\", \"b-.\"),\n data[\"rlcmrac-sac\"][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(r\"RL-CMRAC $x_{2}$\", \"b-.\"),\n data[\"rlcmrac-sac\"][\"state\"][\"main_system\"][:, 1],\n ),\n ]\n\n dist_lines = {\n \"rlcmrac-sac\": plt.vlines(\n [], [], [],\n colors=FORMATTING[\"rlcmrac-sac\"][\"color\"],\n alpha=1,\n label=\"RL-CMRAC\",\n ),\n \"fecmrac-nullagent\": plt.vlines(\n [], [], [],\n colors=FORMATTING[\"fecmrac-nullagent\"][\"color\"],\n alpha=1,\n label=\"FE-CMRAC\",\n ),\n }\n memory_time_diff = np.diff(data[\"fecmrac-nullagent\"][\"memory\"][\"time\"])\n\n plt.legend(handles=dist_lines.values())\n\n def to_segments(xs, ys):\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\n\n def init():\n states = np.hstack([\n data[exp][\"state\"][\"main_system\"].ravel() for exp in exp_list\n ])\n ylim_max = states.max()\n ylim_min = states.min()\n ylim_btw = 1.2 * (ylim_max - ylim_min)\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\n\n ax.set_xlim(0, time[-1])\n ax.set_ylim(ylim_min, ylim_max)\n return [line for line, _ in lines] + list(dist_lines.values())\n\n def update(frame):\n for line, line_data in lines:\n line.set_data(time[:frame], line_data[:frame])\n\n # Update FE-CMRAC\n if frame > 0 and memory_time_diff[frame-1] != 0:\n ta_idx = np.argmax(\n time > data[\"fecmrac-nullagent\"][\"memory\"][\"time\"][frame]\n )\n dist_time = time[:ta_idx]\n dist_k = data[\"fecmrac-nullagent\"][\"k\"][:ta_idx]\n dist = [\n -np.exp(-np.trapz(dist_k[i:], dist_time[i:]))\n for i in range(len(dist_time))\n ]\n segments = to_segments(dist_time, dist)\n dist_lines[\"fecmrac-nullagent\"].set_segments(segments)\n\n # Update RL-CMRAC\n dist_time = data[\"rlcmrac-sac\"][\"memory\"][\"t\"][frame]\n dist = 100 * data[\"rlcmrac-sac\"][\"dist\"][frame]\n segments = to_segments(dist_time, dist)\n dist_lines[\"rlcmrac-sac\"].set_segments(segments)\n return [line for line, _ in lines] + list(dist_lines.values())\n\n anim = FuncAnimation(\n fig, update, init_func=init,\n frames=range(0, len(time), 10), interval=10\n )\n # plt.show()\n anim.save(os.path.join(args.save_dir, \"dist-movie.mp4\"))","def problemFive(self):\n # Initialize plot\n plot_5 = plt.figure(figsize=(15, 8))\n plot_5.subplots_adjust(left=.06, right=.95, top=.95, bottom=.08)\n fft = plot_5.add_subplot(1, 1, 1)\n plt.tick_params(labelsize=14)\n fft.set_xlabel('Frequency [Hz]', fontsize=20)\n fft.set_ylabel('FFT Amplitude [Vrms]', fontsize=20)\n fft.set_xlim([0, 1000])\n fft.grid(linewidth=0.5, color='gray', linestyle='--')\n # Get data from files and plot\n dub_slash = r'\\\\'\n data_text = 'V Infinity (m/s), Reynolds Number, Peak Vortex Amplitude (Vrms), ' \\\n 'Frequency at Peak Amplitude (Hz), Strouhal Number'\n latex_text = f'\\t\\hline\\n\\t$U_inf$ [m/s] & Peak Vortex Amp. [Vrms] & ' \\\n f'Freq. at Peak Amp. [Hz] & $Re$ & $St$ {dub_slash} \\hline'\n peak_a_list, peak_f_list = [], []\n for file_loc in self.fft_filenames:\n file = os.path.basename(file_loc).replace('.csv', '')\n index = self.fft_filenames.index(file_loc)\n amplitude = self.fft_data[file]['amplitude'].tolist()\n frequency = self.fft_data[file]['frequency'].tolist()\n v_inf = int(file)\n # Plot data\n fft.plot(frequency, amplitude, color=self.plot_color[index], linewidth=1.5, label=f'{file} m/s')\n # Calculate Reynolds number\n mu = (self.b * self.atm_temp**(3/2)) / (self.atm_temp + self.S)\n Re = (self.atm_density * (self.cylinder_diam/1000) * v_inf)/mu\n # Find peak frequency\n peak_f, peak_a = 0, 0\n for i in range(0, len(frequency)-1):\n a0 = amplitude[i]\n a1 = amplitude[i+1]\n f0 = frequency[i]\n f1 = frequency[i+1]\n slope = (a1 - a0)/(f1 - f0)\n if slope >= 0 and f0 >= 50 and a1 >= peak_a:\n peak_f = f1\n peak_a = a1\n peak_a_list.append(peak_a)\n peak_f_list.append(peak_f)\n # Calc Strouhal number\n strouhal = (peak_f * (self.cylinder_diam/1000))/v_inf\n # Save data to text\n data_text += f'\\n{v_inf}, {round(Re, 5)}, {round(peak_a, 4)}, {round(peak_f, 5)}, {round(strouhal, 5)}'\n latex_text += f'\\n\\t{v_inf} & {round(peak_a, 4)} & {round(peak_f, 5)} & {int(Re)} & {round(strouhal, 5)} {dub_slash} \\hline'\n fft.scatter(peak_f_list, peak_a_list, edgecolors='k', facecolors='none', s=40, label='Peak Vortex Shedding Freq.')\n # Save data_text file\n with open('problem5_data.csv', 'wt') as f:\n f.write(data_text)\n fft.legend(loc='upper right', fontsize=16)\n plot_5.savefig(os.path.join(os.getcwd(), r'plots\\prob5'))\n plt.draw()\n print(latex_text)","def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\n # sum things up across binaries\n total_formation_rate = np.sum(formation_rate, axis=0)\n total_merger_rate = np.sum(merger_rate, axis=0)\n total_detection_rate = np.sum(detection_rate, axis=0)\n \n # and across redshifts\n cumulative_detection_rate = np.cumsum(total_detection_rate)\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\n\n ###########################\n #Start plotting\n\n # set some constants for the plots\n plt.rc('font', family='serif')\n fs = 20\n lw = 3\n\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\n\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\n axes[0,0].set_ylabel(r'Formation rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\n axes[0,1].set_ylabel(r'Merger rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\n axes[1,1].set_xlabel(r'Chirp mass, $\\mathcal{M}_c$', fontsize=fs)\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}\\mathcal{M}_c \\mathrm{d}yr}]$', fontsize=fs)\n\n #########################\n #Plotvalues\n\n # Add text upper left corner\n axes[0,0].text(0.05,0.8, \"mu0=%s \\nmuz=%s \\nsigma0=%s \\nsigmaz=%s \\nalpha=%s\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \n\n for ax in axes.flatten():\n ax.tick_params(labelsize=0.9*fs)\n\n # Save and show :)\n plt.savefig(save_dir +'Rate_Info'+\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \n if show_plot:\n plt.show()\n else:\n plt.close()","def updatePlot(self,*args):\n # set x limits\n timeDisplayOptions = {'10 minutes':10,'1 hour':60,'6 hours':6*60,'24 hours':24*60,'All':0}\n try:\n lastDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[-1])\n firstDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[0])\n except IndexError: # no data yet\n now = datetime.datetime.utcnow().toordinal()\n firstDatetime = mpl.dates.num2date(now)\n lastDatetime = firstDatetime\n xMin = lastDatetime-datetime.timedelta(minutes=timeDisplayOptions[self.wScale.get()])\n xMin = max([ firstDatetime, xMin ])\n if self.wScale.get() == 'All':\n xMin = firstDatetime\n xMinIndex = numpy.searchsorted( self.stage60K.get_xdata(), mpl.dates.date2num(xMin) )\n # rescale axes, with the x being scaled by the slider\n if self.toolbar._active == 'HOME' or self.toolbar._active == None:\n ymin,ymax = 10000000, -10000000\n lineAndVar = { self.stage60K: self.t60K,\n self.stage03K: self.t3K,\n self.stageGGG: self.tGGG,\n self.stageFAA: self.tFAA }\n if len(self.stage60K.get_xdata()) > 1:\n for line in lineAndVar.keys():\n if lineAndVar[line].get() == 0:\n line.set_visible(False)\n else:\n line.set_visible(True)\n ydata = line.get_ydata()[xMinIndex:-1]\n try:\n ymin = min(ymin, numpy.nanmin(ydata))\n ymax = max(ymax, numpy.nanmax(ydata))\n except ValueError as e:\n pass\n self.ax.set_xlim(xMin,lastDatetime)\n self.ax.set_ylim(ymin - (ymax-ymin)/10, ymax + (ymax-ymin)/10)\n hfmt = mpl.dates.DateFormatter('%H:%M:%S', tz=tz.tzlocal())\n self.ax.xaxis.set_major_formatter(hfmt)\n self.fig.autofmt_xdate()\n self.fig.tight_layout()\n #draw\n self.canvas.draw()","def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\n \n # Variables assignment\n t_fcs = data_fcs[:,0]\n delta_a = data_fcs[:,18]\n delta_e = data_fcs[:,6]\n delta_r = data_fcs[:,9]\n delta_t = data_fcs[:,20]\n \n t_vel = data_vel[:,0]\n p_rad = data_vel[:,4]\n q_rad = data_vel[:,5]\n r_rad = data_vel[:,6]\n \n t_att = data_att[:,0]\n phi_rad = data_att[:,1]\n the_rad = data_att[:,2]\n psi_rad = data_att[:,3]\n \n fig = plt.figure(figsize=(12.3,15))\n \n \n # Commands\n ax1a = fig.add_subplot(3,1,1)\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\delta_a$')\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\delta_e$')\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\delta_r$')\n \n ax1a.set_title(\"Commands\") \n ax1a.set_xlabel(r'$t$ (s)')\n ax1a.set_ylabel(r'$\\delta_a$ , $\\delta_e$ , $\\delta_r$ (°)')\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\n \n \n ax1b = ax1a.twinx()\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\delta_t$')\n \n ax1b.set_ylabel(r'$\\delta_t$')\n ax1b.set_ylim(ymax=1, ymin=-0.05)\n \n handlesa, labelsa = ax1a.get_legend_handles_labels()\n handlesb, labelsb = ax1b.get_legend_handles_labels()\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\n \n\n # Angular velocities\n ax2 = fig.add_subplot(3,1,2)\n \n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\n \n ax2.set_title(\"Angular velocities\") \n ax2.set_xlabel(r'$t$ (s)')\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\n \n handles, labels = ax2.get_legend_handles_labels()\n ax2.legend(handles, labels, ncol=3, loc='best')\n \n \n # Euler angles\n ax3a = fig.add_subplot(3,1,3)\n \n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\"$\\phi$\")\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\"$\\theta$\")\n \n ax3a.set_title(\"Euler angles\") \n ax3a.set_xlabel(r'$t$ (s)')\n ax3a.set_ylabel(r'$\\phi$ , $\\theta$ (°)')\n \n \n ax3b = ax3a.twinx()\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\"$\\psi$\")\n \n ax3b.set_ylabel(r'$\\psi$ (°)')\n \n handlesa, labelsa = ax3a.get_legend_handles_labels()\n handlesb, labelsb = ax3b.get_legend_handles_labels()\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\n \n plt.tight_layout()\n \n \n # Export\n if dest_folder != None:\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')","def overviewCommand(self):\n plt.figure(11)\n plt.clf()\n ax = plt.subplot(211)\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*self.raw['OPDC'].data.field('FUOFFSET'),\n color='r', label='FUOFFSET',\n linewidth=1, alpha=1) \n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\n self.raw['OPDC'].data.field('PSP')),\n color='r', linewidth=3, alpha=0.5,\n label=self.DLtrack+'-PSP')\n plt.legend()\n plt.subplot(212, sharex=ax)\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*self.raw['OPDC'].data.field('FUOFFSET')-\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\n self.raw['OPDC'].data.field('PSP')),\n color='k', label='$\\Delta$',\n linewidth=1, alpha=1) \n \n signal = self.raw['OPDC'].data.field('FUOFFSET')\n plt.figure(12)\n plt.clf()\n ax2 = plt.subplot(111)\n Fs = 1e6/np.diff(self.raw['OPDC'].data.field('TIME')).mean()\n print Fs\n ax2.psd(signal[:50000], NFFT=5000, Fs=Fs, label='FUOFFSET',scale_by_freq=0)\n plt.legend()","def plot(self, **kwargs):\n if self.order != None:\n name = str(_constructModelName(self.teff, self.logg, \n self.metal, self.en, self.order, self.path))\n output = kwargs.get('output', str(name) + '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', \n alpha=.8, linewidth=1, label=name)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim) \n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()\n\n else:\n output = kwargs.get('output'+ '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim)\n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()","def plot_tariff(self):\n\t\tplt.figure(1)\n\t\tplt.cla() # clear the plotting window to allow for re-plotting\n\n\t\tif self.chargetypetoplot.get() == 'energy':\n\t\t\ttoplot = []\n\t\t\tenergy_filter = ('energy' == self.data[\"Charge\"]) | ('Energy' == self.data[\"Charge\"])\n\t\t\tfor mo in range(1, 13):\n\t\t\t\tmonth_filter = (mo >= self.data[\"Start Month\"]) & (mo <= self.data[\"End Month\"])\n\t\t\t\ttemp = self.data.loc[(energy_filter & month_filter), :]\n\t\t\t\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \"Value\"])\n\t\t\t\t\t\t\t for hr in range(1, 25)])\n\t\t\tim = plt.imshow(toplot, interpolation='nearest')\n\t\t\tplt.xticks(ticks=[i-.5 for i in range(25)],\n\t\t\t\t\t labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)], rotation=45)\n\t\t\tplt.yticks(ticks=[i-0.5 for i in range(13)],\n\t\t\t\t\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',\n\t\t\t\t\t\t\t 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''], va='top')\n\n\t\t\t# get the colors of the values, according to the\n\t\t\t# colormap used by imshow\n\t\t\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\n\t\t\tcolors = [im.cmap(im.norm(value)) for value in values]\n\t\t\t# create a patch (proxy artist) for every color\n\t\t\tpatches = [mpatches.Patch(color=colors[i], label=\"${:1.5}/kWh\".format(values[i]))\n\t\t\t\t\t for i in range(len(values))]\n\t\t\t# put those patched as legend-handles into the legend\n\t\t\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\"upper right\", borderaxespad=0.)\n\t\t\tplt.title('Energy Price Heatmap')\n\t\telse:\n\t\t\ttoplot = []\n\t\t\tdemand_filter = ('demand' == self.data[\"Charge\"]) | ('Demand' == self.data[\"Charge\"])\n\t\t\tfor mo in range(1, 13):\n\t\t\t\tmonth_filter = (mo >= self.data[\"Start Month\"]) & (mo <= self.data[\"End Month\"])\n\t\t\t\ttemp = self.data.loc[(demand_filter & month_filter), :]\n\t\t\t\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \"Value\"]) for hr in\n\t\t\t\t\t\t\t range(1, 25)])\n\t\t\tim = plt.imshow(toplot, interpolation='nearest')\n\t\t\tplt.xticks(ticks=[i - .5 for i in range(25)], labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)],\n\t\t\t\t\t rotation=45)\n\t\t\tplt.yticks(ticks=[i - 0.5 for i in range(13)],\n\t\t\t\t\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''],\n\t\t\t\t\t va='top')\n\n\t\t\t# get the colors of the values, according to the\n\t\t\t# colormap used by imshow\n\t\t\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\n\t\t\tcolors = [im.cmap(im.norm(value)) for value in values]\n\t\t\t# create a patch (proxy artist) for every color\n\t\t\tpatches = [mpatches.Patch(color=colors[i], label=\"${:1.5}/kW\".format(values[i])) for i in\n\t\t\t\t\t range(len(values))]\n\t\t\t# put those patched as legend-handles into the legend\n\t\t\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\"upper right\", borderaxespad=0.)\n\t\t\tplt.title('Demand Price Heatmap')\n\n\t\tself.chart_type.draw()\n\n\t\treturn 0","def update_graph(self):\n parameters = []\n dtype = {'Timestamp': 'str'}\n for header in self.headers:\n if self.top_plot.current_param in header or self.bottom_plot.current_param in header:\n parameters.append(header)\n dtype[header] = 'float'\n data = pd.read_csv(self.reactor.file,\n dtype=dtype,\n parse_dates=['Timestamp'], usecols=['Timestamp'] + parameters, low_memory=False,\n na_filter=False)\n start_time = data['Timestamp'][0]\n data.insert(loc=2, column='EFT', value=(data['Timestamp'] - start_time) / np.timedelta64(1, 'h'))\n\n for label, content in data.iteritems():\n if label == 'Timestamp' or label == 'EFT':\n continue\n elif self.top_plot.current_param in label:\n self.top_plot.clear()\n self.top_plot.plot(data['EFT'], content)\n else:\n self.bottom_plot.clear()\n self.bottom_plot.plot(data['EFT'], content)","def eeg_fdr(p_array,q,plot='false'):\t\n\tN = len(p_array) \n\tp_array_srtind = np.argsort(p_array)\n\tp_array_srt = p_array[p_array_srtind]\n\tp_bound=np.zeros((N))\n\tfor i in range(N):\n\t\tp_bound[i] = i * q/N\n\t\n\tidx = p_array_srt < p_bound\n\t\n\tif np.sum(idx == 'true') > 0:\n\t\tp_thresh_fdr = np.max(p_array_srt[idx])\n\t\ti_max_fdr = p_array_srt[idx].argmax()\t\t\t\n\t\tif plot == 'true':\n\t\t\tfig = plt.figure(19,figsize=[5,5])\n\t\t\tax = fig.add_subplot(111, autoscale_on=False, xlim=[0,120], ylim=[0,10])\n\t\t\tplt.plot(N*p_array_srt,'bo-',lw=2)\n\t\t\tplt.plot(N*p_bound,'k--',lw=2)\n\t\t\tplt.plot([10,20],[9,9],'bo-',lw=2)\n\t\t\tplt.plot([10,20],[8,8],'k--',lw=2)\n\t\t\tplt.text(25,9, r'$p_{i} \\cdot N$', fontsize = 13, va='center')\n\t\t\tplt.text(25,8, r'$q \\cdot i$', fontsize = 13,va='center')\n\t\t\tplt.text(1.2 * i_max_fdr,0.5 * p_thresh_fdr*N,'FDR (q = ' + str('%.2f' %q) + ') = ' + str('%.4f' %p_thresh_fdr),va = 'center')\n\t\t\tplt.fill_between([0,i_max_fdr],[p_thresh_fdr*N,p_thresh_fdr*N],0,color='k',alpha=0.3,lw=0)\n\t\t\tplt.xlabel('i',fontsize = 13)\n\t\t\tplt.ylabel(r'$N_{FP}$',fontsize = 13)\t\n\telse:\n\t\tprint \"None of the p-value exceeds the FDR threshold (there is no p-value (p_i) for which p_i < i*q/N) \"\n\t\tp_thresh_fdr = []\n\t\n\treturn p_thresh_fdr","def plot_speed_hist(dlc_df, cam_times, trials_df, feature='paw_r', cam='left', legend=True):\r\n # Threshold the dlc traces\r\n dlc_df = likelihood_threshold(dlc_df)\r\n # For pre-GPIO sessions, remove the first few timestamps to match the number of frames\r\n cam_times = cam_times[-len(dlc_df):]\r\n if len(cam_times) != len(dlc_df):\r\n raise ValueError(\"Camera times length and DLC length are inconsistent\")\r\n # Get speeds\r\n speeds = get_speed(dlc_df, cam_times, camera=cam, feature=feature)\r\n # Windows aligned to align_to\r\n start_window, end_window = plt_window(trials_df['stimOn_times'])\r\n start_idx = insert_idx(cam_times, start_window)\r\n end_idx = np.array(start_idx + int(WINDOW_LEN * SAMPLING[cam]), dtype='int64')\r\n # Add speeds to trials_df\r\n trials_df[f'speed_{feature}'] = [speeds[start_idx[i]:end_idx[i]] for i in range(len(start_idx))]\r\n # Plot\r\n times = np.arange(len(trials_df[f'speed_{feature}'].iloc[0])) / SAMPLING[cam] + WINDOW_LAG\r\n # Need to expand the series of lists into a dataframe first, for the nan skipping to work\r\n correct = trials_df[trials_df['feedbackType'] == 1][f'speed_{feature}']\r\n incorrect = trials_df[trials_df['feedbackType'] == -1][f'speed_{feature}']\r\n plt.plot(times, pd.DataFrame.from_dict(dict(zip(correct.index, correct.values))).mean(axis=1),\r\n c='k', label='correct trial')\r\n plt.plot(times, pd.DataFrame.from_dict(dict(zip(incorrect.index, incorrect.values))).mean(axis=1),\r\n c='gray', label='incorrect trial')\r\n plt.axvline(x=0, label='stimOn', linestyle='--', c='r')\r\n plt.title(f'{feature.capitalize()} speed trial avg\\n({cam.upper()} cam)')\r\n plt.xticks([-0.5, 0, 0.5, 1, 1.5])\r\n plt.xlabel('time [sec]')\r\n plt.ylabel('speed [px/sec]')\r\n if legend:\r\n plt.legend()\r\n\r\n return plt.gca()","def plot_predicted_observed_discharge(\n data: pd.DataFrame, s: Saver, show_plt: bool = False, ax=None\n):\n if ax is None:\n fig, ax = plt.subplots()\n else:\n fig = plt.gcf()\n\n # x = s.z[:, 0] # Measured Discharge\n x = data[\"q_true\"] # True (unobserved) Discharge\n y = (s.H @ s.x)[:, 0] # Filtered Discharge\n ax.scatter(x, y, marker=\"x\", label=\"Filtered Discharge\")\n\n # 1:1 line\n one_to_one_line = np.linspace(x.min(), x.max(), 10)\n ax.plot(one_to_one_line, one_to_one_line, \"k--\", label=\"1:1 Line\")\n\n # beautifying the plot\n ax.set_xlabel(\"Unobserved (true) Discharge ($q_{true}$)\")\n ax.set_ylabel(\"Filtered Discharge ($Hx$)\")\n ax.set_title(\"Filtered Discharge vs. True Discharge\")\n plt.legend()\n sns.despine()\n\n return fig, ax","def visualize_historicals(dcfs):\n pass\n\n dcf_share_prices = {}\n for k, v in dcfs.items():\n dcf_share_prices[dcfs[k]['date']] = dcfs[k]['share_price']\n\n xs = list(dcf_share_prices.keys())[::-1]\n ys = list(dcf_share_prices.values())[::-1]\n\n plt.scatter(xs, ys)\n plt.show()","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def fig_event_corrected(evstream, TF_list, fmin=1./150., fmax=2.):\n\n # Unpack vertical trace and filter\n trZ = evstream.trZ.copy()\n trZ.filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n sr = trZ.stats.sampling_rate\n taxis = np.arange(0., trZ.stats.npts/sr, 1./sr)\n\n plt.figure(figsize=(8, 8))\n\n plt.subplot(611)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['Z1']:\n tr = Trace(\n data=evstream.correct['Z1'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.key + ' ' + evstream.tstamp +\n ': Z1', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.subplot(612)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['Z2-1']:\n tr = Trace(\n data=evstream.correct['Z2-1'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.tstamp + ': Z2-1', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.subplot(613)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['ZP-21']:\n tr = Trace(\n data=evstream.correct['ZP-21'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.tstamp + ': ZP-21', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.subplot(614)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['ZH']:\n tr = Trace(\n data=evstream.correct['ZH'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.tstamp + ': ZH', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.subplot(615)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['ZP-H']:\n tr = Trace(\n data=evstream.correct['ZP-H'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.tstamp + ': ZP-H', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.subplot(616)\n plt.plot(\n taxis, trZ.data, 'lightgray', lw=0.5)\n if TF_list['ZP']:\n tr = Trace(\n data=evstream.correct['ZP'],\n header=trZ.stats).filter(\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\n plt.plot(taxis, tr.data, 'k', lw=0.5)\n plt.title(evstream.tstamp + ': ZP', fontdict={'fontsize': 8})\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\n scilimits=(-3, 3))\n plt.xlim((0., trZ.stats.npts/sr))\n\n plt.xlabel('Time since earthquake (sec)')\n plt.tight_layout()\n\n return plt","def update_graphs(self):\n profile_time = False\n if profile_time:\n start_time = time.time()\n\n # Update the graph data with data only within the chosen time_range\n now = time.time()\n i_tr_prs = np.where(now - self.prs_data[0, :] < \n self.time_range[1] - self.time_range[0])[0]\n self.prs_graph.setData(self.prs_data[0, i_tr_prs] - now, self.prs_data[1, i_tr_prs])\n # Updates the graph title\n self.prs_pw.setTitle(f\"Pressão: {self.prs_data[1, 0]:.1f} cmH2O\", **self.ttl_style)\n\n if profile_time == True:\n time_at_pressure = time.time()\n print(f\"Until pressure graph: {time_at_pressure - start_time:.4f} s\")\n \n # Update the graph data with data only within the chosen time_range\n now = time.time()\n i_tr_flw = np.where(now - self.flw_data[0, :] < \n self.time_range[1] - self.time_range[0])[0]\n self.flw_pw.setTitle(f\"Fluxo: {self.flw_data[1, 0]:.1f} l/min\", **self.ttl_style)\n self.flw_graph.setData(self.flw_data[0, i_tr_flw] - now, self.flw_data[1, i_tr_flw])\n\n if profile_time == True:\n time_at_flow = time.time()\n print(f\"Until flow graph: {time_at_flow - start_time:.4f} s\")\n\n i_tr_vol = np.where(now - self.vol_data[0, :] < \n self.time_range[1] - self.time_range[0])[0]\n self.vol_pw.setTitle(f\"Volume: {self.vol_data[1, 0]:.0f} ml\", **self.ttl_style)\n self.vol_graph.setData(self.vol_data[0, i_tr_vol] - now, self.vol_data[1, i_tr_vol])\n\n if profile_time == True:\n time_at_volume = time.time()\n print(f\"After the volume graph: {time_at_volume - time_at_flow:.4f} s\")\n\n # Adjust the Y range every N measurements\n # Manually adjusting by calculating the max and min with numpy is faster than autoscale on \n # the graph. Also calculates FPS\n N = 20\n if self.run_counter % N == 0:\n # definition of the minimum acceptable range for the volume\n min_range_vol = [-5, 50]\n # Tries to get the max and min from each data set \n try:\n range_vol = [np.min(self.vol_data[1, i_tr_vol]), np.max(self.vol_data[1, i_tr_vol])]\n # Adjusts the minimum and maximum, if the measured values are outside the minimum range\n self.vol_pw.setYRange(np.min([range_vol[0], min_range_vol[0]]), \n np.max([range_vol[1], min_range_vol[1]]))\n except:\n pass\n min_range_prs = [-0.2, 5]\n try:\n range_prs = [np.min(self.prs_data[1, i_tr_prs]), np.max(self.prs_data[1, i_tr_prs])]\n self.prs_pw.setYRange(np.min([range_prs[0], min_range_prs[0]]), \n np.max([range_prs[1], min_range_prs[1]]))\n except:\n pass\n\n min_range_flw = [-0.1, 1]\n try:\n range_flw = [np.min(self.flw_data[1, i_tr_flw]), np.max(self.flw_data[1, i_tr_flw])]\n self.flw_pw.setYRange(np.min([range_flw[0], min_range_flw[0]]), \n np.max([range_flw[1], min_range_flw[1]]))\n except:\n pass\n mean_pts = 50\n try:\n FPS = np.nan_to_num(1.0 / np.mean(self.vol_data[0, 0:mean_pts] - \n self.vol_data[0, 1:1+mean_pts]))\n except:\n FPS = 0\n self.fps_lbl.setText(f\"FPS: {FPS:.2f}\")\n self.run_counter = 0\n self.run_counter += 1","def plot_f(self, *args, **kwargs):\r\n kwargs['plot_raw'] = True\r\n self.plot(*args, **kwargs)","def plot_r(f=500, d=100e-3, dr=0.01, picture_file=None, picture_formats=['png', 'pdf', 'svg']):#x_axis='r', \n import matplotlib.pyplot\n i = 0\n rs = []\n sigmas = []\n ys = []\n print \"r_soll ->\\tsigma ->\\tr\"\n datas = []\n for r in numpy.arange(0, 1+dr, dr) :\n for t in [0] :\n print \"%f\\t\" %(r),\n sigma = getSigma(r)\n print \"%f\\t\" % (sigma),\n rs.append(r)\n sigmas.append(sigma)\n v = getSynapticActivity(f=f, r=r, fireing_rate=1, duration=d, delay=t)\n #print v\n #matplotlib.pyplot.scatter(v, numpy.zeros( len(v) ) + i )\n r = vector_strength(f, v)\n print \"%f\" % (r)\n ys.append(r)\n i = i+1\n datas.append([sigma,r])\n numpy.savetxt(\"../../../Data/%.1f_%f@%i.dat\" % (getSigma(dr),dr,int(f*d)), datas) \n\n matplotlib.pyplot.figure()\n matplotlib.pyplot.xlabel('sigma')\n matplotlib.pyplot.ylabel('measured vector strength')\n matplotlib.pyplot.xlim(0, getSigma(dr))\n matplotlib.pyplot.ylim(0, 1)\n matplotlib.pyplot.grid()\n matplotlib.pyplot.scatter(sigmas,ys, marker='x', color='black')#, basex=10, basey=10, ls=\"-\"\n if(picture_file != None):\n for picture_format in picture_formats:\n matplotlib.pyplot.savefig(picture_file+'sigma_'+str(getSigma(dr))+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\n else:\n matplotlib.pyplot.show()\n\n matplotlib.pyplot.figure()\n matplotlib.pyplot.xlabel('aimed vector strength')\n matplotlib.pyplot.ylabel('measured vector strength')\n #matplotlib.pyplot.legend([\"based on %i examples / dot\" % (f*d) ], loc='best');\n matplotlib.pyplot.xlim(0, 1)\n matplotlib.pyplot.ylim(0, 1)\n matplotlib.pyplot.grid()\n\n matplotlib.pyplot.scatter(rs,ys, marker='x', color='black')\n if(picture_file != None):\n for picture_format in picture_formats:\n matplotlib.pyplot.savefig(picture_file+'_'+str(dr)+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\n else:\n matplotlib.pyplot.show()\n\n matplotlib.pyplot.close('all')\n datas = numpy.ndarray((len(datas),2), buffer=numpy.array(datas),dtype=float)\n return datas","def plot_db_f():\n db = np.arange(-24, -13)\n mw = dbm_mw(db)\n f = mw_f(mw)\n plt.plot(db, f, '.-')\n f = np.linspace(0.06, 0.20, 10)\n mw = f_mw(f)\n db = mw_dbm(mw)\n for i, field in enumerate(f):\n print(db[i])\n plt.plot(db, f, 'o-')\n return","def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices['E_tot1'])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\n \n plt.ylabel('Energy [kWh]')\n plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(24)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\n\n plt.ylabel('Energy Difference [kWh]')\n plt.legend()\n\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n return fig","def worker_plot(fname):\n with Database() as base:\n _filter = base.get_filter(fname)\n plt.clf()\n plt.plot(_filter.trans_table[0], _filter.trans_table[1], color='k')\n plt.xlim(_filter.trans_table[0][0], _filter.trans_table[0][-1])\n plt.minorticks_on()\n plt.xlabel('Wavelength [nm]')\n plt.ylabel('Relative transmission')\n plt.title(\"{} filter\".format(fname))\n plt.tight_layout()\n plt.savefig(\"{}.pdf\".format(fname))","def display_data(\n # shared requirements / general settings\n df, file_metadata_list, data_column,\n x_vals_column=None, coord_2d_column=None,\n x_vals_label=None, coord_2d_label=None,\n figsize_scale=1.0, font_scale=1.0,\n # 2d colorplot / waterfall\n display_2d_colorplot=False, imshow_kwargs=None,\n display_waterfall=False, num_waterfall_plots=4,\n display_2d_save_filepath=None,\n # requirements for fit analysis plots\n results_df=None, minimize_results=None,\n fit_function=None, \n # display all fits at once or w/ widget\n display_fits=None, num_fit_plots_cols=3,\n residuals_fcn=None, indep_vars_columns=None,\n display_fits_save_filepath=None,\n # display fit params (and more) \n display_fit_results=None,\n num_result_plots_cols=3,\n other_results_list=['chisqr'],\n display_fit_results_save_filepath=None,\n # display covariance / correlations matrix\n display_covar=None,\n display_covar_save_filepath=None,\n # display detailed fit reports\n display_fit_reports=False):\n # PLOT 2D REPRESENTATION\n if not (display_2d_colorplot or display_waterfall):\n pass\n elif display_2d_colorplot and display_waterfall:\n plt.figure(figsize=(figsize_scale * 4,\n figsize_scale * 2))\n nplots = 2\n else: # xor\n plt.figure(figsize=(figsize_scale * 2.5,\n figsize_scale * 2.5))\n nplots = 1\n if imshow_kwargs is None:\n imshow_kwargs = {'aspect': 1.0,\n 'origin': 'upper'}\n if display_2d_colorplot:\n ax1 = plt.subplot(1, nplots, 1)\n plot_dataframe_colorplot(df, data_column,\n x_vals_column, coord_2d_column,\n xlabel=x_vals_label, ylabel=coord_2d_label,\n ax=ax1, **imshow_kwargs)\n if display_waterfall:\n plotnum = 2 if display_2d_colorplot else 1\n ylabel = None if display_2d_colorplot else coord_2d_label\n ax2 = plt.subplot(1, nplots, plotnum)\n plot_dataframe_waterfall(df, data_column,\n num_waterfall_plots,\n x_vals_column, coord_2d_column,\n xlabel=x_vals_label, ylabel=ylabel, ax=ax2)\n ax2.yaxis.set_ticklabels([])\n if (display_2d_colorplot or display_waterfall) \\\n and display_2d_save_filepath:\n plt.savefig(display_2d_save_filepath,\n bbox_inches='tight', transparent=False)\n if display_2d_colorplot or display_waterfall:\n plt.show()\n\n # plot fit results if given\n if results_df is None or minimize_results is None:\n return\n\n # plot fits\n if (display_fits == 'all' or display_fits == 'widget') \\\n and (indep_vars_columns and residuals_fcn):\n if x_vals_column is None:\n x_vals_column = df.index.names[-1]\n def plot_fit(result_index, axes=None):\n if axes:\n ax = axes\n else:\n plt.figure(figsize=(figsize_scale * 3,\n figsize_scale * 3))\n ax = plt.subplot(111)\n result = minimize_results[result_index]\n dataset_index = results_df.index[result_index]\n xvals = df.loc[dataset_index][x_vals_column]\n yvals = df.loc[dataset_index][data_column]\n indep_vars_vecs = [df.loc[dataset_index][colname]\n for colname in indep_vars_columns]\n fit_yvals = residuals_fcn(result.params, *indep_vars_vecs)\n ax.plot(xvals, yvals, 'bd', label='dataset {}'.format(result_index))\n ax.plot(xvals, fit_yvals, 'r')\n if axes is None:\n plt.show()\n if display_fits_save_filepath or display_fits == 'all':\n ncols = num_fit_plots_cols\n nplots = len(minimize_results)\n nrows = np.int(np.ceil(nplots / ncols))\n plt.figure(figsize=(figsize_scale * 1.5 * min(ncols, 5),\n figsize_scale * 1.3 * nrows))\n for result_index in list(range(nplots)):\n ax = plt.subplot(nrows, ncols, result_index + 1)\n plot_fit(result_index, ax)\n plt.tight_layout()\n if display_fits_save_filepath:\n plt.savefig(display_fits_save_filepath,\n bbox_inches='tight', transparent=False)\n if display_fits == 'all':\n plt.show()\n else:\n plt.close()\n if display_fits == 'widget':\n result_slider = IntSlider(min=0, max=len(minimize_results) - 1,\n step=1, value=0)\n interactive_plot = interactive(plot_fit,\n result_index=result_slider,\n axes=fixed(None)) \n # Note: axes=fixed(None) was once in those params, not sure why\n output = interactive_plot.children[-1]\n output.layout.height = '350px'\n display(interactive_plot)\n interactive_plot.update()\n elif not display_fits: # False or None\n pass\n else:\n raise ValueError(\"Invalid value for keyword argument display_fits\")\n\n # plot params, grouped by all but last column\n if display_fit_results:\n results_df_2d, _ = dfproc.get_2d_indexed_df(results_df)\n result = minimize_results[0]\n if display_fit_results == 'params':\n params_to_plot_list = list(result.var_names)\n else:\n try:\n test_iterator = iter(display_fit_results)\n except TypeError: # not iterable\n raise ValueError(\"Invalid value for keyword \" +\n \"argument display_fit_results\")\n else:\n params_to_plot_list = list(test_iterator)\n params_to_plot_list += list(other_results_list)\n ncols = num_result_plots_cols\n nplots = len(params_to_plot_list)\n nrows = np.int(np.ceil(nplots / ncols))\n plt.figure(figsize=(figsize_scale * 1.5 * min(ncols, 6),\n figsize_scale * 1.3 * nrows))\n for ind, param in enumerate(params_to_plot_list):\n ax = plt.subplot(nrows, ncols, ind + 1)\n indices_2d = results_df_2d.index.get_level_values(-2).unique()\n for index_2d in indices_2d:\n subdf = results_df_2d.loc[index_2d]\n if (param + '_error') in list(results_df_2d):\n ax.errorbar(x=subdf.index.get_level_values(-1),\n y=subdf[param],\n yerr=subdf[param + '_error'],\n fmt='d-', label=index_2d)\n else:\n ax.plot(subdf.index.get_level_values(-1),\n subdf[param].values, 'd-', label=index_2d)\n if len(indices_2d) <= 5:\n plt.legend()\n plt.xlabel(results_df_2d.index.names[-1])\n plt.tight_layout()\n plt.title(param)\n if display_fit_results_save_filepath:\n plt.savefig(display_fit_results_save_filepath,\n bbox_inches='tight', transparent=False)\n plt.show()\n\n # Plot the avg. covariance matrix\n if (display_covar == 'covariance' or\n display_covar == 'correlation'):\n covar_mats = []\n corr_mats = []\n for result in minimize_results:\n covar = result.covar\n covar_mats.append(covar)\n if display_covar == 'correlation':\n oostd = np.diagflat(\n [1.0 / param.stderr\n for param in list(result.params.values())\n if param.name in result.var_names\n if param.stderr != 0])\n corr = np.dot(np.dot(oostd, result.covar),\n oostd).astype(np.float)\n mask = np.zeros_like(corr, dtype=np.bool)\n mask[np.triu_indices_from(mask)] = True\n corr[mask] = np.nan\n corr_mats.append(corr)\n\n # filter out malformed covariance / correlation matrices\n if display_covar == 'covariance':\n valid_mats = [mat for mat in covar_mats\n if mat.size is not None\n if mat.size > 0]\n else:\n valid_mats = [mat for mat in corr_mats\n if mat.size is not None\n if mat.size > 0]\n num_nan = lambda mat: np.count_nonzero(np.isnan(mat))\n avg_nan = np.mean([num_nan(mat) for mat in valid_mats])\n avgcorr = np.mean([mat for mat in valid_mats\n if num_nan(mat) <= avg_nan], axis=0)\n\n plt.figure()\n plt.imshow(avgcorr, vmin=-1, vmax=1)\n plt.colorbar()\n plt.xticks(np.arange(result.nvarys), result.var_names,\n rotation=-35, ha='left')\n plt.yticks(np.arange(result.nvarys), result.var_names)\n plt.title('Avg. correlation matrix, off-diagonal')\n if display_covar_save_filepath:\n plt.savefig(display_covar_save_filepath,\n bbox_inches='tight', transparent=False)\n plt.show()\n elif not display_covar: # False or None\n pass\n else:\n raise ValueError(\"Invalid value for keyword argument display_covar\")\n\n # DETAILED FIT REPORTS\n if display_fit_reports:\n for result_index, result in enumerate(minimize_results):\n print('----------------------------------------')\n if (display_covar == 'covariance' or\n display_covar == 'correlation') \\\n and (indep_vars_columns and residuals_fcn):\n fig, (ax1, ax2) = plt.subplots(\n ncols=2, sharey=False, figsize=(figsize_scale * 4.0,\n figsize_scale * 1.5))\n elif (display_covar == 'covariance' or\n display_covar == 'correlation') \\\n or (indep_vars_columns and residuals_fcn):\n fig = plt.figure(figsize=(figsize_scale * 2.0,\n figsize_scale * 1.0))\n ax1 = plt.subplot(111)\n ax2 = ax1 # either alias points to same fig\n if indep_vars_columns and residuals_fcn:\n dataset_index = results_df.index[result_index]\n xvals = df.loc[dataset_index][x_vals_column]\n yvals = df.loc[dataset_index][data_column]\n indep_vars_vecs = [df.loc[dataset_index][colname]\n for colname in indep_vars_columns]\n fit_yvals = residuals_fcn(result.params, *indep_vars_vecs)\n ax1.plot(xvals, yvals, 'bd',\n label='dataset {}'.format(result_index))\n ax1.plot(xvals, fit_yvals, 'r')\n ax1.set_title('Data vs. Fit')\n if (display_covar == 'covariance' or\n display_covar == 'correlation'):\n if display_covar == 'correlation':\n mat = corr_mats[result_index]\n else:\n mat = covar_mats[result_index]\n if mat.size is not None and mat.size > 0:\n img = ax2.imshow(mat, vmin=-1, vmax=1)\n fig.colorbar(img, ax=ax2)\n plt.xticks(np.arange(result.nvarys), result.var_names,\n rotation=-35, ha='left', fontsize=font_scale*8)\n plt.yticks(np.arange(result.nvarys), result.var_names,\n fontsize=font_scale*8)\n ax2.set_title('Correlations')\n plt.tight_layout()\n plt.show()\n print('FIT #{}'.format(result_index + 1))\n for col, val in zip(results_df.index.names,\n results_df.index[result_index]):\n print('{}: {}'.format(col, val))\n display(report_fit(result))","def plot_ECG_peaks(ecg_df, r_peaks):\n\t# peak_times = ecg_df.iloc[r_peaks]['timestamp']\n\tpeak_times = r_peaks\n\tecg_df['is_peak'] = ecg_df['timestamp'].isin(peak_times) \n\n\tplt.figure()\n\tplt.plot(ecg_df['timestamp'], ecg_df['ecg'])\n\tplt.plot(ecg_df[ecg_df['is_peak']]['timestamp'], ecg_df[ecg_df['is_peak']]['ecg'], 'ro')\n\tplt.title('Detected R-peaks on ECG Data')\n\tplt.xlabel('Time (ms)')\n\tplt.ylabel('Voltage (mV)')\n\tplt.show()","def plot_carrier_frequency(self):\r\n roi = self.phase_roi\r\n phase_slice = (slice(roi[2], roi[3]), slice(roi[0], roi[1]))\r\n # calculation\r\n S = self.image[phase_slice] # signal in phase_roi\r\n t_axis = self.image.x_axis[roi[0]:roi[1]] # [ns] time axis\r\n y_axis = self.image.y_axis[roi[2]:roi[3]] # [mic] spatial scale\r\n N = S.shape[0]//2\r\n\r\n s = np.fft.fft(S, axis=0) / N # fft\r\n s_abs = np.abs(s[:N,:])\r\n f_axis = np.arange(N) / (2 * N) # spatial frequency axis\r\n\r\n s_mean = np.log10(np.mean(s_abs, axis=1))\r\n i0 = np.argmax(s_mean[3:])\r\n f0 = f_axis[3+i0] # [px^-1] fringe carrier frequency (estimate)\r\n s0 = s_mean[3+i0]\r\n sys.stdout.write(\"{} VISAR-{} fringe period = {:.1f} px\\n\".format(\r\n self.h5.shot_id[:11], self.leg, 1/f0))\r\n\r\n # plot calcs\r\n vlim_0 = dataimage.thresh_vlim(S, 0.01)\r\n vlim_1 = dataimage.thresh_vlim(np.log10(s_abs), (0.02, 0.005))\r\n tlim = (t_axis[0], t_axis[-1])\r\n ylim = (y_axis[0], y_axis[-1])\r\n flim = (0, 0.5) # [1/px]\r\n extent_0 = tlim + (0, S.shape[0]) # extent for signal\r\n# extent_0 = tlim + ylim # extent for signal\r\n extent_1 = tlim + flim # extent for fft\r\n\r\n # figure\r\n fig = plt.figure(figsize=(7,7), dpi=100)\r\n axs = []\r\n axs.append(fig.add_subplot(221, ylabel='[px]', title='signal'))\r\n axs.append(fig.add_subplot(222, sharey=axs[0], title='spatial lineout'))\r\n axs.append(fig.add_subplot(223, sharex=axs[0], title='log(fft(signal))',\r\n xlabel='time [ns]', ylabel=\"spatial frequency [px^-1]\"))\r\n axs.append(fig.add_subplot(224, sharey=axs[2], xlabel='log10(power)', title='spectral lineout'))\r\n\r\n axs[0].imshow(S, extent=extent_0,\r\n aspect='auto', vmin=vlim_0[0], vmax=vlim_0[1])\r\n axs[2].imshow(np.log10(s_abs), extent=extent_1,\r\n aspect='auto', vmin=vlim_1[0], vmax=vlim_1[1])\r\n axs[1].plot(np.mean(S, axis=1), np.arange(S.shape[0]))\r\n axs[3].plot(s_mean, f_axis)\r\n axs[0].set_ylim(*extent_0[2:])\r\n \r\n axs[3].annotate(\"fringe period\\n= {:.1f} px\".format(1/f0),\r\n (s0, f0), (0.95, 0.5), textcoords='axes fraction',\r\n arrowprops=dict(width=1, headwidth=6, facecolor='k',\r\n shrink=0.03), ha='right',)\r\n\r\n axs[3].axhline(f0*0.7, color='r', linestyle='dashed')\r\n axs[3].axhline(f0*1.4, color='r', linestyle='dashed')\r\n\r\n fig.tight_layout()\r\n fig.canvas.window().move(0,0)\r\n return fig","def plot_comparison(step_test_data, model, inputs, outputs, start_time, end_time, plt_input=False, scale_plt=False):\n \n val_data = step_test_data.loc[start_time:end_time]\n val_data.columns = [col[0] for col in val_data.columns]\n \n Time = val_data.index\n u = val_data[inputs].to_numpy().T\n y = val_data[outputs].to_numpy().T\n\n\n # Use the model to predict the output-signals.\n mdl = np.load(model)\n \n # The output of the model\n xid, yid = fsetSIM.SS_lsim_innovation_form(A=mdl['A'], B=mdl['B'], C=mdl['C'], D=mdl['D'], K=mdl['K'], y=y, u=u, x0=mdl['X0'])\n \n # Make the plotting-canvas bigger.\n plt.rcParams['figure.figsize'] = [25, 5]\n # For each output-signal.\n for idx in range(0,len(outputs)):\n plt.figure(idx)\n plt.xticks(rotation=15)\n plt.plot(Time, y[idx],color='r')\n plt.plot(Time, yid[idx],color='b')\n plt.ylabel(outputs[idx])\n plt.grid()\n plt.xlabel(\"Time\")\n plt.title('output_'+ str(idx+1))\n plt.legend(['measurment', 'prediction'])\n ax=plt.gca()\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\n ax.xaxis.set_major_formatter(xfmt) \n if scale_plt==True:\n plt.ylim(np.amin(y[idx])*.99, np.amax(y[idx])*1.01)\n \n if plt_input == True:\n for idx in range(len(outputs), len(outputs) + len(inputs)):\n plt.figure(idx)\n plt.xticks(rotation=15)\n plt.plot(Time, u[idx-len(outputs)], color='r')\n plt.ylabel(inputs[idx-len(outputs)])\n plt.grid()\n plt.xlabel(\"Time\")\n plt.title('input_'+ str(idx-len(outputs)+1))\n ax=plt.gca()\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\n ax.xaxis.set_major_formatter(xfmt) \n plt.show()","def plot_stress_time(F_tot, response_t, coords, t_range):\n section = np.where((t>t_range[0]) & (t<t_range[1]))[0]\n fig, ax1 = plt.subplots(figsize=[15,5])\n ax2 = ax1.twinx()\n# ax1.set_title('Load and response at '+str(coords),fontsize = 14)\n ax1.set_xlim(t_range)\n ax1.set_xlabel('t [s]')\n resp = ax1.plot(t[section], response_t[section]/10**6, color=\"#00A6D6\",\n label='Equivalent gate stress')\n ax1.set_ylabel('Stress [MPa]', fontsize=12)\n d_max = 1.2*max(response_t[section])/10**6\n d_mean = np.mean(response_t[section])/10**6\n ax1.set_ylim(d_mean-d_max,d_max)\n ax1.legend()\n\n force = ax2.plot(t[section], F_tot[section]/1000, color=\"#c3312f\", label = 'Wave force')\n ax2.set_ylabel('Integrated wave force [$kN/m$]', fontsize = 12)\n F_lim = 1.2*max(F_tot[section])/1000\n F_mean = np.mean(F_tot[section]/1000)\n ax2.set_ylim(F_mean-F_lim,F_lim)\n\n lines = resp + force\n labs = [l.get_label() for l in lines]\n ax1.grid(lw=0.25)\n ax1.legend(lines,labs, fontsize = 12)\n return fig","def _run():\n\n temperatures_kelvins = _create_temperature_grid()\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\n second_derivs_kelvins_pt01 = numpy.gradient(\n numpy.absolute(first_derivs_kelvins_pt01)\n )\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(first_derivs_kelvins_pt01)\n )\n\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(second_derivs_kelvins_pt01)\n )\n\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\n\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n temperature_handle = axes_object.plot(\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n second_deriv_handle = axes_object.plot(\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n first_deriv_handle = axes_object.plot(\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n this_min_index = numpy.argmin(second_derivs_unitless)\n second_derivs_unitless[\n (this_min_index - 10):(this_min_index + 10)\n ] = second_derivs_unitless[this_min_index]\n\n tfp_handle = axes_object.plot(\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n axes_object.set_yticks([0])\n axes_object.set_xticks([], [])\n\n x_label_string = r'$x$-coordinate (increasing to the right)'\n axes_object.set_xlabel(x_label_string)\n\n legend_handles = [\n temperature_handle, first_deriv_handle, second_deriv_handle,\n tfp_handle\n ]\n\n legend_strings = [\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\n ]\n\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\n\n print 'Saving figure to file: \"{0:s}\"...'.format(OUTPUT_FILE_NAME)\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\n pyplot.close()","def display1(*args):\n #----------*----------* # unpack\n twiss_func = args[0]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- transverse X\n splot111=plt.subplot(111)\n splot111.set_title('beta functions')\n plt.plot(s,bx, label=r'$\\beta_x$ [m]', color='red', linestyle='-') # beta x\n plt.plot(s,by, label=r'$\\beta_y$ [m]', color='blue', linestyle='-') # beta y\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\n vscale=splot111.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')","def _plot(self):\n # Read results\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\n x1, y1, _ = read_results('openmc', path)\n if self.code == 'serpent':\n path = self.other_dir / 'input_det0.m'\n else:\n path = self.other_dir / 'outp'\n x2, y2, sd = read_results(self.code, path)\n\n # Convert energies to eV\n x1 *= 1e6\n x2 *= 1e6\n\n # Normalize the spectra\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\n\n # Compute the relative error\n err = np.zeros_like(y2)\n idx = np.where(y2 > 0)\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\n \n # Set up the figure\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\n ax1 = fig.add_subplot(111)\n \n # Create a second y-axis that shares the same x-axis, keeping the first\n # axis in front\n ax2 = ax1.twinx()\n ax1.set_zorder(ax2.get_zorder() + 1)\n ax1.patch.set_visible(False)\n \n # Plot the spectra\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\n \n # Plot the relative error and uncertainties\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\n \n # Set grid and tick marks\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\n ax1.grid(b=False, axis='both', which='both')\n ax2.tick_params(axis='y', which='both', right=False)\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\n \n # Set axes labels and limits\n ax1.set_xlim([self._min_energy, self.energy])\n ax1.set_xlabel('Energy (eV)', size=12)\n ax1.set_ylabel('Spectrum', size=12)\n ax1.legend()\n ax2.set_ylabel(\"Relative error\", size=12)\n title = f'{self.nuclide}'\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n title += f' + {thermal_name}'\n title += f', {self.energy:.1e} eV Source'\n plt.title(title)\n \n # Save plot\n os.makedirs('plots', exist_ok=True)\n if self.name is not None:\n name = self.name\n else:\n name = f'{self.nuclide}'\n if self.thermal is not None:\n name += f'-{thermal_name}'\n name += f'-{self.energy:.1e}eV'\n if self._temperature is not None:\n name += f'-{self._temperature:.1f}K'\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\n plt.close()","def plot_fitter(self):\n\n total_time=self.interval*self.maxspectra\n times = np.linspace(self.interval,total_time + 1,self.interval)\n spectra_fitter.main(self.rt_plot.sum_data, times)","def plot(self, data_frame):\n self.axes.plot(data_frame, 'o-')\n self.axes.set_ylim(0.0, 200.0)\n self.fig.autofmt_xdate()\n self.draw()","def plot_history(data):\n fig = go.Figure()\n for col in data.columns:\n fig.add_trace(go.Scatter(x=data.index, y=data[col], mode='lines', name=col))\n fig.update_xaxes(title_text=\"Time\",\n showline=True, mirror=True, linewidth=1, linecolor='black',\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\n fig.update_yaxes(title_text=\"Share Price ($ USD)\",\n showline=True, mirror=True, linewidth=1, linecolor='black',\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\n fig.update_layout(legend=dict(orientation=\"h\", yanchor=\"bottom\", y=-0.2, xanchor=\"center\", x=0.5),\n font=dict(family='Times New Roman', size=15), plot_bgcolor='rgba(0,0,0,0)',\n margin_l=20, margin_r=20, margin_t=20, margin_b=20,)\n\n fig.write_image(join('..', 'docs', 'share_prices_all_time.png'), height=700, width=900, engine='kaleido')\n fig.write_html(join('..', 'docs', 'share_prices_all_time.html'))\n fig.show()\n\n recent = data[:data.first_valid_index() - pd.Timedelta(weeks=52)]\n fig = go.Figure()\n for col in data.columns:\n fig.add_trace(go.Scatter(x=recent.index, y=recent[col], mode='lines', name=col))\n fig.update_xaxes(title_text=\"Time\",\n showline=True, mirror=True, linewidth=1, linecolor='black',\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\n fig.update_yaxes(title_text=\"Share Price ($ USD)\",\n showline=True, mirror=True, linewidth=1, linecolor='black',\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\n fig.update_layout(legend=dict(orientation=\"h\", yanchor=\"bottom\", y=-0.2, xanchor=\"center\", x=0.5),\n font=dict(family='Times New Roman', size=15), plot_bgcolor='rgba(0,0,0,0)',\n margin_l=20, margin_r=20, margin_t=20, margin_b=20,)\n\n fig.write_image(join('..', 'docs', 'share_prices_past_year.png'), height=700, width=900, engine='kaleido')\n fig.write_html(join('..', 'docs', 'share_prices_past_year.html'))\n fig.show()","def plot_corr_diff(tseries1, tseries2, fig=None,\r\n ts_names=['1', '2']):\r\n\r\n if fig is None:\r\n fig = plt.figure()\r\n\r\n ax = fig.add_subplot(1, 1, 1)\r\n\r\n SNR1 = []\r\n SNR2 = []\r\n corr1 = []\r\n corr2 = []\r\n corr_e1 = []\r\n corr_e2 = []\r\n\r\n for i in range(tseries1.shape[0]):\r\n SNR1.append(nta.SNRAnalyzer(ts.TimeSeries(tseries1.data[i],\r\n sampling_rate=tseries1.sampling_rate)))\r\n\r\n corr1.append(np.arctanh(np.abs(SNR1[-1].correlation[0])))\r\n corr_e1.append(SNR1[-1].correlation[1])\r\n\r\n SNR2.append(nta.SNRAnalyzer(ts.TimeSeries(tseries2.data[i],\r\n sampling_rate=tseries2.sampling_rate)))\r\n\r\n corr2.append(np.arctanh(np.abs(SNR2[-1].correlation[0])))\r\n corr_e2.append(SNR1[-1].correlation[1])\r\n\r\n ax.scatter(np.array(corr1), np.array(corr2))\r\n ax.errorbar(np.mean(corr1), np.mean(corr2),\r\n yerr=np.std(corr2),\r\n xerr=np.std(corr1))\r\n plot_min = min(min(corr1), min(corr2))\r\n plot_max = max(max(corr1), max(corr2))\r\n ax.plot([plot_min, plot_max], [plot_min, plot_max], 'k--')\r\n ax.set_xlabel('Correlation (Fischer Z) %s' % ts_names[0])\r\n ax.set_ylabel('Correlation (Fischer Z) %s' % ts_names[1])\r\n\r\n return fig, corr1, corr2","def do_data_plots(cat, subdir):\n dla_data.noterdaeme_12_data()\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\"blue\")\n np.savetxt(path.join(subdir,\"cddf_all.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n plt.xlim(1e20, 1e23)\n plt.ylim(1e-28, 5e-21)\n plt.legend(loc=0)\n save_figure(path.join(subdir, \"cddf_gp\"))\n plt.clf()\n\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\"blue\", moment=True)\n plt.xlim(1e20, 1e23)\n plt.legend(loc=0)\n save_figure(path.join(subdir, \"cddf_moment_gp\"))\n plt.clf()\n\n #Evolution with redshift\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(4,5, label=\"4-5\", color=\"brown\")\n np.savetxt(path.join(subdir,\"cddf_z45.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(3,4, label=\"3-4\", color=\"black\")\n np.savetxt(path.join(subdir,\"cddf_z34.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2.5,3, label=\"2.5-3\", color=\"green\")\n np.savetxt(path.join(subdir,\"cddf_z253.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2,2.5, label=\"2-2.5\", color=\"blue\")\n np.savetxt(path.join(subdir,\"cddf_z225.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n plt.xlim(1e20, 1e23)\n plt.ylim(1e-28, 5e-21)\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"cddf_zz_gp\"))\n plt.clf()\n\n #dNdX\n dla_data.dndx_not()\n dla_data.dndx_pro()\n (z_cent, dNdX, dndx68, dndx95) = cat.plot_line_density(zmax=5)\n np.savetxt(path.join(subdir,\"dndx_all.txt\"), (z_cent, dNdX, dndx68[:,0],dndx68[:,1], dndx95[:,0],dndx95[:,1]) )\n plt.legend(loc=0)\n plt.ylim(0,0.16)\n save_figure(path.join(subdir,\"dndx_gp\"))\n plt.clf()\n\n #Omega_DLA\n dla_data.omegahi_not()\n dla_data.omegahi_pro()\n dla_data.crighton_omega()\n (z_cent, omega_dla, omega_dla_68, omega_dla_95) = cat.plot_omega_dla(zmax=5)\n# cat.tophat_prior = True\n# cat.plot_omega_dla(zmax=5, label=\"Tophat Prior\", twosigma=False)\n# cat.tophat_prior = False\n np.savetxt(path.join(subdir,\"omega_dla_all.txt\"), (z_cent, omega_dla, omega_dla_68[:,0],omega_dla_68[:,1], omega_dla_95[:,0], omega_dla_95[:,1]))\n plt.legend(loc=0)\n plt.xlim(2,5)\n plt.ylim(0,2.5)\n save_figure(path.join(subdir,\"omega_gp\"))\n plt.clf()","def view_datashade(self):\n # Select only sufficient data\n if self.x in self.y:\n self.y.remove(self.x)\n if self.y == []:\n return self.gif\n\n df = self.dataframe[[self.x] + self.y].copy()\n plot_opts = {\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\n\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\n # Compute\n dataframe = df.copy()\n if x_range is not None:\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\n data_length = len(dataframe) * len(dataframe.columns)\n step = 1 if data_length < self.max_step else data_length // self.max_step\n \n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \n plot_opts = {\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n if len(self.y) != 1:\n plot_opts['Scatter']['color'] = self.color_key\n return plot_df.options(plot_opts)\n\n # Define a RangeXY stream linked to the image\n rangex = hv.streams.RangeX(source=lines_overlay)\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\n if len(self.y) == 1:\n data_shade_plot *= datashade(lines_overlay)\n else:\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\n return pn.panel(data_shade_plot)","def fdplot(self, imx):\n fig = plt.figure()\n maxval = np.max(imx)\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\n animation = anim.ArtistAnimation(fig,ims,interval=50)\n plt.show()","def psf_plot(self, irfname=None, outfile='psf.csv', title=''):\n psf = self.get_psf(irfname)\n \n def bkg_size(e, ct):\n f2 = lambda delta: psf(e,ct, delta)**2 * 2*np.pi*delta\n return np.degrees(1./np.sqrt(np.pi*integrate.quad(f2, 0, np.inf)[0]))\n \n def loc_size(e, ct):\n func = lambda x : psf(e,ct, x)\n fprime = lambda x : misc.derivative(func, x, dx=0.0001, order=5)\n integrand = lambda rp : rp * fprime(rp)**2/func(rp) * np.pi\n return np.degrees(1/np.sqrt(integrate.quad(integrand, 0, np.radians(5))[0]))\n \n \n egev = np.logspace(-1.+1/8., 2.5+1/8., 3.5*4+1)\n front, back = [[bkg_size(e*1e3,ct) for e in egev] for ct in range(2)]\n floc, bloc = [[loc_size(e*1e3,ct) for e in egev] for ct in range(2)]\n f68,b68 = [[psf.inverse_integral(e*1e3, ct) for e in egev] for ct in range(2)]\n fig,ax = plt.subplots(figsize=(6,6))\n for x, s, label in zip((front, back, floc, bloc, f68, b68),\n ('-g', 'r', '--g', '--r', ':g', ':r'),\n ('front bkg', 'back bkg','front loc', 'back loc', 'front 68', 'back 68')):\n ax.plot(egev, x, s, lw=2, label=label)\n \n plt.setp(ax, xlabel='Energy (GeV)', ylabel='PSF size (deg)', xscale='log', yscale='log',\n xlim=(0.1, 100), ylim=(0.02, 8), title=title)\n ax.legend(prop=dict(size=10)); ax.grid()\n #x.set_xticklabels('0.1 1 10 100'.split())\n #ax.set_yticklabels('0.01 0.1 1'.split())\n if outfile is None: return fig\n self.psf_df = pd.DataFrame(dict(front=front, floc=floc, back=back, bloc=bloc,f68=f68,b68=b68), \n index=egev.round(3))\n self.psf_df.index.name='energy'\n self.psf_df.to_csv(os.path.join(self.plotfolder, outfile))\n print ('wrote file %s' % os.path.join(self.plotfolder, outfile))\n return fig","def plot(self):\n\n fig, ax = plt.subplots()\n\n for run in self.runs:\n # Load datasets\n data_measure = run.get_dataset(\"stats-collect_link_congestion-raw-*.csv\")\n data_sp = run.get_dataset(\"stats-collect_link_congestion-sp-*.csv\")\n\n # Extract link congestion information\n data_measure = data_measure['msgs']\n data_sp = data_sp['msgs']\n\n # Compute ECDF and plot it\n ecdf_measure = sm.distributions.ECDF(data_measure)\n ecdf_sp = sm.distributions.ECDF(data_sp)\n\n variable_label = \"\"\n size = run.orig.settings.get('size', None)\n if size is not None:\n variable_label = \" (n=%d)\" % size\n\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\n label=\"U-Sphere%s\" % variable_label)\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\n label=u\"Klasični usmerjevalni protokol%s\" % variable_label)\n\n ax.set_xlabel('Obremenjenost povezave')\n ax.set_ylabel('Kumulativna verjetnost')\n ax.grid()\n ax.axis((28, None, 0.99, 1.0005))\n self.convert_axes_to_bw(ax)\n\n legend = ax.legend(loc='lower right')\n if self.settings.GRAPH_TRANSPARENCY:\n legend.get_frame().set_alpha(0.8)\n fig.savefig(self.get_figure_filename())","def plot_snapshots(snapshots: HoomdFrame) -> Figure:\n return _plot_grid([style_snapshot(plot_frame(snap)) for snap in snapshots])","def plot_and_save_2d(file_name, path_name, raw_data_file, show=False):\n print '-'*23+'PLOT (2d)'+'-'*24\n \n print 'Loading data...',\n data = load_file(path_name+file_name)\n t = data['t']\n \n pic_path = path_name+'pics/'\n if not os.path.exists(pic_path):\n os.makedirs(pic_path)\n print 'done'\n print 'Creating and saving plots...', \n\n # Moment.\n plt.figure(1)\n plt.plot(t, data['dyn']['M'], t, data['static']['M'])\n plt.legend([\"Dynamic\", \"Static\"])\n plt.xlabel('t')\n plt.ylabel('M')\n plt.title('Moment')\n plt.grid()\n plt.savefig('%sM.png' %pic_path)\n\n # Axial force.\n plt.figure(2)\n plt.plot(t, data['dyn']['FY'], t, data['static']['FY'])\n plt.legend([\"Dynamic\", \"Static\"])\n plt.xlabel('t')\n plt.ylabel('Fa')\n plt.title('Fa')\n plt.grid()\n plt.savefig('%sFa.png' %pic_path)\n\n # Transverse force.\n plt.figure(3)\n plt.plot(t, data['dyn']['FZ'], t, data['static']['FZ'])\n plt.legend([\"Dynamic\", \"Static\"])\n plt.xlabel('t')\n plt.ylabel('Ft')\n plt.title('Ft')\n plt.grid()\n plt.savefig('%sFt.png' %pic_path)\n\n # Resultant force.\n plt.figure(4)\n plt.plot(t, np.sqrt(data['dyn']['FY']**2+data['dyn']['FZ']**2),\n t, np.sqrt(data['static']['FY']**2+data['static']['FZ']**2))\n plt.legend([\"Dynamic\", \"Static\"])\n plt.xlabel('t')\n plt.ylabel('Fr')\n plt.title('Fr')\n plt.grid()\n plt.savefig('%sFr.png' %pic_path)\n print 'done'\n\n if show:\n plt.show()","def fiducial_evolution():\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n x = pk['x'].to(u.kpc)\n xorig = x[:2]\n \n plt.close()\n fig, ax = plt.subplots(1,1,figsize=(6,6))\n \n plt.sca(ax)\n \n Nsnap = 8\n times = np.linspace(0,0.5,Nsnap)[::-1]\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\n\n for e, t in enumerate(times):\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\n \n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\n x = pk['x'].to(u.kpc)\n x_, y_ = x[0], x[1]\n \n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\n \n xt = 24*np.cos(angles[e]+90*u.deg)\n yt = 24*np.sin(angles[e]+90*u.deg)\n if e<Nsnap-1:\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\n \n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\n\n lim = 27\n plt.xlim(-lim,lim)\n plt.ylim(-lim,lim)\n plt.gca().set_aspect('equal')\n \n plt.xlabel('x [kpc]')\n plt.ylabel('y [kpc]')\n \n plt.tight_layout()\n plt.savefig('../plots/loop_evolution.pdf')","def plot_energy_vs_rmsd(\n set1_rmsds_x, set1_energies_y, set2_rmsds_x, set2_energies_y,\n x_ticks, x_label, y_label, point_size, set1_color, set2_color,\n set1_marker, set2_marker, output_filename):\n\n plt.scatter(set1_rmsds_x, set1_energies_y, color=set1_color,\n s=point_size, marker=set1_marker)\n plt.scatter(set2_rmsds_x, set2_energies_y, color=set2_color,\n s=point_size, marker=set2_marker)\n plt.xlabel(x_label, fontsize=13)\n plt.ylabel(y_label, fontsize=13)\n plt.xticks(x_ticks)\n\n plt.savefig(output_filename + \".pdf\", dpi=300, transparent='True',\n bbox_inches='tight', figsize=(5, 5), pad_inches=0.05)\n plt.savefig(output_filename + \".png\", dpi=300, transparent='True',\n bbox_inches='tight', figsize=(5, 5), pad_inches=0.05)","def plot_ef2(n_points, er, cov):\n if er.shape[0] != 2 or er.shape[0] != 2:\n raise ValueError(\"plot_ef2 can only plot 2-asset frontiers\")\n weights = [np.array([w, 1-w]) for w in np.linspace(0, 1, n_points)]\n rets = [portfolio_return(w, er) for w in weights]\n vols = [portfolio_vol(w, cov) for w in weights]\n ef = pd.DataFrame({\n \"Returns\": rets, \n \"Volatility\": vols\n })\n return ef.plot.line(x=\"Volatility\", y=\"Returns\", style=\".-\")"],"string":"[\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def sysPLQF(mirror, blkFlag=True):\\n import matplotlib.pyplot as plt\\n import numpy as np # to ndarray.flatten ax\\n\\n mir = mirror\\n xend = max(mir.r_t)\\n\\n fig, ax = plt.subplots(nrows=2, ncols=2,)\\n ax = np.ndarray.flatten(ax)\\n ax[0].set_title('Real Power Generated')\\n for mach in mir.Machines:\\n ax[0].plot(mir.r_t, mach.r_Pe, \\n marker = 10,\\n fillstyle='none',\\n #linestyle = ':',\\n label = 'Pe Gen '+ mach.Busnam)\\n ax[0].set_xlabel('Time [sec]')\\n ax[0].set_ylabel('MW')\\n\\n ax[2].set_title('Reactive Power Generated')\\n for mach in mir.Machines:\\n ax[2].plot(mir.r_t, mach.r_Q, \\n marker = 10,\\n fillstyle='none',\\n #linestyle = ':',\\n label = 'Q Gen '+ mach.Busnam)\\n ax[2].set_xlabel('Time [sec]')\\n ax[2].set_ylabel('MVAR')\\n\\n ax[1].set_title('Total System P Loading')\\n ax[1].plot(mir.r_t, mir.r_ss_Pload, \\n marker = 11,\\n #fillstyle='none',\\n #linestyle = ':',\\n label = 'Pload')\\n ax[1].set_xlabel('Time [sec]')\\n ax[1].set_ylabel('MW')\\n\\n ax[3].set_title('System Mean Frequency')\\n ax[3].plot(mir.r_t, mir.r_f,\\n marker = '.',\\n #linestyle = ':',\\n label = r'System Frequency')\\n ax[3].set_xlabel('Time [sec]')\\n ax[3].set_ylabel('Frequency [PU]')\\n\\n # Global Plot settings\\n for x in np.ndarray.flatten(ax):\\n x.set_xlim(0,xend)\\n x.legend()\\n x.grid(True)\\n\\n fig.tight_layout()\\n\\n plt.show(block = blkFlag)\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def plot_fvc_distances(\\n configuration: BaseConfiguration,\\n fibre_data_F: pandas.DataFrame,\\n path: str | pathlib.Path | None = None,\\n):\\n\\n data = configuration.assignment_data.fibre_table.copy()\\n data = data.reset_index().set_index([\\\"positioner_id\\\", \\\"fibre_type\\\"])\\n\\n data_F = fibre_data_F.copy()\\n data_F = data_F.reset_index().set_index([\\\"positioner_id\\\", \\\"fibre_type\\\"])\\n\\n is_dither = configuration.is_dither\\n\\n data = data.loc[data_F.index, :]\\n\\n data_F[\\\"xwok_distance\\\"] = data.xwok - data_F.xwok\\n data_F[\\\"ywok_distance\\\"] = data.ywok - data_F.ywok\\n data_F[\\\"wok_distance\\\"] = numpy.hypot(data_F.xwok_distance, data_F.ywok_distance)\\n\\n deccen = configuration.assignment_data.boresight[0][1]\\n cos_dec = numpy.cos(numpy.deg2rad(float(deccen)))\\n\\n data_F[\\\"ra_distance\\\"] = (data.ra_epoch - data_F.ra_epoch) * cos_dec * 3600.0\\n data_F[\\\"dec_distance\\\"] = (data.dec_epoch - data_F.dec_epoch) * 3600.0\\n data_F[\\\"sky_distance\\\"] = numpy.hypot(data_F.ra_distance, data_F.dec_distance)\\n\\n if not is_dither:\\n data_F[\\\"racat_distance\\\"] = (data_F.ra_icrs - data_F.ra_epoch) * cos_dec * 3600.0\\n data_F[\\\"deccat_distance\\\"] = (data_F.dec_icrs - data_F.dec_epoch) * 3600.0\\n data_F[\\\"skycat_distance\\\"] = numpy.hypot(\\n data_F.racat_distance, data_F.deccat_distance\\n )\\n\\n with plt.ioff(): # type: ignore\\n seaborn.set_theme()\\n\\n fig, axes = plt.subplots(1, 3, figsize=(30, 10))\\n\\n if not is_dither:\\n data_F = data_F.groupby(\\\"positioner_id\\\").filter(\\n lambda g: g.assigned.any() & g.on_target.any() & g.valid.all()\\n )\\n\\n assert isinstance(axes, numpy.ndarray)\\n\\n _plot_wok_distance(data_F, axes[0])\\n\\n _plot_sky_distance(\\n data_F,\\n axes[1],\\n \\\"sky_distance\\\",\\n is_dither=is_dither,\\n plot_metrology=True,\\n title=\\\"Sky distance (ra/dec vs ra/dec)\\\",\\n )\\n\\n # if not is_dither:\\n # _plot_sky_distance(\\n # data_F,\\n # axes[1, 0],\\n # \\\"skycat_distance\\\",\\n # is_dither=is_dither,\\n # plot_metrology=False,\\n # title=\\\"Sky distance (ra/dec vs racat/deccat)\\\",\\n # )\\n\\n _plot_sky_quiver(data_F, axes[2], is_dither=is_dither)\\n\\n fig.suptitle(\\n f\\\"Configuration ID: {configuration.configuration_id}\\\"\\n + (\\\" (dithered)\\\" if is_dither else \\\"\\\")\\n )\\n\\n plt.tight_layout()\\n\\n if path:\\n fig.savefig(str(path))\\n plt.close(fig)\\n\\n seaborn.reset_defaults()\\n\\n return fig\",\n \"def plot_delta(fname, temp, delta_ts_list, delta_rxn_list, labels, var='G'):\\n max_y_lines = 5\\n x_axis = np.array([0, 1, 3, 4, 6, 7])\\n y_axis = []\\n y_labels = []\\n # y_min = np.floor(np.array(g_rxn_list).min())\\n # y_max = np.ceil(np.array(g_ts_list).max())\\n for index in range(max_y_lines):\\n try:\\n y_axis.append(np.array([0.0, 0.0, delta_ts_list[index], delta_ts_list[index],\\n delta_rxn_list[index], delta_rxn_list[index]]))\\n except IndexError:\\n y_axis.append(None)\\n try:\\n y_labels.append(labels[index])\\n except IndexError:\\n y_labels.append(None)\\n\\n make_fig(fname, x_axis, y_axis[0],\\n x_label='reaction coordinate', y_label='\\\\u0394' + var + ' at {} K (kcal/mol)'.format(temp),\\n y1_label=y_labels[0], y2_label=y_labels[1], y3_label=y_labels[2], y4_label=y_labels[3],\\n y5_label=y_labels[4], y2_array=y_axis[1], y3_array=y_axis[2], y4_array=y_axis[3], y5_array=y_axis[4],\\n ls2='-', ls3='-', ls4='-', ls5='-',\\n # y_lima=y_min, y_limb=y_max,\\n hide_x=True,\\n )\",\n \"def plot(self):\\n\\t\\t\\n\\t\\ttf=tfData(self.shotno,tStart=None,tStop=None)\\n\\t\\t\\n\\t\\t_plt.figure()\\n\\t\\tax1 = _plt.subplot2grid((3,2), (0,1), rowspan=3) #tf\\n\\t\\tax2 = _plt.subplot2grid((3,2), (0,0)) #vf\\n\\t\\tax3 = _plt.subplot2grid((3,2), (1,0),sharex=ax2) #oh\\n\\t\\tax4 = _plt.subplot2grid((3,2), (2, 0),sharex=ax2) #sh\\n\\t\\tfig=_plt.gcf()\\n\\t\\tfig.set_size_inches(10,5)\\n\\t\\t\\t\\t\\n\\t\\ttStart=-2\\n\\t\\ttStop=20\\n\\t\\t\\n\\t\\tax1.plot(tf.time*1e3,tf.tfBankField)\\n\\t\\tax1.axvspan(tStart,tStop,color='r',alpha=0.3)\\n\\t\\t_plot.finalizeSubplot(ax1,xlabel='Time (s)',xlim=[-150,450],ylabel='TF Field (T)')#,title=self.title\\n\\t\\t\\n\\t\\tax2.plot(self.vfTime*1e3,self.vfBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax2,ylabel='VF Current\\\\n(kA)')\\n\\t\\t\\n\\t\\tax3.plot(self.ohTime*1e3,self.ohBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax3,ylim=[-20,30],ylabel='OH Current\\\\n(kA)')\\n\\t\\t\\n\\t\\tax4.plot(self.shTime*1e3,self.shBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax4,ylim=[tStart,tStop],xlabel='Time (s)',ylabel='SH Current\\\\n(kA)')\\n\\t\\t\\n\\t\\t_plot.finalizeFigure(fig,title=self.title)\\n#\\t\\tfig.set_tight_layout(True)\\n\\t\\t\\n\\t\\treturn fig\",\n \"def show_dcr_results(dg):\\n cycle = dg.fileDB['cycle'].values[0]\\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\\n # print(df_dsp.describe()) \\n\\n # compare DCR and A/E distributions\\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\\n \\n elo, ehi, epb = 0, 25000, 100\\n \\n # aoe distribution\\n # ylo, yhi, ypb = -1, 2, 0.1\\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p0.set_ylabel('A/E', ha='right', y=1)\\n\\n # dcr distribution\\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\\n # ylo, yhi, ypb = -3, 2, 0.1\\n ylo, yhi, ypb = 0.9, 1.08, 0.001\\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p1.set_ylabel('DCR', ha='right', y=1)\\n \\n # plt.show()\\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\\n plt.cla()\",\n \"def show_derivative(self):\\n for trace in self.plotWidget.plotDataItems:\\n dt = float(trace.attrs['dt'])\\n dtrace = np.diff(trace.data)\\n x = pgplot.make_xvector(dtrace, dt)\\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))\",\n \"def plot_rfs(self):\\n self.xe = self.data['XE']\\n self.ye = self.data['YE']\\n# self.IE = self.data['IE']\\n self.Var = self.data['Var']\\n std = np.sqrt(np.mean(self.Var))\\n fig = plt.gcf()\\n ax = plt.gca()\\n ax.set_xlim((np.min(self.xe), np.max(self.xe)))\\n ax.set_ylim((np.min(self.ye), np.max(self.ye)))\\n for xe, ye in zip(self.xe, self.ye):\\n circ = plt.Circle((xe, ye), std, color='b', alpha=0.4)\\n fig.gca().add_artist(circ)\",\n \"def volatility_factor_plot(prices: list, dates: list, vf_data: VFStopsResultType,\\n green_zone_x_values: List[list], red_zone_x_values: List[list],\\n yellow_zone_x_values: List[list], y_range: float, minimum: float,\\n text_str: str = \\\"\\\", str_color: str = \\\"\\\", **kwargs):\\n # pylint: disable=too-many-locals,too-many-branches,too-many-statements\\n register_matplotlib_converters()\\n\\n title = kwargs.get('title', '')\\n save_fig = kwargs.get('save_fig', False)\\n filename = kwargs.get('filename', 'temp_candlestick.png')\\n\\n stop_loss_objects = vf_data.data_sets\\n\\n shown_stop_loss = f\\\"VF: {np.round(vf_data.vf.curated, 3)}\\\\n\\\"\\n if vf_data.current_status.status.value != 'stopped_out':\\n shown_stop_loss += f\\\"Stop Loss: ${np.round(vf_data.stop_loss.curated, 2)}\\\"\\n else:\\n shown_stop_loss += \\\"Stop Loss: n/a\\\"\\n\\n fig, ax_handle = plt.subplots()\\n\\n date_indexes = [datetime.strptime(date, '%Y-%m-%d').date() for date in dates]\\n ax_handle.plot(date_indexes, prices, color='black')\\n\\n # Set the tick spacing (this is because dates crowd easily)\\n mid_tick_size = int(len(date_indexes) / 4)\\n ax_handle.xaxis.set_ticks([\\n date_indexes[0], date_indexes[mid_tick_size], date_indexes[mid_tick_size * 2],\\n date_indexes[mid_tick_size * 3], date_indexes[-1]\\n ])\\n\\n y_start = minimum - (y_range * 0.05)\\n height = y_range * 0.02\\n\\n for stop in stop_loss_objects:\\n sub_dates = [date_indexes[index] for index in stop.time_index_list]\\n ax_handle.plot(sub_dates, stop.caution_line, color='gold')\\n ax_handle.plot(sub_dates, stop.stop_loss_line, color='red')\\n\\n for green_zone in green_zone_x_values:\\n start = mdates.date2num(date_indexes[green_zone[0]])\\n end = mdates.date2num(date_indexes[green_zone[-1]])\\n width = end - start\\n ax_handle.add_patch(\\n Rectangle(\\n (start, y_start),\\n width,\\n height,\\n edgecolor='green',\\n facecolor='green',\\n fill=True\\n )\\n )\\n\\n for red_zone in red_zone_x_values:\\n start = mdates.date2num(date_indexes[red_zone[0]])\\n end = mdates.date2num(date_indexes[red_zone[-1]])\\n width = end - start\\n ax_handle.add_patch(\\n Rectangle(\\n (start, y_start),\\n width,\\n height,\\n edgecolor='red',\\n facecolor='red',\\n fill=True\\n )\\n )\\n\\n for yellow_zone in yellow_zone_x_values:\\n start = mdates.date2num(date_indexes[yellow_zone[0]])\\n end = mdates.date2num(date_indexes[yellow_zone[-1]])\\n width = end - start\\n ax_handle.add_patch(\\n Rectangle(\\n (start, y_start),\\n width,\\n height,\\n edgecolor='yellow',\\n facecolor='yellow',\\n fill=True\\n )\\n )\\n\\n ax_handle.set_title(title)\\n\\n if len(text_str) > 0 and len(str_color) > 0:\\n new_start = minimum - (y_range * 0.2)\\n new_end = minimum + (y_range * 1.02)\\n ax_handle.set_ylim(new_start, new_end)\\n props = dict(boxstyle='round', facecolor='white', alpha=0.25)\\n ax_handle.text(\\n 0.02,\\n 0.02,\\n text_str,\\n color=str_color,\\n transform=ax_handle.transAxes,\\n bbox=props\\n )\\n\\n if len(shown_stop_loss) > 0:\\n props = dict(boxstyle='round', facecolor='white', alpha=0.25)\\n ax_handle.text(\\n 0.02,\\n 0.90,\\n shown_stop_loss,\\n transform=ax_handle.transAxes,\\n bbox=props\\n )\\n\\n try:\\n if save_fig:\\n temp_path = os.path.join(\\\"output\\\", \\\"temp\\\")\\n if not os.path.exists(temp_path):\\n # For functions, this directory may not exist.\\n plt.close(fig)\\n plt.clf()\\n return\\n\\n filename = os.path.join(temp_path, filename)\\n if os.path.exists(filename):\\n os.remove(filename)\\n plt.savefig(filename)\\n\\n else:\\n plt.show()\\n\\n except: # pylint: disable=bare-except\\n print(\\n f\\\"{utils.WARNING}Warning: plot failed to render in 'volatility factor plot' of \\\" +\\n f\\\"title: {title}{utils.NORMAL}\\\")\\n\\n plt.close('all')\\n plt.clf()\",\n \"def v_positions_history(self, end=yesterdaydash(), rendered=True):\\n start = self.totcftable.iloc[0].date\\n times = pd.date_range(start, end)\\n tdata = []\\n for date in times:\\n sdata = sorted(\\n [\\n (\\n date,\\n fob.briefdailyreport(date).get(\\\"currentvalue\\\", 0),\\n fob.name,\\n )\\n for fob in self.fundtradeobj\\n ],\\n key=lambda x: x[1],\\n reverse=True,\\n )\\n tdata.extend(sdata)\\n\\n tr = ThemeRiver()\\n tr.add(\\n series_name=[foj.name for foj in self.fundtradeobj],\\n data=tdata,\\n label_opts=opts.LabelOpts(is_show=False),\\n singleaxis_opts=opts.SingleAxisOpts(type_=\\\"time\\\", pos_bottom=\\\"10%\\\"),\\n )\\n if rendered:\\n return tr.render_notebook()\\n else:\\n return tr\",\n \"def show(self, fig=None):\\n i = 0\\n # for t = 0:obj.step_size:obj.duration\\n # TODO: make a generator?\\n iterator = np.linspace(0, self.duration(), num=math.ceil(self.duration() / self.step_precision) + 1)\\n tfInterp_l = np.zeros((4, 4, len(iterator)))\\n tfInterp_r = np.zeros((4, 4, len(iterator)))\\n for t in iterator:\\n [lfp, rfp] = self.footPosition(t)\\n tfInterp_l[:, :, i] = lfp\\n tfInterp_r[:, :, i] = rfp\\n i = i + 1\\n\\n self.show_tf(fig, tfInterp_l, len(iterator))\\n self.show_tf(fig, tfInterp_r, len(iterator))\",\n \"def plot_fits_and_residuals(all_fits_df, dfs_list, expt_name, **kwargs):\\n\\n colors = cm.rainbow(np.linspace(0, 1, len(dfs_list)))\\n fig = plt.figure(figsize=(5, 5), tight_layout=True)\\n fig.set_dpi(300)\\n\\n filename = f'{expt_name}_fits_and_residuals'\\n fileformat = '.png'\\n \\n # Set parameters for decay traces plot\\n xlabel_traces = kwargs.get('xlabel_traces', 'Time after Chase (Hrs.)')\\n ylabel_traces = kwargs.get('ylabel_traces', 'YFP(t)/YFP(0)')\\n ylim_traces = kwargs.get('ylim_traces', (0, 1.2))\\n xticks_traces = kwargs.get('xticks_traces', make_ticks(all_fits_df.x_input, decimals=0))\\n yticks_traces = kwargs.get('y_ticks_traces', make_ticks((0, 1), decimals=1, n_ticks=7))\\n xlim_traces = kwargs.get('xlim_traces', (xticks_traces.min(), xticks_traces.max())) \\n # Set parameters for decay fit residuals plot\\n xlabel_resids = kwargs.get('xlabel_resids', xlabel_traces)\\n ylabel_resids = kwargs.get('ylabel_resids', 'Residuals')\\n xlim_resids = kwargs.get('xlim_resids', xlim_traces)\\n xticks_resids = xticks_traces\\n yticks_resids = kwargs.get('yticks_resids', make_yticks_0cent(all_fits_df.residual))\\n ylim_resids = kwargs.get('ylim_resids', (yticks_resids.min(), yticks_resids.max()))\\n \\n # Set parameters for decay fit residuals kernel density estimate\\n # plot \\n xlabel_kde = kwargs.get('xlabel_kde', ylabel_resids)\\n ylabel_kde = kwargs.get('ylabel_kde', 'Density')\\n xlim_kde = kwargs.get('xlim_kde', ylim_resids)\\n ylim_kde = kwargs.get('ylim_kde', None)\\n xticks_kde = yticks_resids\\n # yticks_kde will get set below during \\n # density calcuation\\n \\n # Set parameters used across all plots\\n hidden_spines = kwargs.get('hidden_spine', ['top', 'right'])\\n labelfontsize = kwargs.get('labelfontsize', 12)\\n linewidth = kwargs.get('linewidth', 1)\\n linealpha = kwargs.get('linealpha', 1)\\n scatteralpha = kwargs.get('scatteralpha', 0.8)\\n scattersize = kwargs.get('scattersize', 5)\\n \\n # Make the residuals scatter plot\\n ax = fig.add_subplot(222)\\n for cell_index in all_fits_df.cell_index.unique()[:]:\\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\\n ax.scatter(cell_df.x_input, cell_df.residual,\\n s=scattersize, alpha=scatteralpha,\\n facecolor='white', edgecolor=colors[cell_index])\\n\\n ax.axhline(0, linewidth=linewidth, alpha=linealpha, color='black')\\n for spine in [ax.spines[hidden_spine] for hidden_spine in hidden_spines]:\\n spine.set_visible(False)\\n try:\\n ax.set_xticks(xticks_resids)\\n except:\\n pass\\n try:\\n ax.set_yticks(yticks_resids)\\n except:\\n pass\\n try:\\n ax.set_ylim(ylim_resids)\\n except:\\n pass\\n if xlabel_resids:\\n ax.set_xlabel(xlabel_resids, fontsize=labelfontsize)\\n if ylabel_resids:\\n ax.set_ylabel(ylabel_resids, fontsize=labelfontsize) \\n\\n ax.set_aspect(1.0/ax.get_data_ratio(), adjustable='box')\\n\\n # Scatter plot of traces and line plot of fitted decays\\n ax2 = fig.add_subplot(221)\\n\\n for cell_index in all_fits_df.cell_index.unique()[:]:\\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\\n ax2.plot(cell_df.x_input, cell_df.y_pred_norm/cell_df.y_pred_norm.max(),\\n linewidth=linewidth, alpha=linealpha, color=colors[cell_index])\\n ax2.scatter(cell_df.x_input, cell_df.y_input_norm/cell_df.y_input_norm.max(),\\n s=scattersize, alpha=scatteralpha, color=colors[cell_index])\\n\\n if ylim_traces:\\n ax2.set_ylim(ylim_traces)\\n if xlim_traces:\\n ax2.set_xlim(xlim_traces) \\n try:\\n ax2.set_xticks(xticks_traces)\\n except:\\n pass\\n try:\\n ax2.set_yticks(yticks_traces)\\n except:\\n pass \\n if xlabel_traces:\\n ax2.set_xlabel(xlabel_traces, fontsize=labelfontsize)\\n if ylabel_traces:\\n ax2.set_ylabel(ylabel_traces, fontsize=labelfontsize) \\n\\n ax2.set_aspect(1.0/ax2.get_data_ratio(), adjustable='box')\\n for spine in [ax2.spines[hidden_spine] for hidden_spine in hidden_spines]:\\n spine.set_visible(False)\\n\\n # Smoothed hist of residuals for each cell (KDE plot)\\n ax3 = fig.add_subplot(223)\\n \\n densities = []\\n for cell_index in all_fits_df.cell_index.unique()[:]:\\n cell_df = all_fits_df.loc[all_fits_df.cell_index == cell_index, :]\\n density = gaussian_kde(cell_df.residual)\\n xs = np.linspace(all_fits_df.residual.min(),all_fits_df.residual.max(),200)\\n ax3.plot(xs,density(xs), color=colors[cell_index],\\n alpha=linealpha, linewidth=linewidth)\\n densities.append(density(xs))\\n\\n # Also plot total residuals\\n density = gaussian_kde(all_fits_df.residual)\\n xs = np.linspace(all_fits_df.residual.min(),all_fits_df.residual.max(),200)\\n ax3.plot(xs,density(xs), color='black',\\n alpha=linealpha*2, linewidth=linewidth)\\n densities.append(density(xs))\\n \\n # Figure out whech density outuput array has the highest y value and\\n # set the yticks of the plot using that density array\\n max_dens = np.array([np.max(arr) for arr in densities])\\n longest_range_den = densities[max_dens.argmax()]\\n yticks_kde = make_ticks(longest_range_den)\\n\\n if ylim_kde:\\n ax3.set_ylim(ylim)\\n if xlim_kde:\\n ax3.set_xlim(xlim_kde)\\n if xlabel_kde:\\n ax3.set_xlabel(xlabel_kde, fontsize=labelfontsize)\\n if ylabel_kde:\\n ax3.set_ylabel(ylabel_kde, fontsize=labelfontsize)\\n try:\\n ax3.set_yticks(yticks_kde)\\n except:\\n pass\\n try:\\n ax3.set_xticks(xticks_kde)\\n except:\\n pass\\n\\n ax3.set_aspect(1.0/ax3.get_data_ratio(), adjustable='box')\\n for spine in [ax3.spines[hidden_spine] for hidden_spine in hidden_spines]:\\n spine.set_visible(False)\\n\\n if filename and fileformat:\\n fig.savefig(f'{filename}{fileformat}', transparent=True)\\n print(f'Saved plot at {filename}{fileformat}')\",\n \"def plot_image_and_rfs(self, fig=None, ax=None, legend=True, q=None,\\n alpha_rf=0.5, cmap=plt.cm.gray_r):\\n if fig is None:\\n fig, ax = plt.subplots(1, 1)\\n\\n if q is None:\\n dx, dy = 0., 0.\\n xr, yr = self.xr, self.yr\\n\\n else:\\n dx = self.xr[q]\\n dy = self.yr[q]\\n xr, yr = self.xr[0:q], self.yr[0:q]\\n\\n m = max(max(self.data['XE']), max(self.data['YE']))\\n ax.set_xlim([-m, m])\\n ax.set_ylim([-m, m])\\n\\n if self.s_range == 'sym':\\n ax.imshow(np.zeros((1, 1)), cmap=cmap, vmin=-0.5, vmax=0.5,\\n extent=[-m, m, -m, m])\\n\\n self.plot_base_image(\\n fig, ax, colorbar=False, alpha=1., cmap=cmap, dx=dx, dy=dy)\\n\\n _plot_rfs(\\n ax, self.data['XE'], self.data['YE'], self.data['de'],\\n legend, alpha=alpha_rf)\\n\\n ax.plot(-xr, yr, label='Eye path', c='g')\",\n \"def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\\n plt.figure()\\n\\n #legacy beamprofile data is a 1-D array of the peak negative pressure\\n if len(self.hydoutput.shape)<2:\\n pnp = self.hydoutput\\n else:\\n sensitivity = hyd_calibration(self.cfreq)\\n pnp = -1*np.min(self.hydoutput,1)/sensitivity\\n\\n if dbdown:\\n pnp = 20.0*np.log10(pnp/np.max(pnp))\\n else:\\n pnp = pnp*1e-6\\n\\n figure1 = plt.plot(self.depth, pnp)\\n #the latest beamprofile data should be a 2-D array of the hydrophone output\\n plt.xlabel('Depth (mm)')\\n if dbdown:\\n plt.ylabel('Peak Negative Pressure (dB Max)')\\n else:\\n plt.ylabel('Peak Negative Pressure (MPa)')\\n plt.title(self.txdr)\\n if displayplt:\\n plt.show()\\n if saveplt:\\n if savepath=='':\\n #prompt for a save path using a default filename\\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_depthprofile.png'\\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\\n plt.savefig(savepath)\\n return figure1, savepath\",\n \"def plot_snapshot(snap):\\n\\n q = snap['q'][:]\\n phi = snap['phi'][:]\\n t = snap['t'][()]\\n\\n fig = plt.figure(figsize=(10.5,5))\\n cv = np.linspace(-.2,.2,30)\\n cphi = np.linspace(0,4.,30)\\n Ew = epsilon_w/muw/2\\n Q = (2*np.pi)**-2 * epsilon/(mu**2 / kf**2)\\n PHI = np.sqrt(epsilon_w/muw)\\n PHI2 = PHI**2\\n\\n ax = fig.add_subplot(121,aspect=1)\\n im1 = plt.contourf(x[:nmax,:nmax]/Lf,y[:nmax,:nmax]/Lf,q[:nmax,:nmax]/Q,cv,\\\\\\n cmin=-0.2,cmax=0.2,extend='both',cmap=cmocean.cm.curl)\\n plt.xlabel(r'$x\\\\, k_f$')\\n plt.ylabel(r'$y\\\\, k_f$')\\n\\n plt.text(25.25,25.5,r\\\"$t\\\\,\\\\,\\\\gamma = %3.2f$\\\" % (t*muw))\\n\\n cbaxes = fig.add_axes([0.15, 1., 0.3, 0.025]) \\n plt.colorbar(im1, cax = cbaxes, ticks=[-.2,-.1,0,.1,.2],orientation='horizontal',label=r'Potential vorticity $[q/Q]$')\\n\\n ax = fig.add_subplot(122,aspect=1)\\n im2 = plt.contourf(x[:nmax,:nmax]/Lf,y[:nmax,:nmax]/Lf,np.abs(phi[:nmax,:nmax])**2/PHI2,cphi,\\\\\\n cmin=0,cmax=4,extend='max',cmap=cmocean.cm.ice_r)\\n\\n plt.xlabel(r'$x\\\\, k_f$')\\n plt.yticks([])\\n\\n cbaxes = fig.add_axes([0.575, 1., 0.3, 0.025]) \\n plt.colorbar(im2,cax=cbaxes,ticks=[0,1,2,3,4],orientation='horizontal',label=r'Wave action density $[\\\\mathcal{A}/A]$')\\n\\n figname = \\\"figs2movie/qgniw/\\\"+ fni[-18:-3]+\\\".png\\\"\\n\\n plt.savefig(figname, dpi=80, pad_inces=0, bbox_inches='tight')\\n\\n plt.close(\\\"all\\\")\",\n \"def plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def show(self):\\n fixed_cols = [\\\"Recovered\\\", \\\"Actual\\\"]\\n # Predict the future with curve fitting\\n df_list = [\\n self.curve_fit(df, num).drop(fixed_cols, axis=1)\\n for (num, df) in enumerate(self.subsets)\\n ]\\n pred_df = pd.concat(df_list, axis=1)\\n pred_df[fixed_cols] = self.all_df[fixed_cols]\\n if \\\"1st_phase\\\" in pred_df.columns:\\n phase0_name = \\\"Initial_phase\\\"\\n else:\\n phase0_name = \\\"Regression\\\"\\n pred_df = pred_df.rename({\\\"0th_phase\\\": phase0_name}, axis=1)\\n # The list of change points\\n day_list = [df.index.min() for df in df_list]\\n # Show figure and the list of change points in string\\n str_dates = self._show_figure(pred_df, day_list)\\n return str_dates\",\n \"def SA_data_display(opt_df, all_df):\\n fig, axs = plt.subplots(2, 3)\\n\\n axs[0,0].set_title(\\\"Optimal rewire attempts for circularity\\\")\\n axs[0,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[0,0].set_xlabel(\\\"Time (s)\\\")\\n axs[0,0].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Percent waste (%)\\\"])\\n\\n axs[0,1].set_title(\\\"Optimal rewire attempts acceptance probability\\\")\\n axs[0,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[0,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,1].scatter(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Probability\\\"])\\n\\n axs[0,2].set_title(\\\"Optimal rewire attempts temperature decrease\\\")\\n axs[0,2].set_ylabel(\\\"Temperature\\\")\\n axs[0,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,2].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Temperature\\\"])\\n\\n axs[1,0].set_title(\\\"All rewire attempts for circularity\\\")\\n axs[1,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[1,0].set_xlabel(\\\"Time (s)\\\")\\n axs[1,0].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Percent waste (%)\\\"])\\n\\n axs[1,1].set_title(\\\"All rewire attempts acceptance probability\\\")\\n axs[1,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[1,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,1].scatter(all_df[\\\"Time (s)\\\"], all_df[\\\"Probability\\\"])\\n\\n axs[1,2].set_title(\\\"All rewire attempts temperature decrease\\\")\\n axs[1,2].set_ylabel(\\\"Temperature\\\")\\n axs[1,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,2].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Temperature\\\"])\\n\\n return plt.show()\",\n \"def plot_derivatives(self, show=False):\\n\\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(0,self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].set_xscale('log')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[1, 0].set_xscale('log')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 0].set_title('Upper - lower input data: train sample');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 0].set_title('Numerical derivative: train sample');\\n ax[3, 0].set_xlabel(r'$\\\\ell$')\\n ax[3, 0].set_ylabel(r'$\\\\Delta C_\\\\ell / 2\\\\Delta \\\\theta$')\\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 0].set_xscale('log')\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n ax[0, 1].set_xscale('log')\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n ax[1, 1].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 1].set_title('Upper - lower input data: test sample');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 1].set_title('Numerical derivative: train sample');\\n ax[3, 1].set_xlabel(r'$\\\\ell$')\\n ax[3, 1].set_ylabel(r'$\\\\Delta C_\\\\ell / \\\\Delta \\\\theta $')\\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 1].set_xscale('log')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def _create_velocity_figure(dataframe, color_key, title, color_mapper,\\n legend_loc='top_right', plot_width=None, plot_height=None):\\n \\n # these markers are nearly indistinguishble\\n markers = [marker for marker in MarkerType if marker not in ['circle_cross', 'circle_x']]\\n fig = figure(title=title)\\n _set_plot_wh(fig, plot_width, plot_height)\\n\\n for i, (marker, (path, df)) in enumerate(zip(markers, dataframe.iterrows())):\\n ds = dict(df)\\n source = ColumnDataSource(ds)\\n fig.scatter('dpt', 'expr', source=source, color={'field': color_key, 'transform': color_mapper},\\n marker=marker, size=10, legend=f'{path}', muted_alpha=0)\\n\\n fig.xaxis.axis_label = 'dpt'\\n fig.yaxis.axis_label = 'expression'\\n if legend_loc is not None:\\n fig.legend.location = legend_loc\\n\\n if ds.get('x_test') is not None:\\n if ds.get('x_mean') is not None:\\n fig.line('x_test', 'x_mean', source=source, muted_alpha=0, legend=path)\\n if all(map(lambda val: val is not None, ds.get('x_cov', [None]))):\\n x_mean = ds['x_mean']\\n x_cov = ds['x_cov']\\n band_x = np.append(ds['x_test'][::-1], ds['x_test'])\\n # black magic, known only to the most illustrious of wizards\\n band_y = np.append((x_mean - np.sqrt(np.diag(x_cov)))[::-1], (x_mean + np.sqrt(np.diag(x_cov))))\\n fig.patch(band_x, band_y, alpha=0.1, line_color='black', fill_color='black',\\n legend=path, line_dash='dotdash', muted_alpha=0)\\n\\n if ds.get('x_grad') is not None:\\n fig.line('x_test', 'x_grad', source=source, muted_alpha=0)\\n\\n\\n fig.legend.click_policy = 'mute'\\n\\n return fig\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def plot_frenet_serret(self, fig, ax, frame_number=5, frame_scale=0.10):\\n\\n # Compute the tangent, normal and binormal unitary vectors\\n h = 1e-12\\n u = np.linspace(0+h, 1-h, frame_number)\\n position = np.real(self.get_value(u))\\n tangent = np.real(self.get_tangent(u))\\n normal = np.real(self.get_normal(u))\\n binormal = np.real(self.get_binormal(u))\\n\\n # Two dimensions (plane curve)\\n if self.ndim == 2:\\n\\n # Plot the frames of reference\\n for k in range(frame_number):\\n\\n # Plot the tangent vector\\n x, y = position[:, k]\\n u, v = tangent[:, k]\\n ax.quiver(x, y, u, v, color='red', scale=7.5)\\n\\n # Plot the normal vector\\n x, y = position[:, k]\\n u, v = normal[:, k]\\n ax.quiver(x, y, u, v, color='blue', scale=7.5)\\n\\n # Plot the origin of the vectors\\n x, y = position\\n points, = ax.plot(x, y)\\n points.set_linestyle(' ')\\n points.set_marker('o')\\n points.set_markersize(5)\\n points.set_markeredgewidth(1.25)\\n points.set_markeredgecolor('k')\\n points.set_markerfacecolor('w')\\n points.set_zorder(4)\\n # points.set_label(' ')\\n\\n # Three dimensions (space curve)\\n elif self.ndim == 3:\\n\\n # Compute a length scale (fraction of the curve arc length)\\n scale = frame_scale * self.get_arclength(0, 1)\\n\\n # Plot the frames of reference\\n for k in range(frame_number):\\n\\n # Plot the tangent vector\\n x, y, z = position[:, k]\\n u, v, w = tangent[:, k]\\n ax.quiver(x, y, z, u, v, w, color='red', length=scale, normalize=True)\\n\\n # Plot the norma vector\\n x, y, z = position[:, k]\\n u, v, w = normal[:, k]\\n ax.quiver(x, y, z, u, v, w, color='blue', length=scale, normalize=True)\\n\\n # Plot the binormal vector\\n x, y, z = position[:, k]\\n u, v, w = binormal[:, k]\\n ax.quiver(x, y, z, u, v, w, color='green', length=scale, normalize=True)\\n\\n # Plot the origin of the vectors\\n x, y, z = position\\n points, = ax.plot(x, y, z)\\n points.set_linestyle(' ')\\n points.set_marker('o')\\n points.set_markersize(5)\\n points.set_markeredgewidth(1.25)\\n points.set_markeredgecolor('k')\\n points.set_markerfacecolor('w')\\n points.set_zorder(4)\\n # points.set_label(' ')\\n\\n\\n else: raise Exception('The number of dimensions must be 2 or 3')\\n\\n return fig, ax\",\n \"def parameter_forecast_plot(model_obj,time_index,start,end,num_samples = 100,cached_samples=None,col_labels = ['P','PET','Lag-1 Q','Lag-1 P','Seasonal','P$^2$','Constant']):\\n \\n f = plt.figure(figsize = (8,10))\\n num_components = len(col_labels)\\n gs = gridspec.GridSpec(8+2*num_components,6)\\n ax0 = plt.subplot(gs[-8:-6,:])\\n ax1 = plt.subplot(gs[-6::,:])\\n col_labels = ['P','PET','Lag-1 Q','Lag-1 P','Seasonal','P$^2$','Constant']\\n ffbs = model_obj # 120 is French Broad River at Blantyre, NC\\n if cached_samples is None:\\n samples = ffbs.backward_sample(num_samples=num_samples)\\n else: \\n samples = cached_samples\\n for i in range(7):\\n ax_new = plt.subplot(gs[2*i:2*i+2,:])\\n\\n upper = np.percentile(samples[start:end,i,:],75,axis = 1)\\n mid = np.percentile(samples[start:end,i,:],50,axis = 1)\\n lower = np.percentile(samples[start:end,i,:],25,axis = 1)\\n\\n ax_new.plot(time_index[start:end],mid,color='k')\\n ax_new.fill_between(time_index[start:end],upper,lower,color='0.8')\\n ax_new.tick_params(labelbottom=False,direction='in')\\n ax_new.text(0.02, 0.82,col_labels[i],\\n horizontalalignment='left',\\n verticalalignment='center',transform=ax_new.transAxes)\\n\\n ax1.plot(time_index[start:end],ffbs.f[start:end],color='k',label='1-step forecast')\\n ax1.plot(time_index[start:end],ffbs.Y[start:end],color='k',linestyle='',marker='+',\\n markersize = 10,label='Observed streamflow')\\n\\n ax1.fill_between(time_index[start:end],\\n np.squeeze(ffbs.f[start:end] + 2*ffbs.Q[start:end,0]),\\n np.squeeze(ffbs.f[start:end] - 2*ffbs.Q[start:end,0]),color='0.8',\\n label = 'Forecast $\\\\pm 2V_t$')\\n ax1.tick_params(direction='in')\\n ax1.legend(loc='upper right',ncol=1,frameon=True)\\n #ax1.set_ylabel('Standardized streamflow')\\n ax1.set_xlabel('Date',fontsize=16)\\n ax1.get_yaxis().set_label_coords(-0.1,0.5)\\n ax1.text(0.02, 0.92,'Standardized streamflow',\\n horizontalalignment='left',\\n verticalalignment='center',transform=ax1.transAxes,)\\n ax0.plot(time_index[start:end],ffbs.s[start:end],color='k')\\n ax0.text(0.02, 0.82,'$E[V_t]$',\\n horizontalalignment='left',\\n verticalalignment='center',transform=ax0.transAxes,)\\n ax0.get_yaxis().set_label_coords(-0.1,0.5)\\n return f,samples\",\n \"def _plot_rfs(ax, xe, ye, de, legend, alpha=0.5):\\n # ax = plt.axes()\\n ax.set_aspect('equal')\\n # FIXME: HARD CODED 2x\\n r = 0.203 * de\\n for i, (x, y) in enumerate(zip(xe, ye)):\\n if i == 0:\\n label = None # 'One SDev of Neuron RF'\\n else:\\n label = None\\n ax.add_patch(plt.Circle((x, -y), r, color='red', fill=True,\\n alpha=alpha, label=label))\\n\\n if legend:\\n plt.legend()\\n ax.set_xlabel('x (arcmin)')\\n ax.set_ylabel('y (arcmin)')\",\n \"def plot_ef2(self,er,cov,n_points):\\n \\n if er.shape[0] != 2:\\n raise ValueError('Plot ef2 can only plot two asset efficient frontier')\\n \\n \\n weights = [np.array([w, 1-w]) for w in np.linspace(0,1,n_points)]\\n \\n rets = [self.portfolio_returns(w,er) for w in weights]\\n \\n vols = [self.portfolio_vol(w,cov) for w in weights]\\n \\n ef = pd.DataFrame({\\n 'Returns':rets,\\n 'Volatility':vols\\n })\\n \\n return ef.plot.line(x='Volatility',y='Returns',style='.-')\",\n \"def get_temp():\\n epts = [\\\"cage_coldPlate_temp\\\", \\\"cage_pressure\\\"]\\n # t_earlier_aug = '2019-10-02T00:00'\\n # t_later_aug = datetime.utcnow().isoformat()\\n t_earlier_aug = '2019-09-27T13:00'\\n t_later_aug = '2019-09-28T19:49'\\n dfs = pandas_db_query(epts, t_earlier_aug, t_later_aug)\\n print(dfs[epts[0]].tail())\\n\\n exit()\\n\\n xv = dfs[epts[0]][\\\"timestamp\\\"]\\n yv = dfs[epts[0]][epts[0]]\\n plt.plot(xv, yv, '-b')\\n plt.ylabel(epts[0], ha='right', y=1)\\n\\n p1a = plt.gca().twinx()\\n xv = dfs[epts[1]][\\\"timestamp\\\"]\\n yv = dfs[epts[1]][epts[1]]\\n p1a.set_ylabel(epts[1], color='r', ha='right', y=1)\\n p1a.tick_params('y', colors='r')\\n p1a.semilogy(xv, yv, '-r')\\n\\n plt.gcf().autofmt_xdate()\\n plt.tight_layout()\\n plt.show()\",\n \"def plotData(BX,BY,xi,yi,expArr,t,savepath_dir):\\r\\n \\r\\n #Find the current channel data\\r\\n Jz=newCurrent(BX,BY,xi,yi,expArr,t)\\r\\n\\r\\n #Find the dipole vector components\\r\\n BxTime=np.real(BX*expArr[t])\\r\\n ByTime=np.real(BY*expArr[t])\\r\\n\\r\\n #Plot the current density contour and dipole vector grid\\r\\n #Create the figure\\r\\n p1=plt.figure(figsize=(9,8))\\r\\n \\r\\n #Plot the data\\r\\n p1=plt.contourf(xi,yi,Jz,levels=100,vmin=-0.1,vmax=0.1)\\r\\n qv1=plt.quiver(xi,yi,BxTime,ByTime,width=0.004,scale=3)\\r\\n \\r\\n #Add axes labels and title\\r\\n p1=plt.xlabel('X [cm]',fontsize=20)\\r\\n p1=plt.ylabel('Y [cm]',fontsize=20)\\r\\n # p1=plt.title('Alfven Wave Dipole; Frequency='+str(freq)+r'KHz; $\\\\nu_{ei}$='+str(col)+'KHz',fontsize=19,y=1.02)\\r\\n p1=plt.title('E Field; Frequency='+str(freq)+r'KHz; $\\\\nu_{ei}$='+str(col)+'KHz',fontsize=19,y=1.02)\\r\\n \\r\\n #Set axes parameters\\r\\n p1=plt.xticks(np.arange(-50,51,5))\\r\\n p1=plt.yticks(np.arange(-50,51,5))\\r\\n p1=plt.xlim(-xAxisLim,xAxisLim)\\r\\n p1=plt.ylim(-yAxisLim,yAxisLim)\\r\\n \\r\\n #Add colorbar\\r\\n cbar=plt.colorbar()\\r\\n cbar.set_label('Normalized Current Density',rotation=270,labelpad=15)\\r\\n cbar=plt.clim(-1,1)\\r\\n \\r\\n #Add vector label\\r\\n plt.quiverkey(qv1,-0.1,-0.1,0.2,label=r'$(B_x,B_y)$')\\r\\n \\r\\n #Miscellaneous\\r\\n p1=plt.tick_params(axis='both', which='major', labelsize=18)\\r\\n p1=plt.grid(True)\\r\\n p1=plt.gcf().subplots_adjust(left=0.15)\\r\\n\\r\\n #Save the plot\\r\\n savepath_frame=savepath_dir+'frame'+str(t+1)+'.png'\\r\\n p1=plt.savefig(savepath_frame,dpi=100,bbox_to_anchor='tight')\\r\\n p1=plt.close()\\r\\n\\r\\n #Let me know which frame we just saved\\r\\n print('Saved frame '+str(t+1)+' of '+str(len(expArr)))\\r\\n \\r\\n return\",\n \"def plot_ef(self,er,cov,n_points):\\n \\n weights = self.optimal_weights(n_points,er,cov)\\n \\n rets = [self.portfolio_returns(w,er) for w in weights]\\n \\n vols = [self.portfolio_vol(w,cov) for w in weights]\\n \\n ef = pd.DataFrame({\\n 'Returns':rets,\\n 'Volatility':vols\\n })\\n \\n return ef.plot.line(x='Volatility',y='Returns',style='.-')\",\n \"def show_observables(rf, logical_pops_file='qubit_pop.dat',\\n beta_pops_file='beta_pop.dat', exc_file='cavity_excitation.dat',\\n pulse1_file='pulse1.dat', pulse2_file='pulse2.dat'):\\n fig = plt.figure(figsize=(16,3.5), dpi=70)\\n\\n qubit_pop = np.genfromtxt(join(rf, logical_pops_file)).transpose()\\n beta_pop = np.genfromtxt(join(rf, beta_pops_file)).transpose()\\n exc = np.genfromtxt(join(rf, exc_file)).transpose()\\n p1 = QDYN.pulse.Pulse.read(join(rf, pulse1_file))\\n p2 = QDYN.pulse.Pulse.read(join(rf, pulse2_file))\\n\\n ax = fig.add_subplot(131)\\n tgrid = qubit_pop[0] # microsecond\\n ax.plot(tgrid, qubit_pop[1], label=r'00')\\n ax.plot(tgrid, qubit_pop[2], label=r'01')\\n ax.plot(tgrid, qubit_pop[3], label=r'10')\\n ax.plot(tgrid, qubit_pop[4], label=r'11')\\n ax.plot(tgrid, beta_pop[1], label=r'0010')\\n ax.plot(tgrid, beta_pop[2], label=r'0001')\\n analytical_pop = qubit_pop[1] + qubit_pop[2] + qubit_pop[3] \\\\\\n + beta_pop[1] + beta_pop[2]\\n ax.plot(tgrid, analytical_pop, label=r'ana. subsp.')\\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\\n ax.set_xlabel(\\\"time (microsecond)\\\")\\n ax.set_ylabel(\\\"population\\\")\\n\\n ax = fig.add_subplot(132)\\n ax.plot(tgrid, exc[1], label=r'<n> (cav 1)')\\n ax.plot(tgrid, exc[2], label=r'<n> (cav 2)')\\n ax.plot(tgrid, exc[3], label=r'<L>')\\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\\n ax.set_xlabel(\\\"time (microsecond)\\\")\\n ax.set_ylabel(\\\"cavity excitation\\\")\\n\\n ax = fig.add_subplot(133)\\n p1.render_pulse(ax, label='pulse 1')\\n p2.render_pulse(ax, label='pulse 2')\\n ax.legend(loc='best', fancybox=True, framealpha=0.5)\\n\\n #ax.set_xlim(-4, -1)\",\n \"def visualize(dcf_prices, current_share_prices, regress = True):\\n # TODO: implement\\n return NotImplementedError\",\n \"def plotAll(fx,tfarray,tlst,flst,fignum=1,starttime=0,timeinc='hrs',\\r\\n dt=1.0,title=None,vmm=None,cmap=None,aspect=None,interpolation=None,\\r\\n cbori=None,cbshrink=None,cbaspect=None,cbpad=None,normalize='n',\\r\\n scale='log'):\\r\\n \\r\\n #time increment\\r\\n if timeinc=='hrs':\\r\\n tinc=3600/dt\\r\\n elif timeinc=='min':\\r\\n tinc=60/dt\\r\\n elif timeinc=='sec':\\r\\n tinc=1/dt\\r\\n else:\\r\\n raise ValueError(timeinc+'is not defined')\\r\\n #colormap\\r\\n if cmap==None:\\r\\n cmap='jet'\\r\\n else:\\r\\n cmap=cmap\\r\\n #aspect ratio\\r\\n if aspect==None:\\r\\n aspect='auto'\\r\\n else:\\r\\n aspect=aspect\\r\\n #interpolation\\r\\n if interpolation==None:\\r\\n interpolation='gaussian'\\r\\n else:\\r\\n interpolation=interpolation\\r\\n #colorbar orientation\\r\\n if cbori==None:\\r\\n cbori='vertical'\\r\\n else:\\r\\n cbori=cbori\\r\\n #colorbar shinkage\\r\\n if cbshrink==None:\\r\\n cbshrink=.99\\r\\n else:\\r\\n cbshrink=cbshrink\\r\\n #colorbar aspect\\r\\n if cbaspect==None:\\r\\n cbaspect=20\\r\\n else:\\r\\n cbaspect=cbaspect\\r\\n #colorbar pad\\r\\n if cbpad==None:\\r\\n cbpad=.1\\r\\n else:\\r\\n cbpad=cbpad\\r\\n \\r\\n #scale\\r\\n if scale=='log':\\r\\n zerofind=np.where(abs(tfarray)==0)\\r\\n tfarray[zerofind]=1.0\\r\\n if normalize=='y':\\r\\n plottfarray=20*np.log10(abs(tfarray/np.max(abs(tfarray))))\\r\\n else:\\r\\n plottfarray=20*np.log10(abs(tfarray))\\r\\n elif scale=='linear':\\r\\n if normalize=='y':\\r\\n plottfarray=abs(plottfarray/np.max(abs(plottfarray)))**2\\r\\n else:\\r\\n plottfarray=abs(tfarray)**2\\r\\n \\r\\n t=np.arange(len(fx))*dt+starttime*dt\\r\\n FX=np.fft.fft(padzeros(fx))\\r\\n FXfreq=np.fft.fftfreq(len(FX),dt)\\r\\n \\r\\n #set some plot parameters\\r\\n plt.rcParams['font.size']=10\\r\\n plt.rcParams['figure.subplot.left']=.13\\r\\n plt.rcParams['figure.subplot.right']=.98\\r\\n plt.rcParams['figure.subplot.bottom']=.07\\r\\n plt.rcParams['figure.subplot.top']=.96\\r\\n plt.rcParams['figure.subplot.wspace']=.25\\r\\n plt.rcParams['figure.subplot.hspace']=.20\\r\\n #plt.rcParams['font.family']='helvetica'\\r\\n \\r\\n fig=plt.figure(fignum)\\r\\n \\r\\n #plot FFT of fx\\r\\n fax=fig.add_axes([.05,.25,.1,.7])\\r\\n plt.plot(abs(FX[0:len(FX)/2]/max(abs(FX)))**2,FXfreq[0:len(FX)/2],'-k')\\r\\n plt.xlim(0,1)\\r\\n plt.ylim(0,FXfreq[len(FX)/2-1])\\r\\n fax.xaxis.set_major_locator(MultipleLocator(.5))\\r\\n \\r\\n #plot TFD\\r\\n pax=fig.add_axes([.25,.25,.75,.7])\\r\\n if vmm!=None:\\r\\n vmin=vmm[0]\\r\\n vmax=vmm[1]\\r\\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\\r\\n flst[0],flst[-1]),aspect=aspect,vmin=vmin,vmax=vmax,cmap=cmap,\\r\\n interpolation=interpolation)\\r\\n else:\\r\\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\\r\\n flst[0],flst[-1]),aspect=aspect,cmap=cmap,\\r\\n interpolation=interpolation)\\r\\n plt.xlabel('Time('+timeinc+')',fontsize=12,fontweight='bold')\\r\\n plt.ylabel('Frequency (Hz)',fontsize=12,fontweight='bold')\\r\\n if title!=None:\\r\\n plt.title(title,fontsize=14,fontweight='bold')\\r\\n plt.colorbar(orientation=cbori,shrink=cbshrink,pad=cbpad,aspect=cbaspect)\\r\\n \\r\\n #plot timeseries\\r\\n tax=fig.add_axes([.25,.05,.60,.1])\\r\\n plt.plot(t,fx,'-k')\\r\\n plt.axis('tight')\\r\\n plt.show()\",\n \"def ecdf_plot(ecdf_q1, ecdf_q2, ecdf_q3, ecdf_q4, performance_measure, ecdf_parameter):\\n from plotly.offline import iplot\\n import plotly.graph_objs as go\\n\\n performance_measure = performance_measure.replace('_', ' ').capitalize()\\n ecdf_parameter = ecdf_parameter.replace('_', ' ').capitalize()\\n\\n ecdf_1 = go.Scatter(x=ecdf_q1.x,\\n y=ecdf_q1.y,\\n name='0 to 25',\\n mode='lines+markers',\\n marker=dict(size='7', color='#0C3383'))\\n ecdf_2 = go.Scatter(x=ecdf_q2.x,\\n y=ecdf_q2.y,\\n name='25 to 50',\\n mode='lines+markers',\\n marker=dict(size='7', color='#57A18F'))\\n ecdf_3 = go.Scatter(x=ecdf_q3.x,\\n y=ecdf_q3.y,\\n name='50 to 75',\\n mode='lines+markers',\\n marker=dict(size='7', color='#F2A638'))\\n ecdf_4 = go.Scatter(x=ecdf_q4.x,\\n y=ecdf_q4.y,\\n name='75 to 100 (best wells)',\\n mode='lines+markers',\\n marker=dict(size='7', color='#D91E1E'))\\n\\n data = [ecdf_1, ecdf_2, ecdf_3, ecdf_4]\\n\\n layout = go.Layout(height=650,\\n width=650,\\n title='ECDF ' + ecdf_parameter,\\n titlefont=dict(size=18),\\n\\n xaxis=dict(title=ecdf_parameter,\\n titlefont=dict(size=16),\\n type=None,\\n zeroline=False,\\n showgrid=True,\\n showline=False,\\n autorange=True),\\n\\n yaxis=dict(title='Cumulative Probability',\\n titlefont=dict(size=16),\\n showgrid=True,\\n showline=False,\\n zeroline=False,\\n tickvals=[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1],\\n range=[-0.03, 1.03]),\\n\\n legend=dict(x=0.65, y=0.1, font=dict(size=14)),\\n margin={'l': 50, 'r': 10, 'b': 50, 't': 85})\\n\\n layout.update(dict(annotations=[go.Annotation(text='Quantiles: ' + performance_measure,\\n x=np.max(ecdf_q4.x),\\n y=0.3,\\n showarrow=False,\\n bgcolor='#FFFFFF',\\n font=dict(size=16))]))\\n\\n plot = go.Figure(data=data, layout=layout)\\n\\n iplot(plot, show_link=False)\",\n \"def view(self, lo_en: Quantity = Quantity(0.0, \\\"keV\\\"), hi_en: Quantity = Quantity(30.0, \\\"keV\\\"),\\n figsize: Tuple = (8, 6)):\\n if lo_en > hi_en:\\n raise ValueError(\\\"hi_en cannot be greater than lo_en\\\")\\n else:\\n lo_en = lo_en.to(\\\"keV\\\").value\\n hi_en = hi_en.to(\\\"keV\\\").value\\n\\n if len(self._plot_data.keys()) != 0:\\n # Create figure object\\n plt.figure(figsize=figsize)\\n\\n # Set the plot up to look nice and professional.\\n ax = plt.gca()\\n ax.minorticks_on()\\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\\n\\n # Set the title with all relevant information about the spectrum object in it\\n plt.title(\\\"{n} - {o}{i} Spectrum\\\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\\n for mod_ind, mod in enumerate(self._plot_data):\\n x = self._plot_data[mod][\\\"x\\\"]\\n # If the defaults are left, just update them to the min and max of the dataset\\n # to avoid unsightly gaps at the sides of the plot\\n if lo_en == 0.:\\n lo_en = x.min()\\n if hi_en == 30.0:\\n hi_en = x.max()\\n\\n # Cut the x dataset to just the energy range we want\\n plot_x = x[(x > lo_en) & (x < hi_en)]\\n\\n if mod_ind == 0:\\n # Read out the data just for line length reasons\\n # Make the cuts based on energy values supplied to the view method\\n plot_y = self._plot_data[mod][\\\"y\\\"][(x > lo_en) & (x < hi_en)]\\n plot_xerr = self._plot_data[mod][\\\"x_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_yerr = self._plot_data[mod][\\\"y_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\\\"k+\\\", label=\\\"data\\\", zorder=1)\\n else:\\n # Don't want to re-plot data points as they should be identical, so if there is another model\\n # only it will be plotted\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n # The model line is put on\\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\\n\\n # Generate the legend for the data and model(s)\\n plt.legend(loc=\\\"best\\\")\\n\\n # Ensure axis is limited to the chosen energy range\\n plt.xlim(lo_en, hi_en)\\n\\n plt.xlabel(\\\"Energy [keV]\\\")\\n plt.ylabel(\\\"Normalised Counts s$^{-1}$ keV$^{-1}$\\\")\\n\\n ax.set_xscale(\\\"log\\\")\\n ax.xaxis.set_major_formatter(ScalarFormatter())\\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n\\n plt.tight_layout()\\n # Display the spectrum\\n plt.show()\\n\\n # Wipe the figure\\n plt.close(\\\"all\\\")\\n\\n else:\\n warnings.warn(\\\"There are no XSPEC fits associated with this Spectrum, you can't view it.\\\")\",\n \"def plot_fppy_equation(self,LAXIS,xbl,xbr,ybu,ybd,ilg): \\n\\t\\t\\n # load x GRID\\n grd1 = self.xzn0\\n\\n lhs0 = self.minus_dt_fppy\\n lhs1 = self.minus_fht_ux_gradx_fppy\\n\\t\\t\\n rhs0 = self.minus_div_fppyx\\n rhs1 = self.minus_fppx_gradx_uy\\n rhs2 = self.plus_eht_uyf_uxff_gradx_pp\\n rhs3 = self.plus_gamma1_eht_uyf_pp_divu\\n rhs4 = self.plus_gamma3_minus_one_eht_uyf_dd_enuc\\n rhs5 = self.plus_eht_ppf_uyff_divuff\\n rhs6 = self.minus_eht_ppf_GtM_o_dd\\n rhs7 = self.minus_eht_ppf_grady_pp_o_ddrr\\n\\t \\n res = self.minus_resPPfluxEquation\\n\\t\\n # create FIGURE\\n plt.figure(figsize=(7,6))\\n\\t\\t\\n # format AXIS, make sure it is exponential\\n plt.gca().yaxis.get_major_formatter().set_powerlimits((0,0))\\t\\t\\n\\n # set plot boundaries \\n to_plot = [lhs0,lhs1,rhs0,rhs1,rhs2,rhs3,rhs4,rhs5,rhs6,rhs7,res]\\t\\t\\n self.set_plt_axis(LAXIS,xbl,xbr,ybu,ybd,to_plot)\\t\\t\\n\\t\\t\\n # plot DATA \\n plt.title('acoustic flux y equation')\\n plt.plot(grd1,lhs0,color='#FF6EB4',label = r\\\"$-\\\\partial_t f_{py}$\\\")\\n plt.plot(grd1,lhs1,color='k',label = r\\\"$-\\\\widetilde{u}_r \\\\partial_r f_{py}$)\\\")\\t\\n\\t\\t\\n plt.plot(grd1,rhs0,color='#FF8C00',label = r\\\"$-\\\\nabla_r f_p^r $\\\") \\n plt.plot(grd1,rhs1,color='#802A2A',label = r\\\"$-f_{py} \\\\partial_r \\\\overline{u}_r$\\\") \\n plt.plot(grd1,rhs2,color='r',label = r\\\"$+\\\\overline{u'_\\\\theta u''_r} \\\\partial_r \\\\overline{P}$\\\") \\n plt.plot(grd1,rhs3,color='firebrick',label = r\\\"$+\\\\Gamma_1 \\\\overline{u'_\\\\theta P d}$\\\") \\n plt.plot(grd1,rhs4,color='c',label = r\\\"$+(\\\\Gamma_3-1)\\\\overline{u'_\\\\theta \\\\rho \\\\epsilon_{nuc}}$\\\")\\n plt.plot(grd1,rhs5,color='mediumseagreen',label = r\\\"$+\\\\overline{P'u''_\\\\theta d''}$\\\")\\n plt.plot(grd1,rhs6,color='b',label = r\\\"$+\\\\overline{P' G_\\\\theta^M/ \\\\rho}$\\\")\\n plt.plot(grd1,rhs7,color='m',label = r\\\"$+\\\\overline{P'\\\\partial_\\\\theta P/ \\\\rho r}$\\\")\\n\\t\\t\\n plt.plot(grd1,res,color='k',linestyle='--',label=r\\\"res $\\\\sim N_p$\\\")\\n \\n # define and show x/y LABELS\\n setxlabel = r\\\"r (cm)\\\"\\n setylabel = r\\\"erg cm$^{-2}$ s$^{-2}$\\\"\\n plt.xlabel(setxlabel)\\n plt.ylabel(setylabel)\\n\\t\\t\\n # show LEGEND\\n plt.legend(loc=ilg,prop={'size':8})\\n\\n # display PLOT\\n plt.show(block=False)\\n\\n # save PLOT\\n plt.savefig('RESULTS/'+self.data_prefix+'fppy_eq.png')\\t\\n plt.savefig('RESULTS/'+self.data_prefix+'fppy_eq.eps')\",\n \"def surface_plot(name: str = 'start_date_analysis1.pkl'):\\n df = pd.read_pickle(name)\\n\\n # set up a figure twice as wide as it is tall\\n fig = plt.figure(figsize=plt.figaspect(0.5))\\n # ===============\\n # First subplot\\n # ===============\\n # set up the axes for the first plot\\n ax = fig.add_subplot(1, 2, 1, projection='3d')\\n ax.set_title('Modifications per File')\\n ax.set_xlabel('Date (Months)')\\n ax.set_ylabel('Threshold Individual')\\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\\n data = df[df['threshold_pairs'] == row]\\n label = 'Threshold pairs ' + str(row)\\n # Plot the surface.\\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['mpf'], alpha=0.7,\\n linewidth=0, antialiased=False, label=label)\\n surf._facecolors2d = surf._facecolors3d\\n surf._edgecolors2d = surf._edgecolors3d\\n # ===============\\n # Second subplot\\n # ===============\\n # set up the axes for the second plot\\n ax = fig.add_subplot(1, 2, 2, projection='3d')\\n ax.set_title('Transitions per Test')\\n ax.set_xlabel('Date (Months)')\\n ax.set_ylabel('Threshold Individual')\\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\\n data = df[df['threshold_pairs'] == row]\\n label = 'Threshold pairs ' + str(row)\\n # Plot the surface.\\n\\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['tpt'], alpha=0.7,\\n linewidth=0, antialiased=False, label=label)\\n\\n surf._facecolors2d = surf._facecolors3d\\n surf._edgecolors2d = surf._edgecolors3d\\n\\n # cbar = fig.colorbar(surf)\\n # cbar.locator = LinearLocator(numticks=10)\\n # cbar.update_ticks()\\n\\n plt.suptitle('Threshold Start Date Analysis 3D', fontsize=14)\\n plt.legend()\\n plt.show()\",\n \"def plot_diff(self):\\n if not(self.is_attribute(\\\"time\\\") & self.is_attribute(\\\"intensity_up\\\") & \\n self.is_attribute(\\\"intensity_up_sigma\\\") &\\n self.is_attribute(\\\"intensity_down\\\") & \\n self.is_attribute(\\\"intensity_down_sigma\\\") &\\n self.is_attribute(\\\"intensity_up_total\\\") &\\n self.is_attribute(\\\"intensity_down_total\\\")):\\n return\\n fig, ax = plt.subplots()\\n ax.set_title(\\\"Polarized intensity: I_up - I_down\\\")\\n ax.set_xlabel(\\\"Time (microseconds)\\\")\\n ax.set_ylabel('Intensity')\\n \\n np_time = numpy.array(self.time, dtype=float)\\n np_up = numpy.array(self.intensity_up, dtype=float)\\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\\n np_down = numpy.array(self.intensity_down, dtype=float)\\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\\n np_diff = np_up - np_down\\n np_diff_mod = np_up_mod - np_down_mod\\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\\n\\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \\\"b:\\\")\\n ax.plot(np_time, np_diff_mod, \\\"k-\\\",\\n label=\\\"model\\\")\\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\\\"ko\\\", alpha=0.2,\\n label=\\\"experiment\\\")\\n\\n y_min_d, y_max_d = ax.get_ylim()\\n param = y_min_d-(np_diff-np_diff_mod).max()\\n\\n ax.plot([np_time.min(), np_time.max()], [param, param], \\\"k:\\\")\\n ax.plot(np_time, np_diff-np_diff_mod+param, \\\"r-\\\", alpha=0.7,\\n label=\\\"difference\\\")\\n ax.legend(loc='upper right')\\n fig.tight_layout()\\n return (fig, ax)\",\n \"def DETCurve(fps, fns):\\n axis_min = min(fps[0], fns[-1])\\n fig, ax = plt.subplots()\\n plt.xlabel(\\\"FAR\\\")\\n plt.ylabel(\\\"FRR\\\")\\n plt.plot(fps, fns, '-|')\\n plt.yscale('log')\\n plt.xscale('log')\\n ax.get_xaxis().set_major_formatter(\\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\\n ax.get_yaxis().set_major_formatter(\\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\\n ticks_to_use = [0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1]\\n ax.set_xticks(ticks_to_use)\\n ax.set_yticks(ticks_to_use)\\n plt.axis([0.01, 1, 0.01, 1])\\n # plt.show()\",\n \"def plot(frame, clipped, auto, lag, threshold, freq, save):\\n fig, axes = plt.subplots(4, constrained_layout=True)\\n fig.set_size_inches(8.0, 8.0)\\n fig.canvas.set_window_title('Excercise 4')\\n\\n ax_frame, ax_clipped, ax_auto, ax_freq = axes\\n\\n time = np.linspace(0, frame.size / SAMPLE_RATE, num=frame.size)\\n for ax in axes:\\n ax.set_xlabel('time [s]')\\n ax.set_ylabel('y')\\n\\n\\n ax_frame.plot(time, frame)\\n ax_clipped.plot(time, clipped)\\n\\n ax_auto.plot(auto)\\n ax_auto.axvline(threshold, color='black', label='Threshold')\\n ax_auto.stem([lag[0]], [lag[1]], linefmt='r-', basefmt=None, label='Lag')\\n\\n ax_freq.plot(freq[0], 'g-', label='mask-on')\\n ax_freq.plot(freq[1], 'r-', label='mask-off')\\n\\n ax_auto.legend(loc=1)\\n ax_freq.legend(loc=0)\\n\\n ax_frame.set_title('Maskon frame')\\n ax_clipped.set_title('Central clipping with 70%')\\n ax_auto.set_title('Autocorrelation')\\n ax_freq.set_title('Primary frequencies of frames')\\n\\n ax_auto.set_xlabel('frames')\\n ax_freq.set_xlabel('frames')\\n\\n ax_freq.set_ylabel('f0')\\n\\n if save:\\n save_figure(fig, 'ex4')\\n else:\\n plt.show()\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def PMTandPiezoPlot(datadir,run,event,gain): \\n en = event\\n mu = gain\\n e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)\\n print(e[\\\"fastDAQ\\\"].keys())\\n cgate = e[\\\"fastDAQ\\\"][\\\"CAMgate\\\"]\\n dcam = np.diff(cgate)\\n \\n p0=e[\\\"fastDAQ\\\"][\\\"Piezo1\\\"]\\n p1 = e[\\\"fastDAQ\\\"][\\\"Piezo2\\\"]\\n fdt = e[\\\"fastDAQ\\\"][\\\"time\\\"]\\n runreconpath = \\\"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\\\"%run\\n pmtdiffs = []\\n diffs = []\\n \\n camOnTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] < -0.5]\\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\\n print(len(camOnTimes))\\n print(len(camOffTimes))\\n \\n acousticfilename = runreconpath+\\\"AcousticAnalysis_%s.bin\\\"%run\\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\\n bubt0 = a[\\\"bubble_t0\\\"]\\n \\n pmttracetime = e[\\\"PMTtraces\\\"][\\\"t0_sec\\\"][:,0]+e[\\\"PMTtraces\\\"][\\\"t0_frac\\\"][:,0]\\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\\n pmtalign = d[\\\"PMT_trigt0_sec\\\"]+d[\\\"PMT_trigt0_frac\\\"]\\n tracetimes = pmttracetime - pmtalign\\n at0 = bubt0[en,0]\\n at0_1 = bubt0[en,1]\\n \\n allxyzfname = \\\"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\\\"\\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\\n indices = [i for i,x in enumerate(xyzf[\\\"runid\\\"]) if str(x[0])+\\\"_\\\"+str(x[1]) == run]\\n xyz_reconstructed = True\\n if len(indices) > 0:\\n runposreco = {\\\"ev\\\":[xyzf[\\\"ev\\\"][indices]],\\\"x\\\":[xyzf[\\\"bubX\\\"][indices]],\\n \\\"y\\\":[xyzf[\\\"bubY\\\"][indices]],\\\"z\\\":[xyzf[\\\"bubZ\\\"][indices]]}\\n z = runposreco[\\\"z\\\"][0][int(int(en))]\\n else:\\n print(\\\"no handscan?\\\")\\n z = 1.5\\n xyz_reconstructed = False\\n lag_expected = (-23.387649*z - 261.020495)*1e-6 # fit from other analysis\\n t0_expected_p0 = at0 + lag_expected\\n t0_expected_p1 = at0_1 + lag_expected\\n \\n i=0\\n candidates = []\\n candidate_times=[]\\n for t in (tracetimes-at0):\\n \\n if t<0.2 and t>-0.2:\\n lastCamOff = 0\\n for k in range(len(camOffTimes)):\\n if t+at0 > camOffTimes[k]:\\n lastCamOff = camOffTimes[k]\\n elif t+at0 < camOffTimes[k]:\\n break\\n if t+at0-lastCamOff > 25e-6:\\n \\n pmtdiffs.append(t)\\n trace = np.fabs(e[\\\"PMTtraces\\\"][\\\"traces\\\"][i][0])\\n if max(trace) == 128:\\n trace = pi.stitchTraces(trace,np.fabs(e[\\\"PMTtraces\\\"][\\\"traces\\\"][i][1]))\\n dt = e[\\\"PMTtraces\\\"][\\\"dt\\\"][i][0]\\n #baseline = np.mean(trace[0:50])\\n #trace = trace - baseline\\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt)\\n \\n if phe != None:\\n phe /= mu\\n candidates.append(phe)\\n candidate_times.append(t)\\n i+=1\\n candidate_phe = 0\\n the_index = 0\\n i=0\\n near_trace_indices = []\\n for t in candidate_times:\\n if t > -500e-6 and t <0:\\n near_trace_indices.append(list(tracetimes-at0).index(t))\\n if candidates[i]>candidate_phe:\\n candidate_phe = candidates[i]\\n the_index = i\\n i+=1\\n \\n if len(candidates) != 0:\\n if max(candidates)>0:\\n diffs.append(candidate_times[candidates.index(max(candidates))])\\n fig,ax1 = plt.subplots()\\n ax2 = ax1.twinx()\\n ax1.plot(fdt,p0,'b',alpha=0.6, label = 'piezo 0')\\n ax1.plot(fdt,p1,'k',alpha=0.2, label= 'piezo 1')\\n for i in range(len(candidates)):\\n if i == the_index:\\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'r',lw=4)\\n else:\\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'y',lw=4)\\n #ax2.plot([min(candidate_times),max(candidate_times)],[0,0],linewidth=2)\\n ax1.plot([at0,at0],[-0.5,0.5],'b',linewidth=2, label = 'acoustic t0, p0')\\n ax1.plot([at0_1,at0_1],[-0.5,0.5],'k',linewidth=2, label = 'acoustic t0, p1')\\n \\\"\\\"\\\"\\n if xyz_reconstructed:\\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0')\\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1')\\n else:\\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0, center of chamber')\\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1, center of chamber')\\n \\\"\\\"\\\"\\n ax1.plot(fdt,cgate,'c')\\n ax1.plot(fdt[:-1],dcam,'m')\\n ax2.set_ylabel('pmt signal (phe)',fontsize=20)\\n ax1.set_xlabel('time (s)',fontsize=20)\\n ax1.set_ylabel('Acoustic signa(V)',fontsize=20)\\n ax1.set_ylim([min(p1),max(p1)])\\n ax2.set_xlim([-0.1,0.1])\\n #ax2.set_ylim([0,5])\\n ax1.legend()\\n plt.show\\n \\n for j in near_trace_indices:\\n trace = e[\\\"PMTtraces\\\"][\\\"traces\\\"][j][0]\\n dt = e[\\\"PMTtraces\\\"][\\\"dt\\\"]\\n dt_tr = dt[j][0]\\n tPMT = np.arange(len(trace))*dt_tr\\n plt.figure()\\n plt.plot(tPMT,trace)\\n plt.xlabel(\\\"t (s)\\\")\\n plt.ylabel(\\\"PMT signal\\\")\\n plt.show\\n \\n plt.figure()\\n plt.plot(e[\\\"fastDAQ\\\"][\\\"time\\\"],e[\\\"fastDAQ\\\"][\\\"VetoCoinc\\\"])\\n plt.ylabel(\\\"Veto Coincidence signal\\\",fontsize=18)\\n plt.xlabel(\\\"time (s)\\\")\\n plt.show\",\n \"def plot(self):\\n\\n\\t\\tprint('lcrPicker.plot()')\\n\\t\\tif self.dr.dfSparkMaster is None:\\n\\t\\t\\tprint(' error: new_plotSparkMaster() did not find self.dr.dfSparkMaster')\\n\\n\\t\\t#print(self.dfSparkMaster.head)\\n\\t\\tprint(' sm columns:', self.dr.dfSparkMaster.columns)\\n\\n\\t\\ttifFirstFrameSeconds = self.dr.abfTif.tifHeader['firstFrameSeconds']\\n\\t\\ttifSecondsPerLine = self.dr.abfTif.tifHeader['secondsPerLine']\\n\\t\\ttifTotalSeconds = self.dr.abfTif.tifHeader['totalSeconds']\\n\\t\\tprint(' first frame of the image wrt pClamp abf as at', tifFirstFrameSeconds)\\n\\n\\t\\txLineScanSum = self.dr.abfTif.sweepX + tifFirstFrameSeconds\\n\\t\\tyLineScanSum = self.dr.abfTif.sweepY\\n\\n\\t\\t# now stripping leading spaces in SparkMaster columns (see loadSparkMaster)\\n\\t\\t# remember: when traversing rows, t-pos is out of order w.r.t. time\\n\\t\\txSmStatStr = 't-pos' # t-pos is in seconds?\\n\\t\\txSmStat = self.dr.dfSparkMaster[xSmStatStr]\\n\\t\\t# shift wrt tifFirstFrameSeconds\\n\\t\\txSmStatSec = [x+tifFirstFrameSeconds for x in xSmStat]\\n\\n\\t\\tyDoThisSmStat = 'FWHM' # 'Ampl.' # or 'FWHM'\\n\\t\\tySmStatStr = yDoThisSmStat\\n\\t\\tySmStat = self.dr.dfSparkMaster[ySmStatStr]\\n\\n\\t\\tyDoThisSmStat2 = 'Ampl.' # 'Ampl.' # or 'FWHM'\\n\\t\\tySmStatStr2 = yDoThisSmStat2\\n\\t\\tySmStat2 = self.dr.dfSparkMaster[ySmStatStr2]\\n\\n\\t\\ttPos_orig = self.dr.dfSparkMaster['t-pos']\\n\\t\\ttPos_offset = tPos_orig + tifFirstFrameSeconds\\n\\t\\ttPos_bin = [round(x/tifSecondsPerLine) for x in tPos_orig] # t-pos of each LCR as bin # (into tif)\\n\\t\\t#print('tPos_bin:', tPos_bin)\\n\\n\\t\\txPos = self.dr.dfSparkMaster['x-pos'] # pixel along line scan???\\n\\n\\t\\t#\\n\\t\\t# bin sparkmaster time and count the number of LCR ROIs in a bin\\n\\t\\t#print(' self.tifBins_ms:', self.tifBins_ms)\\n\\t\\ttifBins_sec = self.tifBins_ms / 1000\\n\\t\\t# important to consider wrt tifBins_sec\\n\\t\\txNumBins = math.floor(tifTotalSeconds / tifBins_sec)\\n\\t\\tprint('tifBins_sec:', tifBins_sec, 'xNumBins:', xNumBins, 'tifSecondsPerLine:', tifSecondsPerLine)\\n\\t\\t# make new x-axis with bins\\n\\t\\txBins = [tifFirstFrameSeconds+(x*tifBins_sec) for x in range(xNumBins)]\\n\\n\\t\\t# if weights is None, will count LCR in each bin\\n\\t\\t# if weight=ampl, will sum ampl for each LCRR in each bin\\n\\t\\tweights = None\\n\\t\\tweights = self.dr.dfSparkMaster['Ampl.']\\n\\n\\t\\t# plotted below\\n\\t\\t#myHist,myBins = np.histogram(tPos_offset, weights=weights,\\n\\t\\t#\\t\\t\\t\\t\\t\\t\\tbins=xBins)\\n\\n\\t\\t#\\n\\t\\t# plot\\n\\t\\tnumPanels = 5\\n\\t\\tfig, axs = plt.subplots(numPanels, 1, sharex=True)\\n\\t\\tif numPanels == 1:\\n\\t\\t\\taxs = [axs]\\n\\t\\tfig.canvas.mpl_connect('key_press_event', self.key_press_event)\\n\\t\\tfig.canvas.mpl_connect('key_release_event', self.key_release_event)\\n\\t\\tfig.canvas.mpl_connect('button_press_event', self.on_button_press_event)\\n\\t\\tfig.canvas.mpl_connect('pick_event', self.onpick)\\n\\n\\t\\ttitleStr = str(self.region)\\n\\t\\ttitleStr += ' ' + os.path.split(self.dr.abfTif.tifHeader['tif'])[1]\\n\\t\\ttitleStr += ' self.tifBins_ms:' + str(self.tifBins_ms)\\n\\t\\tfig.suptitle(titleStr)\\n\\n\\t\\t# ephys Vm\\n\\t\\txVm = self.dr.abf.sweepX\\n\\t\\tyVm = self.dr.abf.sweepY\\n\\t\\taxs[0].plot(xVm, yVm, 'k')\\n\\t\\taxs[0].set_ylabel('Vm (mV)')\\n\\n\\t\\t# sparkmaster over Vm\\n\\t\\taxRight1 = axs[0].twinx() # instantiate a second axes that shares the same x-axis\\n\\t\\taxRight1.plot(xSmStatSec, ySmStat, '.b')\\n\\t\\t#axRight1.set_xlabel(xStatStr)\\n\\t\\taxRight1.set_ylabel('SM ' + ySmStatStr)\\n\\n\\t\\t#\\n\\t\\t# sum of each line scan\\n\\t\\txLineScan = self.dr.abfTif.sweepX\\n\\t\\tyLineScan = self.dr.abfTif.sweepY\\n\\t\\taxs[1].plot(xLineScanSum, yLineScan, 'r')\\n\\t\\taxs[1].set_ylabel('Ca Line Scan Sum')\\n\\n\\t\\t# sparkmaster over Ca Line Scan Sum\\n\\t\\taxRight1 = axs[1].twinx() # instantiate a second axes that shares the same x-axis\\n\\t\\taxRight1.plot(xSmStatSec, ySmStat2, '.b')\\n\\t\\t#axRight1.set_xlabel(xStatStr)\\n\\t\\taxRight1.set_ylabel('SM ' + ySmStatStr2)\\n\\n\\t\\t#\\n\\t\\taxs[2].plot(xVm, yVm, '-k')\\n\\t\\taxs[2].set_ylabel('Vm (mV)')\\n\\n\\t\\tself.axRight2 = axs[2].twinx() # instantiate a second axes that shares the same x-axis\\n\\t\\t#axRight2.plot(xLineScanSum, yLineScanSum, '-r')\\n\\t\\tn, bins, patches = self.axRight2.hist(tPos_offset, weights=weights,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbins=xBins,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfacecolor='k', histtype='step')\\n\\t\\tif weights is None:\\n\\t\\t\\tself.axRight2.set_ylabel('SM LCR Count')\\n\\t\\telse:\\n\\t\\t\\tself.axRight2.set_ylabel('SM LCR Weight (amp)')\\n\\t\\t# once we mask out Ca++ in response to spikes\\n\\t\\t# we do not need log plot !!!\\n\\t\\t#axRight2.set_yscale('log')\\n\\n\\t\\t#\\n\\t\\t# plot tif image overlaid with position of LCRs\\n\\t\\tif 1:\\n\\t\\t\\tfirstFrameSeconds = self.dr.abfTif.tifHeader['firstFrameSeconds']\\n\\t\\t\\txMin = firstFrameSeconds\\n\\t\\t\\txMax = firstFrameSeconds + self.dr.abfTif.sweepX[-1]\\n\\t\\t\\tyMin = 0\\n\\t\\t\\tyMax = self.dr.abfTif.tifHeader['umLength'] #57.176\\n\\t\\t\\t#extent = [xMin, xMaxImage, yMax, yMin] # flipped y\\n\\t\\t\\textent = [xMin, xMax, yMin, yMax] # flipped y\\n\\t\\t\\taxs[3].imshow(self.dr.abfTif.tif, extent=extent, aspect='auto')\\n\\t\\t\\taxs[3].spines['right'].set_visible(False)\\n\\t\\t\\taxs[3].spines['top'].set_visible(False)\\n\\n\\t\\t\\taxRight3 = axs[3].twinx() # instantiate a second axes that shares the same x-axis\\n\\t\\t\\taxRight3.plot(tPos_offset, xPos, '.r')\\n\\n\\t\\t#\\n\\t\\t# plot analysis results, both (picked lcr) and (picked vm)\\n\\n\\t\\taxsLcrAnalysisLeft = axs[4]\\n\\t\\tself.vmAnalysisLine2D, = axs[4].plot([], [], 'ob')\\n\\n\\t\\taxsLcrAnalysisRight = axs[4].twinx() # instantiate a second axes that shares the same x-axis\\n\\t\\tself.lcrAnalysisLine2D, = axsLcrAnalysisRight.plot(self.dfAnalysis['lcrSec'],\\n\\t\\t\\t\\t\\t\\t\\t\\tself.dfAnalysis['lcrSum'],\\n\\t\\t\\t\\t\\t\\t\\t\\t'or',\\n\\t\\t\\t\\t\\t\\t\\t\\tpicker=5)\\n\\t\\tself.lcrAnalysisSelectionLine2D, = axsLcrAnalysisRight.plot([],\\n\\t\\t\\t\\t\\t\\t\\t\\t[],\\n\\t\\t\\t\\t\\t\\t\\t\\t'oy')\\n\\n\\t\\treturn fig, axs, tPos_offset, n, bins, axsLcrAnalysisLeft, axsLcrAnalysisRight\",\n \"def plot_derivatives_divided(self, show=False):\\n\\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\\n ax[2, 0].set_title('Difference between upper and lower training examples');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n ax[2, 0].legend(frameon=False)\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\\n ax[2, 1].set_title('Difference between upper and lower test samples');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def changeFridge(self,*args):\\n self.selectedADR = self.adrSelect.get()\\n # clear temps plot\\n self.stage60K.set_xdata([])\\n self.stage60K.set_ydata([])\\n self.stage03K.set_xdata([])\\n self.stage03K.set_ydata([])\\n self.stageGGG.set_xdata([])\\n self.stageGGG.set_ydata([])\\n self.stageFAA.set_xdata([])\\n self.stageFAA.set_ydata([])\\n # load saved temp data\\n # We have to sleep for 0.5s here because it seems like it takes\\n # a moment for the connected server to register in self.cxn, even\\n # though all this starts because a message is received saying it\\n # is connected :\\\\\\n time.sleep(0.5)\\n startDateTime = yield self.cxn[self.selectedADR].get_start_datetime()\\n try:\\n reg = self.cxn.registry\\n yield reg.cd(ADR_SETTINGS_BASE_PATH + [self.selectedADR])\\n logPath = yield reg.get('Log Path')\\n tempDataChest = dataChest(logPath)\\n ds = dateStamp()\\n dset = '%s_temperatures'%ds.dateStamp(startDateTime.isoformat())\\n tempDataChest.openDataset(dset)\\n\\n n = tempDataChest.getNumRows()\\n # load approximately the last 6 hours of data\\n pastTempData = tempDataChest.getData(max(0,n-6*60*60),None )\\n for newRow in pastTempData:\\n # change utc time to local\\n utc = newRow[0] # (float)\\n utc = datetime.datetime.utcfromtimestamp(utc)\\n utc = utc.replace(tzinfo=tz.tzutc())\\n newRow[0] = mpl.dates.date2num(utc)\\n # add old data from file into plot\\n self.stage60K.set_xdata(numpy.append(self.stage60K.get_xdata(),newRow[0]))\\n self.stage60K.set_ydata(numpy.append(self.stage60K.get_ydata(),newRow[1]))\\n self.stage03K.set_xdata(numpy.append(self.stage03K.get_xdata(),newRow[0]))\\n self.stage03K.set_ydata(numpy.append(self.stage03K.get_ydata(),newRow[2]))\\n self.stageGGG.set_xdata(numpy.append(self.stageGGG.get_xdata(),newRow[0]))\\n self.stageGGG.set_ydata(numpy.append(self.stageGGG.get_ydata(),newRow[3]))\\n self.stageFAA.set_xdata(numpy.append(self.stageFAA.get_xdata(),newRow[0]))\\n self.stageFAA.set_ydata(numpy.append(self.stageFAA.get_ydata(),newRow[4]))\\n except IOError:\\n # file not created yet if adr server just opened\\n print( 'temp file not created yet?' )\\n self.updatePlot()\\n # clear and reload last 20 messages of log\\n self.log.clear()\\n logMessages = yield self.cxn[self.selectedADR].get_log(20)\\n for (t,m,a) in logMessages:\\n self.updateLog(t,m,a)\\n # update instrument status stuff: delete old, create new\\n for widget in self.instrumentStatusFrame.winfo_children():\\n widget.destroy()\\n returnStatus = yield self.cxn[self.selectedADR].get_instrument_state()\\n self.instrumentStatuses = {}\\n for name,status in returnStatus:\\n self.instrumentStatuses[name] = Tkinter.Label(self.instrumentStatusFrame,\\n text=name,\\n relief=Tkinter.RIDGE,\\n bg='gray70')\\n self.instrumentStatuses[name].pack(side=Tkinter.LEFT,\\n expand=True,\\n fill=Tkinter.X)\\n # update field limits and button statuses\\n self.setFieldLimits()\\n self.magUpButton.configure(state=Tkinter.NORMAL)\\n self.regulateButton.configure(state=Tkinter.NORMAL)\\n self.compressorButton.configure(state=Tkinter.DISABLED)\\n mUp = yield self.cxn[self.selectedADR].get_state_var('maggingUp')\\n reg = yield self.cxn[self.selectedADR].get_state_var('regulating')\\n if mUp:\\n self.magUpButton.configure(text='Stop Magging Up',\\n command=self.cancelMagUp)\\n self.regulateButton.configure(state=Tkinter.DISABLED)\\n if reg:\\n self.regulateButton.configure(text='Stop Regulating',\\n command=self.cancelRegulate)\\n self.magUpButton.configure(state=Tkinter.DISABLED)\\n # update heat switch buttons\\n HSAvailable = yield self.cxn[self.selectedADR].get_instrument_state(['Heat Switch'])\\n if HSAvailable[0][1][0]:\\n self.HSCloseButton.configure(state=Tkinter.NORMAL)\\n self.HSOpenButton.configure(state=Tkinter.NORMAL)\\n else:\\n self.HSCloseButton.configure(state=Tkinter.DISABLED)\\n self.HSOpenButton.configure(state=Tkinter.DISABLED)\\n # refresh interface\\n self.updateInterface()\",\n \"def update_plot(click, contents, filename, start_date, end_date, freq, window_length, mean_diff,\\n max_diff, upper_ll, lower_ll, vardiff, slopedev):\\n if click < 1:\\n return\\n\\n # params = pd.read_json(params)\\n # params = params.apply(pd.to_numeric)\\n # params = params.sort_values('Run')\\n\\n window_length = int(window_length)\\n mean_diff = float(mean_diff)\\n max_diff = float(max_diff)\\n upper_ll = float(upper_ll)\\n lower_ll = float(lower_ll)\\n slopedev = float(slopedev)\\n vardiff = float(vardiff)\\n\\n\\n df = utils.read_df(contents, filename)\\n df = df[(df.index >= start_date) & (df.index <= end_date)]\\n df = df[df.index.minute % freq == 0]\\n is_clear, components, alpha = \\\\\\n cs_utils.detect_clearsky(df['GHI'], df['GHIcs'], df.index,\\n window_length=window_length, mean_diff=mean_diff,\\n max_diff=max_diff, upper_line_length=upper_ll, lower_line_length=lower_ll,\\n slope_dev=slopedev, var_diff=vardiff, return_components=True)\\n\\n df['GHIcs'] = df['GHIcs'] * alpha\\n fig = tls.make_subplots(rows=2, cols=1, shared_xaxes=True)\\n\\n plots = []\\n plots.append(go.Scatter(x=df.index, y=df['GHI'], name='GHI'))\\n plots.append(go.Scatter(x=df.index, y=df['GHIcs'], name='GHIcs'))\\n plots.append(go.Scatter(x=df[is_clear].index, y=df[is_clear]['GHI'], name='PVLib clear', mode='markers'))\\n plots.append(go.Scatter(x=df.index, y=components['mean_diff'],\\n name='Mean diff.', visible='legendonly'))\\n plots.append(go.Scatter(x=df.index, y=components['max_diff'],\\n name='Max diff.', visible='legendonly'))\\n plots.append(go.Scatter(x=df.index, y=components['line_length'],\\n name='Line length', visible='legendonly'))\\n plots.append(go.Scatter(x=df.index, y=components['slope_nstd'],\\n name='Slope std. dev.', visible='legendonly'))\\n plots.append(go.Scatter(x=df.index, y=components['slope_max'],\\n name='Max slope diff.', visible='legendonly'))\\n\\n for p in plots:\\n fig.append_trace(p, 1, 1)\\n\\n plots2 = []\\n passes = pd.DataFrame(components)\\n for i, test in enumerate(['mean_diff_pass', 'max_diff_pass', 'line_length_pass',\\n 'slope_nstd_pass', 'slope_max_pass']):\\n slice = passes[test].astype(int)\\n ii = i / 4\\n yval = [ii] * len(slice.astype(bool) & passes['non_zero'].astype(bool))\\n plots2.append(\\n go.Scatter(x=df.index[:len(slice)][slice.astype(bool) & passes['non_zero'].astype(bool)],\\n y=yval, name='', mode='markers', showlegend=False)\\n )\\n\\n for p in plots2:\\n fig.append_trace(p, 2, 1)\\n\\n fig['layout']['yaxis2'].update(tickmode='text', tickvals=[0, .25, .5, .75, 1],\\n ticktext=['Mean diff.', 'Max diff.', 'Line length',\\n 'Slope std. dev.', 'Max slope diff.'])\\n fig['layout']['xaxis2'].update(title='Date')\\n fig['layout']['yaxis2'].update(domain=[0, 0.2])\\n fig['layout']['yaxis1'].update(title='GHI / W/m2')\\n fig['layout']['yaxis1'].update(domain=[.25, 1])\\n fig['layout'].update(height=500, margin={'l': 100})\\n fig['layout'].update(title='Window length: {}, mean diff: {}, max diff: {}, upper line length: {}, '\\n 'lower line length: {}, max slope difference: {}, std slope differece: {}'\\n .format(window_length, mean_diff, max_diff, upper_ll, lower_ll, slopedev, vardiff))\\n\\n plots = fig\\n\\n layout = go.Layout(xaxis={'title': 'Date'}, # yaxis={'title': 'W/m2'},\\n title='Window length: {}, mean diff: {}, max diff: {}, upper line length: {}, '\\n 'lower line length: {}, max slope difference: {}, std slope differece: {}'\\n .format(window_length, mean_diff, max_diff, upper_ll, lower_ll, slopedev, vardiff),\\n )\\n ts_plot = dcc.Graph(id='cs-plot', figure={'data': plots, 'layout': layout})\\n\\n # scores = [go.Scatter(x=list(range(len(params))),\\n # y=params['F-score'],\\n # text=utils.df_to_text(params), hoverinfo='text')]\\n # scores_layout = go.Layout(xaxis={'title': 'Run', 'tickvals': [i for i in range(1, len(params))],\\n # 'ticktext': [str(i + 1) for i in range(1, len(params))],\\n # 'range': [0, len(params)]}, yaxis={'title': 'F-score'})\\n # scores_plot = dcc.Graph(id='cs-scores', figure={'data': scores, 'layout': scores_layout})\\n #\\n # table = dt.DataTable(\\n # rows=params[['Run', 'Window length', 'Mean difference', 'Max difference',\\n # 'Upper line length', 'Lower line length', 'Variance of slopes',\\n # 'Max difference of slopes', 'F-score']].round(3).to_dict('records'),\\n # columns=['Run', 'Window length', 'Mean difference', 'Max difference',\\n # 'Upper line length', 'Lower line length', 'Variance of slopes',\\n # 'Max difference of slopes', 'F-score'],\\n # selected_row_indices=[],\\n # sortable=True,\\n # filterable=True,\\n # editable=False,\\n # id='cs-param_table'\\n # )\\n\\n final = html.Div([\\n html.Div(ts_plot)\\n ], style={'width': '98%', 'float': 'center', 'pad': {'l': 40}})\\n\\n return final\",\n \"def plot(self,displayplt = True,saveplt = False,savepath=''):\\n figure1 = plt.figure()\\n axa = figure1.add_subplot(2, 1, 1)\\n sensitivity =hyd_calibration_multiple_freq(self.cfreq)\\n pnp = -1e-6 * np.min(self.hydoutput, axis=1) / sensitivity\\n figure2 = axa.plot(self.cfreq, pnp, 'x')\\n axa.set_title('Frequency Sweep')\\n plt.xlabel('Frequency (MHz)')\\n plt.ylabel('Peak Negative Pressure (MPa)')\\n axb = figure1.add_subplot(2, 1, 2)\\n mi_fs = pnp / np.sqrt(self.cfreq)\\n figure4 = axb.plot(self.cfreq, mi_fs, 'x')\\n plt.xlabel('Frequency (MHz)')\\n plt.ylabel('MI')\\n if displayplt:\\n plt.show()\\n if saveplt:\\n if savepath == '':\\n # prompt for a save path using a default filename\\n defaultfn = self.txdr + '_' + self.collectiondate + '_' + self.collectiontime + '_freqsweep.png'\\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\\n plt.savefig(savepath)\\n return figure1, savepath\",\n \"def plot_step_details(df1, df2, rxn, detail):\\n a1, a2 = df1.align(df2, join='outer', axis=0)\\n x_list = [row[detail] for row in a1[rxn]]\\n y_list = [row[detail] for row in a2[rxn]]\\n comparison_plot(x_list, y_list, f'{rxn} {detail}')\",\n \"def test_2d_plot(self):\\n db = pd.HDFStore('test.h5')\\n df_iv = db['iv']\\n dates = df_iv[df_iv['dte'] == 30]['date']\\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\\n db.close()\\n\\n print df_iv.sort_values('impl_vol').head()\\n\\n plt.plot(dates, impl_vols)\\n plt.xlabel('date')\\n plt.ylabel('impl_vols')\\n plt.show()\",\n \"def _rfigure(self, legend=True, fig=None, ax=None):\\n if fig is None and ax is None:\\n fig, ax = plt.subplots()\\n suptitle = True\\n elif fig is None:\\n fig = ax.get_figure()\\n suptitle = False\\n elif ax is None:\\n ax = fig.gca()\\n suptitle = False\\n\\n ax.grid(True)\\n\\n line_rstr = None\\n line_rrls = None\\n line_lstr = None\\n line_lrls = None\\n line_minima = None\\n line_maxima = None\\n t = self.timevector\\n for axis, trace in zip('xy', ['positionX', 'positionY']):\\n s = self.get_data(traces=trace) * 1e6 # m -> µm\\n r_str_rls = self.stress_release_pairs(axis=axis, direction='right')\\n l_str_rls = self.stress_release_pairs(axis=axis, direction='left')\\n rstr = r_str_rls['stress']['idx']\\n lstr = l_str_rls['stress']['idx']\\n rrls = r_str_rls['release']['idx']\\n lrls = l_str_rls['release']['idx']\\n\\n ax.plot(t, s, lw=0.1, ms=2, color='k', alpha=1.0)\\n\\n # line_rstr = None\\n # line_rrls = None\\n # line_lstr = None\\n # line_lrls = None\\n for rstr, rrls in zip(rstr, rrls):\\n line_rstr, = ax.plot(t[rstr], s[rstr], lw=0.4, ms=2, color='m')\\n line_rrls, = ax.plot(t[rrls], s[rrls], lw=0.4, ms=2, color='c')\\n for lstr, lrls in zip(lstr, lrls):\\n line_lstr, = ax.plot(t[lstr], s[lstr], lw=0.4, ms=2, color='g')\\n line_lrls, = ax.plot(t[lrls], s[lrls], lw=0.4, ms=2, color='y')\\n\\n # line_minima = None\\n # line_maxima = None\\n for segment in self._sf.sections[axis]:\\n minima = self.undecimate_and_limit(segment['minima'])\\n maxima = self.undecimate_and_limit(segment['maxima'])\\n line_minima, = ax.plot(t[minima], s[minima], '.', ms=5,\\n color='b')\\n line_maxima, = ax.plot(t[maxima], s[maxima], '.', ms=5,\\n color='r')\\n\\n line_excited_x = None\\n for x_c in (self.undecimate_and_limit(self._sf.excited['x'])\\n / self.resolution):\\n line_excited_x = ax.hlines(0.0, x_c[0], x_c[1], alpha=1,\\n colors='b', linestyle='solid', lw=1)\\n # ax.plot(x_c[0], 0.5, '.k', alpha=1, ms=3)\\n # ax.plot(x_c[1], 0.5, '.k', alpha=1, ms=3)\\n ax.vlines(x_c[0], -0.01, 0.01, alpha=1, colors='b',\\n linestyle='solid', lw=1)\\n ax.vlines(x_c[1], -0.01, 0.01, alpha=1, colors='b',\\n linestyle='solid', lw=1)\\n\\n line_excited_y = None\\n for y_c in (self.undecimate_and_limit(self._sf.excited['y'])\\n / self.resolution):\\n line_excited_y = ax.hlines(0.0, y_c[0], y_c[1], alpha=1,\\n colors='r', linestyle='solid', lw=1)\\n # ax.plot(y_c[0], -0.5, '.k', alpha=1, ms=3)\\n # ax.plot(y_c[1], -0.5, '.k', alpha=1, ms=3)\\n ax.vlines(y_c[0], -0.01, 0.01, alpha=1, colors='r',\\n linestyle='solid', lw=1)\\n ax.vlines(y_c[1], -0.01, 0.01, alpha=1, colors='r',\\n linestyle='solid', lw=1)\\n\\n ax.set_xlim((t[0], t[-1]))\\n\\n ax.set_xlabel(\\\"Time (s)\\\")\\n ax.set_ylabel(\\\"Signal positionX and Y (µm)\\\")\\n if suptitle:\\n fig.suptitle(\\\"Automatically detected excited axis, minima, \\\"\\n \\\"maxima, and sections.\\\")\\n\\n if legend:\\n if line_minima is not None:\\n line_minima.set_label('minima')\\n if line_maxima is not None:\\n line_maxima.set_label('maxima')\\n if line_rstr is not None:\\n line_rstr.set_label('rightstress')\\n if line_rrls is not None:\\n line_rrls.set_label('rightrelease')\\n if line_lstr is not None:\\n line_lstr.set_label('leftstress')\\n if line_lrls is not None:\\n line_lrls.set_label('leftrelease')\\n if line_excited_x is not None:\\n line_excited_x.set_label('excited x')\\n if line_excited_y is not None:\\n line_excited_y.set_label('excited y')\\n\\n ax.legend(loc='upper right')\\n\\n return fig\",\n \"def plot_figure3(df, left_colNames, right_colNames, dvmin=-100, dvmax=101, step=20, show=False, write_to=None):\\n\\t#select left values and right values\\n\\tleft = df[left_colNames]\\n\\tright = df[right_colNames]\\n\\t# 'diff' column: sum(left) - sum(right)\\n\\tlr_diff = pd.DataFrame({'diff': left.sum(axis=1)-right.sum(axis=1)})\\n\\t# 'side_chosen': 0 left, 1 right \\n\\t# 'choice': 1 chose left, 0 chose right. Flipped 'side_chosen' column, b/c we will count the frequency of choosing left\\n\\tlr_diff['choice'] = np.logical_xor(df['side_chosen'],1).astype(int)\\n\\t# sort diff from lowest to highest, and group into buckets\\n\\tlr_diff = lr_diff.sort_values(by=['diff'], ascending=True)\\n\\t#array of prob(choosing left) for each bucket\\n\\tgrouped = group(lr_diff, dvmin, dvmax, step)\\n\\n\\t#plot data\\n\\ty = np.array(grouped)\\n\\tx = np.array([x for x in range(dvmin, dvmax, step)])\\n\\tif show:\\n\\t\\tfig = go.Figure()\\n\\t\\tfig.add_trace(go.Scatter(x=x, y=y, name=\\\"linear\\\", line_shape='linear'))\\n\\t\\tfig.show()\\n\\tif write_to is not None:\\n\\t\\tfig.write_image(write_to)\\n\\treturn x, y\",\n \"def SavingAndPlottingAfterRecursive(self):\\n\\n\\n #Starting points of events in sec.\\n startpoints=self.AnalysisResults[self.sig]['StartPoints']\\n\\n #Ending points of events in sec.\\n endpoints=self.AnalysisResults[self.sig]['EndPoints']\\n\\n #Total number of events\\n numberofevents=self.AnalysisResults[self.sig]['NumberOfEvents']\\n\\n #Current drop in nA\\n deli=self.AnalysisResults[self.sig]['DeltaI']\\n\\n #end[i] - start[i] in sec.\\n dwell=self.AnalysisResults[self.sig]['DwellTime']\\n\\n #current drop / current at start \\n frac=self.AnalysisResults[self.sig]['FractionalCurrentDrop']\\n\\n #start[i+1] - start[i] in sec.\\n dt=self.AnalysisResults[self.sig]['Frequency']\\n\\n #start[i+1] - start[i] in sec.\\n localBaseline=self.AnalysisResults[self.sig]['LocalBaseline']\\n\\n # If plotting takes too much time: \\\"Don_t_plot...\\\" the graph will be deleted\\n if not self.ui.actionDon_t_Plot_if_slow.isChecked():\\n #clear signal plot\\n self.p1.clear()\\n # Event detection plot, Signal Plot\\n self.p1.plot(self.t, self.data[self.sig], pen='b')\\n # Draw green circles indicating start of event\\n self.p1.plot(self.t[startpoints], self.data[self.sig][startpoints], pen=None, symbol='o', symbolBrush='g', symbolSize=10)\\n # Draw red circles indicating end of event\\n self.p1.plot(self.t[endpoints], self.data[self.sig][endpoints], pen=None, symbol='o', symbolBrush='r', symbolSize=10)\\n #self.p1.plot(self.t[startpoints-10], localBaseline, pen=None, symbol='x', symbolBrush='y', symbolSize=10)\\n \\n # choice only data for current file name\\n try:\\n self.p2.data = self.p2.data[np.where(np.array(self.sdf.fn) != self.matfilename)]\\n except:\\n IndexError\\n #Data frame for event info storage\\n self.sdf = self.sdf[self.sdf.fn != self.matfilename]\\n \\n #Panda series with file name of data loaded (without ending .dat or some other) \\n #repeated numberofevents times\\n fn = pd.Series([self.matfilename, ] * numberofevents)\\n \\n #Same color identification repeated numberofevents\\n color = pd.Series([self.cb.color(), ] * numberofevents)\\n \\n self.sdf = self.sdf.append(pd.DataFrame({'fn': fn, 'color': color, 'deli': deli,\\n 'frac': frac, 'dwell': dwell,\\n 'dt': dt, 'startpoints': startpoints,\\n 'endpoints': endpoints, 'baseline': localBaseline}), ignore_index=True)\\n \\n # Create Scatter plot with\\n # x = log10(dwell)\\n # y = current drop / current at start\\n #self.p2.addPoints(x=np.log10(dwell), y=frac, symbol='o', brush=(self.cb.color()), pen=None, size=10)\\n self.p2.addPoints(x=dwell, y=frac,\\n symbol='o', brush=(self.cb.color()), pen=None, size=10)\\n self.w1.addItem(self.p2)\\n self.w1.setLogMode(x=False, y=False)\\n self.p1.autoRange()\\n self.w1.autoRange()\\n self.ui.scatterplot.update() # Replot Scatter plot\\n # Set y - axis range\\n self.w1.setRange(yRange=[0, 1])\\n \\n # Pandas series of colors. \\n colors = self.sdf.color\\n # If we have data from different experiments and different analyte\\n # we can change the color for them \\n for i, x in enumerate(colors):\\n\\n # Preparation for distribution histogram of fraction. Different color\\n # Corresponds to different experiments\\n # For better undarstanding see Feng et. al Indentification of single nucliotides\\n # in MoS2 nanopores - different nucliotides for different colors \\n # frac = current drop / current at start \\n fracy, fracx = np.histogram(self.sdf.frac[self.sdf.color == x],\\n bins=np.linspace(0, 1, int(self.ui.fracbins.text())))\\n # Create pyqtgraph hist of Fraction data\\n hist = pg.PlotCurveItem(fracx, fracy , stepMode = True, \\n fillLevel=0, brush = x, pen = 'k') \\n #Plot Frac histogram \\n self.w2.addItem(hist) \\n \\n\\n # Preparation for distribution histogram of Current drop in nA.\\n # Idea of color choice is the same as in histogram above.\\n deliy, delix = np.histogram(self.sdf.deli[self.sdf.color == x], \\n bins=np.linspace(float(self.ui.delirange0.text()) *1e-9, \\n float(self.ui.delirange1.text()) * 1e-9, \\n int(self.ui.delibins.text())))\\n # Create pyqtgraph hist of Deli data\\n #hist = pg.BarGraphItem(height=deliy, x0=delix[:-1], x1=delix[1:], brush=x)\\n hist = pg.PlotCurveItem(delix, deliy , stepMode = True, \\n fillLevel=0, brush = x, pen = 'k')\\n self.w3.addItem(hist) #Deli histogram plot\\n self.w3.setRange(xRange=[float(self.ui.delirange0.text()) * 10 ** -9,\\n float(self.ui.delirange1.text()) * 10 ** -9])\\n \\n # Preparation for distribution histogram of length of events expressed as\\n # end[i] - start[i] in sec..\\n # Idea of color choice is the same as in histogram above.\\n #linspace for bins\\n print('dwell = ' + str(self.sdf.dwell))\\n bins_dwell = np.linspace(float(self.ui.dwellrange0.text()) * 1e-6, \\n float(self.ui.dwellrange1.text()) * 1e-6, \\n int(self.ui.dwellbins.text()))\\n\\n dwelly, dwellx = np.histogram((self.sdf.dwell[self.sdf.color == x]),\\n bins=bins_dwell,range=(bins_dwell.min(),\\n bins_dwell.max()))\\n hist = pg.PlotCurveItem(dwellx, dwelly , stepMode = True, \\n fillLevel=0, brush = x, pen = 'k')\\n self.w4.addItem(hist)\\n\\n \\n # Preparation for distribution histogram of start[i+1] - start[i] in sec. \\n # \\\"Frequency\\\" of events expressed as\\n # Idea of color choice is the same as in histogram above.\\n\\n dty, dtx = np.histogram(self.sdf.dt[self.sdf.color == x],\\n bins=np.linspace(float(self.ui.dtrange0.text()), \\n float(self.ui.dtrange1.text()),\\n int(self.ui.dtbins.text())))\\n hist = pg.PlotCurveItem(dtx, dty , stepMode = True, \\n fillLevel=0, brush = x, pen = 'k')\\n self.w5.addItem(hist) #Dt histogram plot\",\n \"def plotting(dataframe, prod_num):\\n fig, axs = plt.subplots(2, sharex=True)\\n axs[0].plot(dataframe['STU'])\\n axs[1].plot(dataframe['STU'].diff().dropna())\\n axs[0].set_title(\\\"Time Series of Product\\\" + f\\\"_{prod_num}\\\")\\n axs[1].set_title(\\\"Differenced Time Series of Product\\\" + f\\\"_{prod_num}\\\")\\n plt.savefig(\\\"Time Series of Product\\\" + f\\\"_{prod_num}\\\" + \\\".pdf\\\")\",\n \"def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\\n plt.figure()\\n\\n #legacy beamprofile data is a 1-D array of the peak negative pressure\\n pnp = self.pnp\\n\\n if dbdown:\\n pnp = 20.0*np.log10(pnp/np.max(pnp))\\n else:\\n pnp = pnp*1e-6\\n\\n if polarplt:\\n figure1 = plt.polar(self.angle * np.pi / 180.0, pnp)\\n else:\\n figure1 = plt.plot(self.angle, pnp)\\n #the latest beamprofile data should be a 2-D array of the hydrophone output\\n plt.xlabel('Angle (degrees)')\\n if dbdown:\\n plt.ylabel('Peak Negative Pressure (dB Max)')\\n else:\\n plt.ylabel('Peak Negative Pressure (MPa)')\\n plt.title(self.txdr)\\n if displayplt:\\n plt.show()\\n if saveplt:\\n if savepath=='':\\n #prompt for a save path using a default filename\\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_beamprofile.png'\\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\\n plt.savefig(savepath)\\n return figure1, savepath\",\n \"def plot(\\n self,\\n group_delay=False,\\n slce=None,\\n flim=None,\\n dblim=None,\\n tlim=None,\\n grpdlim=None,\\n dbref=1,\\n show=False,\\n use_fig=None,\\n label=None,\\n unwrap_phase=False,\\n logf=True,\\n third_oct_f=True,\\n plot_kw={},\\n **fig_kw,\\n ):\\n if use_fig is None:\\n fig_kw = {**{\\\"figsize\\\": (10, 10)}, **fig_kw}\\n fig, axes = plt.subplots(nrows=3, constrained_layout=True, **fig_kw)\\n else:\\n fig = use_fig\\n axes = fig.axes\\n\\n self.plot_magnitude(\\n use_ax=axes[0],\\n slce=slce,\\n dblim=dblim,\\n flim=flim,\\n dbref=dbref,\\n label=label,\\n plot_kw=plot_kw,\\n logf=logf,\\n third_oct_f=third_oct_f,\\n )\\n if group_delay:\\n self.plot_group_delay(\\n use_ax=axes[1],\\n slce=slce,\\n flim=flim,\\n ylim=grpdlim,\\n plot_kw=plot_kw,\\n logf=logf,\\n third_oct_f=third_oct_f,\\n )\\n else:\\n self.plot_phase(\\n use_ax=axes[1],\\n slce=slce,\\n flim=flim,\\n plot_kw=plot_kw,\\n unwrap=unwrap_phase,\\n logf=logf,\\n third_oct_f=third_oct_f,\\n )\\n self.plot_time(\\n use_ax=axes[2], tlim=tlim, slce=slce, plot_kw=plot_kw\\n )\\n\\n if show:\\n plt.show()\\n\\n return fig\",\n \"def fig_TF(f, day_trfs, day_list, sta_trfs, sta_list, skey=''):\\n\\n import matplotlib.ticker as mtick\\n\\n # Extract only positive frequencies\\n faxis = f > 0\\n\\n # Get max number of TFs to plot\\n ntf = max(sum(day_list.values()), sum(sta_list.values()))\\n\\n # Define all possible compbinations\\n tf_list = {'ZP': True, 'Z1': True, 'Z2-1': True,\\n 'ZP-21': True, 'ZH': True, 'ZP-H': True}\\n\\n if ntf == 1:\\n fig = plt.figure(figsize=(6, 1.75))\\n else:\\n fig = plt.figure(figsize=(6, 1.33333333*ntf))\\n\\n j = 1\\n for key in tf_list:\\n\\n if not day_list[key] and not sta_list[key]:\\n continue\\n\\n ax = fig.add_subplot(ntf, 1, j)\\n\\n if day_list[key]:\\n for i in range(len(day_trfs)):\\n ax.loglog(\\n f[faxis],\\n np.abs(day_trfs[i][key]['TF_'+key][faxis]),\\n 'gray', lw=0.5)\\n if sta_list[key]:\\n ax.loglog(\\n f[faxis],\\n np.abs(sta_trfs[key]['TF_'+key][faxis]),\\n 'k', lw=0.5)\\n if key == 'ZP':\\n ax.set_ylim(1.e-20, 1.e0)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: ZP',\\n fontdict={'fontsize': 8})\\n elif key == 'Z1':\\n ax.set_ylim(1.e-5, 1.e5)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: Z1',\\n fontdict={'fontsize': 8})\\n elif key == 'Z2-1':\\n ax.set_ylim(1.e-5, 1.e5)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: Z2-1',\\n fontdict={'fontsize': 8})\\n elif key == 'ZP-21':\\n ax.set_ylim(1.e-20, 1.e0)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: ZP-21',\\n fontdict={'fontsize': 8})\\n elif key == 'ZH':\\n ax.set_ylim(1.e-10, 1.e10)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: ZH',\\n fontdict={'fontsize': 8})\\n elif key == 'ZP-H':\\n ax.set_ylim(1.e-20, 1.e0)\\n ax.set_xlim(1.e-4, 2.5)\\n ax.set_title(skey+' Transfer Function: ZP-H',\\n fontdict={'fontsize': 8})\\n\\n j += 1\\n\\n ax.set_xlabel('Frequency (Hz)')\\n plt.tight_layout()\\n\\n return plt\",\n \"def show(self, show_figure=True, filename=None):\\n # Create phase dictionary\\n phase_series = self._create_phases()\\n if not show_figure:\\n return phase_series\\n phase_dict = phase_series.to_dict()\\n # Curve fitting\\n nested = [\\n self._curve_fitting(phase, info)\\n for (phase, info) in phase_dict.items()\\n ]\\n df_list, vlines = zip(*nested)\\n comp_df = pd.concat([self.sr_df, *df_list], axis=1)\\n comp_df = comp_df.rename({self.S: f\\\"{self.S}{self.A}\\\"}, axis=1)\\n comp_df = comp_df.apply(\\n lambda x: pd.to_numeric(x, errors=\\\"coerce\\\", downcast=\\\"integer\\\"),\\n axis=0\\n )\\n # Show figure\\n pred_cols = [\\n col for col in comp_df.columns if col.endswith(self.P)\\n ]\\n if len(pred_cols) == 1:\\n title = f\\\"{self.area}: S-R trend without change points\\\"\\n else:\\n _list = self._change_dates[:]\\n strings = [\\n \\\", \\\".join(_list[i: i + 6]) for i in range(0, len(_list), 6)\\n ]\\n change_str = \\\",\\\\n\\\".join(strings)\\n title = f\\\"{self.area}: S-R trend changed on\\\\n{change_str}\\\"\\n Trend.show_with_many(\\n result_df=comp_df,\\n predicted_cols=pred_cols,\\n title=title,\\n vlines=vlines[1:],\\n filename=filename\\n )\\n return phase_series\",\n \"def display_feds(list1, list2):\\n if len(list1) != len(list2):\\n print(\\\"In display_feds: lists must be of the same length\\\")\\n return \\n fig = plt.figure(dpi=128, figsize=(10, 6))\\n fed_list_answer = fed_list(list1, list2)\\n plt.plot(range(len(fed_list_answer)), fed_list_answer, c='red', alpha=0.5)\\n \\n plt.title(\\\"Feature edit distances between corresponding pairs\\\", fontsize = 24)\\n plt.xlabel('', fontsize =16)\\n #fig.autofmt_xdate()\\n plt.ylabel(\\\"Distance\\\", fontsize =16)\\n plt.tick_params(axis='both', which = 'major', labelsize=16)\\n\\n plt.show()\",\n \"def figure_2():\\n from matplotlib.animation import FuncAnimation\\n from collections import OrderedDict\\n\\n plt.rc(\\\"font\\\", **{\\n \\\"family\\\": \\\"sans-serif\\\",\\n \\\"sans-serif\\\": [\\\"Helvetica\\\"],\\n })\\n plt.rc(\\\"text\\\", usetex=True)\\n plt.rc(\\\"lines\\\", linewidth=1)\\n plt.rc(\\\"axes\\\", grid=True)\\n plt.rc(\\\"grid\\\", linestyle=\\\"--\\\", alpha=0.8)\\n\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n data = {exp: get_data(exp) for exp in exp_list}\\n\\n fig, ax = plt.subplots(figsize=[16, 9])\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n linekw = dict(linewidth=1, alpha=0.3)\\n\\n def make_line(label, *args):\\n ln, = plt.plot([], [], label=label, *args, **linekw)\\n return ln\\n\\n time_list = [data[exp][\\\"time\\\"] for exp in exp_list]\\n time = time_list[np.argmin(list(map(len, time_list)))]\\n lines = [\\n (\\n make_line(\\\"Command\\\", \\\"k--\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"cmd\\\"]\\n ),\\n (\\n make_line(r\\\"$x_{r,1}$\\\", \\\"k\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"reference_system\\\"][:, 0]\\n ),\\n (\\n make_line(r\\\"$x_{r,2}$\\\", \\\"k\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"reference_system\\\"][:, 1]\\n ),\\n (\\n make_line(r\\\"FE-CMRAC $x_{1}$\\\", \\\"r-.\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(r\\\"FE-CMRAC $x_{2}$\\\", \\\"r-.\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n (\\n make_line(r\\\"RL-CMRAC $x_{1}$\\\", \\\"b-.\\\"),\\n data[\\\"rlcmrac-sac\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(r\\\"RL-CMRAC $x_{2}$\\\", \\\"b-.\\\"),\\n data[\\\"rlcmrac-sac\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n ]\\n\\n dist_lines = {\\n \\\"rlcmrac-sac\\\": plt.vlines(\\n [], [], [],\\n colors=FORMATTING[\\\"rlcmrac-sac\\\"][\\\"color\\\"],\\n alpha=1,\\n label=\\\"RL-CMRAC\\\",\\n ),\\n \\\"fecmrac-nullagent\\\": plt.vlines(\\n [], [], [],\\n colors=FORMATTING[\\\"fecmrac-nullagent\\\"][\\\"color\\\"],\\n alpha=1,\\n label=\\\"FE-CMRAC\\\",\\n ),\\n }\\n memory_time_diff = np.diff(data[\\\"fecmrac-nullagent\\\"][\\\"memory\\\"][\\\"time\\\"])\\n\\n plt.legend(handles=dist_lines.values())\\n\\n def to_segments(xs, ys):\\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\\n\\n def init():\\n states = np.hstack([\\n data[exp][\\\"state\\\"][\\\"main_system\\\"].ravel() for exp in exp_list\\n ])\\n ylim_max = states.max()\\n ylim_min = states.min()\\n ylim_btw = 1.2 * (ylim_max - ylim_min)\\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\\n\\n ax.set_xlim(0, time[-1])\\n ax.set_ylim(ylim_min, ylim_max)\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n def update(frame):\\n for line, line_data in lines:\\n line.set_data(time[:frame], line_data[:frame])\\n\\n # Update FE-CMRAC\\n if frame > 0 and memory_time_diff[frame-1] != 0:\\n ta_idx = np.argmax(\\n time > data[\\\"fecmrac-nullagent\\\"][\\\"memory\\\"][\\\"time\\\"][frame]\\n )\\n dist_time = time[:ta_idx]\\n dist_k = data[\\\"fecmrac-nullagent\\\"][\\\"k\\\"][:ta_idx]\\n dist = [\\n -np.exp(-np.trapz(dist_k[i:], dist_time[i:]))\\n for i in range(len(dist_time))\\n ]\\n segments = to_segments(dist_time, dist)\\n dist_lines[\\\"fecmrac-nullagent\\\"].set_segments(segments)\\n\\n # Update RL-CMRAC\\n dist_time = data[\\\"rlcmrac-sac\\\"][\\\"memory\\\"][\\\"t\\\"][frame]\\n dist = 100 * data[\\\"rlcmrac-sac\\\"][\\\"dist\\\"][frame]\\n segments = to_segments(dist_time, dist)\\n dist_lines[\\\"rlcmrac-sac\\\"].set_segments(segments)\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n anim = FuncAnimation(\\n fig, update, init_func=init,\\n frames=range(0, len(time), 10), interval=10\\n )\\n # plt.show()\\n anim.save(os.path.join(args.save_dir, \\\"dist-movie.mp4\\\"))\",\n \"def problemFive(self):\\n # Initialize plot\\n plot_5 = plt.figure(figsize=(15, 8))\\n plot_5.subplots_adjust(left=.06, right=.95, top=.95, bottom=.08)\\n fft = plot_5.add_subplot(1, 1, 1)\\n plt.tick_params(labelsize=14)\\n fft.set_xlabel('Frequency [Hz]', fontsize=20)\\n fft.set_ylabel('FFT Amplitude [Vrms]', fontsize=20)\\n fft.set_xlim([0, 1000])\\n fft.grid(linewidth=0.5, color='gray', linestyle='--')\\n # Get data from files and plot\\n dub_slash = r'\\\\\\\\'\\n data_text = 'V Infinity (m/s), Reynolds Number, Peak Vortex Amplitude (Vrms), ' \\\\\\n 'Frequency at Peak Amplitude (Hz), Strouhal Number'\\n latex_text = f'\\\\t\\\\hline\\\\n\\\\t$U_inf$ [m/s] & Peak Vortex Amp. [Vrms] & ' \\\\\\n f'Freq. at Peak Amp. [Hz] & $Re$ & $St$ {dub_slash} \\\\hline'\\n peak_a_list, peak_f_list = [], []\\n for file_loc in self.fft_filenames:\\n file = os.path.basename(file_loc).replace('.csv', '')\\n index = self.fft_filenames.index(file_loc)\\n amplitude = self.fft_data[file]['amplitude'].tolist()\\n frequency = self.fft_data[file]['frequency'].tolist()\\n v_inf = int(file)\\n # Plot data\\n fft.plot(frequency, amplitude, color=self.plot_color[index], linewidth=1.5, label=f'{file} m/s')\\n # Calculate Reynolds number\\n mu = (self.b * self.atm_temp**(3/2)) / (self.atm_temp + self.S)\\n Re = (self.atm_density * (self.cylinder_diam/1000) * v_inf)/mu\\n # Find peak frequency\\n peak_f, peak_a = 0, 0\\n for i in range(0, len(frequency)-1):\\n a0 = amplitude[i]\\n a1 = amplitude[i+1]\\n f0 = frequency[i]\\n f1 = frequency[i+1]\\n slope = (a1 - a0)/(f1 - f0)\\n if slope >= 0 and f0 >= 50 and a1 >= peak_a:\\n peak_f = f1\\n peak_a = a1\\n peak_a_list.append(peak_a)\\n peak_f_list.append(peak_f)\\n # Calc Strouhal number\\n strouhal = (peak_f * (self.cylinder_diam/1000))/v_inf\\n # Save data to text\\n data_text += f'\\\\n{v_inf}, {round(Re, 5)}, {round(peak_a, 4)}, {round(peak_f, 5)}, {round(strouhal, 5)}'\\n latex_text += f'\\\\n\\\\t{v_inf} & {round(peak_a, 4)} & {round(peak_f, 5)} & {int(Re)} & {round(strouhal, 5)} {dub_slash} \\\\hline'\\n fft.scatter(peak_f_list, peak_a_list, edgecolors='k', facecolors='none', s=40, label='Peak Vortex Shedding Freq.')\\n # Save data_text file\\n with open('problem5_data.csv', 'wt') as f:\\n f.write(data_text)\\n fft.legend(loc='upper right', fontsize=16)\\n plot_5.savefig(os.path.join(os.getcwd(), r'plots\\\\prob5'))\\n plt.draw()\\n print(latex_text)\",\n \"def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\\n # sum things up across binaries\\n total_formation_rate = np.sum(formation_rate, axis=0)\\n total_merger_rate = np.sum(merger_rate, axis=0)\\n total_detection_rate = np.sum(detection_rate, axis=0)\\n \\n # and across redshifts\\n cumulative_detection_rate = np.cumsum(total_detection_rate)\\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\\n\\n ###########################\\n #Start plotting\\n\\n # set some constants for the plots\\n plt.rc('font', family='serif')\\n fs = 20\\n lw = 3\\n\\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\\n\\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\\n axes[0,0].set_ylabel(r'Formation rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\\n axes[0,1].set_ylabel(r'Merger rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\\n axes[1,1].set_xlabel(r'Chirp mass, $\\\\mathcal{M}_c$', fontsize=fs)\\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}\\\\mathcal{M}_c \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n #########################\\n #Plotvalues\\n\\n # Add text upper left corner\\n axes[0,0].text(0.05,0.8, \\\"mu0=%s \\\\nmuz=%s \\\\nsigma0=%s \\\\nsigmaz=%s \\\\nalpha=%s\\\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \\n\\n for ax in axes.flatten():\\n ax.tick_params(labelsize=0.9*fs)\\n\\n # Save and show :)\\n plt.savefig(save_dir +'Rate_Info'+\\\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\\\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \\n if show_plot:\\n plt.show()\\n else:\\n plt.close()\",\n \"def updatePlot(self,*args):\\n # set x limits\\n timeDisplayOptions = {'10 minutes':10,'1 hour':60,'6 hours':6*60,'24 hours':24*60,'All':0}\\n try:\\n lastDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[-1])\\n firstDatetime = mpl.dates.num2date(self.stage60K.get_xdata()[0])\\n except IndexError: # no data yet\\n now = datetime.datetime.utcnow().toordinal()\\n firstDatetime = mpl.dates.num2date(now)\\n lastDatetime = firstDatetime\\n xMin = lastDatetime-datetime.timedelta(minutes=timeDisplayOptions[self.wScale.get()])\\n xMin = max([ firstDatetime, xMin ])\\n if self.wScale.get() == 'All':\\n xMin = firstDatetime\\n xMinIndex = numpy.searchsorted( self.stage60K.get_xdata(), mpl.dates.date2num(xMin) )\\n # rescale axes, with the x being scaled by the slider\\n if self.toolbar._active == 'HOME' or self.toolbar._active == None:\\n ymin,ymax = 10000000, -10000000\\n lineAndVar = { self.stage60K: self.t60K,\\n self.stage03K: self.t3K,\\n self.stageGGG: self.tGGG,\\n self.stageFAA: self.tFAA }\\n if len(self.stage60K.get_xdata()) > 1:\\n for line in lineAndVar.keys():\\n if lineAndVar[line].get() == 0:\\n line.set_visible(False)\\n else:\\n line.set_visible(True)\\n ydata = line.get_ydata()[xMinIndex:-1]\\n try:\\n ymin = min(ymin, numpy.nanmin(ydata))\\n ymax = max(ymax, numpy.nanmax(ydata))\\n except ValueError as e:\\n pass\\n self.ax.set_xlim(xMin,lastDatetime)\\n self.ax.set_ylim(ymin - (ymax-ymin)/10, ymax + (ymax-ymin)/10)\\n hfmt = mpl.dates.DateFormatter('%H:%M:%S', tz=tz.tzlocal())\\n self.ax.xaxis.set_major_formatter(hfmt)\\n self.fig.autofmt_xdate()\\n self.fig.tight_layout()\\n #draw\\n self.canvas.draw()\",\n \"def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\\n \\n # Variables assignment\\n t_fcs = data_fcs[:,0]\\n delta_a = data_fcs[:,18]\\n delta_e = data_fcs[:,6]\\n delta_r = data_fcs[:,9]\\n delta_t = data_fcs[:,20]\\n \\n t_vel = data_vel[:,0]\\n p_rad = data_vel[:,4]\\n q_rad = data_vel[:,5]\\n r_rad = data_vel[:,6]\\n \\n t_att = data_att[:,0]\\n phi_rad = data_att[:,1]\\n the_rad = data_att[:,2]\\n psi_rad = data_att[:,3]\\n \\n fig = plt.figure(figsize=(12.3,15))\\n \\n \\n # Commands\\n ax1a = fig.add_subplot(3,1,1)\\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\\\delta_a$')\\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\\\delta_e$')\\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\\\delta_r$')\\n \\n ax1a.set_title(\\\"Commands\\\") \\n ax1a.set_xlabel(r'$t$ (s)')\\n ax1a.set_ylabel(r'$\\\\delta_a$ , $\\\\delta_e$ , $\\\\delta_r$ (°)')\\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\\n \\n \\n ax1b = ax1a.twinx()\\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\\\delta_t$')\\n \\n ax1b.set_ylabel(r'$\\\\delta_t$')\\n ax1b.set_ylim(ymax=1, ymin=-0.05)\\n \\n handlesa, labelsa = ax1a.get_legend_handles_labels()\\n handlesb, labelsb = ax1b.get_legend_handles_labels()\\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\\n \\n\\n # Angular velocities\\n ax2 = fig.add_subplot(3,1,2)\\n \\n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\\n \\n ax2.set_title(\\\"Angular velocities\\\") \\n ax2.set_xlabel(r'$t$ (s)')\\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\\n \\n handles, labels = ax2.get_legend_handles_labels()\\n ax2.legend(handles, labels, ncol=3, loc='best')\\n \\n \\n # Euler angles\\n ax3a = fig.add_subplot(3,1,3)\\n \\n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\\\"$\\\\phi$\\\")\\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\\\"$\\\\theta$\\\")\\n \\n ax3a.set_title(\\\"Euler angles\\\") \\n ax3a.set_xlabel(r'$t$ (s)')\\n ax3a.set_ylabel(r'$\\\\phi$ , $\\\\theta$ (°)')\\n \\n \\n ax3b = ax3a.twinx()\\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\\\"$\\\\psi$\\\")\\n \\n ax3b.set_ylabel(r'$\\\\psi$ (°)')\\n \\n handlesa, labelsa = ax3a.get_legend_handles_labels()\\n handlesb, labelsb = ax3b.get_legend_handles_labels()\\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\\n \\n plt.tight_layout()\\n \\n \\n # Export\\n if dest_folder != None:\\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')\",\n \"def overviewCommand(self):\\n plt.figure(11)\\n plt.clf()\\n ax = plt.subplot(211)\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*self.raw['OPDC'].data.field('FUOFFSET'),\\n color='r', label='FUOFFSET',\\n linewidth=1, alpha=1) \\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\\n self.raw['OPDC'].data.field('PSP')),\\n color='r', linewidth=3, alpha=0.5,\\n label=self.DLtrack+'-PSP')\\n plt.legend()\\n plt.subplot(212, sharex=ax)\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*self.raw['OPDC'].data.field('FUOFFSET')-\\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\\n self.raw['OPDC'].data.field('PSP')),\\n color='k', label='$\\\\Delta$',\\n linewidth=1, alpha=1) \\n \\n signal = self.raw['OPDC'].data.field('FUOFFSET')\\n plt.figure(12)\\n plt.clf()\\n ax2 = plt.subplot(111)\\n Fs = 1e6/np.diff(self.raw['OPDC'].data.field('TIME')).mean()\\n print Fs\\n ax2.psd(signal[:50000], NFFT=5000, Fs=Fs, label='FUOFFSET',scale_by_freq=0)\\n plt.legend()\",\n \"def plot(self, **kwargs):\\n if self.order != None:\\n name = str(_constructModelName(self.teff, self.logg, \\n self.metal, self.en, self.order, self.path))\\n output = kwargs.get('output', str(name) + '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', \\n alpha=.8, linewidth=1, label=name)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim) \\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\\n\\n else:\\n output = kwargs.get('output'+ '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim)\\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\",\n \"def plot_tariff(self):\\n\\t\\tplt.figure(1)\\n\\t\\tplt.cla() # clear the plotting window to allow for re-plotting\\n\\n\\t\\tif self.chargetypetoplot.get() == 'energy':\\n\\t\\t\\ttoplot = []\\n\\t\\t\\tenergy_filter = ('energy' == self.data[\\\"Charge\\\"]) | ('Energy' == self.data[\\\"Charge\\\"])\\n\\t\\t\\tfor mo in range(1, 13):\\n\\t\\t\\t\\tmonth_filter = (mo >= self.data[\\\"Start Month\\\"]) & (mo <= self.data[\\\"End Month\\\"])\\n\\t\\t\\t\\ttemp = self.data.loc[(energy_filter & month_filter), :]\\n\\t\\t\\t\\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \\\"Value\\\"])\\n\\t\\t\\t\\t\\t\\t\\t for hr in range(1, 25)])\\n\\t\\t\\tim = plt.imshow(toplot, interpolation='nearest')\\n\\t\\t\\tplt.xticks(ticks=[i-.5 for i in range(25)],\\n\\t\\t\\t\\t\\t labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)], rotation=45)\\n\\t\\t\\tplt.yticks(ticks=[i-0.5 for i in range(13)],\\n\\t\\t\\t\\t\\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',\\n\\t\\t\\t\\t\\t\\t\\t 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''], va='top')\\n\\n\\t\\t\\t# get the colors of the values, according to the\\n\\t\\t\\t# colormap used by imshow\\n\\t\\t\\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\\n\\t\\t\\tcolors = [im.cmap(im.norm(value)) for value in values]\\n\\t\\t\\t# create a patch (proxy artist) for every color\\n\\t\\t\\tpatches = [mpatches.Patch(color=colors[i], label=\\\"${:1.5}/kWh\\\".format(values[i]))\\n\\t\\t\\t\\t\\t for i in range(len(values))]\\n\\t\\t\\t# put those patched as legend-handles into the legend\\n\\t\\t\\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\\\"upper right\\\", borderaxespad=0.)\\n\\t\\t\\tplt.title('Energy Price Heatmap')\\n\\t\\telse:\\n\\t\\t\\ttoplot = []\\n\\t\\t\\tdemand_filter = ('demand' == self.data[\\\"Charge\\\"]) | ('Demand' == self.data[\\\"Charge\\\"])\\n\\t\\t\\tfor mo in range(1, 13):\\n\\t\\t\\t\\tmonth_filter = (mo >= self.data[\\\"Start Month\\\"]) & (mo <= self.data[\\\"End Month\\\"])\\n\\t\\t\\t\\ttemp = self.data.loc[(demand_filter & month_filter), :]\\n\\t\\t\\t\\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \\\"Value\\\"]) for hr in\\n\\t\\t\\t\\t\\t\\t\\t range(1, 25)])\\n\\t\\t\\tim = plt.imshow(toplot, interpolation='nearest')\\n\\t\\t\\tplt.xticks(ticks=[i - .5 for i in range(25)], labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)],\\n\\t\\t\\t\\t\\t rotation=45)\\n\\t\\t\\tplt.yticks(ticks=[i - 0.5 for i in range(13)],\\n\\t\\t\\t\\t\\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''],\\n\\t\\t\\t\\t\\t va='top')\\n\\n\\t\\t\\t# get the colors of the values, according to the\\n\\t\\t\\t# colormap used by imshow\\n\\t\\t\\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\\n\\t\\t\\tcolors = [im.cmap(im.norm(value)) for value in values]\\n\\t\\t\\t# create a patch (proxy artist) for every color\\n\\t\\t\\tpatches = [mpatches.Patch(color=colors[i], label=\\\"${:1.5}/kW\\\".format(values[i])) for i in\\n\\t\\t\\t\\t\\t range(len(values))]\\n\\t\\t\\t# put those patched as legend-handles into the legend\\n\\t\\t\\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\\\"upper right\\\", borderaxespad=0.)\\n\\t\\t\\tplt.title('Demand Price Heatmap')\\n\\n\\t\\tself.chart_type.draw()\\n\\n\\t\\treturn 0\",\n \"def update_graph(self):\\n parameters = []\\n dtype = {'Timestamp': 'str'}\\n for header in self.headers:\\n if self.top_plot.current_param in header or self.bottom_plot.current_param in header:\\n parameters.append(header)\\n dtype[header] = 'float'\\n data = pd.read_csv(self.reactor.file,\\n dtype=dtype,\\n parse_dates=['Timestamp'], usecols=['Timestamp'] + parameters, low_memory=False,\\n na_filter=False)\\n start_time = data['Timestamp'][0]\\n data.insert(loc=2, column='EFT', value=(data['Timestamp'] - start_time) / np.timedelta64(1, 'h'))\\n\\n for label, content in data.iteritems():\\n if label == 'Timestamp' or label == 'EFT':\\n continue\\n elif self.top_plot.current_param in label:\\n self.top_plot.clear()\\n self.top_plot.plot(data['EFT'], content)\\n else:\\n self.bottom_plot.clear()\\n self.bottom_plot.plot(data['EFT'], content)\",\n \"def eeg_fdr(p_array,q,plot='false'):\\t\\n\\tN = len(p_array) \\n\\tp_array_srtind = np.argsort(p_array)\\n\\tp_array_srt = p_array[p_array_srtind]\\n\\tp_bound=np.zeros((N))\\n\\tfor i in range(N):\\n\\t\\tp_bound[i] = i * q/N\\n\\t\\n\\tidx = p_array_srt < p_bound\\n\\t\\n\\tif np.sum(idx == 'true') > 0:\\n\\t\\tp_thresh_fdr = np.max(p_array_srt[idx])\\n\\t\\ti_max_fdr = p_array_srt[idx].argmax()\\t\\t\\t\\n\\t\\tif plot == 'true':\\n\\t\\t\\tfig = plt.figure(19,figsize=[5,5])\\n\\t\\t\\tax = fig.add_subplot(111, autoscale_on=False, xlim=[0,120], ylim=[0,10])\\n\\t\\t\\tplt.plot(N*p_array_srt,'bo-',lw=2)\\n\\t\\t\\tplt.plot(N*p_bound,'k--',lw=2)\\n\\t\\t\\tplt.plot([10,20],[9,9],'bo-',lw=2)\\n\\t\\t\\tplt.plot([10,20],[8,8],'k--',lw=2)\\n\\t\\t\\tplt.text(25,9, r'$p_{i} \\\\cdot N$', fontsize = 13, va='center')\\n\\t\\t\\tplt.text(25,8, r'$q \\\\cdot i$', fontsize = 13,va='center')\\n\\t\\t\\tplt.text(1.2 * i_max_fdr,0.5 * p_thresh_fdr*N,'FDR (q = ' + str('%.2f' %q) + ') = ' + str('%.4f' %p_thresh_fdr),va = 'center')\\n\\t\\t\\tplt.fill_between([0,i_max_fdr],[p_thresh_fdr*N,p_thresh_fdr*N],0,color='k',alpha=0.3,lw=0)\\n\\t\\t\\tplt.xlabel('i',fontsize = 13)\\n\\t\\t\\tplt.ylabel(r'$N_{FP}$',fontsize = 13)\\t\\n\\telse:\\n\\t\\tprint \\\"None of the p-value exceeds the FDR threshold (there is no p-value (p_i) for which p_i < i*q/N) \\\"\\n\\t\\tp_thresh_fdr = []\\n\\t\\n\\treturn p_thresh_fdr\",\n \"def plot_speed_hist(dlc_df, cam_times, trials_df, feature='paw_r', cam='left', legend=True):\\r\\n # Threshold the dlc traces\\r\\n dlc_df = likelihood_threshold(dlc_df)\\r\\n # For pre-GPIO sessions, remove the first few timestamps to match the number of frames\\r\\n cam_times = cam_times[-len(dlc_df):]\\r\\n if len(cam_times) != len(dlc_df):\\r\\n raise ValueError(\\\"Camera times length and DLC length are inconsistent\\\")\\r\\n # Get speeds\\r\\n speeds = get_speed(dlc_df, cam_times, camera=cam, feature=feature)\\r\\n # Windows aligned to align_to\\r\\n start_window, end_window = plt_window(trials_df['stimOn_times'])\\r\\n start_idx = insert_idx(cam_times, start_window)\\r\\n end_idx = np.array(start_idx + int(WINDOW_LEN * SAMPLING[cam]), dtype='int64')\\r\\n # Add speeds to trials_df\\r\\n trials_df[f'speed_{feature}'] = [speeds[start_idx[i]:end_idx[i]] for i in range(len(start_idx))]\\r\\n # Plot\\r\\n times = np.arange(len(trials_df[f'speed_{feature}'].iloc[0])) / SAMPLING[cam] + WINDOW_LAG\\r\\n # Need to expand the series of lists into a dataframe first, for the nan skipping to work\\r\\n correct = trials_df[trials_df['feedbackType'] == 1][f'speed_{feature}']\\r\\n incorrect = trials_df[trials_df['feedbackType'] == -1][f'speed_{feature}']\\r\\n plt.plot(times, pd.DataFrame.from_dict(dict(zip(correct.index, correct.values))).mean(axis=1),\\r\\n c='k', label='correct trial')\\r\\n plt.plot(times, pd.DataFrame.from_dict(dict(zip(incorrect.index, incorrect.values))).mean(axis=1),\\r\\n c='gray', label='incorrect trial')\\r\\n plt.axvline(x=0, label='stimOn', linestyle='--', c='r')\\r\\n plt.title(f'{feature.capitalize()} speed trial avg\\\\n({cam.upper()} cam)')\\r\\n plt.xticks([-0.5, 0, 0.5, 1, 1.5])\\r\\n plt.xlabel('time [sec]')\\r\\n plt.ylabel('speed [px/sec]')\\r\\n if legend:\\r\\n plt.legend()\\r\\n\\r\\n return plt.gca()\",\n \"def plot_predicted_observed_discharge(\\n data: pd.DataFrame, s: Saver, show_plt: bool = False, ax=None\\n):\\n if ax is None:\\n fig, ax = plt.subplots()\\n else:\\n fig = plt.gcf()\\n\\n # x = s.z[:, 0] # Measured Discharge\\n x = data[\\\"q_true\\\"] # True (unobserved) Discharge\\n y = (s.H @ s.x)[:, 0] # Filtered Discharge\\n ax.scatter(x, y, marker=\\\"x\\\", label=\\\"Filtered Discharge\\\")\\n\\n # 1:1 line\\n one_to_one_line = np.linspace(x.min(), x.max(), 10)\\n ax.plot(one_to_one_line, one_to_one_line, \\\"k--\\\", label=\\\"1:1 Line\\\")\\n\\n # beautifying the plot\\n ax.set_xlabel(\\\"Unobserved (true) Discharge ($q_{true}$)\\\")\\n ax.set_ylabel(\\\"Filtered Discharge ($Hx$)\\\")\\n ax.set_title(\\\"Filtered Discharge vs. True Discharge\\\")\\n plt.legend()\\n sns.despine()\\n\\n return fig, ax\",\n \"def visualize_historicals(dcfs):\\n pass\\n\\n dcf_share_prices = {}\\n for k, v in dcfs.items():\\n dcf_share_prices[dcfs[k]['date']] = dcfs[k]['share_price']\\n\\n xs = list(dcf_share_prices.keys())[::-1]\\n ys = list(dcf_share_prices.values())[::-1]\\n\\n plt.scatter(xs, ys)\\n plt.show()\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def fig_event_corrected(evstream, TF_list, fmin=1./150., fmax=2.):\\n\\n # Unpack vertical trace and filter\\n trZ = evstream.trZ.copy()\\n trZ.filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n sr = trZ.stats.sampling_rate\\n taxis = np.arange(0., trZ.stats.npts/sr, 1./sr)\\n\\n plt.figure(figsize=(8, 8))\\n\\n plt.subplot(611)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['Z1']:\\n tr = Trace(\\n data=evstream.correct['Z1'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.key + ' ' + evstream.tstamp +\\n ': Z1', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.subplot(612)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['Z2-1']:\\n tr = Trace(\\n data=evstream.correct['Z2-1'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.tstamp + ': Z2-1', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.subplot(613)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['ZP-21']:\\n tr = Trace(\\n data=evstream.correct['ZP-21'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.tstamp + ': ZP-21', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.subplot(614)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['ZH']:\\n tr = Trace(\\n data=evstream.correct['ZH'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.tstamp + ': ZH', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.subplot(615)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['ZP-H']:\\n tr = Trace(\\n data=evstream.correct['ZP-H'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.tstamp + ': ZP-H', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.subplot(616)\\n plt.plot(\\n taxis, trZ.data, 'lightgray', lw=0.5)\\n if TF_list['ZP']:\\n tr = Trace(\\n data=evstream.correct['ZP'],\\n header=trZ.stats).filter(\\n 'bandpass', freqmin=fmin, freqmax=fmax, corners=2, zerophase=True)\\n plt.plot(taxis, tr.data, 'k', lw=0.5)\\n plt.title(evstream.tstamp + ': ZP', fontdict={'fontsize': 8})\\n plt.gca().ticklabel_format(axis='y', style='sci', useOffset=True,\\n scilimits=(-3, 3))\\n plt.xlim((0., trZ.stats.npts/sr))\\n\\n plt.xlabel('Time since earthquake (sec)')\\n plt.tight_layout()\\n\\n return plt\",\n \"def update_graphs(self):\\n profile_time = False\\n if profile_time:\\n start_time = time.time()\\n\\n # Update the graph data with data only within the chosen time_range\\n now = time.time()\\n i_tr_prs = np.where(now - self.prs_data[0, :] < \\n self.time_range[1] - self.time_range[0])[0]\\n self.prs_graph.setData(self.prs_data[0, i_tr_prs] - now, self.prs_data[1, i_tr_prs])\\n # Updates the graph title\\n self.prs_pw.setTitle(f\\\"Pressão: {self.prs_data[1, 0]:.1f} cmH2O\\\", **self.ttl_style)\\n\\n if profile_time == True:\\n time_at_pressure = time.time()\\n print(f\\\"Until pressure graph: {time_at_pressure - start_time:.4f} s\\\")\\n \\n # Update the graph data with data only within the chosen time_range\\n now = time.time()\\n i_tr_flw = np.where(now - self.flw_data[0, :] < \\n self.time_range[1] - self.time_range[0])[0]\\n self.flw_pw.setTitle(f\\\"Fluxo: {self.flw_data[1, 0]:.1f} l/min\\\", **self.ttl_style)\\n self.flw_graph.setData(self.flw_data[0, i_tr_flw] - now, self.flw_data[1, i_tr_flw])\\n\\n if profile_time == True:\\n time_at_flow = time.time()\\n print(f\\\"Until flow graph: {time_at_flow - start_time:.4f} s\\\")\\n\\n i_tr_vol = np.where(now - self.vol_data[0, :] < \\n self.time_range[1] - self.time_range[0])[0]\\n self.vol_pw.setTitle(f\\\"Volume: {self.vol_data[1, 0]:.0f} ml\\\", **self.ttl_style)\\n self.vol_graph.setData(self.vol_data[0, i_tr_vol] - now, self.vol_data[1, i_tr_vol])\\n\\n if profile_time == True:\\n time_at_volume = time.time()\\n print(f\\\"After the volume graph: {time_at_volume - time_at_flow:.4f} s\\\")\\n\\n # Adjust the Y range every N measurements\\n # Manually adjusting by calculating the max and min with numpy is faster than autoscale on \\n # the graph. Also calculates FPS\\n N = 20\\n if self.run_counter % N == 0:\\n # definition of the minimum acceptable range for the volume\\n min_range_vol = [-5, 50]\\n # Tries to get the max and min from each data set \\n try:\\n range_vol = [np.min(self.vol_data[1, i_tr_vol]), np.max(self.vol_data[1, i_tr_vol])]\\n # Adjusts the minimum and maximum, if the measured values are outside the minimum range\\n self.vol_pw.setYRange(np.min([range_vol[0], min_range_vol[0]]), \\n np.max([range_vol[1], min_range_vol[1]]))\\n except:\\n pass\\n min_range_prs = [-0.2, 5]\\n try:\\n range_prs = [np.min(self.prs_data[1, i_tr_prs]), np.max(self.prs_data[1, i_tr_prs])]\\n self.prs_pw.setYRange(np.min([range_prs[0], min_range_prs[0]]), \\n np.max([range_prs[1], min_range_prs[1]]))\\n except:\\n pass\\n\\n min_range_flw = [-0.1, 1]\\n try:\\n range_flw = [np.min(self.flw_data[1, i_tr_flw]), np.max(self.flw_data[1, i_tr_flw])]\\n self.flw_pw.setYRange(np.min([range_flw[0], min_range_flw[0]]), \\n np.max([range_flw[1], min_range_flw[1]]))\\n except:\\n pass\\n mean_pts = 50\\n try:\\n FPS = np.nan_to_num(1.0 / np.mean(self.vol_data[0, 0:mean_pts] - \\n self.vol_data[0, 1:1+mean_pts]))\\n except:\\n FPS = 0\\n self.fps_lbl.setText(f\\\"FPS: {FPS:.2f}\\\")\\n self.run_counter = 0\\n self.run_counter += 1\",\n \"def plot_f(self, *args, **kwargs):\\r\\n kwargs['plot_raw'] = True\\r\\n self.plot(*args, **kwargs)\",\n \"def plot_r(f=500, d=100e-3, dr=0.01, picture_file=None, picture_formats=['png', 'pdf', 'svg']):#x_axis='r', \\n import matplotlib.pyplot\\n i = 0\\n rs = []\\n sigmas = []\\n ys = []\\n print \\\"r_soll ->\\\\tsigma ->\\\\tr\\\"\\n datas = []\\n for r in numpy.arange(0, 1+dr, dr) :\\n for t in [0] :\\n print \\\"%f\\\\t\\\" %(r),\\n sigma = getSigma(r)\\n print \\\"%f\\\\t\\\" % (sigma),\\n rs.append(r)\\n sigmas.append(sigma)\\n v = getSynapticActivity(f=f, r=r, fireing_rate=1, duration=d, delay=t)\\n #print v\\n #matplotlib.pyplot.scatter(v, numpy.zeros( len(v) ) + i )\\n r = vector_strength(f, v)\\n print \\\"%f\\\" % (r)\\n ys.append(r)\\n i = i+1\\n datas.append([sigma,r])\\n numpy.savetxt(\\\"../../../Data/%.1f_%f@%i.dat\\\" % (getSigma(dr),dr,int(f*d)), datas) \\n\\n matplotlib.pyplot.figure()\\n matplotlib.pyplot.xlabel('sigma')\\n matplotlib.pyplot.ylabel('measured vector strength')\\n matplotlib.pyplot.xlim(0, getSigma(dr))\\n matplotlib.pyplot.ylim(0, 1)\\n matplotlib.pyplot.grid()\\n matplotlib.pyplot.scatter(sigmas,ys, marker='x', color='black')#, basex=10, basey=10, ls=\\\"-\\\"\\n if(picture_file != None):\\n for picture_format in picture_formats:\\n matplotlib.pyplot.savefig(picture_file+'sigma_'+str(getSigma(dr))+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\\n else:\\n matplotlib.pyplot.show()\\n\\n matplotlib.pyplot.figure()\\n matplotlib.pyplot.xlabel('aimed vector strength')\\n matplotlib.pyplot.ylabel('measured vector strength')\\n #matplotlib.pyplot.legend([\\\"based on %i examples / dot\\\" % (f*d) ], loc='best');\\n matplotlib.pyplot.xlim(0, 1)\\n matplotlib.pyplot.ylim(0, 1)\\n matplotlib.pyplot.grid()\\n\\n matplotlib.pyplot.scatter(rs,ys, marker='x', color='black')\\n if(picture_file != None):\\n for picture_format in picture_formats:\\n matplotlib.pyplot.savefig(picture_file+'_'+str(dr)+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\\n else:\\n matplotlib.pyplot.show()\\n\\n matplotlib.pyplot.close('all')\\n datas = numpy.ndarray((len(datas),2), buffer=numpy.array(datas),dtype=float)\\n return datas\",\n \"def plot_db_f():\\n db = np.arange(-24, -13)\\n mw = dbm_mw(db)\\n f = mw_f(mw)\\n plt.plot(db, f, '.-')\\n f = np.linspace(0.06, 0.20, 10)\\n mw = f_mw(f)\\n db = mw_dbm(mw)\\n for i, field in enumerate(f):\\n print(db[i])\\n plt.plot(db, f, 'o-')\\n return\",\n \"def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices['E_tot1'])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\\n \\n plt.ylabel('Energy [kWh]')\\n plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(24)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\\n\\n plt.ylabel('Energy Difference [kWh]')\\n plt.legend()\\n\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n return fig\",\n \"def worker_plot(fname):\\n with Database() as base:\\n _filter = base.get_filter(fname)\\n plt.clf()\\n plt.plot(_filter.trans_table[0], _filter.trans_table[1], color='k')\\n plt.xlim(_filter.trans_table[0][0], _filter.trans_table[0][-1])\\n plt.minorticks_on()\\n plt.xlabel('Wavelength [nm]')\\n plt.ylabel('Relative transmission')\\n plt.title(\\\"{} filter\\\".format(fname))\\n plt.tight_layout()\\n plt.savefig(\\\"{}.pdf\\\".format(fname))\",\n \"def display_data(\\n # shared requirements / general settings\\n df, file_metadata_list, data_column,\\n x_vals_column=None, coord_2d_column=None,\\n x_vals_label=None, coord_2d_label=None,\\n figsize_scale=1.0, font_scale=1.0,\\n # 2d colorplot / waterfall\\n display_2d_colorplot=False, imshow_kwargs=None,\\n display_waterfall=False, num_waterfall_plots=4,\\n display_2d_save_filepath=None,\\n # requirements for fit analysis plots\\n results_df=None, minimize_results=None,\\n fit_function=None, \\n # display all fits at once or w/ widget\\n display_fits=None, num_fit_plots_cols=3,\\n residuals_fcn=None, indep_vars_columns=None,\\n display_fits_save_filepath=None,\\n # display fit params (and more) \\n display_fit_results=None,\\n num_result_plots_cols=3,\\n other_results_list=['chisqr'],\\n display_fit_results_save_filepath=None,\\n # display covariance / correlations matrix\\n display_covar=None,\\n display_covar_save_filepath=None,\\n # display detailed fit reports\\n display_fit_reports=False):\\n # PLOT 2D REPRESENTATION\\n if not (display_2d_colorplot or display_waterfall):\\n pass\\n elif display_2d_colorplot and display_waterfall:\\n plt.figure(figsize=(figsize_scale * 4,\\n figsize_scale * 2))\\n nplots = 2\\n else: # xor\\n plt.figure(figsize=(figsize_scale * 2.5,\\n figsize_scale * 2.5))\\n nplots = 1\\n if imshow_kwargs is None:\\n imshow_kwargs = {'aspect': 1.0,\\n 'origin': 'upper'}\\n if display_2d_colorplot:\\n ax1 = plt.subplot(1, nplots, 1)\\n plot_dataframe_colorplot(df, data_column,\\n x_vals_column, coord_2d_column,\\n xlabel=x_vals_label, ylabel=coord_2d_label,\\n ax=ax1, **imshow_kwargs)\\n if display_waterfall:\\n plotnum = 2 if display_2d_colorplot else 1\\n ylabel = None if display_2d_colorplot else coord_2d_label\\n ax2 = plt.subplot(1, nplots, plotnum)\\n plot_dataframe_waterfall(df, data_column,\\n num_waterfall_plots,\\n x_vals_column, coord_2d_column,\\n xlabel=x_vals_label, ylabel=ylabel, ax=ax2)\\n ax2.yaxis.set_ticklabels([])\\n if (display_2d_colorplot or display_waterfall) \\\\\\n and display_2d_save_filepath:\\n plt.savefig(display_2d_save_filepath,\\n bbox_inches='tight', transparent=False)\\n if display_2d_colorplot or display_waterfall:\\n plt.show()\\n\\n # plot fit results if given\\n if results_df is None or minimize_results is None:\\n return\\n\\n # plot fits\\n if (display_fits == 'all' or display_fits == 'widget') \\\\\\n and (indep_vars_columns and residuals_fcn):\\n if x_vals_column is None:\\n x_vals_column = df.index.names[-1]\\n def plot_fit(result_index, axes=None):\\n if axes:\\n ax = axes\\n else:\\n plt.figure(figsize=(figsize_scale * 3,\\n figsize_scale * 3))\\n ax = plt.subplot(111)\\n result = minimize_results[result_index]\\n dataset_index = results_df.index[result_index]\\n xvals = df.loc[dataset_index][x_vals_column]\\n yvals = df.loc[dataset_index][data_column]\\n indep_vars_vecs = [df.loc[dataset_index][colname]\\n for colname in indep_vars_columns]\\n fit_yvals = residuals_fcn(result.params, *indep_vars_vecs)\\n ax.plot(xvals, yvals, 'bd', label='dataset {}'.format(result_index))\\n ax.plot(xvals, fit_yvals, 'r')\\n if axes is None:\\n plt.show()\\n if display_fits_save_filepath or display_fits == 'all':\\n ncols = num_fit_plots_cols\\n nplots = len(minimize_results)\\n nrows = np.int(np.ceil(nplots / ncols))\\n plt.figure(figsize=(figsize_scale * 1.5 * min(ncols, 5),\\n figsize_scale * 1.3 * nrows))\\n for result_index in list(range(nplots)):\\n ax = plt.subplot(nrows, ncols, result_index + 1)\\n plot_fit(result_index, ax)\\n plt.tight_layout()\\n if display_fits_save_filepath:\\n plt.savefig(display_fits_save_filepath,\\n bbox_inches='tight', transparent=False)\\n if display_fits == 'all':\\n plt.show()\\n else:\\n plt.close()\\n if display_fits == 'widget':\\n result_slider = IntSlider(min=0, max=len(minimize_results) - 1,\\n step=1, value=0)\\n interactive_plot = interactive(plot_fit,\\n result_index=result_slider,\\n axes=fixed(None)) \\n # Note: axes=fixed(None) was once in those params, not sure why\\n output = interactive_plot.children[-1]\\n output.layout.height = '350px'\\n display(interactive_plot)\\n interactive_plot.update()\\n elif not display_fits: # False or None\\n pass\\n else:\\n raise ValueError(\\\"Invalid value for keyword argument display_fits\\\")\\n\\n # plot params, grouped by all but last column\\n if display_fit_results:\\n results_df_2d, _ = dfproc.get_2d_indexed_df(results_df)\\n result = minimize_results[0]\\n if display_fit_results == 'params':\\n params_to_plot_list = list(result.var_names)\\n else:\\n try:\\n test_iterator = iter(display_fit_results)\\n except TypeError: # not iterable\\n raise ValueError(\\\"Invalid value for keyword \\\" +\\n \\\"argument display_fit_results\\\")\\n else:\\n params_to_plot_list = list(test_iterator)\\n params_to_plot_list += list(other_results_list)\\n ncols = num_result_plots_cols\\n nplots = len(params_to_plot_list)\\n nrows = np.int(np.ceil(nplots / ncols))\\n plt.figure(figsize=(figsize_scale * 1.5 * min(ncols, 6),\\n figsize_scale * 1.3 * nrows))\\n for ind, param in enumerate(params_to_plot_list):\\n ax = plt.subplot(nrows, ncols, ind + 1)\\n indices_2d = results_df_2d.index.get_level_values(-2).unique()\\n for index_2d in indices_2d:\\n subdf = results_df_2d.loc[index_2d]\\n if (param + '_error') in list(results_df_2d):\\n ax.errorbar(x=subdf.index.get_level_values(-1),\\n y=subdf[param],\\n yerr=subdf[param + '_error'],\\n fmt='d-', label=index_2d)\\n else:\\n ax.plot(subdf.index.get_level_values(-1),\\n subdf[param].values, 'd-', label=index_2d)\\n if len(indices_2d) <= 5:\\n plt.legend()\\n plt.xlabel(results_df_2d.index.names[-1])\\n plt.tight_layout()\\n plt.title(param)\\n if display_fit_results_save_filepath:\\n plt.savefig(display_fit_results_save_filepath,\\n bbox_inches='tight', transparent=False)\\n plt.show()\\n\\n # Plot the avg. covariance matrix\\n if (display_covar == 'covariance' or\\n display_covar == 'correlation'):\\n covar_mats = []\\n corr_mats = []\\n for result in minimize_results:\\n covar = result.covar\\n covar_mats.append(covar)\\n if display_covar == 'correlation':\\n oostd = np.diagflat(\\n [1.0 / param.stderr\\n for param in list(result.params.values())\\n if param.name in result.var_names\\n if param.stderr != 0])\\n corr = np.dot(np.dot(oostd, result.covar),\\n oostd).astype(np.float)\\n mask = np.zeros_like(corr, dtype=np.bool)\\n mask[np.triu_indices_from(mask)] = True\\n corr[mask] = np.nan\\n corr_mats.append(corr)\\n\\n # filter out malformed covariance / correlation matrices\\n if display_covar == 'covariance':\\n valid_mats = [mat for mat in covar_mats\\n if mat.size is not None\\n if mat.size > 0]\\n else:\\n valid_mats = [mat for mat in corr_mats\\n if mat.size is not None\\n if mat.size > 0]\\n num_nan = lambda mat: np.count_nonzero(np.isnan(mat))\\n avg_nan = np.mean([num_nan(mat) for mat in valid_mats])\\n avgcorr = np.mean([mat for mat in valid_mats\\n if num_nan(mat) <= avg_nan], axis=0)\\n\\n plt.figure()\\n plt.imshow(avgcorr, vmin=-1, vmax=1)\\n plt.colorbar()\\n plt.xticks(np.arange(result.nvarys), result.var_names,\\n rotation=-35, ha='left')\\n plt.yticks(np.arange(result.nvarys), result.var_names)\\n plt.title('Avg. correlation matrix, off-diagonal')\\n if display_covar_save_filepath:\\n plt.savefig(display_covar_save_filepath,\\n bbox_inches='tight', transparent=False)\\n plt.show()\\n elif not display_covar: # False or None\\n pass\\n else:\\n raise ValueError(\\\"Invalid value for keyword argument display_covar\\\")\\n\\n # DETAILED FIT REPORTS\\n if display_fit_reports:\\n for result_index, result in enumerate(minimize_results):\\n print('----------------------------------------')\\n if (display_covar == 'covariance' or\\n display_covar == 'correlation') \\\\\\n and (indep_vars_columns and residuals_fcn):\\n fig, (ax1, ax2) = plt.subplots(\\n ncols=2, sharey=False, figsize=(figsize_scale * 4.0,\\n figsize_scale * 1.5))\\n elif (display_covar == 'covariance' or\\n display_covar == 'correlation') \\\\\\n or (indep_vars_columns and residuals_fcn):\\n fig = plt.figure(figsize=(figsize_scale * 2.0,\\n figsize_scale * 1.0))\\n ax1 = plt.subplot(111)\\n ax2 = ax1 # either alias points to same fig\\n if indep_vars_columns and residuals_fcn:\\n dataset_index = results_df.index[result_index]\\n xvals = df.loc[dataset_index][x_vals_column]\\n yvals = df.loc[dataset_index][data_column]\\n indep_vars_vecs = [df.loc[dataset_index][colname]\\n for colname in indep_vars_columns]\\n fit_yvals = residuals_fcn(result.params, *indep_vars_vecs)\\n ax1.plot(xvals, yvals, 'bd',\\n label='dataset {}'.format(result_index))\\n ax1.plot(xvals, fit_yvals, 'r')\\n ax1.set_title('Data vs. Fit')\\n if (display_covar == 'covariance' or\\n display_covar == 'correlation'):\\n if display_covar == 'correlation':\\n mat = corr_mats[result_index]\\n else:\\n mat = covar_mats[result_index]\\n if mat.size is not None and mat.size > 0:\\n img = ax2.imshow(mat, vmin=-1, vmax=1)\\n fig.colorbar(img, ax=ax2)\\n plt.xticks(np.arange(result.nvarys), result.var_names,\\n rotation=-35, ha='left', fontsize=font_scale*8)\\n plt.yticks(np.arange(result.nvarys), result.var_names,\\n fontsize=font_scale*8)\\n ax2.set_title('Correlations')\\n plt.tight_layout()\\n plt.show()\\n print('FIT #{}'.format(result_index + 1))\\n for col, val in zip(results_df.index.names,\\n results_df.index[result_index]):\\n print('{}: {}'.format(col, val))\\n display(report_fit(result))\",\n \"def plot_ECG_peaks(ecg_df, r_peaks):\\n\\t# peak_times = ecg_df.iloc[r_peaks]['timestamp']\\n\\tpeak_times = r_peaks\\n\\tecg_df['is_peak'] = ecg_df['timestamp'].isin(peak_times) \\n\\n\\tplt.figure()\\n\\tplt.plot(ecg_df['timestamp'], ecg_df['ecg'])\\n\\tplt.plot(ecg_df[ecg_df['is_peak']]['timestamp'], ecg_df[ecg_df['is_peak']]['ecg'], 'ro')\\n\\tplt.title('Detected R-peaks on ECG Data')\\n\\tplt.xlabel('Time (ms)')\\n\\tplt.ylabel('Voltage (mV)')\\n\\tplt.show()\",\n \"def plot_carrier_frequency(self):\\r\\n roi = self.phase_roi\\r\\n phase_slice = (slice(roi[2], roi[3]), slice(roi[0], roi[1]))\\r\\n # calculation\\r\\n S = self.image[phase_slice] # signal in phase_roi\\r\\n t_axis = self.image.x_axis[roi[0]:roi[1]] # [ns] time axis\\r\\n y_axis = self.image.y_axis[roi[2]:roi[3]] # [mic] spatial scale\\r\\n N = S.shape[0]//2\\r\\n\\r\\n s = np.fft.fft(S, axis=0) / N # fft\\r\\n s_abs = np.abs(s[:N,:])\\r\\n f_axis = np.arange(N) / (2 * N) # spatial frequency axis\\r\\n\\r\\n s_mean = np.log10(np.mean(s_abs, axis=1))\\r\\n i0 = np.argmax(s_mean[3:])\\r\\n f0 = f_axis[3+i0] # [px^-1] fringe carrier frequency (estimate)\\r\\n s0 = s_mean[3+i0]\\r\\n sys.stdout.write(\\\"{} VISAR-{} fringe period = {:.1f} px\\\\n\\\".format(\\r\\n self.h5.shot_id[:11], self.leg, 1/f0))\\r\\n\\r\\n # plot calcs\\r\\n vlim_0 = dataimage.thresh_vlim(S, 0.01)\\r\\n vlim_1 = dataimage.thresh_vlim(np.log10(s_abs), (0.02, 0.005))\\r\\n tlim = (t_axis[0], t_axis[-1])\\r\\n ylim = (y_axis[0], y_axis[-1])\\r\\n flim = (0, 0.5) # [1/px]\\r\\n extent_0 = tlim + (0, S.shape[0]) # extent for signal\\r\\n# extent_0 = tlim + ylim # extent for signal\\r\\n extent_1 = tlim + flim # extent for fft\\r\\n\\r\\n # figure\\r\\n fig = plt.figure(figsize=(7,7), dpi=100)\\r\\n axs = []\\r\\n axs.append(fig.add_subplot(221, ylabel='[px]', title='signal'))\\r\\n axs.append(fig.add_subplot(222, sharey=axs[0], title='spatial lineout'))\\r\\n axs.append(fig.add_subplot(223, sharex=axs[0], title='log(fft(signal))',\\r\\n xlabel='time [ns]', ylabel=\\\"spatial frequency [px^-1]\\\"))\\r\\n axs.append(fig.add_subplot(224, sharey=axs[2], xlabel='log10(power)', title='spectral lineout'))\\r\\n\\r\\n axs[0].imshow(S, extent=extent_0,\\r\\n aspect='auto', vmin=vlim_0[0], vmax=vlim_0[1])\\r\\n axs[2].imshow(np.log10(s_abs), extent=extent_1,\\r\\n aspect='auto', vmin=vlim_1[0], vmax=vlim_1[1])\\r\\n axs[1].plot(np.mean(S, axis=1), np.arange(S.shape[0]))\\r\\n axs[3].plot(s_mean, f_axis)\\r\\n axs[0].set_ylim(*extent_0[2:])\\r\\n \\r\\n axs[3].annotate(\\\"fringe period\\\\n= {:.1f} px\\\".format(1/f0),\\r\\n (s0, f0), (0.95, 0.5), textcoords='axes fraction',\\r\\n arrowprops=dict(width=1, headwidth=6, facecolor='k',\\r\\n shrink=0.03), ha='right',)\\r\\n\\r\\n axs[3].axhline(f0*0.7, color='r', linestyle='dashed')\\r\\n axs[3].axhline(f0*1.4, color='r', linestyle='dashed')\\r\\n\\r\\n fig.tight_layout()\\r\\n fig.canvas.window().move(0,0)\\r\\n return fig\",\n \"def plot_comparison(step_test_data, model, inputs, outputs, start_time, end_time, plt_input=False, scale_plt=False):\\n \\n val_data = step_test_data.loc[start_time:end_time]\\n val_data.columns = [col[0] for col in val_data.columns]\\n \\n Time = val_data.index\\n u = val_data[inputs].to_numpy().T\\n y = val_data[outputs].to_numpy().T\\n\\n\\n # Use the model to predict the output-signals.\\n mdl = np.load(model)\\n \\n # The output of the model\\n xid, yid = fsetSIM.SS_lsim_innovation_form(A=mdl['A'], B=mdl['B'], C=mdl['C'], D=mdl['D'], K=mdl['K'], y=y, u=u, x0=mdl['X0'])\\n \\n # Make the plotting-canvas bigger.\\n plt.rcParams['figure.figsize'] = [25, 5]\\n # For each output-signal.\\n for idx in range(0,len(outputs)):\\n plt.figure(idx)\\n plt.xticks(rotation=15)\\n plt.plot(Time, y[idx],color='r')\\n plt.plot(Time, yid[idx],color='b')\\n plt.ylabel(outputs[idx])\\n plt.grid()\\n plt.xlabel(\\\"Time\\\")\\n plt.title('output_'+ str(idx+1))\\n plt.legend(['measurment', 'prediction'])\\n ax=plt.gca()\\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\\n ax.xaxis.set_major_formatter(xfmt) \\n if scale_plt==True:\\n plt.ylim(np.amin(y[idx])*.99, np.amax(y[idx])*1.01)\\n \\n if plt_input == True:\\n for idx in range(len(outputs), len(outputs) + len(inputs)):\\n plt.figure(idx)\\n plt.xticks(rotation=15)\\n plt.plot(Time, u[idx-len(outputs)], color='r')\\n plt.ylabel(inputs[idx-len(outputs)])\\n plt.grid()\\n plt.xlabel(\\\"Time\\\")\\n plt.title('input_'+ str(idx-len(outputs)+1))\\n ax=plt.gca()\\n xfmt = md.DateFormatter('%m-%d-%yy %H:%M')\\n ax.xaxis.set_major_formatter(xfmt) \\n plt.show()\",\n \"def plot_stress_time(F_tot, response_t, coords, t_range):\\n section = np.where((t>t_range[0]) & (t<t_range[1]))[0]\\n fig, ax1 = plt.subplots(figsize=[15,5])\\n ax2 = ax1.twinx()\\n# ax1.set_title('Load and response at '+str(coords),fontsize = 14)\\n ax1.set_xlim(t_range)\\n ax1.set_xlabel('t [s]')\\n resp = ax1.plot(t[section], response_t[section]/10**6, color=\\\"#00A6D6\\\",\\n label='Equivalent gate stress')\\n ax1.set_ylabel('Stress [MPa]', fontsize=12)\\n d_max = 1.2*max(response_t[section])/10**6\\n d_mean = np.mean(response_t[section])/10**6\\n ax1.set_ylim(d_mean-d_max,d_max)\\n ax1.legend()\\n\\n force = ax2.plot(t[section], F_tot[section]/1000, color=\\\"#c3312f\\\", label = 'Wave force')\\n ax2.set_ylabel('Integrated wave force [$kN/m$]', fontsize = 12)\\n F_lim = 1.2*max(F_tot[section])/1000\\n F_mean = np.mean(F_tot[section]/1000)\\n ax2.set_ylim(F_mean-F_lim,F_lim)\\n\\n lines = resp + force\\n labs = [l.get_label() for l in lines]\\n ax1.grid(lw=0.25)\\n ax1.legend(lines,labs, fontsize = 12)\\n return fig\",\n \"def _run():\\n\\n temperatures_kelvins = _create_temperature_grid()\\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\\n second_derivs_kelvins_pt01 = numpy.gradient(\\n numpy.absolute(first_derivs_kelvins_pt01)\\n )\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(first_derivs_kelvins_pt01)\\n )\\n\\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(second_derivs_kelvins_pt01)\\n )\\n\\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\\n\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n temperature_handle = axes_object.plot(\\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n second_deriv_handle = axes_object.plot(\\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n first_deriv_handle = axes_object.plot(\\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n this_min_index = numpy.argmin(second_derivs_unitless)\\n second_derivs_unitless[\\n (this_min_index - 10):(this_min_index + 10)\\n ] = second_derivs_unitless[this_min_index]\\n\\n tfp_handle = axes_object.plot(\\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n axes_object.set_yticks([0])\\n axes_object.set_xticks([], [])\\n\\n x_label_string = r'$x$-coordinate (increasing to the right)'\\n axes_object.set_xlabel(x_label_string)\\n\\n legend_handles = [\\n temperature_handle, first_deriv_handle, second_deriv_handle,\\n tfp_handle\\n ]\\n\\n legend_strings = [\\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\\n ]\\n\\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\\n\\n print 'Saving figure to file: \\\"{0:s}\\\"...'.format(OUTPUT_FILE_NAME)\\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\\n pyplot.close()\",\n \"def display1(*args):\\n #----------*----------* # unpack\\n twiss_func = args[0]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- transverse X\\n splot111=plt.subplot(111)\\n splot111.set_title('beta functions')\\n plt.plot(s,bx, label=r'$\\\\beta_x$ [m]', color='red', linestyle='-') # beta x\\n plt.plot(s,by, label=r'$\\\\beta_y$ [m]', color='blue', linestyle='-') # beta y\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\\n vscale=splot111.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\",\n \"def _plot(self):\\n # Read results\\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\\n x1, y1, _ = read_results('openmc', path)\\n if self.code == 'serpent':\\n path = self.other_dir / 'input_det0.m'\\n else:\\n path = self.other_dir / 'outp'\\n x2, y2, sd = read_results(self.code, path)\\n\\n # Convert energies to eV\\n x1 *= 1e6\\n x2 *= 1e6\\n\\n # Normalize the spectra\\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\\n\\n # Compute the relative error\\n err = np.zeros_like(y2)\\n idx = np.where(y2 > 0)\\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\\n \\n # Set up the figure\\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\\n ax1 = fig.add_subplot(111)\\n \\n # Create a second y-axis that shares the same x-axis, keeping the first\\n # axis in front\\n ax2 = ax1.twinx()\\n ax1.set_zorder(ax2.get_zorder() + 1)\\n ax1.patch.set_visible(False)\\n \\n # Plot the spectra\\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\\n \\n # Plot the relative error and uncertainties\\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\\n \\n # Set grid and tick marks\\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\\n ax1.grid(b=False, axis='both', which='both')\\n ax2.tick_params(axis='y', which='both', right=False)\\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\\n \\n # Set axes labels and limits\\n ax1.set_xlim([self._min_energy, self.energy])\\n ax1.set_xlabel('Energy (eV)', size=12)\\n ax1.set_ylabel('Spectrum', size=12)\\n ax1.legend()\\n ax2.set_ylabel(\\\"Relative error\\\", size=12)\\n title = f'{self.nuclide}'\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n title += f' + {thermal_name}'\\n title += f', {self.energy:.1e} eV Source'\\n plt.title(title)\\n \\n # Save plot\\n os.makedirs('plots', exist_ok=True)\\n if self.name is not None:\\n name = self.name\\n else:\\n name = f'{self.nuclide}'\\n if self.thermal is not None:\\n name += f'-{thermal_name}'\\n name += f'-{self.energy:.1e}eV'\\n if self._temperature is not None:\\n name += f'-{self._temperature:.1f}K'\\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\\n plt.close()\",\n \"def plot_fitter(self):\\n\\n total_time=self.interval*self.maxspectra\\n times = np.linspace(self.interval,total_time + 1,self.interval)\\n spectra_fitter.main(self.rt_plot.sum_data, times)\",\n \"def plot(self, data_frame):\\n self.axes.plot(data_frame, 'o-')\\n self.axes.set_ylim(0.0, 200.0)\\n self.fig.autofmt_xdate()\\n self.draw()\",\n \"def plot_history(data):\\n fig = go.Figure()\\n for col in data.columns:\\n fig.add_trace(go.Scatter(x=data.index, y=data[col], mode='lines', name=col))\\n fig.update_xaxes(title_text=\\\"Time\\\",\\n showline=True, mirror=True, linewidth=1, linecolor='black',\\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\\n fig.update_yaxes(title_text=\\\"Share Price ($ USD)\\\",\\n showline=True, mirror=True, linewidth=1, linecolor='black',\\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\\n fig.update_layout(legend=dict(orientation=\\\"h\\\", yanchor=\\\"bottom\\\", y=-0.2, xanchor=\\\"center\\\", x=0.5),\\n font=dict(family='Times New Roman', size=15), plot_bgcolor='rgba(0,0,0,0)',\\n margin_l=20, margin_r=20, margin_t=20, margin_b=20,)\\n\\n fig.write_image(join('..', 'docs', 'share_prices_all_time.png'), height=700, width=900, engine='kaleido')\\n fig.write_html(join('..', 'docs', 'share_prices_all_time.html'))\\n fig.show()\\n\\n recent = data[:data.first_valid_index() - pd.Timedelta(weeks=52)]\\n fig = go.Figure()\\n for col in data.columns:\\n fig.add_trace(go.Scatter(x=recent.index, y=recent[col], mode='lines', name=col))\\n fig.update_xaxes(title_text=\\\"Time\\\",\\n showline=True, mirror=True, linewidth=1, linecolor='black',\\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\\n fig.update_yaxes(title_text=\\\"Share Price ($ USD)\\\",\\n showline=True, mirror=True, linewidth=1, linecolor='black',\\n zeroline=True, zerolinewidth=1, zerolinecolor='lightgrey',\\n showgrid=True, gridwidth=1, gridcolor='lightgrey')\\n fig.update_layout(legend=dict(orientation=\\\"h\\\", yanchor=\\\"bottom\\\", y=-0.2, xanchor=\\\"center\\\", x=0.5),\\n font=dict(family='Times New Roman', size=15), plot_bgcolor='rgba(0,0,0,0)',\\n margin_l=20, margin_r=20, margin_t=20, margin_b=20,)\\n\\n fig.write_image(join('..', 'docs', 'share_prices_past_year.png'), height=700, width=900, engine='kaleido')\\n fig.write_html(join('..', 'docs', 'share_prices_past_year.html'))\\n fig.show()\",\n \"def plot_corr_diff(tseries1, tseries2, fig=None,\\r\\n ts_names=['1', '2']):\\r\\n\\r\\n if fig is None:\\r\\n fig = plt.figure()\\r\\n\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n\\r\\n SNR1 = []\\r\\n SNR2 = []\\r\\n corr1 = []\\r\\n corr2 = []\\r\\n corr_e1 = []\\r\\n corr_e2 = []\\r\\n\\r\\n for i in range(tseries1.shape[0]):\\r\\n SNR1.append(nta.SNRAnalyzer(ts.TimeSeries(tseries1.data[i],\\r\\n sampling_rate=tseries1.sampling_rate)))\\r\\n\\r\\n corr1.append(np.arctanh(np.abs(SNR1[-1].correlation[0])))\\r\\n corr_e1.append(SNR1[-1].correlation[1])\\r\\n\\r\\n SNR2.append(nta.SNRAnalyzer(ts.TimeSeries(tseries2.data[i],\\r\\n sampling_rate=tseries2.sampling_rate)))\\r\\n\\r\\n corr2.append(np.arctanh(np.abs(SNR2[-1].correlation[0])))\\r\\n corr_e2.append(SNR1[-1].correlation[1])\\r\\n\\r\\n ax.scatter(np.array(corr1), np.array(corr2))\\r\\n ax.errorbar(np.mean(corr1), np.mean(corr2),\\r\\n yerr=np.std(corr2),\\r\\n xerr=np.std(corr1))\\r\\n plot_min = min(min(corr1), min(corr2))\\r\\n plot_max = max(max(corr1), max(corr2))\\r\\n ax.plot([plot_min, plot_max], [plot_min, plot_max], 'k--')\\r\\n ax.set_xlabel('Correlation (Fischer Z) %s' % ts_names[0])\\r\\n ax.set_ylabel('Correlation (Fischer Z) %s' % ts_names[1])\\r\\n\\r\\n return fig, corr1, corr2\",\n \"def do_data_plots(cat, subdir):\\n dla_data.noterdaeme_12_data()\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\\\"blue\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_all.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n plt.xlim(1e20, 1e23)\\n plt.ylim(1e-28, 5e-21)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir, \\\"cddf_gp\\\"))\\n plt.clf()\\n\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\\\"blue\\\", moment=True)\\n plt.xlim(1e20, 1e23)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir, \\\"cddf_moment_gp\\\"))\\n plt.clf()\\n\\n #Evolution with redshift\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(4,5, label=\\\"4-5\\\", color=\\\"brown\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z45.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(3,4, label=\\\"3-4\\\", color=\\\"black\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z34.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2.5,3, label=\\\"2.5-3\\\", color=\\\"green\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z253.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2,2.5, label=\\\"2-2.5\\\", color=\\\"blue\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z225.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n plt.xlim(1e20, 1e23)\\n plt.ylim(1e-28, 5e-21)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"cddf_zz_gp\\\"))\\n plt.clf()\\n\\n #dNdX\\n dla_data.dndx_not()\\n dla_data.dndx_pro()\\n (z_cent, dNdX, dndx68, dndx95) = cat.plot_line_density(zmax=5)\\n np.savetxt(path.join(subdir,\\\"dndx_all.txt\\\"), (z_cent, dNdX, dndx68[:,0],dndx68[:,1], dndx95[:,0],dndx95[:,1]) )\\n plt.legend(loc=0)\\n plt.ylim(0,0.16)\\n save_figure(path.join(subdir,\\\"dndx_gp\\\"))\\n plt.clf()\\n\\n #Omega_DLA\\n dla_data.omegahi_not()\\n dla_data.omegahi_pro()\\n dla_data.crighton_omega()\\n (z_cent, omega_dla, omega_dla_68, omega_dla_95) = cat.plot_omega_dla(zmax=5)\\n# cat.tophat_prior = True\\n# cat.plot_omega_dla(zmax=5, label=\\\"Tophat Prior\\\", twosigma=False)\\n# cat.tophat_prior = False\\n np.savetxt(path.join(subdir,\\\"omega_dla_all.txt\\\"), (z_cent, omega_dla, omega_dla_68[:,0],omega_dla_68[:,1], omega_dla_95[:,0], omega_dla_95[:,1]))\\n plt.legend(loc=0)\\n plt.xlim(2,5)\\n plt.ylim(0,2.5)\\n save_figure(path.join(subdir,\\\"omega_gp\\\"))\\n plt.clf()\",\n \"def view_datashade(self):\\n # Select only sufficient data\\n if self.x in self.y:\\n self.y.remove(self.x)\\n if self.y == []:\\n return self.gif\\n\\n df = self.dataframe[[self.x] + self.y].copy()\\n plot_opts = {\\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\\n\\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\\n # Compute\\n dataframe = df.copy()\\n if x_range is not None:\\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\\n data_length = len(dataframe) * len(dataframe.columns)\\n step = 1 if data_length < self.max_step else data_length // self.max_step\\n \\n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\\\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \\n plot_opts = {\\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n if len(self.y) != 1:\\n plot_opts['Scatter']['color'] = self.color_key\\n return plot_df.options(plot_opts)\\n\\n # Define a RangeXY stream linked to the image\\n rangex = hv.streams.RangeX(source=lines_overlay)\\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\\n if len(self.y) == 1:\\n data_shade_plot *= datashade(lines_overlay)\\n else:\\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\\n return pn.panel(data_shade_plot)\",\n \"def fdplot(self, imx):\\n fig = plt.figure()\\n maxval = np.max(imx)\\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\\n animation = anim.ArtistAnimation(fig,ims,interval=50)\\n plt.show()\",\n \"def psf_plot(self, irfname=None, outfile='psf.csv', title=''):\\n psf = self.get_psf(irfname)\\n \\n def bkg_size(e, ct):\\n f2 = lambda delta: psf(e,ct, delta)**2 * 2*np.pi*delta\\n return np.degrees(1./np.sqrt(np.pi*integrate.quad(f2, 0, np.inf)[0]))\\n \\n def loc_size(e, ct):\\n func = lambda x : psf(e,ct, x)\\n fprime = lambda x : misc.derivative(func, x, dx=0.0001, order=5)\\n integrand = lambda rp : rp * fprime(rp)**2/func(rp) * np.pi\\n return np.degrees(1/np.sqrt(integrate.quad(integrand, 0, np.radians(5))[0]))\\n \\n \\n egev = np.logspace(-1.+1/8., 2.5+1/8., 3.5*4+1)\\n front, back = [[bkg_size(e*1e3,ct) for e in egev] for ct in range(2)]\\n floc, bloc = [[loc_size(e*1e3,ct) for e in egev] for ct in range(2)]\\n f68,b68 = [[psf.inverse_integral(e*1e3, ct) for e in egev] for ct in range(2)]\\n fig,ax = plt.subplots(figsize=(6,6))\\n for x, s, label in zip((front, back, floc, bloc, f68, b68),\\n ('-g', 'r', '--g', '--r', ':g', ':r'),\\n ('front bkg', 'back bkg','front loc', 'back loc', 'front 68', 'back 68')):\\n ax.plot(egev, x, s, lw=2, label=label)\\n \\n plt.setp(ax, xlabel='Energy (GeV)', ylabel='PSF size (deg)', xscale='log', yscale='log',\\n xlim=(0.1, 100), ylim=(0.02, 8), title=title)\\n ax.legend(prop=dict(size=10)); ax.grid()\\n #x.set_xticklabels('0.1 1 10 100'.split())\\n #ax.set_yticklabels('0.01 0.1 1'.split())\\n if outfile is None: return fig\\n self.psf_df = pd.DataFrame(dict(front=front, floc=floc, back=back, bloc=bloc,f68=f68,b68=b68), \\n index=egev.round(3))\\n self.psf_df.index.name='energy'\\n self.psf_df.to_csv(os.path.join(self.plotfolder, outfile))\\n print ('wrote file %s' % os.path.join(self.plotfolder, outfile))\\n return fig\",\n \"def plot(self):\\n\\n fig, ax = plt.subplots()\\n\\n for run in self.runs:\\n # Load datasets\\n data_measure = run.get_dataset(\\\"stats-collect_link_congestion-raw-*.csv\\\")\\n data_sp = run.get_dataset(\\\"stats-collect_link_congestion-sp-*.csv\\\")\\n\\n # Extract link congestion information\\n data_measure = data_measure['msgs']\\n data_sp = data_sp['msgs']\\n\\n # Compute ECDF and plot it\\n ecdf_measure = sm.distributions.ECDF(data_measure)\\n ecdf_sp = sm.distributions.ECDF(data_sp)\\n\\n variable_label = \\\"\\\"\\n size = run.orig.settings.get('size', None)\\n if size is not None:\\n variable_label = \\\" (n=%d)\\\" % size\\n\\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\\n label=\\\"U-Sphere%s\\\" % variable_label)\\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\\n label=u\\\"Klasični usmerjevalni protokol%s\\\" % variable_label)\\n\\n ax.set_xlabel('Obremenjenost povezave')\\n ax.set_ylabel('Kumulativna verjetnost')\\n ax.grid()\\n ax.axis((28, None, 0.99, 1.0005))\\n self.convert_axes_to_bw(ax)\\n\\n legend = ax.legend(loc='lower right')\\n if self.settings.GRAPH_TRANSPARENCY:\\n legend.get_frame().set_alpha(0.8)\\n fig.savefig(self.get_figure_filename())\",\n \"def plot_snapshots(snapshots: HoomdFrame) -> Figure:\\n return _plot_grid([style_snapshot(plot_frame(snap)) for snap in snapshots])\",\n \"def plot_and_save_2d(file_name, path_name, raw_data_file, show=False):\\n print '-'*23+'PLOT (2d)'+'-'*24\\n \\n print 'Loading data...',\\n data = load_file(path_name+file_name)\\n t = data['t']\\n \\n pic_path = path_name+'pics/'\\n if not os.path.exists(pic_path):\\n os.makedirs(pic_path)\\n print 'done'\\n print 'Creating and saving plots...', \\n\\n # Moment.\\n plt.figure(1)\\n plt.plot(t, data['dyn']['M'], t, data['static']['M'])\\n plt.legend([\\\"Dynamic\\\", \\\"Static\\\"])\\n plt.xlabel('t')\\n plt.ylabel('M')\\n plt.title('Moment')\\n plt.grid()\\n plt.savefig('%sM.png' %pic_path)\\n\\n # Axial force.\\n plt.figure(2)\\n plt.plot(t, data['dyn']['FY'], t, data['static']['FY'])\\n plt.legend([\\\"Dynamic\\\", \\\"Static\\\"])\\n plt.xlabel('t')\\n plt.ylabel('Fa')\\n plt.title('Fa')\\n plt.grid()\\n plt.savefig('%sFa.png' %pic_path)\\n\\n # Transverse force.\\n plt.figure(3)\\n plt.plot(t, data['dyn']['FZ'], t, data['static']['FZ'])\\n plt.legend([\\\"Dynamic\\\", \\\"Static\\\"])\\n plt.xlabel('t')\\n plt.ylabel('Ft')\\n plt.title('Ft')\\n plt.grid()\\n plt.savefig('%sFt.png' %pic_path)\\n\\n # Resultant force.\\n plt.figure(4)\\n plt.plot(t, np.sqrt(data['dyn']['FY']**2+data['dyn']['FZ']**2),\\n t, np.sqrt(data['static']['FY']**2+data['static']['FZ']**2))\\n plt.legend([\\\"Dynamic\\\", \\\"Static\\\"])\\n plt.xlabel('t')\\n plt.ylabel('Fr')\\n plt.title('Fr')\\n plt.grid()\\n plt.savefig('%sFr.png' %pic_path)\\n print 'done'\\n\\n if show:\\n plt.show()\",\n \"def fiducial_evolution():\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n x = pk['x'].to(u.kpc)\\n xorig = x[:2]\\n \\n plt.close()\\n fig, ax = plt.subplots(1,1,figsize=(6,6))\\n \\n plt.sca(ax)\\n \\n Nsnap = 8\\n times = np.linspace(0,0.5,Nsnap)[::-1]\\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\\n\\n for e, t in enumerate(times):\\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\\n \\n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\\n x = pk['x'].to(u.kpc)\\n x_, y_ = x[0], x[1]\\n \\n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\\n \\n xt = 24*np.cos(angles[e]+90*u.deg)\\n yt = 24*np.sin(angles[e]+90*u.deg)\\n if e<Nsnap-1:\\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\\n \\n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\\n\\n lim = 27\\n plt.xlim(-lim,lim)\\n plt.ylim(-lim,lim)\\n plt.gca().set_aspect('equal')\\n \\n plt.xlabel('x [kpc]')\\n plt.ylabel('y [kpc]')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/loop_evolution.pdf')\",\n \"def plot_energy_vs_rmsd(\\n set1_rmsds_x, set1_energies_y, set2_rmsds_x, set2_energies_y,\\n x_ticks, x_label, y_label, point_size, set1_color, set2_color,\\n set1_marker, set2_marker, output_filename):\\n\\n plt.scatter(set1_rmsds_x, set1_energies_y, color=set1_color,\\n s=point_size, marker=set1_marker)\\n plt.scatter(set2_rmsds_x, set2_energies_y, color=set2_color,\\n s=point_size, marker=set2_marker)\\n plt.xlabel(x_label, fontsize=13)\\n plt.ylabel(y_label, fontsize=13)\\n plt.xticks(x_ticks)\\n\\n plt.savefig(output_filename + \\\".pdf\\\", dpi=300, transparent='True',\\n bbox_inches='tight', figsize=(5, 5), pad_inches=0.05)\\n plt.savefig(output_filename + \\\".png\\\", dpi=300, transparent='True',\\n bbox_inches='tight', figsize=(5, 5), pad_inches=0.05)\",\n \"def plot_ef2(n_points, er, cov):\\n if er.shape[0] != 2 or er.shape[0] != 2:\\n raise ValueError(\\\"plot_ef2 can only plot 2-asset frontiers\\\")\\n weights = [np.array([w, 1-w]) for w in np.linspace(0, 1, n_points)]\\n rets = [portfolio_return(w, er) for w in weights]\\n vols = [portfolio_vol(w, cov) for w in weights]\\n ef = pd.DataFrame({\\n \\\"Returns\\\": rets, \\n \\\"Volatility\\\": vols\\n })\\n return ef.plot.line(x=\\\"Volatility\\\", y=\\\"Returns\\\", style=\\\".-\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6313317","0.6141398","0.6133596","0.61213934","0.58762604","0.5865189","0.5831045","0.5801431","0.57747483","0.5743009","0.57139415","0.56994927","0.56850445","0.5679581","0.5657056","0.5632359","0.56177044","0.5578176","0.5577838","0.55500615","0.5545676","0.5531571","0.55263895","0.5517456","0.5490388","0.54902756","0.5473974","0.5468654","0.5463605","0.54427654","0.54323596","0.5431581","0.5431475","0.54050094","0.54037756","0.5399395","0.53991693","0.5398226","0.53828424","0.53715324","0.5364194","0.5358834","0.5357061","0.5356572","0.53540206","0.5352961","0.5352129","0.53448373","0.5338358","0.5328108","0.53243685","0.5323","0.5319882","0.53175014","0.53072184","0.5303821","0.53022444","0.5298477","0.5298431","0.52965665","0.5292054","0.5286963","0.52853143","0.527751","0.52761155","0.5263926","0.52637255","0.52635306","0.52630115","0.52531457","0.5232518","0.5230721","0.5223387","0.52201027","0.5219714","0.52168036","0.52135015","0.5213461","0.5212025","0.5204789","0.5204676","0.52012604","0.519932","0.51958025","0.5195207","0.51941603","0.5189297","0.5185231","0.51838493","0.5181257","0.51797175","0.5176571","0.5166831","0.5164551","0.516259","0.51597035","0.5156832","0.5155705","0.5154054","0.51529336"],"string":"[\n \"0.6313317\",\n \"0.6141398\",\n \"0.6133596\",\n \"0.61213934\",\n \"0.58762604\",\n \"0.5865189\",\n \"0.5831045\",\n \"0.5801431\",\n \"0.57747483\",\n \"0.5743009\",\n \"0.57139415\",\n \"0.56994927\",\n \"0.56850445\",\n \"0.5679581\",\n \"0.5657056\",\n \"0.5632359\",\n \"0.56177044\",\n \"0.5578176\",\n \"0.5577838\",\n \"0.55500615\",\n \"0.5545676\",\n \"0.5531571\",\n \"0.55263895\",\n \"0.5517456\",\n \"0.5490388\",\n \"0.54902756\",\n \"0.5473974\",\n \"0.5468654\",\n \"0.5463605\",\n \"0.54427654\",\n \"0.54323596\",\n \"0.5431581\",\n \"0.5431475\",\n \"0.54050094\",\n \"0.54037756\",\n \"0.5399395\",\n \"0.53991693\",\n \"0.5398226\",\n \"0.53828424\",\n \"0.53715324\",\n \"0.5364194\",\n \"0.5358834\",\n \"0.5357061\",\n \"0.5356572\",\n \"0.53540206\",\n \"0.5352961\",\n \"0.5352129\",\n \"0.53448373\",\n \"0.5338358\",\n \"0.5328108\",\n \"0.53243685\",\n \"0.5323\",\n \"0.5319882\",\n \"0.53175014\",\n \"0.53072184\",\n \"0.5303821\",\n \"0.53022444\",\n \"0.5298477\",\n \"0.5298431\",\n \"0.52965665\",\n \"0.5292054\",\n \"0.5286963\",\n \"0.52853143\",\n \"0.527751\",\n \"0.52761155\",\n \"0.5263926\",\n \"0.52637255\",\n \"0.52635306\",\n \"0.52630115\",\n \"0.52531457\",\n \"0.5232518\",\n \"0.5230721\",\n \"0.5223387\",\n \"0.52201027\",\n \"0.5219714\",\n \"0.52168036\",\n \"0.52135015\",\n \"0.5213461\",\n \"0.5212025\",\n \"0.5204789\",\n \"0.5204676\",\n \"0.52012604\",\n \"0.519932\",\n \"0.51958025\",\n \"0.5195207\",\n \"0.51941603\",\n \"0.5189297\",\n \"0.5185231\",\n \"0.51838493\",\n \"0.5181257\",\n \"0.51797175\",\n \"0.5176571\",\n \"0.5166831\",\n \"0.5164551\",\n \"0.516259\",\n \"0.51597035\",\n \"0.5156832\",\n \"0.5155705\",\n \"0.5154054\",\n \"0.51529336\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65924156"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9283,"cells":{"query":{"kind":"string","value":"Plots the free energy differences evaluated for each pair of adjacent states for all methods."},"document":{"kind":"string","value":"def plotdFvsLambda1():\n x = numpy.arange(len(df_allk))\n if x[-1]<8:\n fig = pl.figure(figsize = (8,6))\n else:\n fig = pl.figure(figsize = (len(x),6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\n lines = tuple()\n for name in P.methods:\n y = [df_allk[i][name]/P.beta_report for i in x]\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\n lines += (line[0],)\n pl.xlabel('States', fontsize=12, color='#151B54')\n pl.ylabel('$\\Delta G$ '+P.units, fontsize=12, color='#151B54')\n pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)\n pl.yticks(fontsize=8)\n pl.xlim(x[0], x[-1]+len(lines)*width)\n ax = pl.gca()\n for dir in ['right', 'top', 'bottom']:\n ax.spines[dir].set_color('none')\n ax.yaxis.set_ticks_position('left')\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n\n leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)\n leg.get_frame().set_alpha(0.5)\n pl.title('The free energy change breakdown', fontsize = 12)\n pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')\n pl.close(fig)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def vis_difference(self):\n print(self.init_vec)\n\n init = self.init_output.numpy()\n\n alphas = np.linspace(0, 1, 20)\n for i, alpha in enumerate(alphas):\n\n display.clear_output(wait=True)\n norm = [torch.linalg.norm(torch.tensor(\n self.init_vec + alpha*self.eigen[i]), axis=1).detach().numpy() for i in range(2)]\n\n diff = np.array([self.compute_difference(\n alpha, self.eigen[i]) for i in range(2)])\n\n fig = plt.figure(figsize=(14, 12), tight_layout=True)\n fig.suptitle(\"Latent direction variation\", fontsize=20)\n gs = gridspec.GridSpec(2, 2)\n\n ax_temp = plt.subplot(gs[0, :])\n ax_temp.scatter(\n init[:, 0], init[:, 1])\n ax_temp.set_title(\"Initial Dataset\")\n ax_temp.set_xlim(-1, 1)\n ax_temp.set_ylim(-1, 1)\n [s.set_visible(False) for s in ax_temp.spines.values()]\n\n for j in range(2):\n ax_temp = plt.subplot(gs[1, j])\n sc = ax_temp.quiver(\n init[:, 0], init[:, 1], diff[j, :, 0], diff[j, :, 1], norm[j])\n sc.set_clim(np.min(norm[j]), np.max(norm[j]))\n plt.colorbar(sc)\n ax_temp.set_title(\n \"Direction: {}, alpha: {}\".format(j+1, alpha))\n ax_temp.set_xlim(-1, 1)\n ax_temp.set_ylim(-1, 1)\n [s.set_visible(False) for s in ax_temp.spines.values()]\n\n plt.savefig(\"frames_dir/fig_{}\".format(i))\n plt.show()","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def show_derivative(self):\n for trace in self.plotWidget.plotDataItems:\n dt = float(trace.attrs['dt'])\n dtrace = np.diff(trace.data)\n x = pgplot.make_xvector(dtrace, dt)\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))","def plot_derivatives_divided(self, show=False):\n\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\n ax[2, 0].set_title('Difference between upper and lower training examples');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n ax[2, 0].legend(frameon=False)\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\n ax[2, 1].set_title('Difference between upper and lower test samples');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def plot_diff(self):\n if not(self.is_attribute(\"time\") & self.is_attribute(\"intensity_up\") & \n self.is_attribute(\"intensity_up_sigma\") &\n self.is_attribute(\"intensity_down\") & \n self.is_attribute(\"intensity_down_sigma\") &\n self.is_attribute(\"intensity_up_total\") &\n self.is_attribute(\"intensity_down_total\")):\n return\n fig, ax = plt.subplots()\n ax.set_title(\"Polarized intensity: I_up - I_down\")\n ax.set_xlabel(\"Time (microseconds)\")\n ax.set_ylabel('Intensity')\n \n np_time = numpy.array(self.time, dtype=float)\n np_up = numpy.array(self.intensity_up, dtype=float)\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\n np_down = numpy.array(self.intensity_down, dtype=float)\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\n np_diff = np_up - np_down\n np_diff_mod = np_up_mod - np_down_mod\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\n\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \"b:\")\n ax.plot(np_time, np_diff_mod, \"k-\",\n label=\"model\")\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\"ko\", alpha=0.2,\n label=\"experiment\")\n\n y_min_d, y_max_d = ax.get_ylim()\n param = y_min_d-(np_diff-np_diff_mod).max()\n\n ax.plot([np_time.min(), np_time.max()], [param, param], \"k:\")\n ax.plot(np_time, np_diff-np_diff_mod+param, \"r-\", alpha=0.7,\n label=\"difference\")\n ax.legend(loc='upper right')\n fig.tight_layout()\n return (fig, ax)","def plot_variables(self, n, show=False, diagnostics=False):\n\n if diagnostics:\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\n else:\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\n\n plt.subplots_adjust(hspace = 0)\n end = len(n.history[\"det F\"])\n epochs = np.arange(end)\n a, = ax[0].plot(epochs, n.history[\"det F\"], label = 'Training data')\n b, = ax[0].plot(epochs, n.history[\"det test F\"], label = 'Test data')\n # ax[0].axhline(y=5,ls='--',color='k')\n ax[0].legend(frameon = False)\n ax[0].set_ylabel(r'$|{\\bf F}_{\\alpha\\beta}|$')\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\"det test F\"][-1])\n ax[1].plot(epochs, n.history[\"loss\"])\n ax[1].plot(epochs, n.history[\"test loss\"])\n # ax[1].set_xlabel('Number of epochs')\n ax[1].set_ylabel(r'$\\Lambda$')\n ax[1].set_xlim([0, len(epochs)]);\n \n if diagnostics:\n ax[2].plot(epochs, n.history[\"det C\"])\n ax[2].plot(epochs, n.history[\"det test C\"])\n # ax[2].set_xlabel('Number of epochs')\n ax[2].set_ylabel(r'$|{\\bf C}|$')\n ax[2].set_xlim([0, len(epochs)]);\n \n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,0]\n , color = 'C0', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,1]\n , color = 'C0', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n \"\"\"\n\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,0]\n , color = 'C1', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,1]\n , color = 'C1', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n ax[3].legend(frameon=False)\n \"\"\"\n\n ax[3].set_ylabel(r'$\\partial\\mu/\\partial\\theta$')\n # ax[3].set_xlabel('Number of epochs')\n ax[3].set_xlim([0, len(epochs)])\n\n # Mean of network output summary 1\n ax[4].plot(epochs, np.array(n.history[\"μ\"])[:,0],alpha=0.5)\n # Mean of test output network summary 1\n ax[4].plot(epochs, np.array(n.history[\"test μ\"])[:,0],alpha=0.5)\n ax[4].set_ylabel('μ')\n ax[4].set_xlabel('Number of epochs')\n ax[4].set_xlim([0, len(epochs)])\n \n\n print ('Maximum Fisher info on train data:',np.max(n.history[\"det F\"]))\n print ('Final Fisher info on train data:',(n.history[\"det F\"][-1]))\n \n print ('Maximum Fisher info on test data:',np.max(n.history[\"det test F\"]))\n print ('Final Fisher info on test data:',(n.history[\"det test F\"][-1]))\n\n if np.max(n.history[\"det test F\"]) == n.history[\"det test F\"][-1]:\n print ('Promising network found, possibly more epochs needed')\n\n plt.tight_layout()\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def plot_derivatives(self, show=False):\n\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(0,self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].set_xscale('log')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[1, 0].set_xscale('log')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 0].set_title('Upper - lower input data: train sample');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 0].set_title('Numerical derivative: train sample');\n ax[3, 0].set_xlabel(r'$\\ell$')\n ax[3, 0].set_ylabel(r'$\\Delta C_\\ell / 2\\Delta \\theta$')\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 0].set_xscale('log')\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n ax[0, 1].set_xscale('log')\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n ax[1, 1].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 1].set_title('Upper - lower input data: test sample');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 1].set_title('Numerical derivative: train sample');\n ax[3, 1].set_xlabel(r'$\\ell$')\n ax[3, 1].set_ylabel(r'$\\Delta C_\\ell / \\Delta \\theta $')\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 1].set_xscale('log')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def show_calculations(self):\n self.view.set_sum(self.model.get_sum())\n self.view.set_diff(self.model.get_diff())","def plot(self):\n\t\tself.plotOfLoopVoltage()","def plot_energies(self):\n plt.plot(self.energies[0], self.energies[1])\n plt.xlabel('Time (s)')\n plt.ylabel('Energy (J)')\n plt.show()","def main():\n # Load properties that will be needed\n store = [Storage.Storage(2), Storage.Storage(4)] \n pre_energy = [s.get(\"free_energy\") for s in store]\n post_energy = [s.get(\"post_energy\") for s in store]\n x_range = store[0].get(\"x_range\")\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\n y_range = store[0].get(\"y_range\")\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\n # Calculate step size\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \n # Set up the figure\n fig = plt.figure(1, figsize=(7.5,2.5)) \n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\n # Plot the results\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\n # Annotate the plots\n axe[0].set_title(\"4sXB step size\")\n axe[0].set_xlabel(\"Lattice spacing (nm)\") \n axe[0].set_ylabel(\"Step size (nm)\")\n axe[0].set_xlim((25.5, 39))\n axe[0].set_ylim((1, 8))\n axe[1].set_title(\"2sXB step size\")\n axe[1].set_xlabel(\"Lattice spacing (nm)\") \n axe[1].set_ylabel(\"Step size (nm)\")\n axe[1].set_xlim((25.5, 39))\n axe[1].set_ylim((1, 8))\n # Display the plots\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\n left=0.08, right=0.98,\n top=0.85, bottom=0.21)\n plt.show()","def energies():\n # Hardcoded initial values\n numsteps = 10000\n time_max = 1\n # Running the calculation in the solver class using the velocity verlet method\n # for better accuracy.\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\n output_matrix, KE, PE, AM = verlet.main()\n # Creating a simple time axis for plotting\n x = np.linspace(0, 1, numsteps+1)\n\n # Plotting kinetic energy over time\n plt.figure(1, figsize=(10, 10))\n plt.plot(x, KE)\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE'])\n\n # Plotting potential energy over time\n plt.figure(2, figsize=(10, 10))\n plt.plot(x, PE)\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE'])\n\n # Plotting total energy against time\n plt.figure(3, figsize=(10, 10))\n plt.plot(x, PE+KE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE+PE'])\n\n # Plotting angular momentum against time. print the amplitude to terminal\n amplitude = max(AM)-min(AM)\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\n plt.figure(4, figsize=(10, 10))\n plt.plot(x, AM)\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\n plt.legend(['AM'])\n\n # Plotting the kinetic, potential and total energy against time to see\n # how great the variations are\n plt.figure(5, figsize=(10, 10))\n plt.plot(x, PE, x, KE, x, KE+PE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE', 'KE', 'KE+PE'])\n plt.show()","def plot_results(self):\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))","def plotBondEnergy(self, phys, forces, step):\r\n self.plotQuantity(step, phys.app.energies.getTable(2), 'bondenergy')","def _run():\n\n temperatures_kelvins = _create_temperature_grid()\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\n second_derivs_kelvins_pt01 = numpy.gradient(\n numpy.absolute(first_derivs_kelvins_pt01)\n )\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(first_derivs_kelvins_pt01)\n )\n\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(second_derivs_kelvins_pt01)\n )\n\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\n\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n temperature_handle = axes_object.plot(\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n second_deriv_handle = axes_object.plot(\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n first_deriv_handle = axes_object.plot(\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n this_min_index = numpy.argmin(second_derivs_unitless)\n second_derivs_unitless[\n (this_min_index - 10):(this_min_index + 10)\n ] = second_derivs_unitless[this_min_index]\n\n tfp_handle = axes_object.plot(\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n axes_object.set_yticks([0])\n axes_object.set_xticks([], [])\n\n x_label_string = r'$x$-coordinate (increasing to the right)'\n axes_object.set_xlabel(x_label_string)\n\n legend_handles = [\n temperature_handle, first_deriv_handle, second_deriv_handle,\n tfp_handle\n ]\n\n legend_strings = [\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\n ]\n\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\n\n print 'Saving figure to file: \"{0:s}\"...'.format(OUTPUT_FILE_NAME)\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\n pyplot.close()","def plot_dereddening():\n extinction_coefficients = {'2365-2764-1': np.array([0.2622, 0.844]), '4109-638-1': np.array([0.0524, 0.1576]),\n '2058-56-1': np.array([0.0751, 0.248]), '3642-2459-1': np.array([0.1907, 0.608]),\n '3999-1391-1': np.array([0.3911, 1.2480]), '2607-1448-1': np.array([0.0430, 0.1310])}\n cepheids = {'2365-2764-1': np.array([0.959, 2.09]), '4109-638-1': np.array([0.705, 2.385]), '2058-56-1':\n np.array([1.222, 1.333]), '3642-2459-1': np.array([1.088, 2.0518]), '3999-1391-1':\n np.array([1.360, 1.2567]), '2607-1448-1': np.array([1.484, 0.6963])}\n periods = {'2365-2764-1': 1.61, '4109-638-1': 15.31, '2058-56-1': 63.08, '3642-2459-1': 1.86, '3999-1391-1': 24.98,\n '2607-1448-1': 8.54}\n max_periods = max(periods.values())\n\n new_positions_bv_mv = [] # in M_V vs B-V space\n colors = []\n theoretical_position = []\n for obj in extinction_coefficients.keys():\n # new_positions_bv_mv.append(cepheids[obj]-extinction_coefficients[obj])\n new_positions_bv_mv.append(cepheids[obj])\n colors.append(periods[obj]/max_periods)\n theoretical_position.append(-2.78*np.log10(periods[obj])-1.35)\n\n for pos in range(len(new_positions_bv_mv)):\n plt.scatter(new_positions_bv_mv[pos][0], new_positions_bv_mv[pos][1], marker='^', facecolor='w', s=40)\n plt.scatter(new_positions_bv_mv[pos][0], theoretical_position[pos], marker='o', facecolor='r', s=50)\n return new_positions_bv_mv, colors","def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices['E_tot1'])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\n \n plt.ylabel('Energy [kWh]')\n plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(24)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\n\n plt.ylabel('Energy Difference [kWh]')\n plt.legend()\n\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n return fig","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def convergence():\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n # point spread and point total subplots\n subplots = [\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\n (True, [200.5], league.totals, 'probability total > 200.5'),\n ]\n\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\n\n # train margin-dependent Elo model\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, values)\n\n line = lines[-1]\n\n for label2 in label2_list:\n\n # evaluation times and labels\n times = np.arange(league.times.size)[::1000]\n labels1 = times.size * [label1]\n labels2 = times.size * [label2]\n\n # observed win probability\n prob = melo.probability(times, labels1, labels2, lines=line)\n ax.plot(times, prob)\n\n # true (analytic) win probability\n if ax.is_first_row():\n prob = skellam.sf(line, int(label1), int(label2))\n ax.axhline(prob, color='k')\n else:\n prob = poisson.sf(line, int(label1) + int(label2))\n ax.axhline(prob, color='k')\n\n # axes labels\n if ax.is_last_row():\n ax.set_xlabel('Iterations')\n ax.set_ylabel(ylabel)\n\n set_tight(w_pad=.5)","def plot_bs(self, show=False, density=True, pcolor=\"r\", mcolor=\"b\", lw=1.0, subtract = 0):\n cm = matplotlib.cm.jet\n\n if (subtract !=0):\n geqbispectra = subtract\n else:\n geqbispectra = np.zeros(np.shape(self.eqbispectra))\n\n if (density):\n \"\"\" also read the local overdensity value and plot line colors according to\n the density value, + = red, - = blue; adjust alpha accordingly\n \"\"\"\n if len(self.ds)<self.Nsubs:\n print (\"no density data\")\n return 0\n\n ads=np.abs(self.ds)\n meands=np.mean(self.ds)\n mads=np.max(ads)\n normds=np.array([ads[i]/mads for i in range(len(ads))])\n self.normds=normds\n\n cNorm = colors.Normalize(min(self.ds), vmax=max(self.ds))\n scalarMap = cmap.ScalarMappable(norm=cNorm, cmap=cm)\n scalarMap.set_array([])\n\n fig, ax = self.plt.subplots()\n\n for sub in range(self.Nsubs):\n #print sub\n if not(density):\n lplot=ax.plot(self.klist, self.fNLeq[sub])\n else:\n colorVal = scalarMap.to_rgba(self.ds[sub])\n lplot = ax.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=colorVal, alpha=normds[sub], linewidth=lw)\n \"\"\"\n if self.ds[sub]>meands:\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=pcolor, alpha=normds[sub], linewidth=lw)\n else:\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=mcolor, alpha=normds[sub], linewidth=lw)\n \"\"\"\n\n ax.set_xlabel(r\"$k {\\rm (h/Mpc)}$\")\n ax.set_ylabel(r\"${\\rm Q}(k)$\")\n ax.set_xscale('log')\n cbar = fig.colorbar(scalarMap, format='%.0e')\n #self.plt.yscale('log')\n if (show):\n self.plt.show()","def plot(self):\n self.plotsite()\n self.plotbond()\n plt.show()","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def sysPLQF(mirror, blkFlag=True):\n import matplotlib.pyplot as plt\n import numpy as np # to ndarray.flatten ax\n\n mir = mirror\n xend = max(mir.r_t)\n\n fig, ax = plt.subplots(nrows=2, ncols=2,)\n ax = np.ndarray.flatten(ax)\n ax[0].set_title('Real Power Generated')\n for mach in mir.Machines:\n ax[0].plot(mir.r_t, mach.r_Pe, \n marker = 10,\n fillstyle='none',\n #linestyle = ':',\n label = 'Pe Gen '+ mach.Busnam)\n ax[0].set_xlabel('Time [sec]')\n ax[0].set_ylabel('MW')\n\n ax[2].set_title('Reactive Power Generated')\n for mach in mir.Machines:\n ax[2].plot(mir.r_t, mach.r_Q, \n marker = 10,\n fillstyle='none',\n #linestyle = ':',\n label = 'Q Gen '+ mach.Busnam)\n ax[2].set_xlabel('Time [sec]')\n ax[2].set_ylabel('MVAR')\n\n ax[1].set_title('Total System P Loading')\n ax[1].plot(mir.r_t, mir.r_ss_Pload, \n marker = 11,\n #fillstyle='none',\n #linestyle = ':',\n label = 'Pload')\n ax[1].set_xlabel('Time [sec]')\n ax[1].set_ylabel('MW')\n\n ax[3].set_title('System Mean Frequency')\n ax[3].plot(mir.r_t, mir.r_f,\n marker = '.',\n #linestyle = ':',\n label = r'System Frequency')\n ax[3].set_xlabel('Time [sec]')\n ax[3].set_ylabel('Frequency [PU]')\n\n # Global Plot settings\n for x in np.ndarray.flatten(ax):\n x.set_xlim(0,xend)\n x.legend()\n x.grid(True)\n\n fig.tight_layout()\n\n plt.show(block = blkFlag)","def test_run_beta_diversity_through_plots(self):\r\n run_beta_diversity_through_plots(\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=False,\r\n status_update_callback=no_status_updates)\r\n\r\n unweighted_unifrac_dm_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_dm.txt')\r\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\r\n unweighted_unifrac_pc_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_pc.txt')\r\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\r\n weighted_unifrac_html_fp = join(self.test_out,\r\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def plot_results(self, energies=None, differences=None,\n experimental_values=None):\n import matplotlib.pyplot as plt\n import numpy as np\n\n y = np.array(self.results['differences'])\n x = np.array(self.results['experimental_values'])\n\n # Computes the fit for the regresion\n coef = np.polyfit(x, y, deg=1)\n\n # Histogram\n abs_val = abs(x - y)\n bins = np.arange(0, 10, 0.75)\n plt.figure()\n plt.grid(axis='y', alpha=0.75)\n plt.ylabel('Frequency')\n plt.xlabel('Absolute difference (kcal/mol)')\n plt.title('Absolute difference')\n _, bins, patches = plt.hist(np.clip(abs_val, bins[0], bins[-1]),\n bins=bins, color=['#0504aa'], alpha=0.7,\n rwidth=0.8)\n\n # Regression\n poly1d_fn = np.poly1d(coef)\n plt.figure()\n plt.title('Experimental value vs. Energetic Difference')\n plt.ylabel('Energetic difference (kcal/mol)')\n plt.xlabel('Experimental value (kcal/mol)')\n plt.plot(x, y, 'yo', x, poly1d_fn(x), '--k')","def plotImproperEnergy(self, phys, forces, step): \r\n self.plotQuantity(step, phys.app.energies.getTable(5), 'improperenergy')","def plot_dif_eq(self):\n try:\n self.canvas.get_tk_widget().pack_forget()\n self.toolbar.pack_forget()\n except AttributeError:\n pass\n\n f = Figure(figsize=(8, 8), dpi=100)\n p = f.add_subplot(111)\n\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\n\n p.set_ylabel('y')\n p.set_xlabel('x')\n\n p.legend(['Exact', 'EU', \"IEU\", \"RK\"])\n p.set_title(\"Solutions\")\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\n p.set_ylim([-100, 100])\n\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\n p.set_ylim([-100, 100])\n\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\n self.canvas.draw()\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\n\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\n self.toolbar.update()\n\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)","def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\n df_decomposed = df.loc[df['block'] == 'decomposed']\n df_joint = df.loc[df['block'] == 'joint']\n ticklabels = []\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\n for i in range(len(num_sweeps)):\n ticklabels.append('K=%d\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\n fig = plt.figure(figsize=(fs*2.5, fs))\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax1.set_xticks(num_sweeps)\n ax1.set_xticklabels(ticklabels)\n ax1.tick_params(labelsize=fontsize)\n ax1.grid(alpha=0.4)\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax2.set_xticks(num_sweeps)\n ax2.set_xticklabels(ticklabels)\n ax2.tick_params(labelsize=fontsize)\n ax2.grid(alpha=0.4)\n ax2.legend(fontsize=fontsize)\n ax1.legend(fontsize=fontsize)\n ax1.set_ylabel(r'$\\log \\: p_\\theta(x, \\: z)$', fontsize=35)\n ax2.set_ylabel('ESS / L', fontsize=35)","def plot(self) -> None:\n if self.__fig is None:\n self.__fig = plt.figure()\n\n xv = []\n yv = []\n for x in np.arange(self.state_min(), self.state_max(), self.state_step()):\n xv.append(x)\n yv.append(self.reward(x))\n ax = self.__fig.gca()\n ax.set_xlabel('X (State)')\n ax.set_ylabel('Y (Reward)')\n ax.set_title('Reward Function')\n ax.plot(xv, yv)\n plt.pause(self.__plot_pause)\n plt.show(block=False)\n return","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def plot_envs_opt_vs_gym():\n for i in range(len(envs)):\n env = envs[i]\n vel_new = get_log_key(fdir + envs[i] + '-v1/VRPG/', string='fvel_avg', plot=False)\n vel_old = get_log_key(fdir + envs[i] + '-v1/VRPG_old/', string='fvel_avg', plot=False)\n print(len(vel_new), len(vel_old))\n fig = plot_trials(vel_new, fdir + envs[i] + '-v1/', f=lambda it: vel_new[it], name='Hopper_opt', shape='-s',\n step=20)\n plt.ylabel(envs[i] + ' Cumulative reward $R_{iter}$')\n fig = plot_trials(vel_old, fdir + envs[i] + '-v1/', f=lambda it: vel_old[it], name='Hopper_Gym', fig=fig,\n shape='-o', step=20)\n return","def plot(self, noTLS, path_plots, interactive):\n fig = plt.figure(figsize=(10,12))\n ax1 = fig.add_subplot(4, 1, 1)\n ax2 = fig.add_subplot(4, 1, 2)\n ax3 = fig.add_subplot(4, 2, 5)\n ax4 = fig.add_subplot(4, 2, 6)\n ax5 = fig.add_subplot(4, 2, 7)\n ax6 = fig.add_subplot(4, 2, 8)\n\n # First panel: data from each sector\n colors = self._get_colors(self.nlc)\n for i, lci in enumerate(self.alllc):\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\n ax1.legend(fontsize='small', ncol=4)\n\n # Second panel: Detrended light curve\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\n color='black',\n label='Detrended')\n\n # Third panel: BLS\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\n mean_SR = np.mean(self.BLS.power)\n std_SR = np.std(self.BLS.power)\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\n SDE = (best_power - mean_SR)/std_SR\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\n for n in range(2, 10):\n if n*self.BLS.period_max <= max(self.BLS.period.value):\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n sx, ex = ax3.get_xlim()\n sy, ey = ax3.get_ylim()\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.2f\\nDepth = %.4f\\nDuration = %.2f d\\nSDE = %.3f' %\n (self.BLS.period_max, self.BLS.t0_max,\n self.BLS.depth_max, self.BLS.duration_max, SDE))\n\n\n # Fourth panel: lightcurve folded to the best period from the BLS\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\n marker='.', alpha=0.5)\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\n\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\n duration=self.BLS.duration_max,\n transit_time=self.BLS.t0_max)\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\n ax4.set_xlim(-l, l)\n h = max(lc_model.flux)\n l = min(lc_model.flux)\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\n del lc_model, lc_model_folded, r1, dt1\n\n\n if not noTLS:\n # Fifth panel: TLS periodogram\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\n for n in range(2, 10):\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.set_ylabel(r'SDE')\n ax5.set_xlabel('Period (days)')\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\n ax5.set_xlim(0, max(self.tls.periods))\n\n period_tls = self.tls.period\n T0_tls = self.tls.T0\n depth_tls = self.tls.depth\n duration_tls = self.tls.duration\n FAP_tls = self.tls.FAP\n\n sx, ex = ax5.get_xlim()\n sy, ey = ax5.get_ylim()\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.1f\\nDepth = %.4f\\nDuration = %.2f d\\nFAP = %.4f' %\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\n\n # Sixth panel: folded light curve to the best period from the TLS\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\n alpha=0.5, ls='None', markersize=0.7)\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\n x0=0.0, nbins=nbins, useBinCenter=True)\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\n ax6.set_xlim(0.5-l, 0.5+l)\n h = max(self.tls.model_folded_model)\n l = min(self.tls.model_folded_model)\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\n ax6.set_xlabel('Phase')\n ax6.set_ylabel('Relative flux')\n del r1, dt1\n\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\n if interactive:\n plt.show()\n plt.close('all')\n del fig","def _plot(self):\n # Read results\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\n x1, y1, _ = read_results('openmc', path)\n if self.code == 'serpent':\n path = self.other_dir / 'input_det0.m'\n else:\n path = self.other_dir / 'outp'\n x2, y2, sd = read_results(self.code, path)\n\n # Convert energies to eV\n x1 *= 1e6\n x2 *= 1e6\n\n # Normalize the spectra\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\n\n # Compute the relative error\n err = np.zeros_like(y2)\n idx = np.where(y2 > 0)\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\n \n # Set up the figure\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\n ax1 = fig.add_subplot(111)\n \n # Create a second y-axis that shares the same x-axis, keeping the first\n # axis in front\n ax2 = ax1.twinx()\n ax1.set_zorder(ax2.get_zorder() + 1)\n ax1.patch.set_visible(False)\n \n # Plot the spectra\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\n \n # Plot the relative error and uncertainties\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\n \n # Set grid and tick marks\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\n ax1.grid(b=False, axis='both', which='both')\n ax2.tick_params(axis='y', which='both', right=False)\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\n \n # Set axes labels and limits\n ax1.set_xlim([self._min_energy, self.energy])\n ax1.set_xlabel('Energy (eV)', size=12)\n ax1.set_ylabel('Spectrum', size=12)\n ax1.legend()\n ax2.set_ylabel(\"Relative error\", size=12)\n title = f'{self.nuclide}'\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n title += f' + {thermal_name}'\n title += f', {self.energy:.1e} eV Source'\n plt.title(title)\n \n # Save plot\n os.makedirs('plots', exist_ok=True)\n if self.name is not None:\n name = self.name\n else:\n name = f'{self.nuclide}'\n if self.thermal is not None:\n name += f'-{thermal_name}'\n name += f'-{self.energy:.1e}eV'\n if self._temperature is not None:\n name += f'-{self._temperature:.1f}K'\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\n plt.close()","def plot(self):\n t = np.linspace(0, self.days, self.days + 1)\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\n ax1.plot(t, self.S, label=\"Susceptible\", color='r')\n ax1.set_ylabel(\"Number of Susceptible People\")\n ax1.set_title(\"Strong Infecitous Model SEIRV Simulation\")\n ax3.plot(t, self.I, label=\"Active Cases\", color='b')\n ax3.set_ylabel(\"Active Cases\")\n ax2.plot(t, self.E, label=\"Exposed\", color='c')\n ax2.set_ylabel(\"# of Exposed\")\n ax4.plot(t, self.R, label=\"Recovered\", color='m')\n ax5.set_xlabel(\"Days\")\n ax4.set_ylabel('Number of Recovered')\n ax5.plot(t, self.V, label=\"Vaccinated\")\n ax5.set_ylabel(\"# Vaccinated\")\n ax1.legend()\n ax2.legend()\n ax3.legend()\n ax4.legend()\n plt.show()\n return fig","def plot_resiliences(nodes, network_vals, er_vals, upa_vals):\n node_vals = range(0, nodes)\n\n plt.plot(node_vals, network_vals, '-b', label='Network')\n plt.plot(node_vals, er_vals, '-r', label='ER')\n plt.plot(node_vals, upa_vals, '-g', label='UPA')\n\n plt.legend(loc='upper right')\n plt.ylabel('Size of Largest Connected Component')\n plt.xlabel('Number of Nodes Removed')\n plt.grid(True)\n plt.title('Comparison of Graph Resilience\\nMeasured by Largest Connected Component vs Nodes Removed by Target Attack\\n')\n plt.show()","def update(self):\n self.plot.draw()\n \n func=str(self.edit1b.currentText())\n if self.win.test()==0:\n x=np.linspace(0,10,200)\n elif self.win.test()==1:\n x=np.linspace(0,0.40,200)\n \n pattern1=r'Steel'\n pattern2=r'Aluminium'\n pattern3=r'[\\d]+'\n \n if (func!='Comparison Chart'):\n self.edit2b.setDisabled(False)\n self.edit3b.setDisabled(False)\n self.edit4b.setDisabled(False)\n if (func=='Quenched/Tempered Steel'):\n alpha = 0.0025\n elif (func=='Annealed Steel'):\n alpha = 0.01\n elif (func=='Steel (input Su)'):\n S = str(self.edit2b.text())\n if (self.win.test()==0):\n S = str(float(S)/6.895)\n alpha = notch.alpha(eval(S))\n elif (func=='Aluminium Alloy 356.0 as cast'):\n rho = 0.08\n elif (func=='Aluminium Alloy 6061'):\n rho = 0.025\n elif (func=='Aluminium Alloy 7075'):\n rho = 0.015\n elif (func=='Material dropdown'):\n pass\n \n y1=[]\n if re.search(pattern1,func):\n Su=notch.su_s(alpha)\n if (self.win.test()==0):\n Su = Su*6.895\n for i in range(len(x)):\n y1.append(notch.nsp(alpha,x[i],self.win.test()))\n y=np.asarray(y1)\n if (re.search(pattern3,str(self.edit3b.text()))):\n r=eval(str(self.edit3b.text()))\n self.edit4b.setText(str(notch.nsp(alpha,r,self.win.test())))\n elif re.search(pattern2,func):\n Su=notch.su_a(rho)\n if (self.win.test()==0):\n Su = Su*6.895\n for i in range(len(x)):\n y1.append(notch.nsn(rho,x[i],self.win.test()))\n y=np.asarray(y1)\n if (re.search(pattern3,str(self.edit3b.text()))):\n r=eval(str(self.edit3b.text()))\n self.edit4b.setText(str(notch.nsn(rho,r,self.win.test())))\n \n self.edit2b.setText(str(Su))\n func1 = 'Steel (Su='+str(self.edit2b.text())+')'\n if (func!='Steel (input Su)'):\n self.plot.redraw(x,y,func, self.xlabel)\n elif (func=='Steel (input Su)'):\n self.plot.redraw(x,y,func1, self.xlabel)\n \n elif (func=='Comparison Chart'):\n self.edit2b.setText(\"\")\n self.edit2b.setDisabled(True)\n self.edit3b.setText(\"\")\n self.edit3b.setDisabled(True)\n self.edit4b.setText(\"\")\n self.edit4b.setDisabled(True)\n self.plot.draw_comp(self.xlabel, self.win.test())","def plotEnergiesOpt(monthlyData, optIdx):\n \n \n dummyRange = np.asarray(range(len(optIdx)))\n \n fig = plt.figure(figsize=(16, 8))\n \n plt.suptitle('Energy Comparison')\n ax1 = plt.subplot(1,1,1)\n plt.plot(monthlyData['H'][optIdx, dummyRange], label = 'H', color='r')\n plt.plot(monthlyData['C'][optIdx, dummyRange], label = 'C', color='b')\n plt.plot(monthlyData['L'][optIdx, dummyRange], label = 'L', color='g')\n plt.plot(monthlyData['PV'][optIdx, dummyRange], label = 'PV', color='c')\n plt.plot(monthlyData['E_HCL'][optIdx, dummyRange], label = 'HCL', color='m')\n plt.plot(monthlyData['E_tot'][optIdx, dummyRange], label = 'E_tot', color='k')\n plt.ylabel('Energy [kWh]')\n plt.xlim(0,288)\n\n# plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(4)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which=u'major')\n \n # Shrink current axis by 20%\n box = ax1.get_position()\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n \n # Put a legend to the right of the current axis\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\n# \n\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\n# ax2 = plt.subplot(2,1,2, sharex=ax1)\n# plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\n# plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\n# plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\n# plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\n# plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\n# plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\n# plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\n# plt.ylabel('Energy Difference [kWh]')\n# plt.legend()\n#\n# ax2.xaxis.set_major_locator(majorLocator)\n# ax2.xaxis.set_major_formatter(majorFormatter)\n# ax2.xaxis.set_minor_locator(minorLocator)\n## ax2.xaxis.set_minor_formatter(minorFormatter)\n# plt.grid(True, which='both')\n# \n return fig","def plot(self, nsteps_max=10):\r\n fig = plt.figure()\r\n ax1 = plt.subplot(221)\r\n ax2 = plt.subplot(222)\r\n ax3 = plt.subplot(224)\r\n\r\n if 'fig' in locals(): # assures tight layout even when plot is manually resized\r\n def onresize(event): plt.tight_layout()\r\n try: cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\r\n except: pass\r\n\r\n self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax1)\r\n\r\n if getattr(self.px_spec, 'ref_tree', None) is None:\r\n self.calc_px(method='LT', nsteps=nsteps_max, keep_hist=True)\r\n\r\n self.plot_bt(bt=self.px_spec.ref_tree, ax=ax2, title='Binary tree of stock prices; ' + self.specs)\r\n self.plot_bt(bt=self.px_spec.opt_tree, ax=ax3, title='Binary tree of option prices; ' + self.specs)\r\n # fig, ax = plt.subplots()\r\n # def onresize(event): fig.tight_layout()\r\n # cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\r\n # self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax)\r\n\r\n try: plt.tight_layout()\r\n except: pass\r\n plt.show()","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def display_distances(self) -> None:\n self.svg.clear()\n for colnum, valtup in enumerate(self.dist_lst):\n epc, dist_val = valtup\n self.drawcolumn(colnum, epc, dist_val)","def plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def display_feds(list1, list2):\n if len(list1) != len(list2):\n print(\"In display_feds: lists must be of the same length\")\n return \n fig = plt.figure(dpi=128, figsize=(10, 6))\n fed_list_answer = fed_list(list1, list2)\n plt.plot(range(len(fed_list_answer)), fed_list_answer, c='red', alpha=0.5)\n \n plt.title(\"Feature edit distances between corresponding pairs\", fontsize = 24)\n plt.xlabel('', fontsize =16)\n #fig.autofmt_xdate()\n plt.ylabel(\"Distance\", fontsize =16)\n plt.tick_params(axis='both', which = 'major', labelsize=16)\n\n plt.show()","def visualize(self, network, f):\n import matplotlib\n matplotlib.use('Agg',warn=False)\n import matplotlib.pyplot as plt\n # Convert to a network if it is not.\n if not isinstance(network, NeuralNetwork):\n network = NeuralNetwork(network)\n \n fig = plt.figure()\n steps, states, actions = self._loop(network, max_steps=1000)\n # TEMP STUFF\n actions = np.array(actions)\n print((actions.size, np.histogram(actions)[0]))\n ##\n x, dx, theta, dtheta = list(zip(*states))\n theta = np.vstack(theta).T\n dtheta = np.vstack(dtheta).T\n # The top plot (cart position)\n top = fig.add_subplot(211)\n top.fill_between(list(range(len(x))), -self.h, self.h, facecolor='green', alpha=0.3)\n top.plot(x, label=r'$x$') \n top.plot(dx, label=r'$\\delta x$')\n top.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\n # The bottom plot (pole angles)\n bottom = fig.add_subplot(212)\n bottom.fill_between(list(range(theta.shape[1])), -self.r, self.r, facecolor='green', alpha=0.3)\n for i, (t, dt) in enumerate(zip(theta, dtheta)):\n bottom.plot(t, label=r'$\\theta_%d$'%i)\n bottom.plot(dt, ls='--', label=r'$\\delta \\theta_%d$'%i)\n bottom.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\n fig.savefig(f)","def get_energy(edr, annealing_times, energy_type = 'Potential', out_fig = 'energy_distribution.svg'): # Could be Total-Energy\n fig, ax = plt.subplots(figsize = (16,9))\n data = pd.DataFrame()\n xvg_tmp_file = tempfile.NamedTemporaryFile(suffix='.xvg')\n energy = []\n iterator = range(0, len(annealing_times)-1, 2)\n\n for state, index in tqdm.tqdm(enumerate(iterator), total=len(iterator)):#enumerate(iterator):# # the calculation is per pair of times, beetween the first to time the temperature was keep constant, then the system was heated and repeated again.\n run = tools.run(f\"export GMX_MAXBACKUP=-1; echo {energy_type} | gmx energy -f {edr} -b {annealing_times[index]} -e {annealing_times[index + 1]} -o {xvg_tmp_file.name} | grep \\'{energy_type.replace('-',' ')}\\'\")\n energy.append(float(run.stdout.split()[-5]))\n \"\"\"\n Energy Average Err.Est. RMSD Tot-Drift\n -------------------------------------------------------------------------------\n Potential -1.30028e+06 -- 1682.1 -2422.24 (kJ/mol)\n Total Energy -952595 -- 2606.81 -3688.3 (kJ/mol)\n \"\"\"\n # Getting the histograms and checking for the same len in all intervals\n if state == 0:\n data[state] = xvg.XVG(xvg_tmp_file.name).data[:,1]\n else:\n xvg_data = xvg.XVG(xvg_tmp_file.name).data[:,1]\n if xvg_data.shape[0] > data.shape[0]:\n data[state] = xvg_data[:data.shape[0]]\n else:\n data = data.iloc[:xvg_data.shape[0]]\n data[state] = xvg_data\n\n\n print(data)\n sns.histplot(data = data, element='poly', stat = 'probability', axes = ax)\n ax.set(\n xlabel = f'{energy_type} [kJ/mol]',\n ylabel = 'Probability',\n title = f'Distribution of {energy_type}')\n # plt.show()\n fig.savefig(out_fig)\n return energy","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def visualize(dcf_prices, current_share_prices, regress = True):\n # TODO: implement\n return NotImplementedError","def plot_one_state_evolution(self, value, option='density'):\n\n fig = plt.figure(figsize=(16, 8), dpi=100)\n ax = fig.add_subplot(111)\n if option == 'density':\n ax.plot(np.squeeze(np.array(self.est_density[value, :])), 'r--', label='Estimated')\n elif option == 'flow':\n if value == 0:\n # plot qin\n index = self.x_index['qin']\n elif value == self.num_cells:\n # plot qout\n index = self.x_index['qout']\n elif value in self.x_index['onramp'].keys():\n # plot onramp flow\n index = self.x_index['onramp'][value]\n elif value in self.x_index['offramp'].keys():\n # plot offramp flow\n index = self.x_index['offramp'][value]\n else:\n raise Exception('KeyError: value must be the cell id')\n\n ax.plot(np.squeeze(np.array(self.est_state_all[index, :])), 'r--', label='Estimated')\n\n plt.title('{0} at {1}'.format(option, value))\n plt.xlabel('Time (step)')\n plt.ylabel('Value')\n\n plt.grid(True)\n plt.legend()\n\n plt.draw()","def compare_one_state_evolution(self, value, true_state, option='density'):\n\n fig = plt.figure(figsize=(16, 8), dpi=100)\n ax = fig.add_subplot(111)\n if option == 'density':\n ax.plot(np.squeeze(np.array(self.est_density[value, :])), 'r--', label='Estimated')\n elif option == 'flow':\n if value == 0:\n # plot qin\n index = self.x_index['qin']\n elif value == self.num_cells:\n # plot qout\n index = self.x_index['qout']\n elif value in self.x_index['onramp'].keys():\n # plot onramp flow\n index = self.x_index['onramp'][value]\n elif value in self.x_index['offramp'].keys():\n # plot offramp flow\n index = self.x_index['offramp'][value]\n else:\n raise Exception('KeyError: value must be the cell id')\n\n ax.plot(np.squeeze(np.array(self.est_state_all[index, :])), 'r--', label='Estimated')\n ax.plot(np.squeeze(np.array(true_state)), 'b', label='True')\n\n plt.title('{0} at {1}'.format(option, value))\n plt.xlabel('Time (step)')\n plt.ylabel('Value')\n\n plt.grid(True)\n plt.legend()\n\n plt.draw()","def overview(self, minState=5):\n n = 600\n \n ### first plot: the RTOFFSETs and STATES\n plt.figure(10)\n plt.clf()\n plt.subplots_adjust(hspace=0.05, top=0.95, left=0.05,\n right=0.99, wspace=0.00, bottom=0.1)\n ax1 = plt.subplot(n+11)\n try:\n print self.insmode+' | pri:'+\\\n self.getKeyword('OCS PS ID')+' | sec:'+\\\n self.getKeyword('OCS SS ID')\n \n plt.title(self.filename+' | '+self.insmode+' | pri:'+\n self.getKeyword('OCS PS ID')+' | sec:'+\n self.getKeyword('OCS SS ID'))\n except:\n pass\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n self.raw['OPDC'].data.field('FUOFFSET')*1e3,\n color=(1.0, 0.5, 0.0), label=self.DLtrack+' (FUOFFSET)',\n linewidth=3, alpha=0.5)\n plt.legend(prop={'size':9})\n plt.ylabel('(mm)')\n plt.xlim(0)\n \n plt.subplot(n+12, sharex=ax1) # == DDL movements\n \n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n 1e3*self.raw['DOPDC'].data.field(self.DDLtrack),\n color=(0.0, 0.5, 1.0), linewidth=3, alpha=0.5,\n label=self.DDLtrack)\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n 1e3*self.raw['DOPDC'].data.field('PSP'),\n color=(0.0, 0.5, 1.0), linewidth=1, alpha=0.9,\n label='PSP', linestyle='dashed')\n plt.legend(prop={'size':9})\n plt.ylabel('(mm)')\n plt.xlim(0)\n \n plt.subplot(n+13, sharex=ax1) # == states\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n self.raw['OPDC'].data.field('STATE'),\n color=(1.0, 0.5, 0.0), label='OPDC')\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n self.raw['DOPDC'].data.field('STATE'),\n color=(0.0, 0.5, 1.0), label='DOPDC')\n plt.legend(prop={'size':9})\n plt.ylabel('STATES')\n yl=plt.ylim()\n plt.ylim(yl[0]-1, yl[1]+1)\n plt.xlim(0)\n ### fluxes\n plt.subplot(n+14, sharex=ax1)\n try:\n fsua_dark = self.fsu_calib[('FSUA', 'DARK')][0,0]\n fsub_dark = self.fsu_calib[('FSUB', 'DARK')][0,0]\n fsua_alldark = self.fsu_calib[('FSUA', 'DARK')].sum(axis=1)[0]\n fsub_alldark = self.fsu_calib[('FSUB', 'DARK')].sum(axis=1)[0]\n except:\n print 'WARNING: there are no FSUs calibrations in the header'\n fsua_dark = 0.0\n fsub_dark = 0.0\n fsua_alldark = 0.0\n fsub_alldark = 0.0\n\n M0 = 17.5\n fluxa = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\n fsua_alldark)/\\\n (4*self.getKeyword('ISS PRI FSU1 DIT'))\n print 'FLUX FSUA (avg, rms):', round(fluxa.mean(), 0), 'ADU/s',\\\n round(100*fluxa.std()/fluxa.mean(), 0), '%'\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\n round(M0-2.5*np.log10(fluxa.mean()),2)\n fluxb = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\n fsub_alldark)/\\\n (4*self.getKeyword('ISS PRI FSU2 DIT'))\n print 'FLUX FSUB (avg, rms):', round(fluxb.mean(), 0), 'ADU/s',\\\n round(100*fluxb.std()/fluxb.mean(), 0), '%'\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\n round(M0-2.5*np.log10(fluxb.mean()),2)\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\\n fluxa/1000, color='b', alpha=0.5, label='FSUA')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\\n fluxb/1000, color='r', alpha=0.5, label='FSUB')\n\n plt.ylim(1)\n plt.legend(prop={'size':9})\n plt.ylabel('flux - DARK (kADU)')\n plt.xlim(0)\n plt.subplot(n+15, sharex=ax1)\n try:\n # -- old data version\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUA'].data.field('OPDSNR'),\n color='b', alpha=0.5, label='FSUA SNR')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUB'].data.field('OPDSNR'),\n color='r', alpha=0.5, label='FSUB SNR')\n except:\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUA'].data.field(self.OPDSNR),\n color='b', alpha=0.5, label='FSUA SNR')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUB'].data.field(self.OPDSNR),\n color='r', alpha=0.5, label='FSUB SNR')\n plt.legend(prop={'size':9})\n \n A = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,0])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,0]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,0])\n B = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,1])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,1]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,1])\n C = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,2])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,2]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,2])\n D = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,3])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,3]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,3])\n snrABCD_a = ((A-C)**2+(B-D)**2)\n snrABCD_a /= ((A-C).std()**2+ (B-D).std()**2)\n #plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n # snrABCD_a, color='b', alpha=0.5, linestyle='dashed')\n \n A = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,0])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,0]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,0])\n B = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,1])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,1]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,1])\n C = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,2])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,2]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,2])\n D = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,3])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,3]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,3])\n \n snrABCD_b = ((A-C)**2+(B-D)**2)\n snrABCD_b /= ((A-C).std()**2+ (B-D).std()**2)\n #plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n # snrABCD_b, color='r', alpha=0.5, linestyle='dashed') \n \n # -- SNR levels:\n #plt.hlines([self.getKeyword('INS OPDC OPEN'),\n # self.getKeyword('INS OPDC CLOSE'),\n # self.getKeyword('INS OPDC DETECTION')],\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\n # color=(1.0, 0.5, 0.0))\n #plt.hlines([self.getKeyword('INS DOPDC OPEN'),\n # self.getKeyword('INS DOPDC CLOSE'),\n # self.getKeyword('INS DOPDC DETECTION')],\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\n # color=(0.0, 0.5, 1.0))\n # -- plot thresholds\n plt.ylabel('SNR')\n plt.xlim(0)\n \n if self.getKeyword('OCS DET IMGNAME')=='PACMAN_OBJ_ASTRO_':\n # == dual FTK\n plt.subplot(n+16, sharex=ax1)\n plt.ylabel('PRIMET ($\\mu$m)')\n #met = interp1d(np.float_(self.raw['METROLOGY_DATA'].\\\n # data.field('TIME')),\\\n # self.raw['METROLOGY_DATA'].data.field('DELTAL'),\\\n # kind = 'linear', bounds_error=False, fill_value=0.0)\n met = lambda x: np.interp(x,\n np.float_(self.raw['METROLOGY_DATA'].data.field('TIME')),\n self.raw['METROLOGY_DATA'].data.field('DELTAL'))\n metro = met(self.raw['DOPDC'].data.field('TIME'))*1e6\n n_ = min(len(self.raw['DOPDC'].data.field('TIME')),\n len(self.raw['OPDC'].data.field('TIME')))\n\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n metro, color=(0.5,0.5,0.), label='A-B')\n\n w1 = np.where((self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'OPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\n except:\n print 'OPDC FTK stat: 0%'\n\n w1 = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'DOPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\n except:\n print 'DOPDC FTK stat: 0%'\n\n w = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'DUAL FTK stat:', round(100*len(w[0])/float(n_),1), '%'\n except:\n print 'DUAL FTK stat: 0%'\n\n plt.xlim(0)\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\n metro[w], '.g', linewidth=2,\n alpha=0.5, label='dual FTK')\n #plt.legend()\n if len(w[0])>10 and False:\n coef = np.polyfit(self.raw['DOPDC'].data.field('TIME')[w],\n metro[w], 2)\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n np.polyval(coef, self.raw['DOPDC'].\n data.field('TIME')),\n color='g')\n plt.ylabel('metrology')\n\n print 'PRIMET drift (polyfit) :', 1e6*coef[1], 'um/s'\n slope, rms, synth = NoisySlope(self.raw['DOPDC'].\n data.field('TIME')[w],\n metro[w], 3e6)\n plt.figure(10)\n yl = plt.ylim()\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\n synth, color='r')\n plt.ylim(yl)\n print 'PRIMET drift (NoisySlope):',\\\n slope*1e6,'+/-', rms*1e6, 'um/s'\n else:\n # == scanning\n plt.subplot(n+16, sharex=ax1)\n fringesOPDC = \\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA1')[:,0]-\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA3')[:,0]\n \n fringesDOPDC =\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA1')[:,0]-\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA3')[:,0]\n \n plt.plot(self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('TIME'),\n scipy.signal.wiener(fringesOPDC/fringesOPDC.std()),\n color=(1.0, 0.5, 0.0), alpha=0.6,\n label=self.primary_fsu+'/OPDC')\n plt.plot(self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('TIME'),\n scipy.signal.wiener(fringesDOPDC/fringesDOPDC.std()),\n color=(0.0, 0.5, 1.0), alpha=0.6,\n label=self.secondary_fsu+'/DOPDC')\n plt.legend(prop={'size':9})\n plt.ylabel('A-C')\n plt.xlabel('time stamp ($\\mu$s)')\n return","def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\n if axdelta is None:\n axdelta = plt.gca()\n delta = self.means - exact\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\n if blocked:\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\n if blockederr:\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\n axdelta.set_xlabel('Number of determinants in estimator')\n axdelta.set_ylabel(r'$E-E_\\mathrm{CCSD}$ / ha')\n axdelta.legend()\n return axdelta","def energy_kde_paperplot(fields,df):\n plt.figure()\n i = 0\n colorList = ['dodgerblue','tomato']\n lw = 2\n\n meanE_2 = []\n meanE_3 = []\n mup = np.min(df['energy [eV]']) - pp.mu\n chi_0 = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(fields[0]))\n g_en_axis, _, _, _, _, _, _, _, _, _, _, _, _, _ = \\\n occupation_plotter.occupation_v_energy_sep(chi_0, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), np.zeros(len(g_en_axis)), '-', color='black', lineWidth=lw,label='Equilibrium')\n\n for ee in fields:\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n # meanE_2 = utilities.mean_energy(chi_2_i,df)\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\n occupation_plotter.occupation_v_energy_sep(chi_2_i, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,'--',color = colorList[i],lineWidth=lw,label=r'Low Field {:.0f} '.format(ee/100)+r'$V \\, cm^{-1}$')\n print(integrate.trapz(g_chiax,g_en_axis))\n\n # plt.plot(meanE_2-np.min(df['energy [eV]']),0,'.')\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\n occupation_plotter.occupation_v_energy_sep(chi_3_i, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,color = colorList[i],lineWidth=lw,label=r'Full Drift {:.0f} '.format(ee/100)+r'$V \\, cm^{-1}$')\n print(integrate.trapz(g_chiax,g_en_axis))\n\n i = i + 1\n # plt.plot(g_en_axis - np.min(df['energy [eV]']), g_f0ax, '--', color='black', lineWidth=lw,label=r'$f_0$')\n\n plt.legend()\n # plt.ylim([-0.02, 0.015])\n plt.xlabel(r'Energy above CBM ($eV$)')\n plt.ylabel(r'Deviational occupation $\\delta f_{\\mathbf{k}}$ (norm.)')\n # plt.ylabel(r'$\\delta f_{\\mathbf{k}}/f_{\\mathbf{k}}^0$')\n plt.savefig(pp.figureLoc+'energy_KDE.png', bbox_inches='tight',dpi=600)\n\n plt.figure()\n plt.plot(g_en_axis,g_chiax)\n\n plt.figure()\n Z, xedges, yedges = np.histogram2d(df['kx [1/A]']*chi_3_i,df['ky [1/A]']*chi_3_i)\n plt.pcolormesh(xedges, yedges, Z.T)\n\n from scipy.stats.kde import gaussian_kde\n g_inds,_,_ = utilities.gaas_split_valleys(df,False)\n g_df = df.loc[g_inds]\n\n x = g_df['kx [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\n y = g_df['ky [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\n\n # y = g_df['energy [eV]']*(chi_3_i[g_inds]+g_df['k_FD'])\n k = gaussian_kde(np.vstack([x, y]))\n xi, yi = np.mgrid[x.min():x.max():x.size ** 0.5 * 1j, y.min():y.max():y.size ** 0.5 * 1j]\n zi = k(np.vstack([xi.flatten(), yi.flatten()]))\n\n fig = plt.figure(figsize=(7, 8))\n ax1 = fig.add_subplot(211)\n ax2 = fig.add_subplot(212)\n\n # alpha=0.5 will make the plots semitransparent\n ax1.pcolormesh(xi, yi, zi.reshape(xi.shape), alpha=0.5)\n ax2.contourf(xi, yi, zi.reshape(xi.shape), alpha=0.5)\n\n ax1.set_xlim(x.min(), x.max())\n ax1.set_ylim(y.min(), y.max())\n ax2.set_xlim(x.min(), x.max())\n ax2.set_ylim(y.min(), y.max())","def plot_2nd(self, mod = 'F'):\n if not mpl: raise \"Problem with matplotib: Plotting not possible.\"\n f = plt.figure(figsize=(5,4), dpi=100)\n \n A2 = []\n \n strainList= self.__structures.items()[0][1].strainList\n \n if len(strainList)<=5:\n kk=1\n ll=len(strainList)\n grid=[ll]\n elif len(strainList)%5 == 0:\n kk=len(strainList)/5\n ll=5\n grid=[5 for i in range(kk)]\n else:\n kk=len(strainList)/5+1\n ll=5\n grid=[5 for i in range(kk)]\n grid[-1]=len(strainList)%5\n \n \n n=1\n m=1\n for stype in strainList:\n atoms = self.get_atomsByStraintype(stype)\n self.__V0 = atoms[0].V0\n strainList = atoms[0].strainList\n if self.__thermodyn and mod == 'F':\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\n elif self.__thermodyn and mod=='E0':\n energy = [i.gsenergy for i in atoms]\n elif self.__thermodyn and mod=='Fvib':\n energy = [i.phenergy[-1] for i in atoms]\n else:\n energy = [i.gsenergy for i in atoms]\n \n strain = [i.eta for i in atoms]\n \n spl = '1'+str(len(strainList))+str(n)\n #plt.subplot(int(spl))\n #a = f.add_subplot(int(spl))\n if (n-1)%5==0: m=0\n \n \n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\n #print (kk,ll), ((n-1)/5,m)\n j = 0\n for i in [2,4,6]:\n ans = Energy()\n ans.energy = energy\n ans.strain = strain\n ans.V0 = self.__V0\n \n fitorder = i\n ans.set_2nd(fitorder)\n A2.append(ans.get_2nd())\n \n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\n \n try:\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\n except:\n continue\n a.plot(strains, dE, label=str(fitorder))\n a.set_title(stype)\n a.set_xlabel('strain')\n a.set_ylabel(r'$\\frac{d^2E}{d\\epsilon^2}$ in eV')\n \n j+=1\n \n n+=1\n m+=1\n \n a.legend(title='Order of fit')\n return f","def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\n other_program_name, **kw):\n\n #plot absolute error\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\n pan['absolute-difference'][field].values,\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\n ax_abs.set_ylabel('Absolute Difference ' + unit)\n #plot percentage error\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\n pan['percent-difference'][field].values,\n color='firebrick', zorder=-1)\n ax_per.set_ylabel('Percent Difference', color='firebrick')\n #set error axes legend\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\n #ax_per.get_legend().set_zorder(1)\n #plot full results profiles\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\n color=_colormap[1])[0],\n ax_mag.plot(pan['emf.fields-results'][field],\n color=_colormap[0])[0]]\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\n ax_mag.set_xlabel('Distance (ft)')","def plot_diff(self, ax, d0, d1):\n i1 = 0\n for i0 in range(d0.shape[0]):\n try:\n while d0[i0,0] > d1[i1,0]:\n print((d0[i0,0], d1[i1,0]))\n i1 += 1\n except IndexError:\n break\n if d0[i0,0] == d1[i1,0]:\n break\n assert d0[i0,0] == d1[i1,0]\n i0s = i0\n d0s = 0\n d1s = 0\n dt = []\n dd = []\n for i0 in range(i0s, d0.shape[0]):\n d0s += d0[i0,1]\n try:\n d1s += d1[i1,1]\n assert d0[i0,0] == d1[i1,0]\n except IndexError:\n pass\n dt.append(d0[i0,0])\n dd.append(d0s - d1s)\n i1 += 1\n while i1 < d1.shape[0]:\n d1s += d1[i1,1]\n dt.append(d0[i0,0])\n dd.append(d0s - d1s)\n i1 += 1\n dd = np.array(dd)\n dd -= dd[-1]\n i = 0\n if self.start is not None:\n while dt[i] < self.start:\n i += 1\n ax.plot_date(dt[i:], dd[i:], fmt='-', color='yellow')","def plotDihedralEnergy(self, phys, forces, step): \r\n self.plotQuantity(step, phys.app.energies.getTable(4), 'dihedralenergy')","def plot_all(self):\n self.plot_ramps()\n self.plot_groupdq()","def plot_grating_coupler_sweep_efficiency(matlab_file_path, function=log):\n d = loadmat(matlab_file_path)\n print(d.keys())\n\n N = len(d[\"M_sweep\"][0])\n parameter = np.zeros(N)\n efficiency = np.zeros(N)\n\n for i in range(N):\n parameter[i] = 1e9 * d[\"M_sweep\"][0][i]\n # x = d[\"WL\"][0] * 1e9\n y = function(d[\"M_T\"][i])\n efficiency[i] = np.max(y)\n\n plt.figure()\n plt.xlabel(\"waveguide height (nm)\")\n plt.ylabel(\"Eficiency (dB)\")\n plt.plot(parameter, efficiency, \".\")\n plt.legend()","def show_dcr_results(dg):\n cycle = dg.fileDB['cycle'].values[0]\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\n # print(df_dsp.describe()) \n\n # compare DCR and A/E distributions\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\n \n elo, ehi, epb = 0, 25000, 100\n \n # aoe distribution\n # ylo, yhi, ypb = -1, 2, 0.1\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\n p0.set_ylabel('A/E', ha='right', y=1)\n\n # dcr distribution\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\n # ylo, yhi, ypb = -3, 2, 0.1\n ylo, yhi, ypb = 0.9, 1.08, 0.001\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\n p1.set_ylabel('DCR', ha='right', y=1)\n \n # plt.show()\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\n plt.cla()","def distance_plot():\n day = \"20131210\"\n file = \"Data/matfiles/\" + day + \".mat\"\n object = MatReader(file)\n\n\n\n # ind1 = 2606\n # ind2 = 13940 + 1*7000\n\n ind1 = 0\n ind2 = 150000\n\n times = object.secondsB[ind1:ind2]\n\n xA = object.latA[ind1:ind2]\n yA = object.longA[ind1:ind2]\n zA = object.radA[ind1:ind2]\n\n xB = object.latB[ind1:ind2]\n yB = object.longB[ind1:ind2]\n zB = object.radB[ind1:ind2]\n\n xC = object.latC[ind1:ind2]\n yC = object.longC[ind1:ind2]\n zC = object.radC[ind1:ind2]\n\n mltA = object.mltA[ind1:ind2]\n mltB = object.mltB[ind1:ind2]\n\n\n dist_BA = object.great_circle_distance(xB, yB, zB, xA, yA, zA)\n dist_BC = object.great_circle_distance(xB, yB, zB, xC, yC, zC)\n dist_AC = object.great_circle_distance(xA, yA, zA, xC, yC, zC)\n\n\n plt.figure(0)\n plt.plot(times, dist_BA)\n plt.plot(times, dist_BC)\n plt.plot(times, dist_AC)\n plt.title(\"Distance over time\")\n plt.xlabel(\"Seconds since midnight UTC of sat B\")\n plt.ylabel(\"Distance [m]\")\n plt.legend([\"B - A\", \"B - C\", \"A - C\"])\n plt.grid(\"on\")\n # plt.savefig(\"Figures/matfigs/distance_over_time_\" + day + \".pdf\")\n plt.figure(1)\n\n plt.plot(times, xB - xA)\n plt.plot(times, xB - xC)\n plt.title(\"difference in latitude\")\n plt.xlabel(\"time of sat B [s]\")\n plt.ylabel(\"difference in latitude [degrees]\")\n plt.legend([\"B - A\", \"B - C\"])\n\n plt.figure(2)\n\n plt.plot(times, yB - yA)\n plt.plot(times, yB - yC)\n #plt.axis([0, 7000, -10, 10])\n plt.title(\"difference in longitude\")\n plt.xlabel(\"time of sat B [s]\")\n plt.ylabel(\"difference in latitude [degrees]\")\n plt.legend([\"B - A\", \"B - C\"])\n plt.show()\n\n # plt.plot(times, zB - zA)\n # plt.plot(times, zB - zC)\n # plt.title(\"Difference in altitude\")\n # plt.xlabel(\"time of sat B [s]\")\n # plt.ylabel(\"difference in altitude [m]\")\n # plt.legend([\"B - A\", \"B - C\"])\n # plt.show()\n\n plt.plot(xB, dist_BA)\n plt.plot(xB, dist_BC)\n plt.plot(xB, dist_AC)\n plt.xlabel(\"Latitude [Degrees]\")\n plt.ylabel(\"Distance [m]\")\n plt.title(\"Distance over latitude\")\n plt.grid(\"on\")\n plt.legend([\"B - A\", \"B - C\", \"A - C\"])\n plt.xticks([-90, -77, -70, -30, 0, 30, 70, 77, 90])\n plt.savefig(\"Figures/matfigs/distance_over_latitude_\" + day + \".pdf\")\n plt.show()\n\n mltdiff = mltA - mltB\n\n for i in range(len(mltdiff)):\n if mltdiff[i] > 24:\n mltdiff[i] = mltdiff[i] - 24\n elif mltdiff[i] < -24:\n mltdiff[i] = mltdiff[i] + 24\n\n\n print(\"mean distance B-A = %g m\" % np.mean(dist_BA))\n print(\"mean distance B-C = %g m\" % np.mean(dist_BC))\n\n print(\"velocity times timediff BA = %g\" % (object.BA_shift/2*np.mean(object.velA)))\n print(\"velocity times timediff BC = %g\" % (object.BC_shift/2*np.mean(object.velC)))\n print(np.min(dist_BA))\n print(object.BA_shift)\n print(object.BC_shift - object.BA_shift)\n print(np.mean(object.velA))","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\n\n figure = plt.figure()\n figure.subplots_adjust(top=0.76)\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\n\n functionGraph = figure.add_subplot(311)\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\n functionGraph.set_xlabel('X-values')\n functionGraph.set_ylabel('Y-values')\n\n errorGraph = figure.add_subplot(313)\n errorGraph.set_title('Truncation errors', fontsize=15)\n errorGraph.set_xlabel('X-values')\n errorGraph.set_ylabel('Error-values')\n\n if EU == True:\n euler = EulerMethod(self._IVP)\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\n\n if IEM == True:\n improvedEuler = ImprovedEulerMethod(self._IVP)\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\n \n if RK == True:\n rungeKutta = RungeKutta(self._IVP)\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\n\n if ES == True:\n exactSolution = AnalyticalSolution(self._IVP)\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\n \n functionGraph.legend(loc='lower right')\n errorGraph.legend(loc='lower right')\n\n return figure","def plot_compartments(self, compartments, show=True, save_path=None, names=None):\n print 'Copying voltages and recovery variables for debugging...'\n # Note if they have already been copied then the following functions won't\n # do a copy\n v = self.get_voltages()\n\n # Check for infinities\n x, y = np.where(np.isinf(np.array(v)))\n print \"Bad compartments found \", y\n _, naning = np.where(np.isnan(np.array(v)))\n print \"Nans found:\", naning\n # If none found, yay and set tmax to whole range\n if len(x) == 0:\n t_max = v.shape[0]\n else:\n t_max = x[0] - 1\n print \"Voltage shape\", v.shape\n\n m, n, h = self.get_recovery_variables()\n f, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, sharex=True)\n neighbours = self.neuron_collection.get_neighbour_idx(compartments[1])\n\n ax1.set_title('Compartments ' + str(compartments))\n ax1.set_ylabel('Voltage /mV')\n ax2.set_ylabel('m')\n ax3.set_ylabel('n')\n ax4.set_ylabel('h')\n ax4.set_xlabel('Step')\n ax5.axis('off')\n for index, i in enumerate(np.append(compartments, neighbours)):\n\n p_v = v[:t_max, i]\n p_m = m[:t_max, i]\n p_n = n[:t_max, i]\n p_h = h[:t_max, i]\n\n if index < len(names):\n label = names[index]\n else:\n label = \"c_idx:\" + str(i)\n\n ax1.plot(p_v, label=label)\n ax2.plot(p_m, label=label)\n ax3.plot(p_n, label=label)\n ax4.plot(p_h, label=label)\n ax1.set_ylim(-50, 200)\n ax2.set_ylim(0, 1)\n ax3.set_ylim(0, 1)\n ax4.set_ylim(0, 1)\n\n handles, labels = ax1.get_legend_handles_labels()\n f.legend(handles, labels, loc='lower center', ncol=3, borderaxespad=2)\n\n if save_path is not None:\n #fig.tight_layout()\n plt.savefig(save_path)\n print \"Saved figure to \" + save_path\n if show:\n plt.show()\n if not show:\n plt.clf()","def task_2():\n\n # To store the list of speeds to plot\n list_of_speeds = []\n list_of_times = []\n list_of_time_difference = [0]\n\n # To go from 1 through 80\n for i in range(LOW_SPEED, HIGH_SPEED + 1, 5):\n list_of_speeds.append(i)\n list_of_times.append(((DISTANCE / i) * 60))\n\n for i in range(1, len(list_of_times)):\n list_of_time_difference.append(list_of_times[i-1] - list_of_times[i])\n\n plt.plot(list_of_speeds, list_of_time_difference)\n plt.xlabel(\"Speed (in mph)\")\n plt.ylabel(\"Time saved (in minutes)\")\n plt.show()","def compute_visuals(self):\n pass","def figure_1():\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n\n # Draw common plots\n print(exp_list)\n data = get_data(exp_list[0])\n plt.figure(num=\"state 1\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"cmd\"],\n **FORMATTING[\"command\"]\n )\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 0],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_1$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"state 2\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 1],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_2$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"control\")\n plt.ylabel(r\"$u$\")\n plt.xlabel(\"Time, sec\")\n\n def general_figures(exp):\n data = get_data(exp)\n plt.figure(num=\"state 1\")\n ax = plt.gca()\n ax.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 0],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"state 2\")\n plt.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 1],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"control\")\n plt.plot(\n data[\"time\"], data[\"control\"],\n **FORMATTING[exp],\n )\n\n for exp in exp_list:\n general_figures(exp)\n\n # Estimation error\n for exp in exp_list:\n data = get_data(exp)\n error = nla.norm(\n data[\"state\"][\"adaptive_system\"] - data[\"real_param\"],\n axis=1\n )\n plt.figure(num=\"Estimation error\")\n plt.plot(data[\"time\"], error, **FORMATTING[exp])\n plt.xlabel(\"Time, sec\")\n plt.ylabel(\"Error norm\")\n\n # Real parameter\n data = get_data(exp_list[0])\n plt.plot(data[\"time\"], data[\"real_param\"].squeeze())\n\n\n exp_list.remove(\"mrac-nullagent\")\n\n def eig_figures(exp, minmax):\n data = get_data(exp)\n if minmax == \"min\":\n eig = np.min(data[\"eigs\"], axis=1)\n elif minmax == \"max\":\n eig = np.max(data[\"eigs\"], axis=1)\n plt.plot(data[\"time\"], eig, **FORMATTING[exp])\n\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\"Eigenvalues\", sharex=True)\n\n plt.subplot(211)\n plt.ticklabel_format(style=\"sci\", scilimits=(0, 0), useOffset=True)\n for exp in exp_list:\n eig_figures(exp, \"min\")\n plt.ylabel(r\"Minimum $\\lambda$\")\n plt.legend()\n\n plt.subplot(212)\n for exp in exp_list:\n eig_figures(exp, \"max\")\n plt.ylabel(r\"Maximum $\\lambda$\")\n plt.xlabel(\"Time, sec\")\n\n # Saving\n def savefig(name):\n path = os.path.join(args.save_dir, name + \".\" + args.save_ext)\n plt.savefig(path, bbox_inches=\"tight\")\n\n plt.figure(num=\"state 1\")\n plt.legend()\n savefig(\"state-1\")\n\n plt.figure(num=\"state 2\")\n plt.legend()\n savefig(\"state-2\")\n\n plt.figure(num=\"control\")\n plt.legend()\n savefig(\"control\")\n\n plt.figure(num=\"Eigenvalues\")\n savefig(\"eigs\")\n\n plt.figure(num=\"Estimation error\")\n plt.legend()\n savefig(\"estim-error\")\n\n plt.show()","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def plot_energy(self, color=['r','g','b','c','m','y','k'], mod = 'E0'):\n if not mpl: raise \"Problem with matplotib: Plotting not possible.\"\n f = plt.figure(figsize=(5,4), dpi=100)\n a = f.add_subplot(111)\n strainList= self.__structures.items()[0][1].strainList\n \n if len(strainList)<=5:\n kk=1\n ll=len(strainList)\n grid=[ll]\n elif len(strainList)%5 == 0:\n kk=len(strainList)/5\n ll=5\n grid=[5 for i in range(kk)]\n else:\n kk=len(strainList)/5+1\n ll=5\n grid=[5 for i in range(kk)]\n grid[-1]=len(strainList)%5\n \n \n n=1\n m=1\n j=0\n for stype in strainList:\n \n spl = '1'+str(len(strainList))+str(n)\n if (n-1)%5==0: m=0\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\n \n \n \n fi=open(stype+'.energy','w')\n \n #self.search_for_failed()\n atoms = self.get_atomsByStraintype(stype)\n if self.__thermodyn and mod=='F':\n energy = [i.gsenergy+i.phenergy[100] for i in atoms]\n elif self.__thermodyn and mod=='E0':\n energy = [i.gsenergy for i in atoms]\n elif self.__thermodyn and mod=='Fvib':\n energy = [i.phenergy[100] for i in atoms]\n else:\n energy = [i.gsenergy for i in atoms]\n strain = [i.eta for i in atoms]\n \n ii=0\n for (e,s) in zip(energy,strain):\n if e==0.: \n energy.pop(ii); strain.pop(ii)\n ii-=1\n ii+=1\n #print stype, energy, [i.scale for i in atoms]\n plt.plot(strain, energy, '%s*'%color[j%7])\n \n k=0\n for st in strain:\n fi.write('%s %s \\n'%(st,energy[k]))\n k+=1\n fi.close()\n \n poly = np.poly1d(np.polyfit(strain,energy,self.__fitorder[j]))\n xp = np.linspace(min(strain), max(strain), 100)\n a.plot(xp, poly(xp),color[j%7],label=stype)\n \n a.set_title(stype)\n \n j+=1\n \n n+=1\n m+=1\n \n a.set_xlabel('strain')\n a.set_ylabel(r'energy in eV')\n #a.legend(title='Strain type:')\n \n return f","def show():\n\tplt.show()","def bodePlot(H_s,w_range=(0,8),points=800):\n \n w = logspace(*w_range,points)\n h_s = lambdify(s,H_s,'numpy')\n H_jw = h_s(1j*w)\n \n # find mag and phase\n mag = 20*np.log10(np.abs(H_jw))\n phase = angle(H_jw,deg = True)\n \n eqn = Eq(H,simplify(H_s))\n display(eqn)\n \n fig,axes = plt.subplots(1,2,figsize=(18,6))\n ax1,ax2 = axes[0],axes[1]\n \n # mag plot\n ax1.set_xscale('log')\n ax1.set_ylabel('Magntiude in dB')\n ax1.set_xlabel('$\\omega$ in rad/s')\n ax1.plot(w,mag)\n ax1.grid()\n ax1.set_title(\"Magnitude of $H(j \\omega)$\")\n \n # phase plot\n ax2.set_ylabel('Phase in degrees')\n ax2.set_xlabel('$\\omega$ in rad/s')\n ax2.set_xscale('log')\n ax2.plot(w,phase)\n ax2.grid()\n ax2.set_title(\"Phase of $H(j \\omega)$\")\n \n plt.show()","def Compare(self,step,steps,saving=True):\n\t\tplt.ioff()\n\t\tplt.figure()\n\t\tplt.plot(np.arange(1,5),self.expected,'o-',color='black',label\\\n\t\t\t='expected')\n\t\tplt.plot(np.arange(1,5),np.divide(self.states,np.sum(self.states))\\\n\t\t\t,'o-',color='green',label='actual')\n\t\tplt.legend()\n\t\tplt.title('Expected vs Actual Atom Distribution at State ' + str(step))\n\t\tplt.xlabel('n (principle quantum number)')\n\t\tplt.ylabel('Fraction of Atoms')\n\t\tplt.ylim(0,1)\n\t\tplt.xlim(1,4)\n\t\tif saving:\n\t\t\tself.files.append('temp_' + str(step+steps*100)+'.png')\n\t\t\tplt.savefig('temp_' + str(step+steps*100) + '.png')\n\t\tplt.close()","def plot_error_versus_x_compare(num_sites, num_solutes, column_name, barriers, methods):\n errors, column = get_errors_n_column(num_sites, num_solutes, column_name)\n print errors\n print column\n print len(errors['svd'][0]), len(column)\n fig = plt.figure()\n axis = fig.add_subplot(111)\n for barrier in barriers:\n for i, method in enumerate(methods):\n axis.scatter(column, errors[method][barrier],\n label=\"{0} over barrier {1}\".format(method, barrier), s=5,\n color=COLOR_MAP[i])\n axis.set_ylim([10 ** -20, 10 ** 14])\n axis.set_xscale('log')\n axis.set_yscale('log')\n plt.legend()\n plt.show()","def vanderpol_dymos_plots(p):\n\n # check validity by using scipy.integrate.solve_ivp to integrate the solution\n sim_out = p.model.traj.simulate()\n\n # plots\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 9))\n\n # state variable x1\n axes[0, 0].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.states:x1'),\n 'ro', label='solution')\n\n axes[0, 0].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\n 'b-', label='simulation')\n\n axes[0, 0].set_xlabel('time (s)')\n axes[0, 0].set_ylabel('x1 (V)')\n axes[0, 0].legend()\n axes[0, 0].grid()\n\n # state variable x0\n axes[0, 1].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.states:x0'),\n 'ro', label='solution')\n\n axes[0, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.states:x0'),\n 'b-', label='simulation')\n\n axes[0, 1].set_xlabel('time (s)')\n axes[0, 1].set_ylabel('x0 (V/s)')\n axes[0, 1].legend()\n axes[0, 1].grid()\n\n # state variable x1 vs x0\n axes[1, 0].plot(p.get_val('traj.phase0.timeseries.states:x0'),\n p.get_val('traj.phase0.timeseries.states:x1'),\n 'ro', label='solution')\n\n axes[1, 0].plot(sim_out.get_val('traj.phase0.timeseries.states:x0'),\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\n 'b-', label='simulation')\n\n axes[1, 0].set_xlabel('x0 (V/s)')\n axes[1, 0].set_ylabel('x1 (V)')\n axes[1, 0].legend()\n axes[1, 0].grid()\n\n # control variable u\n axes[1, 1].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.controls:u'),\n 'ro', label='solution')\n\n axes[1, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.controls:u'),\n 'b-', label='simulation')\n\n axes[1, 1].set_xlabel('time (s)')\n axes[1, 1].set_ylabel('control u')\n axes[1, 1].legend()\n axes[1, 1].grid()\n\n plt.show()","def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):\n if self.interactive:\n display.clear_output(wait=True) \n \n pred_2plot = pred_.detach().to(\"cpu\")\n if not self.ODE_order:\n validate_y_2plot = validate_y.detach().to(\"cpu\")\n try:\n self.ax[1].clear()\n self.ax[0].clear()\n except:\n pass\n\n \n\n labels = \"best value\", \"all samples\"\n #log2 = np.log(2)\n\n # Plot 1: the training history of the bayesian optimization\n # if not self.log_score:\n # self.ax[0].plot(np.log(self.errorz_step), alpha = 0.5, color = \"blue\", label = labels[0] )\n # self.ax[0].plot(np.log(self.errorz), alpha = 0.2, color = \"green\", label = labels[1])\n # else:\n font_dict = {\"prop\" : {\"size\":14}}\n ticks_font_size = 14\n\n self.ax[0].plot(10**np.array(self.errorz_step), alpha = 0.5, color = \"blue\", label = labels[0] )\n self.ax[0].plot(10**np.array(self.errorz), alpha = 0.2, color = \"green\", label = labels[1])\n #self.ax[0].set_title(\"log(error) vs Thompson Sampling step\")\n self.ax[0].set_ylabel(f\"log({self.scoring_method})\")\n self.ax[0].set_xlabel(\"BO step\")\n self.ax[0].set_ylabel(\"Error\")\n self.ax[0].legend(**font_dict)\n self.ax[0].set_yscale(\"log\")\n #self.ax[0].set_ylim(10**-8,1)\n # self.ax[0].set_xtickslabels(fontsize= ticks_font_size )\n # self.ax[0].set_ytickslabels(fontsize= ticks_font_size )\n \n #plot 2: the turbo state #plot 2: the turbo state\n self.ax[1].axhline(np.log(self.state.length_max)/self.log2, color = 'green', label = 'max length')\n self.ax[1].set_title(\"TURBO state\")\n self.ax[1].plot(np.log(self.length_progress)/self.log2, color = 'blue', label = 'current length')\n self.ax[1].axhline(np.log(self.state.length_min)/self.log2, color = 'red', label = 'target length')\n self.ax[1].legend() \n\n #plot 3 (most recent prediction)\n self.ax[2].clear()\n if not self.ODE_order:\n self.ax[2].plot(validate_y_2plot.to(\"cpu\"), alpha = 0.5, color = \"blue\", label = \"val set\") #[:steps_displayed]\n self.ax[2].set_ylim(self.y.min().item() - 0.1, self.y.max().item() )\n self.ax[2].plot(pred_2plot[:steps_displayed], alpha = 0.3, color = \"red\", label = \"latest pred\")\n \n self.ax[2].set_title(\"Val Set Prediction\")\n self.ax[2].set_ylabel(\"y\")\n self.ax[2].set_xlabel(r'$t$')\n\n pl.legend()\n pl.tight_layout()\n\n display.display(pl.gcf())\n\n #clear the plot outputt and then re-plot","def demo_SIR():\r\n\tdef f(u,t):\r\n\t\tS, I, R = u # takes u and stores to respective variable arrays\r\n\t\treturn [-beta*S*I, beta*S*I - gamma*I, gamma*I]\r\n\r\n\tbeta = 10./(40*8*24)\r\n\tgamma = 3./(15*24)\r\n\tdt = 0.1\r\n\tD = 30\r\n\tN_t = int(D*24/dt)\r\n\tT = dt *N_t\r\n\tU_0 = [50, 1, 0]\r\n\r\n\tu, t = ode_FE(f, U_0, dt, T)\r\n#\tprint(u,t)\r\n#\tprint(len(u))\r\n\r\n\tS = u[:,0]\r\n\tI = u[:,1]\r\n\tR = u[:,2]\r\n\r\n\tfig = plt.figure()\r\n\tl1, l2, l3 = plt.plot(t, S, t, I, t, R)\r\n\tfig.legend((l1, l2, l3), ('S', 'I', 'R'), 'lower right')\r\n\tplt.xlabel('hours')\r\n\tplt.show()\r\n\r\n\t# Consistency check:\r\n\tN = S[0] + I[0] + R[0]\r\n\teps = 1E-12 # Tolerance for comparing real numbers\r\n\tfor n in range(len(S)):\r\n\t\tSIR_sum = S[n] + I[n] + R[n]\r\n\t\tif abs(SIR_sum - N) > eps:\r\n\t\t\tprint('*** consistency check failes : S+I+R=%g != %g' %(SIR_sum, N))","def plot(self):\n pass","def plot_results(delaytype):\n \n if delaytype == 'Polynomial':\n # results for ind_obs=graph.indlinks.keys()\n tolls_collected1 = [[164.76921455176952, 690.919364787199, 1003.9715271443032], [164.76920846294715, 690.9196375266908, 1003.971503332828]]\n so_costs1 = [[1952.813985915695, 2991.422528084584, 4716.77478205995], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs1 = [[1961.4088544768533, 3035.621746689017, 4751.282035585294], [1961.4088092322784, 3035.619283467948, 4751.282202058287]]\n ue_costs1 = [[1993.9477013089333, 3087.4591784440836, 4889.555908205202], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected2 = [[165.05685117271955, 354.1634370314711, 1015.9141858070569], [165.0567022829941, 354.1917223859498, 1015.9119098321756]]\n so_costs2 = [[1952.4102665477528, 2990.2968764530697, 4714.092736177128], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs2 = [[1961.0182151023969, 3019.353015234613, 4750.051821659878], [1961.4090940730164, 3020.4668352547183, 4752.675436210774]]\n ue_costs2 = [[1993.5324364880598, 3086.401670312004, 4886.656461616093], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected3 = [[122.37203827953705, 369.5962596851687, 993.1260548913893], [124.00144138458633, 375.65796385498777, 1018.6147484597942]]\n so_costs3 = [[1819.720988976306, 2777.3939885366685, 4677.595258102356], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs3 = [[1834.6351015726038, 2802.3016403566235, 4714.102145227426], [1965.8049083549738, 3020.126090534662, 4750.071391283308]]\n ue_costs3 = [[1872.3492340077084, 2897.9834368843217, 4886.769726452165], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\n tolls_collected4 = [[602.0313412901077, 596.7300601881633, 833.3678073460065], [609.094482012133, 542.8579545671112, 843.1817520139325]]\n so_costs4 = [[13252.728980891832, 20178.927282098706, 28549.614451166774], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs4 = [[13254.342842900576, 20239.30287102026, 28549.614731411177], [1992.3969007442322, 3130.0522527298062, 4805.6728306302175]]\n ue_costs4 = [[13259.433117552415, 20185.90937054816, 28556.779443740656], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n \n if delaytype == 'Hyperbolic':\n # results for ind_obs=graph.indlinks.keys() \n tolls_collected1 = [[161.15742640370462, 416.80264009965265, 948.124688583883], [161.4013529462645, 417.25218843773354, 950.1674351402539]]\n so_costs1 = [[2519.5329969919685, 3679.4257321044365, 5325.940489651684], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs1 = [[2525.7590340322095, 3679.4261220632625, 5356.8071818038225], [2551.0113714206195, 3718.3028736461647, 5412.310857035818]]\n ue_costs1 = [[2548.8303153671195, 3736.67165067958, 5444.499035875823], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected2 = [[355.56391097372205, 701.3544774585599, 806.6640717434449], [374.34816990991186, 736.3763770517197, 842.0768966826593]]\n so_costs2 = [[2174.1387842065237, 3306.974167934956, 4969.5560792612605], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs2 = [[2201.273656230071, 3338.7536674213156, 4988.732654672769], [2564.0153714222406, 3746.115605602468, 5398.046518880896]]\n ue_costs2 = [[2209.622435372754, 3380.7186533697286, 5104.755602389524], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected3 = [[339.37838703976513, 737.9887571945254, 930.0531221139565], [353.28118085588176, 763.3708450755438, 955.644104623869]]\n so_costs3 = [[2520.1983680076073, 3833.234908857907, 5645.320052639795], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs3 = [[2536.138622203524, 3862.614483834193, 5668.430527845267], [2562.897499637454, 3750.9322754235955, 5406.402328441233]]\n ue_costs3 = [[2556.0266644367803, 3903.9758481975805, 5741.545038028959], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\n tolls_collected4 = [[443.85669649193784, 837.5428841560781, 1380.117295219297], [479.57423528502, 931.2309202734045, 1499.6972922042573]]\n so_costs4 = [[2158.995768390798, 3843.4202195503713, 7595.092411648515], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs4 = [[2192.900868595389, 3888.0172745668465, 7626.17585256234], [2575.5748442305207, 3755.844017718783, 5450.304046277645]]\n ue_costs4 = [[2231.1674179937672, 3999.772800567613, 7867.415688946321], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # effects of toll pricing\n opacity = 0.4\n width = 0.2\n index = np.arange(4)\n plt.xticks(index, ('all', '10', '4 good', '4 bad') )\n colors = ['y', 'r', 'b']\n demands = ['94', '118', '142']\n for i in [0,1,2]:\n so = so_costs1[1][i]\n ue = ue_costs1[1][i]\n delta = ue-so\n plt.bar(index-width/2+(i-1)*width,\n [100.0*(costs1[1][i]-so)/delta, \n 100.0*(costs2[1][i]-so)/delta, \n 100.0*(costs3[1][i]-so)/delta, \n 100.0*(costs4[1][i]-so)/delta],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative loss (%)')\n plt.title('Effects of toll pricing with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted UE\n for i in [0,1,2]:\n ue = ue_costs1[1][i]\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(ue_costs1[0][i]-ue)/ue,\n 100.0*abs(ue_costs2[0][i]-ue)/ue,\n 100.0*abs(ue_costs3[0][i]-ue)/ue,\n 100.0*abs(ue_costs4[0][i]-ue)/ue],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted UE with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted SO\n for i in [0,1,2]:\n so = so_costs1[1][i]\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(so_costs1[0][i]-so)/so,\n 100.0*abs(so_costs2[0][i]-so)/so,\n 100.0*abs(so_costs3[0][i]-so)/so,\n 100.0*abs(so_costs4[0][i]-so)/so],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted SO with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted tolled ue\n for i in [0,1,2]:\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(costs1[0][i]-costs1[1][i])/costs1[1][i],\n 100.0*abs(costs2[0][i]-costs2[1][i])/costs2[1][i],\n 100.0*abs(costs3[0][i]-costs3[1][i])/costs3[1][i],\n 100.0*abs(costs4[0][i]-costs4[1][i])/costs4[1][i]],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted tooled UE with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()","def notebook_01():\n\n freq_list, volt_list = las.load_freq_volt()\n\n n_steps, n_det, n_f, _ = np.shape(volt_list)\n\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\n\n # print(np.shape(y_sym_mat_o))\n # print(np.shape(y_sym_mat_i))\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\n # print(mu_o, sigma_o)\n # print(mu_i, sigma_i)\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\n\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\n\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\n\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\n\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\n\n\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\n\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n fp.fit_params_FH_data(ff.f_b_field)\n\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)","def plot(self):\n\t\tself.plotOfHeatingCurrent().plot()","def plot_solution(self):\n\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \"Analytical\")\n plt.plot(self.x_values, self.numerical, label = \"Numerical\")\n plt.title(\"Numerical vs. Analytical Solution\")\n plt.xlabel(\"x\")\n plt.ylabel(\"u(x)\")\n plt.legend()\n plt.show()","def main():\n\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n\n for function in range(1, 21):\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\n\n col_name = 'F{}'.format(function)\n index = function-1\n\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\n\n success_rates.insert(index, col_name, results.SuccessRate)\n peak_ratios.insert(index, col_name, results.PeakRatio)\n\n for i in results.SimulationSwarms:\n\n x_axis = [k for k, _ in i.items()]\n y_axis = [v for _, v in i.items()]\n\n plt.subplot(4, 5, function) # subplot indexes from 1\n plt.plot(x_axis, y_axis, 'k-')\n\n plt.savefig('results/nmmso_benchmark.png')\n plt.show()\n\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\n print(convergence_rates_e1)\n print(convergence_rates_e4)\n print(success_rates)\n print(peak_ratios)\n\n # Table V from Fieldsend et al.\n table4 = pd.Series([\n peak_ratios.stack().median(),\n peak_ratios.stack().mean(),\n peak_ratios.stack().std()\n ])\n print(table4)\n\n # do we want to reproduce Fig. 3","def main():\n save = False\n show = True\n\n #hd_parameter_plots = HDparameterPlots(save=save)\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\n #ice5g_comparison_plots.plotLine()\n #ice5g_comparison_plots.plotFilled()\n #ice5g_comparison_plots.plotCombined()\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\n #flowmapplot = FlowMapPlots(save)\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\n #flowmapplot.Etopo1FlowMap()\n #flowmapplot.ICE5G_data_all_points_0k()\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\n #flowmapplot.Etopo1FlowMap_two_color()\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\n outflowplots = OutflowPlots(save)\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #hd_output_plots = HDOutputPlots()\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\n #lake_plots = LakePlots()\n #lake_plots.plotLakeDepths()\n #lake_plots.LakeAndRiverMap()\n #lake_plots.LakeAndRiverMaps()\n if show:\n plt.show()","def test_run_beta_diversity_through_plots_parallel(self):\r\n run_beta_diversity_through_plots(\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=True,\r\n status_update_callback=no_status_updates)\r\n\r\n unweighted_unifrac_dm_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_dm.txt')\r\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\r\n unweighted_unifrac_pc_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_pc.txt')\r\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\r\n weighted_unifrac_html_fp = join(self.test_out,\r\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def visualize(self):\n print('{0} is {1} time steps old'.format(self.name, self.timestep))\n\n self.amygdala.visualize(self.timestep, self.name, self.log_dir)\n self.cerebellum.visualize(self.name, self.log_dir)\n self.cingulate.visualize(self.name, self.log_dir)\n self.hippocampus.visualize(self.name, self.log_dir)\n #self.ganglia.visualize(self.name, self.log_dir)\n #self.cortex.visualize(self.name, self.log_dir)","def derivatives(self, state):\n raise NotImplementedError()","def plot_bus_load(self):\n stops = {key: 0 for key, _ in self.route.timetable().items()}\n for passenger in self.passengers:\n trip = self.passenger_trip(passenger)\n stops[trip[0][1]] += 1\n stops[trip[1][1]] -= 1\n prev = None\n for i, stop in enumerate(stops):\n if i > 0:\n stops[stop] += stops[prev]\n prev = stop\n fig, ax = plt.subplots()\n ax.step(range(len(stops)), list(stops.values()), where=\"post\")\n ax.set_xticks(range(len(stops)))\n ax.set_xticklabels(list(stops.keys()))\n return fig, ax","def plot(self):\n\n fig, ax = plt.subplots()\n\n for run in self.runs:\n # Load datasets\n data_measure = run.get_dataset(\"stats-collect_link_congestion-raw-*.csv\")\n data_sp = run.get_dataset(\"stats-collect_link_congestion-sp-*.csv\")\n\n # Extract link congestion information\n data_measure = data_measure['msgs']\n data_sp = data_sp['msgs']\n\n # Compute ECDF and plot it\n ecdf_measure = sm.distributions.ECDF(data_measure)\n ecdf_sp = sm.distributions.ECDF(data_sp)\n\n variable_label = \"\"\n size = run.orig.settings.get('size', None)\n if size is not None:\n variable_label = \" (n=%d)\" % size\n\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\n label=\"U-Sphere%s\" % variable_label)\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\n label=u\"Klasični usmerjevalni protokol%s\" % variable_label)\n\n ax.set_xlabel('Obremenjenost povezave')\n ax.set_ylabel('Kumulativna verjetnost')\n ax.grid()\n ax.axis((28, None, 0.99, 1.0005))\n self.convert_axes_to_bw(ax)\n\n legend = ax.legend(loc='lower right')\n if self.settings.GRAPH_TRANSPARENCY:\n legend.get_frame().set_alpha(0.8)\n fig.savefig(self.get_figure_filename())","def plot_comparison(results):\n dfs = []\n for res in results:\n equity = (1 + res['equity']).cumprod()\n equity.name = 'equity'\n equity = equity.reset_index()\n equity['name'] = res['name']\n dfs.append(equity)\n data = pd.concat(dfs, axis=0)\n\n fig = px.line(data, x='time_idx', y='equity', color='name')\n fig.show()","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def display_sweep(self):\n for sweep in range(len(self.sweep_points)):\n lidar_x_coordinate=self.flight_points[sweep][0]\n lidar_y_coordinate=self.flight_points[sweep][1]\n\n xx=[]\n yy=[]\n for point in range(len(self.sweep_points[sweep])):\n angle_degree=self.sweep_points[sweep][point][0]\n distance=self.sweep_points[sweep][point][1]\n angle_redian = (math.pi * angle_degree) / 180.0\n sweep_point_x=lidar_x_coordinate+ (distance * math.cos(angle_redian))/1000.0\n sweep_point_y=lidar_y_coordinate+ (distance * math.sin(angle_redian))/1000.0\n xx.append(sweep_point_x)\n yy.append(sweep_point_y)\n\n self.plot_sweep(xx,yy,sweep)","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def showPlot1():\n\n interested_in = list(range(5,30,5))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on room size')\n xlabel('area of the room (tiles)')\n ylabel('mean time (clocks)')\n show()","def plot(self):\n \n \n x_ibs=[] \n x_gss=[]\n y_ibs=[] \n y_gss=[]\n x_pso=[]\n x_bgd=[]\n y_bgd=[]\n y_pso=[]\n x_gd=[]\n y_gd=[]\n \n i=0.0000001\n \n # for k in range(1,51):\n # i= random.uniform(0.00000001, 1)\n # t_avg_ibs=[]\n # t_avg_gss=[]\n # for j in range(1,51):\n #L=random.randint(-100, 0)\n #U=random.randint(0, 100)\n max_iter=self.Max_iter \n L=self.Lower_bound\n U=self.Upper_bound\n \n minima=self.gss(L,U,i,1000)\n #print(\"minima at X = \",minima[1])\n x_ibs.append(self.I_bisection(L,U,minima[1],max_iter)[0])\n x_gss.append(self.gss(L,U,i,max_iter)[0])\n x_pso.append(self.particle_Swarm(self.func, L, U, 2, max_iter)[0])\n x_gd.append(self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)[0])\n x_bgd.append(self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)[0])\n #print(x_pso)\n for i in x_ibs[0]:\n #print(self.Func(i)) \n y_ibs.append(self.Func(i))\n for i in x_gss[0]:\n y_gss.append(self.Func(i)) \n for i in x_pso[0]:\n y_pso.append(self.Func(i)) \n for i in x_gd[0]:\n y_gd.append(self.Func(i)) \n for i in x_bgd[0]:\n y_bgd.append(self.Func(i)) \n #print(y_gss)\n\n plt.plot(x_ibs[0], y_ibs, 'r.')\n plt.plot(x_gss[0], y_gss, '.')\n plt.plot(x_pso[0], y_pso, 'y.')\n #plt.plot(x_gd[0], y_gd, 'y.')\n #plt.plot(x_bgd[0], y_bgd, 'k.')\n plt.xlabel('x')\n plt.ylabel('y')\n \n plt.suptitle('Interval Bisection Search (Red) vs Golden Section Search (Blue) vs Particle swarm optimization (Green)')\n #plt.axis([0, 100, 0.00000001, 1]) \n plt.show()\n plt.plot(x_gd[0], y_gd, 'r.')\n plt.plot(x_bgd[0], y_bgd, 'k.')\n plt.xlabel('x')\n plt.ylabel('y') \n plt.suptitle('Gradient Descent (Red) vs Batch Gradient Descent (Black) ')\n \n plt.show()\n \n start_time = timeit.default_timer()\n ibs=self.I_bisection(L,U,minima[1],max_iter)\n print(\" Execution time for Interval bisection Method is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n gss=self.gss(L,U,i,max_iter)\n print(\" Execution time for Golden Section Search is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n pso=self.particle_Swarm(self.func, L, U, 2, max_iter)\n print(\" Execution time for Particle swarm optimization is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n gd=self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)\n print(\" Execution time for Gradient Descent is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n bgd=self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)\n print(\" Execution time for Batch Gradient Descent is\", timeit.default_timer() - start_time,\"s\")\n plt.plot(ibs[1], ibs[2], 'r.')\n plt.text(ibs[1], ibs[2],\"IB\")\n plt.plot(gss[1], gss[2], '.')\n plt.text(gss[1], gss[2],\" GSS\")\n plt.plot(pso[1], pso[2], 'y.')\n plt.text(pso[1], pso[2],\" PSO\")\n plt.plot(gd[1], gd[2], 'g.')\n plt.text(gd[1], gd[2],\" GD \")\n plt.plot(bgd[1],bgd[2], 'k.')\n plt.text(bgd[1], bgd[2],\" Batch_GD\")\n \n plt.xlabel('Value of X')\n plt.ylabel('NUmber of iteration') \n plt.suptitle('Number of iterations vs minimum value of x')\n \n plt.show()","def show_graph(self, symbol1, symbol2):\n # Get the price data for the base coefficient calculation, tick data to calculate last coefficient and and the\n # coefficient history data\n symbol_1_price_data = self.__cor.get_price_data(symbol1)\n symbol_2_price_data = self.__cor.get_price_data(symbol2)\n symbol_1_ticks = self.__cor.get_ticks(symbol1, cache_only=True)\n symbol_2_ticks = self.__cor.get_ticks(symbol2, cache_only=True)\n history_data_short = \\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\n 'Timeframe': self.__config.get('monitor.calculations.short.from')})\n history_data_med = \\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\n 'Timeframe': self.__config.get('monitor.calculations.medium.from')})\n history_data_long = \\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\n 'Timeframe': self.__config.get('monitor.calculations.long.from')})\n # Display if we have any data\n self.__log.debug(f\"Refreshing history graph {symbol1}:{symbol2}.\")\n self.__graph.draw(prices=[symbol_1_price_data, symbol_2_price_data], ticks=[symbol_1_ticks, symbol_2_ticks],\n history=[history_data_short, history_data_med, history_data_long], symbols=[symbol1, symbol2],\n divergence_threshold=self.__cor.divergence_threshold,\n monitor_inverse=self.__cor.monitor_inverse)\n\n # Un-hide and layout if hidden\n if not self.__graph.IsShown():\n self.__graph.Show()\n self.__main_sizer.Layout()","def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def scree_plot(self, ev):\n plt.scatter(range(1,len(ev)+1), ev)\n plt.plot(range(1,len(ev)+1), ev)\n plt.title(\"Scree Plot\")\n plt.xlabel(\"Factors\")\n plt.ylabel(\"Eigenvalue\")\n plt.grid()\n plt.show()","def plot(self):\r\n \r\n\r\n print(\"Printing decision surfaces of decision trees\")\r\n plot_colors = \"rb\"\r\n plot_step = 0.02\r\n n_classes = 2\r\n for _ in range (self.n_estimators):\r\n plt.subplot(2, 3, _ + 1)\r\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\r\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\r\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\r\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\r\n Z = self.clfs[_].predict(np.c_[xx.ravel(), yy.ravel()])\r\n Z = np.array(Z)\r\n Z = Z.reshape(xx.shape)\r\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\r\n for i, color in zip(range(n_classes), plot_colors):\r\n if i == 0:\r\n idx = np.where(self.y == -1)\r\n if i == 1:\r\n idx = np.where(self.y == 1)\r\n for i in range (len(idx[0])):\r\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\r\n plt.suptitle(\"Decision surface of a decision tree using paired features\")\r\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\r\n plt.axis(\"tight\")\r\n\r\n plt.show()\r\n fig1 = plt\r\n\r\n # Figure 2\r\n print(\"Printing decision surface by combining the individual estimators\")\r\n plot_colors = \"rb\"\r\n plot_step = 0.02\r\n n_classes = 2\r\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\r\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\r\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\r\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\r\n Z = config.Classifier_AB.predict(np.c_[xx.ravel(), yy.ravel()])\r\n Z = np.array(Z)\r\n Z = Z.reshape(xx.shape)\r\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\r\n for i, color in zip(range(n_classes), plot_colors):\r\n if i == 0:\r\n idx = np.where(self.y == -1)\r\n if i == 1:\r\n idx = np.where(self.y == 1)\r\n for i in range (len(idx[0])):\r\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\r\n plt.suptitle(\"Decision surface by combining individual estimators\")\r\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\r\n plt.axis(\"tight\")\r\n\r\n plt.show()\r\n fig2 = plt\r\n\r\n return [fig1,fig2]","def SA_data_display(opt_df, all_df):\n fig, axs = plt.subplots(2, 3)\n\n axs[0,0].set_title(\"Optimal rewire attempts for circularity\")\n axs[0,0].set_ylabel(\"Percent waste %\")\n axs[0,0].set_xlabel(\"Time (s)\")\n axs[0,0].plot(opt_df[\"Time (s)\"], opt_df[\"Percent waste (%)\"])\n\n axs[0,1].set_title(\"Optimal rewire attempts acceptance probability\")\n axs[0,1].set_ylabel(\"Acceptance Probability\")\n axs[0,1].set_xlabel(\"Time (s)\") # time??\n axs[0,1].scatter(opt_df[\"Time (s)\"], opt_df[\"Probability\"])\n\n axs[0,2].set_title(\"Optimal rewire attempts temperature decrease\")\n axs[0,2].set_ylabel(\"Temperature\")\n axs[0,2].set_xlabel(\"Time (s)\") # time??\n axs[0,2].plot(opt_df[\"Time (s)\"], opt_df[\"Temperature\"])\n\n axs[1,0].set_title(\"All rewire attempts for circularity\")\n axs[1,0].set_ylabel(\"Percent waste %\")\n axs[1,0].set_xlabel(\"Time (s)\")\n axs[1,0].plot(all_df[\"Time (s)\"], all_df[\"Percent waste (%)\"])\n\n axs[1,1].set_title(\"All rewire attempts acceptance probability\")\n axs[1,1].set_ylabel(\"Acceptance Probability\")\n axs[1,1].set_xlabel(\"Time (s)\") # time??\n axs[1,1].scatter(all_df[\"Time (s)\"], all_df[\"Probability\"])\n\n axs[1,2].set_title(\"All rewire attempts temperature decrease\")\n axs[1,2].set_ylabel(\"Temperature\")\n axs[1,2].set_xlabel(\"Time (s)\") # time??\n axs[1,2].plot(all_df[\"Time (s)\"], all_df[\"Temperature\"])\n\n return plt.show()"],"string":"[\n \"def vis_difference(self):\\n print(self.init_vec)\\n\\n init = self.init_output.numpy()\\n\\n alphas = np.linspace(0, 1, 20)\\n for i, alpha in enumerate(alphas):\\n\\n display.clear_output(wait=True)\\n norm = [torch.linalg.norm(torch.tensor(\\n self.init_vec + alpha*self.eigen[i]), axis=1).detach().numpy() for i in range(2)]\\n\\n diff = np.array([self.compute_difference(\\n alpha, self.eigen[i]) for i in range(2)])\\n\\n fig = plt.figure(figsize=(14, 12), tight_layout=True)\\n fig.suptitle(\\\"Latent direction variation\\\", fontsize=20)\\n gs = gridspec.GridSpec(2, 2)\\n\\n ax_temp = plt.subplot(gs[0, :])\\n ax_temp.scatter(\\n init[:, 0], init[:, 1])\\n ax_temp.set_title(\\\"Initial Dataset\\\")\\n ax_temp.set_xlim(-1, 1)\\n ax_temp.set_ylim(-1, 1)\\n [s.set_visible(False) for s in ax_temp.spines.values()]\\n\\n for j in range(2):\\n ax_temp = plt.subplot(gs[1, j])\\n sc = ax_temp.quiver(\\n init[:, 0], init[:, 1], diff[j, :, 0], diff[j, :, 1], norm[j])\\n sc.set_clim(np.min(norm[j]), np.max(norm[j]))\\n plt.colorbar(sc)\\n ax_temp.set_title(\\n \\\"Direction: {}, alpha: {}\\\".format(j+1, alpha))\\n ax_temp.set_xlim(-1, 1)\\n ax_temp.set_ylim(-1, 1)\\n [s.set_visible(False) for s in ax_temp.spines.values()]\\n\\n plt.savefig(\\\"frames_dir/fig_{}\\\".format(i))\\n plt.show()\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def show_derivative(self):\\n for trace in self.plotWidget.plotDataItems:\\n dt = float(trace.attrs['dt'])\\n dtrace = np.diff(trace.data)\\n x = pgplot.make_xvector(dtrace, dt)\\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))\",\n \"def plot_derivatives_divided(self, show=False):\\n\\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\\n ax[2, 0].set_title('Difference between upper and lower training examples');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n ax[2, 0].legend(frameon=False)\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\\n ax[2, 1].set_title('Difference between upper and lower test samples');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def plot_diff(self):\\n if not(self.is_attribute(\\\"time\\\") & self.is_attribute(\\\"intensity_up\\\") & \\n self.is_attribute(\\\"intensity_up_sigma\\\") &\\n self.is_attribute(\\\"intensity_down\\\") & \\n self.is_attribute(\\\"intensity_down_sigma\\\") &\\n self.is_attribute(\\\"intensity_up_total\\\") &\\n self.is_attribute(\\\"intensity_down_total\\\")):\\n return\\n fig, ax = plt.subplots()\\n ax.set_title(\\\"Polarized intensity: I_up - I_down\\\")\\n ax.set_xlabel(\\\"Time (microseconds)\\\")\\n ax.set_ylabel('Intensity')\\n \\n np_time = numpy.array(self.time, dtype=float)\\n np_up = numpy.array(self.intensity_up, dtype=float)\\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\\n np_down = numpy.array(self.intensity_down, dtype=float)\\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\\n np_diff = np_up - np_down\\n np_diff_mod = np_up_mod - np_down_mod\\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\\n\\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \\\"b:\\\")\\n ax.plot(np_time, np_diff_mod, \\\"k-\\\",\\n label=\\\"model\\\")\\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\\\"ko\\\", alpha=0.2,\\n label=\\\"experiment\\\")\\n\\n y_min_d, y_max_d = ax.get_ylim()\\n param = y_min_d-(np_diff-np_diff_mod).max()\\n\\n ax.plot([np_time.min(), np_time.max()], [param, param], \\\"k:\\\")\\n ax.plot(np_time, np_diff-np_diff_mod+param, \\\"r-\\\", alpha=0.7,\\n label=\\\"difference\\\")\\n ax.legend(loc='upper right')\\n fig.tight_layout()\\n return (fig, ax)\",\n \"def plot_variables(self, n, show=False, diagnostics=False):\\n\\n if diagnostics:\\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\\n else:\\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\\n\\n plt.subplots_adjust(hspace = 0)\\n end = len(n.history[\\\"det F\\\"])\\n epochs = np.arange(end)\\n a, = ax[0].plot(epochs, n.history[\\\"det F\\\"], label = 'Training data')\\n b, = ax[0].plot(epochs, n.history[\\\"det test F\\\"], label = 'Test data')\\n # ax[0].axhline(y=5,ls='--',color='k')\\n ax[0].legend(frameon = False)\\n ax[0].set_ylabel(r'$|{\\\\bf F}_{\\\\alpha\\\\beta}|$')\\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\\\"det test F\\\"][-1])\\n ax[1].plot(epochs, n.history[\\\"loss\\\"])\\n ax[1].plot(epochs, n.history[\\\"test loss\\\"])\\n # ax[1].set_xlabel('Number of epochs')\\n ax[1].set_ylabel(r'$\\\\Lambda$')\\n ax[1].set_xlim([0, len(epochs)]);\\n \\n if diagnostics:\\n ax[2].plot(epochs, n.history[\\\"det C\\\"])\\n ax[2].plot(epochs, n.history[\\\"det test C\\\"])\\n # ax[2].set_xlabel('Number of epochs')\\n ax[2].set_ylabel(r'$|{\\\\bf C}|$')\\n ax[2].set_xlim([0, len(epochs)]);\\n \\n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,0]\\n , color = 'C0', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,1]\\n , color = 'C0', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n \\\"\\\"\\\"\\n\\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,0]\\n , color = 'C1', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,1]\\n , color = 'C1', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n ax[3].legend(frameon=False)\\n \\\"\\\"\\\"\\n\\n ax[3].set_ylabel(r'$\\\\partial\\\\mu/\\\\partial\\\\theta$')\\n # ax[3].set_xlabel('Number of epochs')\\n ax[3].set_xlim([0, len(epochs)])\\n\\n # Mean of network output summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],alpha=0.5)\\n # Mean of test output network summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"test μ\\\"])[:,0],alpha=0.5)\\n ax[4].set_ylabel('μ')\\n ax[4].set_xlabel('Number of epochs')\\n ax[4].set_xlim([0, len(epochs)])\\n \\n\\n print ('Maximum Fisher info on train data:',np.max(n.history[\\\"det F\\\"]))\\n print ('Final Fisher info on train data:',(n.history[\\\"det F\\\"][-1]))\\n \\n print ('Maximum Fisher info on test data:',np.max(n.history[\\\"det test F\\\"]))\\n print ('Final Fisher info on test data:',(n.history[\\\"det test F\\\"][-1]))\\n\\n if np.max(n.history[\\\"det test F\\\"]) == n.history[\\\"det test F\\\"][-1]:\\n print ('Promising network found, possibly more epochs needed')\\n\\n plt.tight_layout()\\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def plot_derivatives(self, show=False):\\n\\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(0,self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].set_xscale('log')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[1, 0].set_xscale('log')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 0].set_title('Upper - lower input data: train sample');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 0].set_title('Numerical derivative: train sample');\\n ax[3, 0].set_xlabel(r'$\\\\ell$')\\n ax[3, 0].set_ylabel(r'$\\\\Delta C_\\\\ell / 2\\\\Delta \\\\theta$')\\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 0].set_xscale('log')\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n ax[0, 1].set_xscale('log')\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n ax[1, 1].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 1].set_title('Upper - lower input data: test sample');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 1].set_title('Numerical derivative: train sample');\\n ax[3, 1].set_xlabel(r'$\\\\ell$')\\n ax[3, 1].set_ylabel(r'$\\\\Delta C_\\\\ell / \\\\Delta \\\\theta $')\\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 1].set_xscale('log')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def show_calculations(self):\\n self.view.set_sum(self.model.get_sum())\\n self.view.set_diff(self.model.get_diff())\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def plot_energies(self):\\n plt.plot(self.energies[0], self.energies[1])\\n plt.xlabel('Time (s)')\\n plt.ylabel('Energy (J)')\\n plt.show()\",\n \"def main():\\n # Load properties that will be needed\\n store = [Storage.Storage(2), Storage.Storage(4)] \\n pre_energy = [s.get(\\\"free_energy\\\") for s in store]\\n post_energy = [s.get(\\\"post_energy\\\") for s in store]\\n x_range = store[0].get(\\\"x_range\\\")\\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\\n y_range = store[0].get(\\\"y_range\\\")\\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\\n # Calculate step size\\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \\n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \\n # Set up the figure\\n fig = plt.figure(1, figsize=(7.5,2.5)) \\n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\\n # Plot the results\\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\\n # Annotate the plots\\n axe[0].set_title(\\\"4sXB step size\\\")\\n axe[0].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[0].set_ylabel(\\\"Step size (nm)\\\")\\n axe[0].set_xlim((25.5, 39))\\n axe[0].set_ylim((1, 8))\\n axe[1].set_title(\\\"2sXB step size\\\")\\n axe[1].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[1].set_ylabel(\\\"Step size (nm)\\\")\\n axe[1].set_xlim((25.5, 39))\\n axe[1].set_ylim((1, 8))\\n # Display the plots\\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\\n left=0.08, right=0.98,\\n top=0.85, bottom=0.21)\\n plt.show()\",\n \"def energies():\\n # Hardcoded initial values\\n numsteps = 10000\\n time_max = 1\\n # Running the calculation in the solver class using the velocity verlet method\\n # for better accuracy.\\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\\n output_matrix, KE, PE, AM = verlet.main()\\n # Creating a simple time axis for plotting\\n x = np.linspace(0, 1, numsteps+1)\\n\\n # Plotting kinetic energy over time\\n plt.figure(1, figsize=(10, 10))\\n plt.plot(x, KE)\\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE'])\\n\\n # Plotting potential energy over time\\n plt.figure(2, figsize=(10, 10))\\n plt.plot(x, PE)\\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE'])\\n\\n # Plotting total energy against time\\n plt.figure(3, figsize=(10, 10))\\n plt.plot(x, PE+KE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE+PE'])\\n\\n # Plotting angular momentum against time. print the amplitude to terminal\\n amplitude = max(AM)-min(AM)\\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\\n plt.figure(4, figsize=(10, 10))\\n plt.plot(x, AM)\\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\\n plt.legend(['AM'])\\n\\n # Plotting the kinetic, potential and total energy against time to see\\n # how great the variations are\\n plt.figure(5, figsize=(10, 10))\\n plt.plot(x, PE, x, KE, x, KE+PE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE', 'KE', 'KE+PE'])\\n plt.show()\",\n \"def plot_results(self):\\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))\",\n \"def plotBondEnergy(self, phys, forces, step):\\r\\n self.plotQuantity(step, phys.app.energies.getTable(2), 'bondenergy')\",\n \"def _run():\\n\\n temperatures_kelvins = _create_temperature_grid()\\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\\n second_derivs_kelvins_pt01 = numpy.gradient(\\n numpy.absolute(first_derivs_kelvins_pt01)\\n )\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(first_derivs_kelvins_pt01)\\n )\\n\\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(second_derivs_kelvins_pt01)\\n )\\n\\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\\n\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n temperature_handle = axes_object.plot(\\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n second_deriv_handle = axes_object.plot(\\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n first_deriv_handle = axes_object.plot(\\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n this_min_index = numpy.argmin(second_derivs_unitless)\\n second_derivs_unitless[\\n (this_min_index - 10):(this_min_index + 10)\\n ] = second_derivs_unitless[this_min_index]\\n\\n tfp_handle = axes_object.plot(\\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n axes_object.set_yticks([0])\\n axes_object.set_xticks([], [])\\n\\n x_label_string = r'$x$-coordinate (increasing to the right)'\\n axes_object.set_xlabel(x_label_string)\\n\\n legend_handles = [\\n temperature_handle, first_deriv_handle, second_deriv_handle,\\n tfp_handle\\n ]\\n\\n legend_strings = [\\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\\n ]\\n\\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\\n\\n print 'Saving figure to file: \\\"{0:s}\\\"...'.format(OUTPUT_FILE_NAME)\\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\\n pyplot.close()\",\n \"def plot_dereddening():\\n extinction_coefficients = {'2365-2764-1': np.array([0.2622, 0.844]), '4109-638-1': np.array([0.0524, 0.1576]),\\n '2058-56-1': np.array([0.0751, 0.248]), '3642-2459-1': np.array([0.1907, 0.608]),\\n '3999-1391-1': np.array([0.3911, 1.2480]), '2607-1448-1': np.array([0.0430, 0.1310])}\\n cepheids = {'2365-2764-1': np.array([0.959, 2.09]), '4109-638-1': np.array([0.705, 2.385]), '2058-56-1':\\n np.array([1.222, 1.333]), '3642-2459-1': np.array([1.088, 2.0518]), '3999-1391-1':\\n np.array([1.360, 1.2567]), '2607-1448-1': np.array([1.484, 0.6963])}\\n periods = {'2365-2764-1': 1.61, '4109-638-1': 15.31, '2058-56-1': 63.08, '3642-2459-1': 1.86, '3999-1391-1': 24.98,\\n '2607-1448-1': 8.54}\\n max_periods = max(periods.values())\\n\\n new_positions_bv_mv = [] # in M_V vs B-V space\\n colors = []\\n theoretical_position = []\\n for obj in extinction_coefficients.keys():\\n # new_positions_bv_mv.append(cepheids[obj]-extinction_coefficients[obj])\\n new_positions_bv_mv.append(cepheids[obj])\\n colors.append(periods[obj]/max_periods)\\n theoretical_position.append(-2.78*np.log10(periods[obj])-1.35)\\n\\n for pos in range(len(new_positions_bv_mv)):\\n plt.scatter(new_positions_bv_mv[pos][0], new_positions_bv_mv[pos][1], marker='^', facecolor='w', s=40)\\n plt.scatter(new_positions_bv_mv[pos][0], theoretical_position[pos], marker='o', facecolor='r', s=50)\\n return new_positions_bv_mv, colors\",\n \"def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices['E_tot1'])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\\n \\n plt.ylabel('Energy [kWh]')\\n plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(24)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\\n\\n plt.ylabel('Energy Difference [kWh]')\\n plt.legend()\\n\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n return fig\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def convergence():\\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n # point spread and point total subplots\\n subplots = [\\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\\n (True, [200.5], league.totals, 'probability total > 200.5'),\\n ]\\n\\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, values)\\n\\n line = lines[-1]\\n\\n for label2 in label2_list:\\n\\n # evaluation times and labels\\n times = np.arange(league.times.size)[::1000]\\n labels1 = times.size * [label1]\\n labels2 = times.size * [label2]\\n\\n # observed win probability\\n prob = melo.probability(times, labels1, labels2, lines=line)\\n ax.plot(times, prob)\\n\\n # true (analytic) win probability\\n if ax.is_first_row():\\n prob = skellam.sf(line, int(label1), int(label2))\\n ax.axhline(prob, color='k')\\n else:\\n prob = poisson.sf(line, int(label1) + int(label2))\\n ax.axhline(prob, color='k')\\n\\n # axes labels\\n if ax.is_last_row():\\n ax.set_xlabel('Iterations')\\n ax.set_ylabel(ylabel)\\n\\n set_tight(w_pad=.5)\",\n \"def plot_bs(self, show=False, density=True, pcolor=\\\"r\\\", mcolor=\\\"b\\\", lw=1.0, subtract = 0):\\n cm = matplotlib.cm.jet\\n\\n if (subtract !=0):\\n geqbispectra = subtract\\n else:\\n geqbispectra = np.zeros(np.shape(self.eqbispectra))\\n\\n if (density):\\n \\\"\\\"\\\" also read the local overdensity value and plot line colors according to\\n the density value, + = red, - = blue; adjust alpha accordingly\\n \\\"\\\"\\\"\\n if len(self.ds)<self.Nsubs:\\n print (\\\"no density data\\\")\\n return 0\\n\\n ads=np.abs(self.ds)\\n meands=np.mean(self.ds)\\n mads=np.max(ads)\\n normds=np.array([ads[i]/mads for i in range(len(ads))])\\n self.normds=normds\\n\\n cNorm = colors.Normalize(min(self.ds), vmax=max(self.ds))\\n scalarMap = cmap.ScalarMappable(norm=cNorm, cmap=cm)\\n scalarMap.set_array([])\\n\\n fig, ax = self.plt.subplots()\\n\\n for sub in range(self.Nsubs):\\n #print sub\\n if not(density):\\n lplot=ax.plot(self.klist, self.fNLeq[sub])\\n else:\\n colorVal = scalarMap.to_rgba(self.ds[sub])\\n lplot = ax.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=colorVal, alpha=normds[sub], linewidth=lw)\\n \\\"\\\"\\\"\\n if self.ds[sub]>meands:\\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=pcolor, alpha=normds[sub], linewidth=lw)\\n else:\\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=mcolor, alpha=normds[sub], linewidth=lw)\\n \\\"\\\"\\\"\\n\\n ax.set_xlabel(r\\\"$k {\\\\rm (h/Mpc)}$\\\")\\n ax.set_ylabel(r\\\"${\\\\rm Q}(k)$\\\")\\n ax.set_xscale('log')\\n cbar = fig.colorbar(scalarMap, format='%.0e')\\n #self.plt.yscale('log')\\n if (show):\\n self.plt.show()\",\n \"def plot(self):\\n self.plotsite()\\n self.plotbond()\\n plt.show()\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def sysPLQF(mirror, blkFlag=True):\\n import matplotlib.pyplot as plt\\n import numpy as np # to ndarray.flatten ax\\n\\n mir = mirror\\n xend = max(mir.r_t)\\n\\n fig, ax = plt.subplots(nrows=2, ncols=2,)\\n ax = np.ndarray.flatten(ax)\\n ax[0].set_title('Real Power Generated')\\n for mach in mir.Machines:\\n ax[0].plot(mir.r_t, mach.r_Pe, \\n marker = 10,\\n fillstyle='none',\\n #linestyle = ':',\\n label = 'Pe Gen '+ mach.Busnam)\\n ax[0].set_xlabel('Time [sec]')\\n ax[0].set_ylabel('MW')\\n\\n ax[2].set_title('Reactive Power Generated')\\n for mach in mir.Machines:\\n ax[2].plot(mir.r_t, mach.r_Q, \\n marker = 10,\\n fillstyle='none',\\n #linestyle = ':',\\n label = 'Q Gen '+ mach.Busnam)\\n ax[2].set_xlabel('Time [sec]')\\n ax[2].set_ylabel('MVAR')\\n\\n ax[1].set_title('Total System P Loading')\\n ax[1].plot(mir.r_t, mir.r_ss_Pload, \\n marker = 11,\\n #fillstyle='none',\\n #linestyle = ':',\\n label = 'Pload')\\n ax[1].set_xlabel('Time [sec]')\\n ax[1].set_ylabel('MW')\\n\\n ax[3].set_title('System Mean Frequency')\\n ax[3].plot(mir.r_t, mir.r_f,\\n marker = '.',\\n #linestyle = ':',\\n label = r'System Frequency')\\n ax[3].set_xlabel('Time [sec]')\\n ax[3].set_ylabel('Frequency [PU]')\\n\\n # Global Plot settings\\n for x in np.ndarray.flatten(ax):\\n x.set_xlim(0,xend)\\n x.legend()\\n x.grid(True)\\n\\n fig.tight_layout()\\n\\n plt.show(block = blkFlag)\",\n \"def test_run_beta_diversity_through_plots(self):\\r\\n run_beta_diversity_through_plots(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=False,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n unweighted_unifrac_dm_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_dm.txt')\\r\\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\\r\\n unweighted_unifrac_pc_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_pc.txt')\\r\\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\\r\\n weighted_unifrac_html_fp = join(self.test_out,\\r\\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def plot_results(self, energies=None, differences=None,\\n experimental_values=None):\\n import matplotlib.pyplot as plt\\n import numpy as np\\n\\n y = np.array(self.results['differences'])\\n x = np.array(self.results['experimental_values'])\\n\\n # Computes the fit for the regresion\\n coef = np.polyfit(x, y, deg=1)\\n\\n # Histogram\\n abs_val = abs(x - y)\\n bins = np.arange(0, 10, 0.75)\\n plt.figure()\\n plt.grid(axis='y', alpha=0.75)\\n plt.ylabel('Frequency')\\n plt.xlabel('Absolute difference (kcal/mol)')\\n plt.title('Absolute difference')\\n _, bins, patches = plt.hist(np.clip(abs_val, bins[0], bins[-1]),\\n bins=bins, color=['#0504aa'], alpha=0.7,\\n rwidth=0.8)\\n\\n # Regression\\n poly1d_fn = np.poly1d(coef)\\n plt.figure()\\n plt.title('Experimental value vs. Energetic Difference')\\n plt.ylabel('Energetic difference (kcal/mol)')\\n plt.xlabel('Experimental value (kcal/mol)')\\n plt.plot(x, y, 'yo', x, poly1d_fn(x), '--k')\",\n \"def plotImproperEnergy(self, phys, forces, step): \\r\\n self.plotQuantity(step, phys.app.energies.getTable(5), 'improperenergy')\",\n \"def plot_dif_eq(self):\\n try:\\n self.canvas.get_tk_widget().pack_forget()\\n self.toolbar.pack_forget()\\n except AttributeError:\\n pass\\n\\n f = Figure(figsize=(8, 8), dpi=100)\\n p = f.add_subplot(111)\\n\\n p.plot(self.model.ex.x_coord_plot, self.model.ex.y_coord_plot, c = 'C6')\\n p.scatter(self.model.ex.x_coord, self.model.ex.y_coord, c = 'C6')\\n p.plot(self.model.eu.x_coord, self.model.eu.y_coord, marker='o')\\n p.plot(self.model.ieu.x_coord, self.model.ieu.y_coord, marker='o')\\n p.plot(self.model.rk.x_coord, self.model.rk.y_coord, marker='o')\\n\\n p.set_ylabel('y')\\n p.set_xlabel('x')\\n\\n p.legend(['Exact', 'EU', \\\"IEU\\\", \\\"RK\\\"])\\n p.set_title(\\\"Solutions\\\")\\n if max(self.model.ex.y_coord_plot) >= 1e5 or max(self.model.eu.y_coord) >= 1e5 \\\\\\n or max(self.model.ieu.y_coord) >= 1e5 or max(self.model.rk.y_coord) >= 1e5:\\n p.set_ylim([-100, 100])\\n\\n if min(self.model.ex.y_coord_plot) <= -1e5 or min(self.model.eu.y_coord) <= -1e5 \\\\\\n or min(self.model.ieu.y_coord) <= -1e5 or min(self.model.rk.y_coord) <= -1e5:\\n p.set_ylim([-100, 100])\\n\\n self.canvas = FigureCanvasTkAgg(f, self.f_left)\\n self.canvas.draw()\\n self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=False)\\n\\n self.toolbar = NavigationToolbar2Tk(self.canvas, self.f_left)\\n self.toolbar.update()\\n\\n self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=False)\",\n \"def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\\n df_decomposed = df.loc[df['block'] == 'decomposed']\\n df_joint = df.loc[df['block'] == 'joint']\\n ticklabels = []\\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\\n for i in range(len(num_sweeps)):\\n ticklabels.append('K=%d\\\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\\n fig = plt.figure(figsize=(fs*2.5, fs))\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax1.set_xticks(num_sweeps)\\n ax1.set_xticklabels(ticklabels)\\n ax1.tick_params(labelsize=fontsize)\\n ax1.grid(alpha=0.4)\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax2.set_xticks(num_sweeps)\\n ax2.set_xticklabels(ticklabels)\\n ax2.tick_params(labelsize=fontsize)\\n ax2.grid(alpha=0.4)\\n ax2.legend(fontsize=fontsize)\\n ax1.legend(fontsize=fontsize)\\n ax1.set_ylabel(r'$\\\\log \\\\: p_\\\\theta(x, \\\\: z)$', fontsize=35)\\n ax2.set_ylabel('ESS / L', fontsize=35)\",\n \"def plot(self) -> None:\\n if self.__fig is None:\\n self.__fig = plt.figure()\\n\\n xv = []\\n yv = []\\n for x in np.arange(self.state_min(), self.state_max(), self.state_step()):\\n xv.append(x)\\n yv.append(self.reward(x))\\n ax = self.__fig.gca()\\n ax.set_xlabel('X (State)')\\n ax.set_ylabel('Y (Reward)')\\n ax.set_title('Reward Function')\\n ax.plot(xv, yv)\\n plt.pause(self.__plot_pause)\\n plt.show(block=False)\\n return\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def plot_envs_opt_vs_gym():\\n for i in range(len(envs)):\\n env = envs[i]\\n vel_new = get_log_key(fdir + envs[i] + '-v1/VRPG/', string='fvel_avg', plot=False)\\n vel_old = get_log_key(fdir + envs[i] + '-v1/VRPG_old/', string='fvel_avg', plot=False)\\n print(len(vel_new), len(vel_old))\\n fig = plot_trials(vel_new, fdir + envs[i] + '-v1/', f=lambda it: vel_new[it], name='Hopper_opt', shape='-s',\\n step=20)\\n plt.ylabel(envs[i] + ' Cumulative reward $R_{iter}$')\\n fig = plot_trials(vel_old, fdir + envs[i] + '-v1/', f=lambda it: vel_old[it], name='Hopper_Gym', fig=fig,\\n shape='-o', step=20)\\n return\",\n \"def plot(self, noTLS, path_plots, interactive):\\n fig = plt.figure(figsize=(10,12))\\n ax1 = fig.add_subplot(4, 1, 1)\\n ax2 = fig.add_subplot(4, 1, 2)\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax4 = fig.add_subplot(4, 2, 6)\\n ax5 = fig.add_subplot(4, 2, 7)\\n ax6 = fig.add_subplot(4, 2, 8)\\n\\n # First panel: data from each sector\\n colors = self._get_colors(self.nlc)\\n for i, lci in enumerate(self.alllc):\\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\\n ax1.legend(fontsize='small', ncol=4)\\n\\n # Second panel: Detrended light curve\\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\\n color='black',\\n label='Detrended')\\n\\n # Third panel: BLS\\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\\n mean_SR = np.mean(self.BLS.power)\\n std_SR = np.std(self.BLS.power)\\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\\n SDE = (best_power - mean_SR)/std_SR\\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\\n for n in range(2, 10):\\n if n*self.BLS.period_max <= max(self.BLS.period.value):\\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n sx, ex = ax3.get_xlim()\\n sy, ey = ax3.get_ylim()\\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.2f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nSDE = %.3f' %\\n (self.BLS.period_max, self.BLS.t0_max,\\n self.BLS.depth_max, self.BLS.duration_max, SDE))\\n\\n\\n # Fourth panel: lightcurve folded to the best period from the BLS\\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\\n marker='.', alpha=0.5)\\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n\\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\\n duration=self.BLS.duration_max,\\n transit_time=self.BLS.t0_max)\\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\\n ax4.set_xlim(-l, l)\\n h = max(lc_model.flux)\\n l = min(lc_model.flux)\\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n del lc_model, lc_model_folded, r1, dt1\\n\\n\\n if not noTLS:\\n # Fifth panel: TLS periodogram\\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\\n for n in range(2, 10):\\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.set_ylabel(r'SDE')\\n ax5.set_xlabel('Period (days)')\\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\\n ax5.set_xlim(0, max(self.tls.periods))\\n\\n period_tls = self.tls.period\\n T0_tls = self.tls.T0\\n depth_tls = self.tls.depth\\n duration_tls = self.tls.duration\\n FAP_tls = self.tls.FAP\\n\\n sx, ex = ax5.get_xlim()\\n sy, ey = ax5.get_ylim()\\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.1f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nFAP = %.4f' %\\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\\n\\n # Sixth panel: folded light curve to the best period from the TLS\\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\\n alpha=0.5, ls='None', markersize=0.7)\\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\\n x0=0.0, nbins=nbins, useBinCenter=True)\\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\\n ax6.set_xlim(0.5-l, 0.5+l)\\n h = max(self.tls.model_folded_model)\\n l = min(self.tls.model_folded_model)\\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n ax6.set_xlabel('Phase')\\n ax6.set_ylabel('Relative flux')\\n del r1, dt1\\n\\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\\n if interactive:\\n plt.show()\\n plt.close('all')\\n del fig\",\n \"def _plot(self):\\n # Read results\\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\\n x1, y1, _ = read_results('openmc', path)\\n if self.code == 'serpent':\\n path = self.other_dir / 'input_det0.m'\\n else:\\n path = self.other_dir / 'outp'\\n x2, y2, sd = read_results(self.code, path)\\n\\n # Convert energies to eV\\n x1 *= 1e6\\n x2 *= 1e6\\n\\n # Normalize the spectra\\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\\n\\n # Compute the relative error\\n err = np.zeros_like(y2)\\n idx = np.where(y2 > 0)\\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\\n \\n # Set up the figure\\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\\n ax1 = fig.add_subplot(111)\\n \\n # Create a second y-axis that shares the same x-axis, keeping the first\\n # axis in front\\n ax2 = ax1.twinx()\\n ax1.set_zorder(ax2.get_zorder() + 1)\\n ax1.patch.set_visible(False)\\n \\n # Plot the spectra\\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\\n \\n # Plot the relative error and uncertainties\\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\\n \\n # Set grid and tick marks\\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\\n ax1.grid(b=False, axis='both', which='both')\\n ax2.tick_params(axis='y', which='both', right=False)\\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\\n \\n # Set axes labels and limits\\n ax1.set_xlim([self._min_energy, self.energy])\\n ax1.set_xlabel('Energy (eV)', size=12)\\n ax1.set_ylabel('Spectrum', size=12)\\n ax1.legend()\\n ax2.set_ylabel(\\\"Relative error\\\", size=12)\\n title = f'{self.nuclide}'\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n title += f' + {thermal_name}'\\n title += f', {self.energy:.1e} eV Source'\\n plt.title(title)\\n \\n # Save plot\\n os.makedirs('plots', exist_ok=True)\\n if self.name is not None:\\n name = self.name\\n else:\\n name = f'{self.nuclide}'\\n if self.thermal is not None:\\n name += f'-{thermal_name}'\\n name += f'-{self.energy:.1e}eV'\\n if self._temperature is not None:\\n name += f'-{self._temperature:.1f}K'\\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\\n plt.close()\",\n \"def plot(self):\\n t = np.linspace(0, self.days, self.days + 1)\\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\\n ax1.plot(t, self.S, label=\\\"Susceptible\\\", color='r')\\n ax1.set_ylabel(\\\"Number of Susceptible People\\\")\\n ax1.set_title(\\\"Strong Infecitous Model SEIRV Simulation\\\")\\n ax3.plot(t, self.I, label=\\\"Active Cases\\\", color='b')\\n ax3.set_ylabel(\\\"Active Cases\\\")\\n ax2.plot(t, self.E, label=\\\"Exposed\\\", color='c')\\n ax2.set_ylabel(\\\"# of Exposed\\\")\\n ax4.plot(t, self.R, label=\\\"Recovered\\\", color='m')\\n ax5.set_xlabel(\\\"Days\\\")\\n ax4.set_ylabel('Number of Recovered')\\n ax5.plot(t, self.V, label=\\\"Vaccinated\\\")\\n ax5.set_ylabel(\\\"# Vaccinated\\\")\\n ax1.legend()\\n ax2.legend()\\n ax3.legend()\\n ax4.legend()\\n plt.show()\\n return fig\",\n \"def plot_resiliences(nodes, network_vals, er_vals, upa_vals):\\n node_vals = range(0, nodes)\\n\\n plt.plot(node_vals, network_vals, '-b', label='Network')\\n plt.plot(node_vals, er_vals, '-r', label='ER')\\n plt.plot(node_vals, upa_vals, '-g', label='UPA')\\n\\n plt.legend(loc='upper right')\\n plt.ylabel('Size of Largest Connected Component')\\n plt.xlabel('Number of Nodes Removed')\\n plt.grid(True)\\n plt.title('Comparison of Graph Resilience\\\\nMeasured by Largest Connected Component vs Nodes Removed by Target Attack\\\\n')\\n plt.show()\",\n \"def update(self):\\n self.plot.draw()\\n \\n func=str(self.edit1b.currentText())\\n if self.win.test()==0:\\n x=np.linspace(0,10,200)\\n elif self.win.test()==1:\\n x=np.linspace(0,0.40,200)\\n \\n pattern1=r'Steel'\\n pattern2=r'Aluminium'\\n pattern3=r'[\\\\d]+'\\n \\n if (func!='Comparison Chart'):\\n self.edit2b.setDisabled(False)\\n self.edit3b.setDisabled(False)\\n self.edit4b.setDisabled(False)\\n if (func=='Quenched/Tempered Steel'):\\n alpha = 0.0025\\n elif (func=='Annealed Steel'):\\n alpha = 0.01\\n elif (func=='Steel (input Su)'):\\n S = str(self.edit2b.text())\\n if (self.win.test()==0):\\n S = str(float(S)/6.895)\\n alpha = notch.alpha(eval(S))\\n elif (func=='Aluminium Alloy 356.0 as cast'):\\n rho = 0.08\\n elif (func=='Aluminium Alloy 6061'):\\n rho = 0.025\\n elif (func=='Aluminium Alloy 7075'):\\n rho = 0.015\\n elif (func=='Material dropdown'):\\n pass\\n \\n y1=[]\\n if re.search(pattern1,func):\\n Su=notch.su_s(alpha)\\n if (self.win.test()==0):\\n Su = Su*6.895\\n for i in range(len(x)):\\n y1.append(notch.nsp(alpha,x[i],self.win.test()))\\n y=np.asarray(y1)\\n if (re.search(pattern3,str(self.edit3b.text()))):\\n r=eval(str(self.edit3b.text()))\\n self.edit4b.setText(str(notch.nsp(alpha,r,self.win.test())))\\n elif re.search(pattern2,func):\\n Su=notch.su_a(rho)\\n if (self.win.test()==0):\\n Su = Su*6.895\\n for i in range(len(x)):\\n y1.append(notch.nsn(rho,x[i],self.win.test()))\\n y=np.asarray(y1)\\n if (re.search(pattern3,str(self.edit3b.text()))):\\n r=eval(str(self.edit3b.text()))\\n self.edit4b.setText(str(notch.nsn(rho,r,self.win.test())))\\n \\n self.edit2b.setText(str(Su))\\n func1 = 'Steel (Su='+str(self.edit2b.text())+')'\\n if (func!='Steel (input Su)'):\\n self.plot.redraw(x,y,func, self.xlabel)\\n elif (func=='Steel (input Su)'):\\n self.plot.redraw(x,y,func1, self.xlabel)\\n \\n elif (func=='Comparison Chart'):\\n self.edit2b.setText(\\\"\\\")\\n self.edit2b.setDisabled(True)\\n self.edit3b.setText(\\\"\\\")\\n self.edit3b.setDisabled(True)\\n self.edit4b.setText(\\\"\\\")\\n self.edit4b.setDisabled(True)\\n self.plot.draw_comp(self.xlabel, self.win.test())\",\n \"def plotEnergiesOpt(monthlyData, optIdx):\\n \\n \\n dummyRange = np.asarray(range(len(optIdx)))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n plt.suptitle('Energy Comparison')\\n ax1 = plt.subplot(1,1,1)\\n plt.plot(monthlyData['H'][optIdx, dummyRange], label = 'H', color='r')\\n plt.plot(monthlyData['C'][optIdx, dummyRange], label = 'C', color='b')\\n plt.plot(monthlyData['L'][optIdx, dummyRange], label = 'L', color='g')\\n plt.plot(monthlyData['PV'][optIdx, dummyRange], label = 'PV', color='c')\\n plt.plot(monthlyData['E_HCL'][optIdx, dummyRange], label = 'HCL', color='m')\\n plt.plot(monthlyData['E_tot'][optIdx, dummyRange], label = 'E_tot', color='k')\\n plt.ylabel('Energy [kWh]')\\n plt.xlim(0,288)\\n\\n# plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(4)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which=u'major')\\n \\n # Shrink current axis by 20%\\n box = ax1.get_position()\\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\\n \\n # Put a legend to the right of the current axis\\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\\n# \\n\\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\\n# ax2 = plt.subplot(2,1,2, sharex=ax1)\\n# plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\\n# plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\\n# plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\\n# plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\\n# plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\\n# plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\\n# plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\\n# plt.ylabel('Energy Difference [kWh]')\\n# plt.legend()\\n#\\n# ax2.xaxis.set_major_locator(majorLocator)\\n# ax2.xaxis.set_major_formatter(majorFormatter)\\n# ax2.xaxis.set_minor_locator(minorLocator)\\n## ax2.xaxis.set_minor_formatter(minorFormatter)\\n# plt.grid(True, which='both')\\n# \\n return fig\",\n \"def plot(self, nsteps_max=10):\\r\\n fig = plt.figure()\\r\\n ax1 = plt.subplot(221)\\r\\n ax2 = plt.subplot(222)\\r\\n ax3 = plt.subplot(224)\\r\\n\\r\\n if 'fig' in locals(): # assures tight layout even when plot is manually resized\\r\\n def onresize(event): plt.tight_layout()\\r\\n try: cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\\r\\n except: pass\\r\\n\\r\\n self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax1)\\r\\n\\r\\n if getattr(self.px_spec, 'ref_tree', None) is None:\\r\\n self.calc_px(method='LT', nsteps=nsteps_max, keep_hist=True)\\r\\n\\r\\n self.plot_bt(bt=self.px_spec.ref_tree, ax=ax2, title='Binary tree of stock prices; ' + self.specs)\\r\\n self.plot_bt(bt=self.px_spec.opt_tree, ax=ax3, title='Binary tree of option prices; ' + self.specs)\\r\\n # fig, ax = plt.subplots()\\r\\n # def onresize(event): fig.tight_layout()\\r\\n # cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\\r\\n # self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax)\\r\\n\\r\\n try: plt.tight_layout()\\r\\n except: pass\\r\\n plt.show()\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def display_distances(self) -> None:\\n self.svg.clear()\\n for colnum, valtup in enumerate(self.dist_lst):\\n epc, dist_val = valtup\\n self.drawcolumn(colnum, epc, dist_val)\",\n \"def plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def display_feds(list1, list2):\\n if len(list1) != len(list2):\\n print(\\\"In display_feds: lists must be of the same length\\\")\\n return \\n fig = plt.figure(dpi=128, figsize=(10, 6))\\n fed_list_answer = fed_list(list1, list2)\\n plt.plot(range(len(fed_list_answer)), fed_list_answer, c='red', alpha=0.5)\\n \\n plt.title(\\\"Feature edit distances between corresponding pairs\\\", fontsize = 24)\\n plt.xlabel('', fontsize =16)\\n #fig.autofmt_xdate()\\n plt.ylabel(\\\"Distance\\\", fontsize =16)\\n plt.tick_params(axis='both', which = 'major', labelsize=16)\\n\\n plt.show()\",\n \"def visualize(self, network, f):\\n import matplotlib\\n matplotlib.use('Agg',warn=False)\\n import matplotlib.pyplot as plt\\n # Convert to a network if it is not.\\n if not isinstance(network, NeuralNetwork):\\n network = NeuralNetwork(network)\\n \\n fig = plt.figure()\\n steps, states, actions = self._loop(network, max_steps=1000)\\n # TEMP STUFF\\n actions = np.array(actions)\\n print((actions.size, np.histogram(actions)[0]))\\n ##\\n x, dx, theta, dtheta = list(zip(*states))\\n theta = np.vstack(theta).T\\n dtheta = np.vstack(dtheta).T\\n # The top plot (cart position)\\n top = fig.add_subplot(211)\\n top.fill_between(list(range(len(x))), -self.h, self.h, facecolor='green', alpha=0.3)\\n top.plot(x, label=r'$x$') \\n top.plot(dx, label=r'$\\\\delta x$')\\n top.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\\n # The bottom plot (pole angles)\\n bottom = fig.add_subplot(212)\\n bottom.fill_between(list(range(theta.shape[1])), -self.r, self.r, facecolor='green', alpha=0.3)\\n for i, (t, dt) in enumerate(zip(theta, dtheta)):\\n bottom.plot(t, label=r'$\\\\theta_%d$'%i)\\n bottom.plot(dt, ls='--', label=r'$\\\\delta \\\\theta_%d$'%i)\\n bottom.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\\n fig.savefig(f)\",\n \"def get_energy(edr, annealing_times, energy_type = 'Potential', out_fig = 'energy_distribution.svg'): # Could be Total-Energy\\n fig, ax = plt.subplots(figsize = (16,9))\\n data = pd.DataFrame()\\n xvg_tmp_file = tempfile.NamedTemporaryFile(suffix='.xvg')\\n energy = []\\n iterator = range(0, len(annealing_times)-1, 2)\\n\\n for state, index in tqdm.tqdm(enumerate(iterator), total=len(iterator)):#enumerate(iterator):# # the calculation is per pair of times, beetween the first to time the temperature was keep constant, then the system was heated and repeated again.\\n run = tools.run(f\\\"export GMX_MAXBACKUP=-1; echo {energy_type} | gmx energy -f {edr} -b {annealing_times[index]} -e {annealing_times[index + 1]} -o {xvg_tmp_file.name} | grep \\\\'{energy_type.replace('-',' ')}\\\\'\\\")\\n energy.append(float(run.stdout.split()[-5]))\\n \\\"\\\"\\\"\\n Energy Average Err.Est. RMSD Tot-Drift\\n -------------------------------------------------------------------------------\\n Potential -1.30028e+06 -- 1682.1 -2422.24 (kJ/mol)\\n Total Energy -952595 -- 2606.81 -3688.3 (kJ/mol)\\n \\\"\\\"\\\"\\n # Getting the histograms and checking for the same len in all intervals\\n if state == 0:\\n data[state] = xvg.XVG(xvg_tmp_file.name).data[:,1]\\n else:\\n xvg_data = xvg.XVG(xvg_tmp_file.name).data[:,1]\\n if xvg_data.shape[0] > data.shape[0]:\\n data[state] = xvg_data[:data.shape[0]]\\n else:\\n data = data.iloc[:xvg_data.shape[0]]\\n data[state] = xvg_data\\n\\n\\n print(data)\\n sns.histplot(data = data, element='poly', stat = 'probability', axes = ax)\\n ax.set(\\n xlabel = f'{energy_type} [kJ/mol]',\\n ylabel = 'Probability',\\n title = f'Distribution of {energy_type}')\\n # plt.show()\\n fig.savefig(out_fig)\\n return energy\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def visualize(dcf_prices, current_share_prices, regress = True):\\n # TODO: implement\\n return NotImplementedError\",\n \"def plot_one_state_evolution(self, value, option='density'):\\n\\n fig = plt.figure(figsize=(16, 8), dpi=100)\\n ax = fig.add_subplot(111)\\n if option == 'density':\\n ax.plot(np.squeeze(np.array(self.est_density[value, :])), 'r--', label='Estimated')\\n elif option == 'flow':\\n if value == 0:\\n # plot qin\\n index = self.x_index['qin']\\n elif value == self.num_cells:\\n # plot qout\\n index = self.x_index['qout']\\n elif value in self.x_index['onramp'].keys():\\n # plot onramp flow\\n index = self.x_index['onramp'][value]\\n elif value in self.x_index['offramp'].keys():\\n # plot offramp flow\\n index = self.x_index['offramp'][value]\\n else:\\n raise Exception('KeyError: value must be the cell id')\\n\\n ax.plot(np.squeeze(np.array(self.est_state_all[index, :])), 'r--', label='Estimated')\\n\\n plt.title('{0} at {1}'.format(option, value))\\n plt.xlabel('Time (step)')\\n plt.ylabel('Value')\\n\\n plt.grid(True)\\n plt.legend()\\n\\n plt.draw()\",\n \"def compare_one_state_evolution(self, value, true_state, option='density'):\\n\\n fig = plt.figure(figsize=(16, 8), dpi=100)\\n ax = fig.add_subplot(111)\\n if option == 'density':\\n ax.plot(np.squeeze(np.array(self.est_density[value, :])), 'r--', label='Estimated')\\n elif option == 'flow':\\n if value == 0:\\n # plot qin\\n index = self.x_index['qin']\\n elif value == self.num_cells:\\n # plot qout\\n index = self.x_index['qout']\\n elif value in self.x_index['onramp'].keys():\\n # plot onramp flow\\n index = self.x_index['onramp'][value]\\n elif value in self.x_index['offramp'].keys():\\n # plot offramp flow\\n index = self.x_index['offramp'][value]\\n else:\\n raise Exception('KeyError: value must be the cell id')\\n\\n ax.plot(np.squeeze(np.array(self.est_state_all[index, :])), 'r--', label='Estimated')\\n ax.plot(np.squeeze(np.array(true_state)), 'b', label='True')\\n\\n plt.title('{0} at {1}'.format(option, value))\\n plt.xlabel('Time (step)')\\n plt.ylabel('Value')\\n\\n plt.grid(True)\\n plt.legend()\\n\\n plt.draw()\",\n \"def overview(self, minState=5):\\n n = 600\\n \\n ### first plot: the RTOFFSETs and STATES\\n plt.figure(10)\\n plt.clf()\\n plt.subplots_adjust(hspace=0.05, top=0.95, left=0.05,\\n right=0.99, wspace=0.00, bottom=0.1)\\n ax1 = plt.subplot(n+11)\\n try:\\n print self.insmode+' | pri:'+\\\\\\n self.getKeyword('OCS PS ID')+' | sec:'+\\\\\\n self.getKeyword('OCS SS ID')\\n \\n plt.title(self.filename+' | '+self.insmode+' | pri:'+\\n self.getKeyword('OCS PS ID')+' | sec:'+\\n self.getKeyword('OCS SS ID'))\\n except:\\n pass\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n self.raw['OPDC'].data.field('FUOFFSET')*1e3,\\n color=(1.0, 0.5, 0.0), label=self.DLtrack+' (FUOFFSET)',\\n linewidth=3, alpha=0.5)\\n plt.legend(prop={'size':9})\\n plt.ylabel('(mm)')\\n plt.xlim(0)\\n \\n plt.subplot(n+12, sharex=ax1) # == DDL movements\\n \\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n 1e3*self.raw['DOPDC'].data.field(self.DDLtrack),\\n color=(0.0, 0.5, 1.0), linewidth=3, alpha=0.5,\\n label=self.DDLtrack)\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n 1e3*self.raw['DOPDC'].data.field('PSP'),\\n color=(0.0, 0.5, 1.0), linewidth=1, alpha=0.9,\\n label='PSP', linestyle='dashed')\\n plt.legend(prop={'size':9})\\n plt.ylabel('(mm)')\\n plt.xlim(0)\\n \\n plt.subplot(n+13, sharex=ax1) # == states\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n self.raw['OPDC'].data.field('STATE'),\\n color=(1.0, 0.5, 0.0), label='OPDC')\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n self.raw['DOPDC'].data.field('STATE'),\\n color=(0.0, 0.5, 1.0), label='DOPDC')\\n plt.legend(prop={'size':9})\\n plt.ylabel('STATES')\\n yl=plt.ylim()\\n plt.ylim(yl[0]-1, yl[1]+1)\\n plt.xlim(0)\\n ### fluxes\\n plt.subplot(n+14, sharex=ax1)\\n try:\\n fsua_dark = self.fsu_calib[('FSUA', 'DARK')][0,0]\\n fsub_dark = self.fsu_calib[('FSUB', 'DARK')][0,0]\\n fsua_alldark = self.fsu_calib[('FSUA', 'DARK')].sum(axis=1)[0]\\n fsub_alldark = self.fsu_calib[('FSUB', 'DARK')].sum(axis=1)[0]\\n except:\\n print 'WARNING: there are no FSUs calibrations in the header'\\n fsua_dark = 0.0\\n fsub_dark = 0.0\\n fsua_alldark = 0.0\\n fsub_alldark = 0.0\\n\\n M0 = 17.5\\n fluxa = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\\n fsua_alldark)/\\\\\\n (4*self.getKeyword('ISS PRI FSU1 DIT'))\\n print 'FLUX FSUA (avg, rms):', round(fluxa.mean(), 0), 'ADU/s',\\\\\\n round(100*fluxa.std()/fluxa.mean(), 0), '%'\\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\\\\n round(M0-2.5*np.log10(fluxa.mean()),2)\\n fluxb = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\\n fsub_alldark)/\\\\\\n (4*self.getKeyword('ISS PRI FSU2 DIT'))\\n print 'FLUX FSUB (avg, rms):', round(fluxb.mean(), 0), 'ADU/s',\\\\\\n round(100*fluxb.std()/fluxb.mean(), 0), '%'\\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\\\\n round(M0-2.5*np.log10(fluxb.mean()),2)\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\\\\\n fluxa/1000, color='b', alpha=0.5, label='FSUA')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\\\\\n fluxb/1000, color='r', alpha=0.5, label='FSUB')\\n\\n plt.ylim(1)\\n plt.legend(prop={'size':9})\\n plt.ylabel('flux - DARK (kADU)')\\n plt.xlim(0)\\n plt.subplot(n+15, sharex=ax1)\\n try:\\n # -- old data version\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUA'].data.field('OPDSNR'),\\n color='b', alpha=0.5, label='FSUA SNR')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUB'].data.field('OPDSNR'),\\n color='r', alpha=0.5, label='FSUB SNR')\\n except:\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUA'].data.field(self.OPDSNR),\\n color='b', alpha=0.5, label='FSUA SNR')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUB'].data.field(self.OPDSNR),\\n color='r', alpha=0.5, label='FSUB SNR')\\n plt.legend(prop={'size':9})\\n \\n A = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,0])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,0]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,0])\\n B = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,1])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,1]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,1])\\n C = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,2])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,2]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,2])\\n D = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,3])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,3]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,3])\\n snrABCD_a = ((A-C)**2+(B-D)**2)\\n snrABCD_a /= ((A-C).std()**2+ (B-D).std()**2)\\n #plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n # snrABCD_a, color='b', alpha=0.5, linestyle='dashed')\\n \\n A = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,0])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,0]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,0])\\n B = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,1])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,1]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,1])\\n C = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,2])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,2]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,2])\\n D = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,3])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,3]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,3])\\n \\n snrABCD_b = ((A-C)**2+(B-D)**2)\\n snrABCD_b /= ((A-C).std()**2+ (B-D).std()**2)\\n #plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n # snrABCD_b, color='r', alpha=0.5, linestyle='dashed') \\n \\n # -- SNR levels:\\n #plt.hlines([self.getKeyword('INS OPDC OPEN'),\\n # self.getKeyword('INS OPDC CLOSE'),\\n # self.getKeyword('INS OPDC DETECTION')],\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\\n # color=(1.0, 0.5, 0.0))\\n #plt.hlines([self.getKeyword('INS DOPDC OPEN'),\\n # self.getKeyword('INS DOPDC CLOSE'),\\n # self.getKeyword('INS DOPDC DETECTION')],\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\\n # color=(0.0, 0.5, 1.0))\\n # -- plot thresholds\\n plt.ylabel('SNR')\\n plt.xlim(0)\\n \\n if self.getKeyword('OCS DET IMGNAME')=='PACMAN_OBJ_ASTRO_':\\n # == dual FTK\\n plt.subplot(n+16, sharex=ax1)\\n plt.ylabel('PRIMET ($\\\\mu$m)')\\n #met = interp1d(np.float_(self.raw['METROLOGY_DATA'].\\\\\\n # data.field('TIME')),\\\\\\n # self.raw['METROLOGY_DATA'].data.field('DELTAL'),\\\\\\n # kind = 'linear', bounds_error=False, fill_value=0.0)\\n met = lambda x: np.interp(x,\\n np.float_(self.raw['METROLOGY_DATA'].data.field('TIME')),\\n self.raw['METROLOGY_DATA'].data.field('DELTAL'))\\n metro = met(self.raw['DOPDC'].data.field('TIME'))*1e6\\n n_ = min(len(self.raw['DOPDC'].data.field('TIME')),\\n len(self.raw['OPDC'].data.field('TIME')))\\n\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n metro, color=(0.5,0.5,0.), label='A-B')\\n\\n w1 = np.where((self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'OPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\\n except:\\n print 'OPDC FTK stat: 0%'\\n\\n w1 = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'DOPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\\n except:\\n print 'DOPDC FTK stat: 0%'\\n\\n w = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'DUAL FTK stat:', round(100*len(w[0])/float(n_),1), '%'\\n except:\\n print 'DUAL FTK stat: 0%'\\n\\n plt.xlim(0)\\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\\n metro[w], '.g', linewidth=2,\\n alpha=0.5, label='dual FTK')\\n #plt.legend()\\n if len(w[0])>10 and False:\\n coef = np.polyfit(self.raw['DOPDC'].data.field('TIME')[w],\\n metro[w], 2)\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n np.polyval(coef, self.raw['DOPDC'].\\n data.field('TIME')),\\n color='g')\\n plt.ylabel('metrology')\\n\\n print 'PRIMET drift (polyfit) :', 1e6*coef[1], 'um/s'\\n slope, rms, synth = NoisySlope(self.raw['DOPDC'].\\n data.field('TIME')[w],\\n metro[w], 3e6)\\n plt.figure(10)\\n yl = plt.ylim()\\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\\n synth, color='r')\\n plt.ylim(yl)\\n print 'PRIMET drift (NoisySlope):',\\\\\\n slope*1e6,'+/-', rms*1e6, 'um/s'\\n else:\\n # == scanning\\n plt.subplot(n+16, sharex=ax1)\\n fringesOPDC = \\\\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA1')[:,0]-\\\\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA3')[:,0]\\n \\n fringesDOPDC =\\\\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA1')[:,0]-\\\\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA3')[:,0]\\n \\n plt.plot(self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('TIME'),\\n scipy.signal.wiener(fringesOPDC/fringesOPDC.std()),\\n color=(1.0, 0.5, 0.0), alpha=0.6,\\n label=self.primary_fsu+'/OPDC')\\n plt.plot(self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('TIME'),\\n scipy.signal.wiener(fringesDOPDC/fringesDOPDC.std()),\\n color=(0.0, 0.5, 1.0), alpha=0.6,\\n label=self.secondary_fsu+'/DOPDC')\\n plt.legend(prop={'size':9})\\n plt.ylabel('A-C')\\n plt.xlabel('time stamp ($\\\\mu$s)')\\n return\",\n \"def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\\n if axdelta is None:\\n axdelta = plt.gca()\\n delta = self.means - exact\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\\n if blocked:\\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\\n if blockederr:\\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\\n axdelta.set_xlabel('Number of determinants in estimator')\\n axdelta.set_ylabel(r'$E-E_\\\\mathrm{CCSD}$ / ha')\\n axdelta.legend()\\n return axdelta\",\n \"def energy_kde_paperplot(fields,df):\\n plt.figure()\\n i = 0\\n colorList = ['dodgerblue','tomato']\\n lw = 2\\n\\n meanE_2 = []\\n meanE_3 = []\\n mup = np.min(df['energy [eV]']) - pp.mu\\n chi_0 = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(fields[0]))\\n g_en_axis, _, _, _, _, _, _, _, _, _, _, _, _, _ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_0, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), np.zeros(len(g_en_axis)), '-', color='black', lineWidth=lw,label='Equilibrium')\\n\\n for ee in fields:\\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n # meanE_2 = utilities.mean_energy(chi_2_i,df)\\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_2_i, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,'--',color = colorList[i],lineWidth=lw,label=r'Low Field {:.0f} '.format(ee/100)+r'$V \\\\, cm^{-1}$')\\n print(integrate.trapz(g_chiax,g_en_axis))\\n\\n # plt.plot(meanE_2-np.min(df['energy [eV]']),0,'.')\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_3_i, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,color = colorList[i],lineWidth=lw,label=r'Full Drift {:.0f} '.format(ee/100)+r'$V \\\\, cm^{-1}$')\\n print(integrate.trapz(g_chiax,g_en_axis))\\n\\n i = i + 1\\n # plt.plot(g_en_axis - np.min(df['energy [eV]']), g_f0ax, '--', color='black', lineWidth=lw,label=r'$f_0$')\\n\\n plt.legend()\\n # plt.ylim([-0.02, 0.015])\\n plt.xlabel(r'Energy above CBM ($eV$)')\\n plt.ylabel(r'Deviational occupation $\\\\delta f_{\\\\mathbf{k}}$ (norm.)')\\n # plt.ylabel(r'$\\\\delta f_{\\\\mathbf{k}}/f_{\\\\mathbf{k}}^0$')\\n plt.savefig(pp.figureLoc+'energy_KDE.png', bbox_inches='tight',dpi=600)\\n\\n plt.figure()\\n plt.plot(g_en_axis,g_chiax)\\n\\n plt.figure()\\n Z, xedges, yedges = np.histogram2d(df['kx [1/A]']*chi_3_i,df['ky [1/A]']*chi_3_i)\\n plt.pcolormesh(xedges, yedges, Z.T)\\n\\n from scipy.stats.kde import gaussian_kde\\n g_inds,_,_ = utilities.gaas_split_valleys(df,False)\\n g_df = df.loc[g_inds]\\n\\n x = g_df['kx [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n y = g_df['ky [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n\\n # y = g_df['energy [eV]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n k = gaussian_kde(np.vstack([x, y]))\\n xi, yi = np.mgrid[x.min():x.max():x.size ** 0.5 * 1j, y.min():y.max():y.size ** 0.5 * 1j]\\n zi = k(np.vstack([xi.flatten(), yi.flatten()]))\\n\\n fig = plt.figure(figsize=(7, 8))\\n ax1 = fig.add_subplot(211)\\n ax2 = fig.add_subplot(212)\\n\\n # alpha=0.5 will make the plots semitransparent\\n ax1.pcolormesh(xi, yi, zi.reshape(xi.shape), alpha=0.5)\\n ax2.contourf(xi, yi, zi.reshape(xi.shape), alpha=0.5)\\n\\n ax1.set_xlim(x.min(), x.max())\\n ax1.set_ylim(y.min(), y.max())\\n ax2.set_xlim(x.min(), x.max())\\n ax2.set_ylim(y.min(), y.max())\",\n \"def plot_2nd(self, mod = 'F'):\\n if not mpl: raise \\\"Problem with matplotib: Plotting not possible.\\\"\\n f = plt.figure(figsize=(5,4), dpi=100)\\n \\n A2 = []\\n \\n strainList= self.__structures.items()[0][1].strainList\\n \\n if len(strainList)<=5:\\n kk=1\\n ll=len(strainList)\\n grid=[ll]\\n elif len(strainList)%5 == 0:\\n kk=len(strainList)/5\\n ll=5\\n grid=[5 for i in range(kk)]\\n else:\\n kk=len(strainList)/5+1\\n ll=5\\n grid=[5 for i in range(kk)]\\n grid[-1]=len(strainList)%5\\n \\n \\n n=1\\n m=1\\n for stype in strainList:\\n atoms = self.get_atomsByStraintype(stype)\\n self.__V0 = atoms[0].V0\\n strainList = atoms[0].strainList\\n if self.__thermodyn and mod == 'F':\\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\\n elif self.__thermodyn and mod=='E0':\\n energy = [i.gsenergy for i in atoms]\\n elif self.__thermodyn and mod=='Fvib':\\n energy = [i.phenergy[-1] for i in atoms]\\n else:\\n energy = [i.gsenergy for i in atoms]\\n \\n strain = [i.eta for i in atoms]\\n \\n spl = '1'+str(len(strainList))+str(n)\\n #plt.subplot(int(spl))\\n #a = f.add_subplot(int(spl))\\n if (n-1)%5==0: m=0\\n \\n \\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\\n #print (kk,ll), ((n-1)/5,m)\\n j = 0\\n for i in [2,4,6]:\\n ans = Energy()\\n ans.energy = energy\\n ans.strain = strain\\n ans.V0 = self.__V0\\n \\n fitorder = i\\n ans.set_2nd(fitorder)\\n A2.append(ans.get_2nd())\\n \\n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\\n \\n try:\\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\\n except:\\n continue\\n a.plot(strains, dE, label=str(fitorder))\\n a.set_title(stype)\\n a.set_xlabel('strain')\\n a.set_ylabel(r'$\\\\frac{d^2E}{d\\\\epsilon^2}$ in eV')\\n \\n j+=1\\n \\n n+=1\\n m+=1\\n \\n a.legend(title='Order of fit')\\n return f\",\n \"def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\\n other_program_name, **kw):\\n\\n #plot absolute error\\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\\n pan['absolute-difference'][field].values,\\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\\n ax_abs.set_ylabel('Absolute Difference ' + unit)\\n #plot percentage error\\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\\n pan['percent-difference'][field].values,\\n color='firebrick', zorder=-1)\\n ax_per.set_ylabel('Percent Difference', color='firebrick')\\n #set error axes legend\\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\\n #ax_per.get_legend().set_zorder(1)\\n #plot full results profiles\\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\\n color=_colormap[1])[0],\\n ax_mag.plot(pan['emf.fields-results'][field],\\n color=_colormap[0])[0]]\\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\\n ax_mag.set_xlabel('Distance (ft)')\",\n \"def plot_diff(self, ax, d0, d1):\\n i1 = 0\\n for i0 in range(d0.shape[0]):\\n try:\\n while d0[i0,0] > d1[i1,0]:\\n print((d0[i0,0], d1[i1,0]))\\n i1 += 1\\n except IndexError:\\n break\\n if d0[i0,0] == d1[i1,0]:\\n break\\n assert d0[i0,0] == d1[i1,0]\\n i0s = i0\\n d0s = 0\\n d1s = 0\\n dt = []\\n dd = []\\n for i0 in range(i0s, d0.shape[0]):\\n d0s += d0[i0,1]\\n try:\\n d1s += d1[i1,1]\\n assert d0[i0,0] == d1[i1,0]\\n except IndexError:\\n pass\\n dt.append(d0[i0,0])\\n dd.append(d0s - d1s)\\n i1 += 1\\n while i1 < d1.shape[0]:\\n d1s += d1[i1,1]\\n dt.append(d0[i0,0])\\n dd.append(d0s - d1s)\\n i1 += 1\\n dd = np.array(dd)\\n dd -= dd[-1]\\n i = 0\\n if self.start is not None:\\n while dt[i] < self.start:\\n i += 1\\n ax.plot_date(dt[i:], dd[i:], fmt='-', color='yellow')\",\n \"def plotDihedralEnergy(self, phys, forces, step): \\r\\n self.plotQuantity(step, phys.app.energies.getTable(4), 'dihedralenergy')\",\n \"def plot_all(self):\\n self.plot_ramps()\\n self.plot_groupdq()\",\n \"def plot_grating_coupler_sweep_efficiency(matlab_file_path, function=log):\\n d = loadmat(matlab_file_path)\\n print(d.keys())\\n\\n N = len(d[\\\"M_sweep\\\"][0])\\n parameter = np.zeros(N)\\n efficiency = np.zeros(N)\\n\\n for i in range(N):\\n parameter[i] = 1e9 * d[\\\"M_sweep\\\"][0][i]\\n # x = d[\\\"WL\\\"][0] * 1e9\\n y = function(d[\\\"M_T\\\"][i])\\n efficiency[i] = np.max(y)\\n\\n plt.figure()\\n plt.xlabel(\\\"waveguide height (nm)\\\")\\n plt.ylabel(\\\"Eficiency (dB)\\\")\\n plt.plot(parameter, efficiency, \\\".\\\")\\n plt.legend()\",\n \"def show_dcr_results(dg):\\n cycle = dg.fileDB['cycle'].values[0]\\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\\n # print(df_dsp.describe()) \\n\\n # compare DCR and A/E distributions\\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\\n \\n elo, ehi, epb = 0, 25000, 100\\n \\n # aoe distribution\\n # ylo, yhi, ypb = -1, 2, 0.1\\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p0.set_ylabel('A/E', ha='right', y=1)\\n\\n # dcr distribution\\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\\n # ylo, yhi, ypb = -3, 2, 0.1\\n ylo, yhi, ypb = 0.9, 1.08, 0.001\\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p1.set_ylabel('DCR', ha='right', y=1)\\n \\n # plt.show()\\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\\n plt.cla()\",\n \"def distance_plot():\\n day = \\\"20131210\\\"\\n file = \\\"Data/matfiles/\\\" + day + \\\".mat\\\"\\n object = MatReader(file)\\n\\n\\n\\n # ind1 = 2606\\n # ind2 = 13940 + 1*7000\\n\\n ind1 = 0\\n ind2 = 150000\\n\\n times = object.secondsB[ind1:ind2]\\n\\n xA = object.latA[ind1:ind2]\\n yA = object.longA[ind1:ind2]\\n zA = object.radA[ind1:ind2]\\n\\n xB = object.latB[ind1:ind2]\\n yB = object.longB[ind1:ind2]\\n zB = object.radB[ind1:ind2]\\n\\n xC = object.latC[ind1:ind2]\\n yC = object.longC[ind1:ind2]\\n zC = object.radC[ind1:ind2]\\n\\n mltA = object.mltA[ind1:ind2]\\n mltB = object.mltB[ind1:ind2]\\n\\n\\n dist_BA = object.great_circle_distance(xB, yB, zB, xA, yA, zA)\\n dist_BC = object.great_circle_distance(xB, yB, zB, xC, yC, zC)\\n dist_AC = object.great_circle_distance(xA, yA, zA, xC, yC, zC)\\n\\n\\n plt.figure(0)\\n plt.plot(times, dist_BA)\\n plt.plot(times, dist_BC)\\n plt.plot(times, dist_AC)\\n plt.title(\\\"Distance over time\\\")\\n plt.xlabel(\\\"Seconds since midnight UTC of sat B\\\")\\n plt.ylabel(\\\"Distance [m]\\\")\\n plt.legend([\\\"B - A\\\", \\\"B - C\\\", \\\"A - C\\\"])\\n plt.grid(\\\"on\\\")\\n # plt.savefig(\\\"Figures/matfigs/distance_over_time_\\\" + day + \\\".pdf\\\")\\n plt.figure(1)\\n\\n plt.plot(times, xB - xA)\\n plt.plot(times, xB - xC)\\n plt.title(\\\"difference in latitude\\\")\\n plt.xlabel(\\\"time of sat B [s]\\\")\\n plt.ylabel(\\\"difference in latitude [degrees]\\\")\\n plt.legend([\\\"B - A\\\", \\\"B - C\\\"])\\n\\n plt.figure(2)\\n\\n plt.plot(times, yB - yA)\\n plt.plot(times, yB - yC)\\n #plt.axis([0, 7000, -10, 10])\\n plt.title(\\\"difference in longitude\\\")\\n plt.xlabel(\\\"time of sat B [s]\\\")\\n plt.ylabel(\\\"difference in latitude [degrees]\\\")\\n plt.legend([\\\"B - A\\\", \\\"B - C\\\"])\\n plt.show()\\n\\n # plt.plot(times, zB - zA)\\n # plt.plot(times, zB - zC)\\n # plt.title(\\\"Difference in altitude\\\")\\n # plt.xlabel(\\\"time of sat B [s]\\\")\\n # plt.ylabel(\\\"difference in altitude [m]\\\")\\n # plt.legend([\\\"B - A\\\", \\\"B - C\\\"])\\n # plt.show()\\n\\n plt.plot(xB, dist_BA)\\n plt.plot(xB, dist_BC)\\n plt.plot(xB, dist_AC)\\n plt.xlabel(\\\"Latitude [Degrees]\\\")\\n plt.ylabel(\\\"Distance [m]\\\")\\n plt.title(\\\"Distance over latitude\\\")\\n plt.grid(\\\"on\\\")\\n plt.legend([\\\"B - A\\\", \\\"B - C\\\", \\\"A - C\\\"])\\n plt.xticks([-90, -77, -70, -30, 0, 30, 70, 77, 90])\\n plt.savefig(\\\"Figures/matfigs/distance_over_latitude_\\\" + day + \\\".pdf\\\")\\n plt.show()\\n\\n mltdiff = mltA - mltB\\n\\n for i in range(len(mltdiff)):\\n if mltdiff[i] > 24:\\n mltdiff[i] = mltdiff[i] - 24\\n elif mltdiff[i] < -24:\\n mltdiff[i] = mltdiff[i] + 24\\n\\n\\n print(\\\"mean distance B-A = %g m\\\" % np.mean(dist_BA))\\n print(\\\"mean distance B-C = %g m\\\" % np.mean(dist_BC))\\n\\n print(\\\"velocity times timediff BA = %g\\\" % (object.BA_shift/2*np.mean(object.velA)))\\n print(\\\"velocity times timediff BC = %g\\\" % (object.BC_shift/2*np.mean(object.velC)))\\n print(np.min(dist_BA))\\n print(object.BA_shift)\\n print(object.BC_shift - object.BA_shift)\\n print(np.mean(object.velA))\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\\n\\n figure = plt.figure()\\n figure.subplots_adjust(top=0.76)\\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\\n\\n functionGraph = figure.add_subplot(311)\\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\\n functionGraph.set_xlabel('X-values')\\n functionGraph.set_ylabel('Y-values')\\n\\n errorGraph = figure.add_subplot(313)\\n errorGraph.set_title('Truncation errors', fontsize=15)\\n errorGraph.set_xlabel('X-values')\\n errorGraph.set_ylabel('Error-values')\\n\\n if EU == True:\\n euler = EulerMethod(self._IVP)\\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\\n\\n if IEM == True:\\n improvedEuler = ImprovedEulerMethod(self._IVP)\\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\\n \\n if RK == True:\\n rungeKutta = RungeKutta(self._IVP)\\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\\n\\n if ES == True:\\n exactSolution = AnalyticalSolution(self._IVP)\\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\\n \\n functionGraph.legend(loc='lower right')\\n errorGraph.legend(loc='lower right')\\n\\n return figure\",\n \"def plot_compartments(self, compartments, show=True, save_path=None, names=None):\\n print 'Copying voltages and recovery variables for debugging...'\\n # Note if they have already been copied then the following functions won't\\n # do a copy\\n v = self.get_voltages()\\n\\n # Check for infinities\\n x, y = np.where(np.isinf(np.array(v)))\\n print \\\"Bad compartments found \\\", y\\n _, naning = np.where(np.isnan(np.array(v)))\\n print \\\"Nans found:\\\", naning\\n # If none found, yay and set tmax to whole range\\n if len(x) == 0:\\n t_max = v.shape[0]\\n else:\\n t_max = x[0] - 1\\n print \\\"Voltage shape\\\", v.shape\\n\\n m, n, h = self.get_recovery_variables()\\n f, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, sharex=True)\\n neighbours = self.neuron_collection.get_neighbour_idx(compartments[1])\\n\\n ax1.set_title('Compartments ' + str(compartments))\\n ax1.set_ylabel('Voltage /mV')\\n ax2.set_ylabel('m')\\n ax3.set_ylabel('n')\\n ax4.set_ylabel('h')\\n ax4.set_xlabel('Step')\\n ax5.axis('off')\\n for index, i in enumerate(np.append(compartments, neighbours)):\\n\\n p_v = v[:t_max, i]\\n p_m = m[:t_max, i]\\n p_n = n[:t_max, i]\\n p_h = h[:t_max, i]\\n\\n if index < len(names):\\n label = names[index]\\n else:\\n label = \\\"c_idx:\\\" + str(i)\\n\\n ax1.plot(p_v, label=label)\\n ax2.plot(p_m, label=label)\\n ax3.plot(p_n, label=label)\\n ax4.plot(p_h, label=label)\\n ax1.set_ylim(-50, 200)\\n ax2.set_ylim(0, 1)\\n ax3.set_ylim(0, 1)\\n ax4.set_ylim(0, 1)\\n\\n handles, labels = ax1.get_legend_handles_labels()\\n f.legend(handles, labels, loc='lower center', ncol=3, borderaxespad=2)\\n\\n if save_path is not None:\\n #fig.tight_layout()\\n plt.savefig(save_path)\\n print \\\"Saved figure to \\\" + save_path\\n if show:\\n plt.show()\\n if not show:\\n plt.clf()\",\n \"def task_2():\\n\\n # To store the list of speeds to plot\\n list_of_speeds = []\\n list_of_times = []\\n list_of_time_difference = [0]\\n\\n # To go from 1 through 80\\n for i in range(LOW_SPEED, HIGH_SPEED + 1, 5):\\n list_of_speeds.append(i)\\n list_of_times.append(((DISTANCE / i) * 60))\\n\\n for i in range(1, len(list_of_times)):\\n list_of_time_difference.append(list_of_times[i-1] - list_of_times[i])\\n\\n plt.plot(list_of_speeds, list_of_time_difference)\\n plt.xlabel(\\\"Speed (in mph)\\\")\\n plt.ylabel(\\\"Time saved (in minutes)\\\")\\n plt.show()\",\n \"def compute_visuals(self):\\n pass\",\n \"def figure_1():\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n\\n # Draw common plots\\n print(exp_list)\\n data = get_data(exp_list[0])\\n plt.figure(num=\\\"state 1\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"cmd\\\"],\\n **FORMATTING[\\\"command\\\"]\\n )\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 0],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_1$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"state 2\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 1],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_2$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.ylabel(r\\\"$u$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n def general_figures(exp):\\n data = get_data(exp)\\n plt.figure(num=\\\"state 1\\\")\\n ax = plt.gca()\\n ax.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"control\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"control\\\"],\\n **FORMATTING[exp],\\n )\\n\\n for exp in exp_list:\\n general_figures(exp)\\n\\n # Estimation error\\n for exp in exp_list:\\n data = get_data(exp)\\n error = nla.norm(\\n data[\\\"state\\\"][\\\"adaptive_system\\\"] - data[\\\"real_param\\\"],\\n axis=1\\n )\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.plot(data[\\\"time\\\"], error, **FORMATTING[exp])\\n plt.xlabel(\\\"Time, sec\\\")\\n plt.ylabel(\\\"Error norm\\\")\\n\\n # Real parameter\\n data = get_data(exp_list[0])\\n plt.plot(data[\\\"time\\\"], data[\\\"real_param\\\"].squeeze())\\n\\n\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n def eig_figures(exp, minmax):\\n data = get_data(exp)\\n if minmax == \\\"min\\\":\\n eig = np.min(data[\\\"eigs\\\"], axis=1)\\n elif minmax == \\\"max\\\":\\n eig = np.max(data[\\\"eigs\\\"], axis=1)\\n plt.plot(data[\\\"time\\\"], eig, **FORMATTING[exp])\\n\\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\\\"Eigenvalues\\\", sharex=True)\\n\\n plt.subplot(211)\\n plt.ticklabel_format(style=\\\"sci\\\", scilimits=(0, 0), useOffset=True)\\n for exp in exp_list:\\n eig_figures(exp, \\\"min\\\")\\n plt.ylabel(r\\\"Minimum $\\\\lambda$\\\")\\n plt.legend()\\n\\n plt.subplot(212)\\n for exp in exp_list:\\n eig_figures(exp, \\\"max\\\")\\n plt.ylabel(r\\\"Maximum $\\\\lambda$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n # Saving\\n def savefig(name):\\n path = os.path.join(args.save_dir, name + \\\".\\\" + args.save_ext)\\n plt.savefig(path, bbox_inches=\\\"tight\\\")\\n\\n plt.figure(num=\\\"state 1\\\")\\n plt.legend()\\n savefig(\\\"state-1\\\")\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.legend()\\n savefig(\\\"state-2\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.legend()\\n savefig(\\\"control\\\")\\n\\n plt.figure(num=\\\"Eigenvalues\\\")\\n savefig(\\\"eigs\\\")\\n\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.legend()\\n savefig(\\\"estim-error\\\")\\n\\n plt.show()\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def plot_energy(self, color=['r','g','b','c','m','y','k'], mod = 'E0'):\\n if not mpl: raise \\\"Problem with matplotib: Plotting not possible.\\\"\\n f = plt.figure(figsize=(5,4), dpi=100)\\n a = f.add_subplot(111)\\n strainList= self.__structures.items()[0][1].strainList\\n \\n if len(strainList)<=5:\\n kk=1\\n ll=len(strainList)\\n grid=[ll]\\n elif len(strainList)%5 == 0:\\n kk=len(strainList)/5\\n ll=5\\n grid=[5 for i in range(kk)]\\n else:\\n kk=len(strainList)/5+1\\n ll=5\\n grid=[5 for i in range(kk)]\\n grid[-1]=len(strainList)%5\\n \\n \\n n=1\\n m=1\\n j=0\\n for stype in strainList:\\n \\n spl = '1'+str(len(strainList))+str(n)\\n if (n-1)%5==0: m=0\\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\\n \\n \\n \\n fi=open(stype+'.energy','w')\\n \\n #self.search_for_failed()\\n atoms = self.get_atomsByStraintype(stype)\\n if self.__thermodyn and mod=='F':\\n energy = [i.gsenergy+i.phenergy[100] for i in atoms]\\n elif self.__thermodyn and mod=='E0':\\n energy = [i.gsenergy for i in atoms]\\n elif self.__thermodyn and mod=='Fvib':\\n energy = [i.phenergy[100] for i in atoms]\\n else:\\n energy = [i.gsenergy for i in atoms]\\n strain = [i.eta for i in atoms]\\n \\n ii=0\\n for (e,s) in zip(energy,strain):\\n if e==0.: \\n energy.pop(ii); strain.pop(ii)\\n ii-=1\\n ii+=1\\n #print stype, energy, [i.scale for i in atoms]\\n plt.plot(strain, energy, '%s*'%color[j%7])\\n \\n k=0\\n for st in strain:\\n fi.write('%s %s \\\\n'%(st,energy[k]))\\n k+=1\\n fi.close()\\n \\n poly = np.poly1d(np.polyfit(strain,energy,self.__fitorder[j]))\\n xp = np.linspace(min(strain), max(strain), 100)\\n a.plot(xp, poly(xp),color[j%7],label=stype)\\n \\n a.set_title(stype)\\n \\n j+=1\\n \\n n+=1\\n m+=1\\n \\n a.set_xlabel('strain')\\n a.set_ylabel(r'energy in eV')\\n #a.legend(title='Strain type:')\\n \\n return f\",\n \"def show():\\n\\tplt.show()\",\n \"def bodePlot(H_s,w_range=(0,8),points=800):\\n \\n w = logspace(*w_range,points)\\n h_s = lambdify(s,H_s,'numpy')\\n H_jw = h_s(1j*w)\\n \\n # find mag and phase\\n mag = 20*np.log10(np.abs(H_jw))\\n phase = angle(H_jw,deg = True)\\n \\n eqn = Eq(H,simplify(H_s))\\n display(eqn)\\n \\n fig,axes = plt.subplots(1,2,figsize=(18,6))\\n ax1,ax2 = axes[0],axes[1]\\n \\n # mag plot\\n ax1.set_xscale('log')\\n ax1.set_ylabel('Magntiude in dB')\\n ax1.set_xlabel('$\\\\omega$ in rad/s')\\n ax1.plot(w,mag)\\n ax1.grid()\\n ax1.set_title(\\\"Magnitude of $H(j \\\\omega)$\\\")\\n \\n # phase plot\\n ax2.set_ylabel('Phase in degrees')\\n ax2.set_xlabel('$\\\\omega$ in rad/s')\\n ax2.set_xscale('log')\\n ax2.plot(w,phase)\\n ax2.grid()\\n ax2.set_title(\\\"Phase of $H(j \\\\omega)$\\\")\\n \\n plt.show()\",\n \"def Compare(self,step,steps,saving=True):\\n\\t\\tplt.ioff()\\n\\t\\tplt.figure()\\n\\t\\tplt.plot(np.arange(1,5),self.expected,'o-',color='black',label\\\\\\n\\t\\t\\t='expected')\\n\\t\\tplt.plot(np.arange(1,5),np.divide(self.states,np.sum(self.states))\\\\\\n\\t\\t\\t,'o-',color='green',label='actual')\\n\\t\\tplt.legend()\\n\\t\\tplt.title('Expected vs Actual Atom Distribution at State ' + str(step))\\n\\t\\tplt.xlabel('n (principle quantum number)')\\n\\t\\tplt.ylabel('Fraction of Atoms')\\n\\t\\tplt.ylim(0,1)\\n\\t\\tplt.xlim(1,4)\\n\\t\\tif saving:\\n\\t\\t\\tself.files.append('temp_' + str(step+steps*100)+'.png')\\n\\t\\t\\tplt.savefig('temp_' + str(step+steps*100) + '.png')\\n\\t\\tplt.close()\",\n \"def plot_error_versus_x_compare(num_sites, num_solutes, column_name, barriers, methods):\\n errors, column = get_errors_n_column(num_sites, num_solutes, column_name)\\n print errors\\n print column\\n print len(errors['svd'][0]), len(column)\\n fig = plt.figure()\\n axis = fig.add_subplot(111)\\n for barrier in barriers:\\n for i, method in enumerate(methods):\\n axis.scatter(column, errors[method][barrier],\\n label=\\\"{0} over barrier {1}\\\".format(method, barrier), s=5,\\n color=COLOR_MAP[i])\\n axis.set_ylim([10 ** -20, 10 ** 14])\\n axis.set_xscale('log')\\n axis.set_yscale('log')\\n plt.legend()\\n plt.show()\",\n \"def vanderpol_dymos_plots(p):\\n\\n # check validity by using scipy.integrate.solve_ivp to integrate the solution\\n sim_out = p.model.traj.simulate()\\n\\n # plots\\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 9))\\n\\n # state variable x1\\n axes[0, 0].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.states:x1'),\\n 'ro', label='solution')\\n\\n axes[0, 0].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\\n 'b-', label='simulation')\\n\\n axes[0, 0].set_xlabel('time (s)')\\n axes[0, 0].set_ylabel('x1 (V)')\\n axes[0, 0].legend()\\n axes[0, 0].grid()\\n\\n # state variable x0\\n axes[0, 1].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.states:x0'),\\n 'ro', label='solution')\\n\\n axes[0, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.states:x0'),\\n 'b-', label='simulation')\\n\\n axes[0, 1].set_xlabel('time (s)')\\n axes[0, 1].set_ylabel('x0 (V/s)')\\n axes[0, 1].legend()\\n axes[0, 1].grid()\\n\\n # state variable x1 vs x0\\n axes[1, 0].plot(p.get_val('traj.phase0.timeseries.states:x0'),\\n p.get_val('traj.phase0.timeseries.states:x1'),\\n 'ro', label='solution')\\n\\n axes[1, 0].plot(sim_out.get_val('traj.phase0.timeseries.states:x0'),\\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\\n 'b-', label='simulation')\\n\\n axes[1, 0].set_xlabel('x0 (V/s)')\\n axes[1, 0].set_ylabel('x1 (V)')\\n axes[1, 0].legend()\\n axes[1, 0].grid()\\n\\n # control variable u\\n axes[1, 1].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.controls:u'),\\n 'ro', label='solution')\\n\\n axes[1, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.controls:u'),\\n 'b-', label='simulation')\\n\\n axes[1, 1].set_xlabel('time (s)')\\n axes[1, 1].set_ylabel('control u')\\n axes[1, 1].legend()\\n axes[1, 1].grid()\\n\\n plt.show()\",\n \"def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):\\n if self.interactive:\\n display.clear_output(wait=True) \\n \\n pred_2plot = pred_.detach().to(\\\"cpu\\\")\\n if not self.ODE_order:\\n validate_y_2plot = validate_y.detach().to(\\\"cpu\\\")\\n try:\\n self.ax[1].clear()\\n self.ax[0].clear()\\n except:\\n pass\\n\\n \\n\\n labels = \\\"best value\\\", \\\"all samples\\\"\\n #log2 = np.log(2)\\n\\n # Plot 1: the training history of the bayesian optimization\\n # if not self.log_score:\\n # self.ax[0].plot(np.log(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n # self.ax[0].plot(np.log(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n # else:\\n font_dict = {\\\"prop\\\" : {\\\"size\\\":14}}\\n ticks_font_size = 14\\n\\n self.ax[0].plot(10**np.array(self.errorz_step), alpha = 0.5, color = \\\"blue\\\", label = labels[0] )\\n self.ax[0].plot(10**np.array(self.errorz), alpha = 0.2, color = \\\"green\\\", label = labels[1])\\n #self.ax[0].set_title(\\\"log(error) vs Thompson Sampling step\\\")\\n self.ax[0].set_ylabel(f\\\"log({self.scoring_method})\\\")\\n self.ax[0].set_xlabel(\\\"BO step\\\")\\n self.ax[0].set_ylabel(\\\"Error\\\")\\n self.ax[0].legend(**font_dict)\\n self.ax[0].set_yscale(\\\"log\\\")\\n #self.ax[0].set_ylim(10**-8,1)\\n # self.ax[0].set_xtickslabels(fontsize= ticks_font_size )\\n # self.ax[0].set_ytickslabels(fontsize= ticks_font_size )\\n \\n #plot 2: the turbo state #plot 2: the turbo state\\n self.ax[1].axhline(np.log(self.state.length_max)/self.log2, color = 'green', label = 'max length')\\n self.ax[1].set_title(\\\"TURBO state\\\")\\n self.ax[1].plot(np.log(self.length_progress)/self.log2, color = 'blue', label = 'current length')\\n self.ax[1].axhline(np.log(self.state.length_min)/self.log2, color = 'red', label = 'target length')\\n self.ax[1].legend() \\n\\n #plot 3 (most recent prediction)\\n self.ax[2].clear()\\n if not self.ODE_order:\\n self.ax[2].plot(validate_y_2plot.to(\\\"cpu\\\"), alpha = 0.5, color = \\\"blue\\\", label = \\\"val set\\\") #[:steps_displayed]\\n self.ax[2].set_ylim(self.y.min().item() - 0.1, self.y.max().item() )\\n self.ax[2].plot(pred_2plot[:steps_displayed], alpha = 0.3, color = \\\"red\\\", label = \\\"latest pred\\\")\\n \\n self.ax[2].set_title(\\\"Val Set Prediction\\\")\\n self.ax[2].set_ylabel(\\\"y\\\")\\n self.ax[2].set_xlabel(r'$t$')\\n\\n pl.legend()\\n pl.tight_layout()\\n\\n display.display(pl.gcf())\\n\\n #clear the plot outputt and then re-plot\",\n \"def demo_SIR():\\r\\n\\tdef f(u,t):\\r\\n\\t\\tS, I, R = u # takes u and stores to respective variable arrays\\r\\n\\t\\treturn [-beta*S*I, beta*S*I - gamma*I, gamma*I]\\r\\n\\r\\n\\tbeta = 10./(40*8*24)\\r\\n\\tgamma = 3./(15*24)\\r\\n\\tdt = 0.1\\r\\n\\tD = 30\\r\\n\\tN_t = int(D*24/dt)\\r\\n\\tT = dt *N_t\\r\\n\\tU_0 = [50, 1, 0]\\r\\n\\r\\n\\tu, t = ode_FE(f, U_0, dt, T)\\r\\n#\\tprint(u,t)\\r\\n#\\tprint(len(u))\\r\\n\\r\\n\\tS = u[:,0]\\r\\n\\tI = u[:,1]\\r\\n\\tR = u[:,2]\\r\\n\\r\\n\\tfig = plt.figure()\\r\\n\\tl1, l2, l3 = plt.plot(t, S, t, I, t, R)\\r\\n\\tfig.legend((l1, l2, l3), ('S', 'I', 'R'), 'lower right')\\r\\n\\tplt.xlabel('hours')\\r\\n\\tplt.show()\\r\\n\\r\\n\\t# Consistency check:\\r\\n\\tN = S[0] + I[0] + R[0]\\r\\n\\teps = 1E-12 # Tolerance for comparing real numbers\\r\\n\\tfor n in range(len(S)):\\r\\n\\t\\tSIR_sum = S[n] + I[n] + R[n]\\r\\n\\t\\tif abs(SIR_sum - N) > eps:\\r\\n\\t\\t\\tprint('*** consistency check failes : S+I+R=%g != %g' %(SIR_sum, N))\",\n \"def plot(self):\\n pass\",\n \"def plot_results(delaytype):\\n \\n if delaytype == 'Polynomial':\\n # results for ind_obs=graph.indlinks.keys()\\n tolls_collected1 = [[164.76921455176952, 690.919364787199, 1003.9715271443032], [164.76920846294715, 690.9196375266908, 1003.971503332828]]\\n so_costs1 = [[1952.813985915695, 2991.422528084584, 4716.77478205995], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs1 = [[1961.4088544768533, 3035.621746689017, 4751.282035585294], [1961.4088092322784, 3035.619283467948, 4751.282202058287]]\\n ue_costs1 = [[1993.9477013089333, 3087.4591784440836, 4889.555908205202], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected2 = [[165.05685117271955, 354.1634370314711, 1015.9141858070569], [165.0567022829941, 354.1917223859498, 1015.9119098321756]]\\n so_costs2 = [[1952.4102665477528, 2990.2968764530697, 4714.092736177128], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs2 = [[1961.0182151023969, 3019.353015234613, 4750.051821659878], [1961.4090940730164, 3020.4668352547183, 4752.675436210774]]\\n ue_costs2 = [[1993.5324364880598, 3086.401670312004, 4886.656461616093], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected3 = [[122.37203827953705, 369.5962596851687, 993.1260548913893], [124.00144138458633, 375.65796385498777, 1018.6147484597942]]\\n so_costs3 = [[1819.720988976306, 2777.3939885366685, 4677.595258102356], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs3 = [[1834.6351015726038, 2802.3016403566235, 4714.102145227426], [1965.8049083549738, 3020.126090534662, 4750.071391283308]]\\n ue_costs3 = [[1872.3492340077084, 2897.9834368843217, 4886.769726452165], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\\n tolls_collected4 = [[602.0313412901077, 596.7300601881633, 833.3678073460065], [609.094482012133, 542.8579545671112, 843.1817520139325]]\\n so_costs4 = [[13252.728980891832, 20178.927282098706, 28549.614451166774], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs4 = [[13254.342842900576, 20239.30287102026, 28549.614731411177], [1992.3969007442322, 3130.0522527298062, 4805.6728306302175]]\\n ue_costs4 = [[13259.433117552415, 20185.90937054816, 28556.779443740656], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n \\n if delaytype == 'Hyperbolic':\\n # results for ind_obs=graph.indlinks.keys() \\n tolls_collected1 = [[161.15742640370462, 416.80264009965265, 948.124688583883], [161.4013529462645, 417.25218843773354, 950.1674351402539]]\\n so_costs1 = [[2519.5329969919685, 3679.4257321044365, 5325.940489651684], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs1 = [[2525.7590340322095, 3679.4261220632625, 5356.8071818038225], [2551.0113714206195, 3718.3028736461647, 5412.310857035818]]\\n ue_costs1 = [[2548.8303153671195, 3736.67165067958, 5444.499035875823], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected2 = [[355.56391097372205, 701.3544774585599, 806.6640717434449], [374.34816990991186, 736.3763770517197, 842.0768966826593]]\\n so_costs2 = [[2174.1387842065237, 3306.974167934956, 4969.5560792612605], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs2 = [[2201.273656230071, 3338.7536674213156, 4988.732654672769], [2564.0153714222406, 3746.115605602468, 5398.046518880896]]\\n ue_costs2 = [[2209.622435372754, 3380.7186533697286, 5104.755602389524], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected3 = [[339.37838703976513, 737.9887571945254, 930.0531221139565], [353.28118085588176, 763.3708450755438, 955.644104623869]]\\n so_costs3 = [[2520.1983680076073, 3833.234908857907, 5645.320052639795], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs3 = [[2536.138622203524, 3862.614483834193, 5668.430527845267], [2562.897499637454, 3750.9322754235955, 5406.402328441233]]\\n ue_costs3 = [[2556.0266644367803, 3903.9758481975805, 5741.545038028959], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\\n tolls_collected4 = [[443.85669649193784, 837.5428841560781, 1380.117295219297], [479.57423528502, 931.2309202734045, 1499.6972922042573]]\\n so_costs4 = [[2158.995768390798, 3843.4202195503713, 7595.092411648515], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs4 = [[2192.900868595389, 3888.0172745668465, 7626.17585256234], [2575.5748442305207, 3755.844017718783, 5450.304046277645]]\\n ue_costs4 = [[2231.1674179937672, 3999.772800567613, 7867.415688946321], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # effects of toll pricing\\n opacity = 0.4\\n width = 0.2\\n index = np.arange(4)\\n plt.xticks(index, ('all', '10', '4 good', '4 bad') )\\n colors = ['y', 'r', 'b']\\n demands = ['94', '118', '142']\\n for i in [0,1,2]:\\n so = so_costs1[1][i]\\n ue = ue_costs1[1][i]\\n delta = ue-so\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*(costs1[1][i]-so)/delta, \\n 100.0*(costs2[1][i]-so)/delta, \\n 100.0*(costs3[1][i]-so)/delta, \\n 100.0*(costs4[1][i]-so)/delta],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative loss (%)')\\n plt.title('Effects of toll pricing with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted UE\\n for i in [0,1,2]:\\n ue = ue_costs1[1][i]\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(ue_costs1[0][i]-ue)/ue,\\n 100.0*abs(ue_costs2[0][i]-ue)/ue,\\n 100.0*abs(ue_costs3[0][i]-ue)/ue,\\n 100.0*abs(ue_costs4[0][i]-ue)/ue],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted UE with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted SO\\n for i in [0,1,2]:\\n so = so_costs1[1][i]\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(so_costs1[0][i]-so)/so,\\n 100.0*abs(so_costs2[0][i]-so)/so,\\n 100.0*abs(so_costs3[0][i]-so)/so,\\n 100.0*abs(so_costs4[0][i]-so)/so],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted SO with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted tolled ue\\n for i in [0,1,2]:\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(costs1[0][i]-costs1[1][i])/costs1[1][i],\\n 100.0*abs(costs2[0][i]-costs2[1][i])/costs2[1][i],\\n 100.0*abs(costs3[0][i]-costs3[1][i])/costs3[1][i],\\n 100.0*abs(costs4[0][i]-costs4[1][i])/costs4[1][i]],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted tooled UE with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\",\n \"def notebook_01():\\n\\n freq_list, volt_list = las.load_freq_volt()\\n\\n n_steps, n_det, n_f, _ = np.shape(volt_list)\\n\\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\\n\\n # print(np.shape(y_sym_mat_o))\\n # print(np.shape(y_sym_mat_i))\\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\\n # print(mu_o, sigma_o)\\n # print(mu_i, sigma_i)\\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\\n\\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\\n\\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\\n\\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\\n\\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\\n\\n\\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\\n\\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n fp.fit_params_FH_data(ff.f_b_field)\\n\\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\",\n \"def plot(self):\\n\\t\\tself.plotOfHeatingCurrent().plot()\",\n \"def plot_solution(self):\\n\\n plt.plot(self.x_values, self.analytical(self.x_values, self.C,self.D), label = \\\"Analytical\\\")\\n plt.plot(self.x_values, self.numerical, label = \\\"Numerical\\\")\\n plt.title(\\\"Numerical vs. Analytical Solution\\\")\\n plt.xlabel(\\\"x\\\")\\n plt.ylabel(\\\"u(x)\\\")\\n plt.legend()\\n plt.show()\",\n \"def main():\\n\\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n\\n for function in range(1, 21):\\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\\n\\n col_name = 'F{}'.format(function)\\n index = function-1\\n\\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\\n\\n success_rates.insert(index, col_name, results.SuccessRate)\\n peak_ratios.insert(index, col_name, results.PeakRatio)\\n\\n for i in results.SimulationSwarms:\\n\\n x_axis = [k for k, _ in i.items()]\\n y_axis = [v for _, v in i.items()]\\n\\n plt.subplot(4, 5, function) # subplot indexes from 1\\n plt.plot(x_axis, y_axis, 'k-')\\n\\n plt.savefig('results/nmmso_benchmark.png')\\n plt.show()\\n\\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\\n print(convergence_rates_e1)\\n print(convergence_rates_e4)\\n print(success_rates)\\n print(peak_ratios)\\n\\n # Table V from Fieldsend et al.\\n table4 = pd.Series([\\n peak_ratios.stack().median(),\\n peak_ratios.stack().mean(),\\n peak_ratios.stack().std()\\n ])\\n print(table4)\\n\\n # do we want to reproduce Fig. 3\",\n \"def main():\\n save = False\\n show = True\\n\\n #hd_parameter_plots = HDparameterPlots(save=save)\\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\\n #ice5g_comparison_plots.plotLine()\\n #ice5g_comparison_plots.plotFilled()\\n #ice5g_comparison_plots.plotCombined()\\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\\n #flowmapplot = FlowMapPlots(save)\\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\\n #flowmapplot.Etopo1FlowMap()\\n #flowmapplot.ICE5G_data_all_points_0k()\\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\\n outflowplots = OutflowPlots(save)\\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #hd_output_plots = HDOutputPlots()\\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\\n #lake_plots = LakePlots()\\n #lake_plots.plotLakeDepths()\\n #lake_plots.LakeAndRiverMap()\\n #lake_plots.LakeAndRiverMaps()\\n if show:\\n plt.show()\",\n \"def test_run_beta_diversity_through_plots_parallel(self):\\r\\n run_beta_diversity_through_plots(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=True,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n unweighted_unifrac_dm_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_dm.txt')\\r\\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\\r\\n unweighted_unifrac_pc_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_pc.txt')\\r\\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\\r\\n weighted_unifrac_html_fp = join(self.test_out,\\r\\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def visualize(self):\\n print('{0} is {1} time steps old'.format(self.name, self.timestep))\\n\\n self.amygdala.visualize(self.timestep, self.name, self.log_dir)\\n self.cerebellum.visualize(self.name, self.log_dir)\\n self.cingulate.visualize(self.name, self.log_dir)\\n self.hippocampus.visualize(self.name, self.log_dir)\\n #self.ganglia.visualize(self.name, self.log_dir)\\n #self.cortex.visualize(self.name, self.log_dir)\",\n \"def derivatives(self, state):\\n raise NotImplementedError()\",\n \"def plot_bus_load(self):\\n stops = {key: 0 for key, _ in self.route.timetable().items()}\\n for passenger in self.passengers:\\n trip = self.passenger_trip(passenger)\\n stops[trip[0][1]] += 1\\n stops[trip[1][1]] -= 1\\n prev = None\\n for i, stop in enumerate(stops):\\n if i > 0:\\n stops[stop] += stops[prev]\\n prev = stop\\n fig, ax = plt.subplots()\\n ax.step(range(len(stops)), list(stops.values()), where=\\\"post\\\")\\n ax.set_xticks(range(len(stops)))\\n ax.set_xticklabels(list(stops.keys()))\\n return fig, ax\",\n \"def plot(self):\\n\\n fig, ax = plt.subplots()\\n\\n for run in self.runs:\\n # Load datasets\\n data_measure = run.get_dataset(\\\"stats-collect_link_congestion-raw-*.csv\\\")\\n data_sp = run.get_dataset(\\\"stats-collect_link_congestion-sp-*.csv\\\")\\n\\n # Extract link congestion information\\n data_measure = data_measure['msgs']\\n data_sp = data_sp['msgs']\\n\\n # Compute ECDF and plot it\\n ecdf_measure = sm.distributions.ECDF(data_measure)\\n ecdf_sp = sm.distributions.ECDF(data_sp)\\n\\n variable_label = \\\"\\\"\\n size = run.orig.settings.get('size', None)\\n if size is not None:\\n variable_label = \\\" (n=%d)\\\" % size\\n\\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\\n label=\\\"U-Sphere%s\\\" % variable_label)\\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\\n label=u\\\"Klasični usmerjevalni protokol%s\\\" % variable_label)\\n\\n ax.set_xlabel('Obremenjenost povezave')\\n ax.set_ylabel('Kumulativna verjetnost')\\n ax.grid()\\n ax.axis((28, None, 0.99, 1.0005))\\n self.convert_axes_to_bw(ax)\\n\\n legend = ax.legend(loc='lower right')\\n if self.settings.GRAPH_TRANSPARENCY:\\n legend.get_frame().set_alpha(0.8)\\n fig.savefig(self.get_figure_filename())\",\n \"def plot_comparison(results):\\n dfs = []\\n for res in results:\\n equity = (1 + res['equity']).cumprod()\\n equity.name = 'equity'\\n equity = equity.reset_index()\\n equity['name'] = res['name']\\n dfs.append(equity)\\n data = pd.concat(dfs, axis=0)\\n\\n fig = px.line(data, x='time_idx', y='equity', color='name')\\n fig.show()\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def display_sweep(self):\\n for sweep in range(len(self.sweep_points)):\\n lidar_x_coordinate=self.flight_points[sweep][0]\\n lidar_y_coordinate=self.flight_points[sweep][1]\\n\\n xx=[]\\n yy=[]\\n for point in range(len(self.sweep_points[sweep])):\\n angle_degree=self.sweep_points[sweep][point][0]\\n distance=self.sweep_points[sweep][point][1]\\n angle_redian = (math.pi * angle_degree) / 180.0\\n sweep_point_x=lidar_x_coordinate+ (distance * math.cos(angle_redian))/1000.0\\n sweep_point_y=lidar_y_coordinate+ (distance * math.sin(angle_redian))/1000.0\\n xx.append(sweep_point_x)\\n yy.append(sweep_point_y)\\n\\n self.plot_sweep(xx,yy,sweep)\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def showPlot1():\\n\\n interested_in = list(range(5,30,5))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on room size')\\n xlabel('area of the room (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plot(self):\\n \\n \\n x_ibs=[] \\n x_gss=[]\\n y_ibs=[] \\n y_gss=[]\\n x_pso=[]\\n x_bgd=[]\\n y_bgd=[]\\n y_pso=[]\\n x_gd=[]\\n y_gd=[]\\n \\n i=0.0000001\\n \\n # for k in range(1,51):\\n # i= random.uniform(0.00000001, 1)\\n # t_avg_ibs=[]\\n # t_avg_gss=[]\\n # for j in range(1,51):\\n #L=random.randint(-100, 0)\\n #U=random.randint(0, 100)\\n max_iter=self.Max_iter \\n L=self.Lower_bound\\n U=self.Upper_bound\\n \\n minima=self.gss(L,U,i,1000)\\n #print(\\\"minima at X = \\\",minima[1])\\n x_ibs.append(self.I_bisection(L,U,minima[1],max_iter)[0])\\n x_gss.append(self.gss(L,U,i,max_iter)[0])\\n x_pso.append(self.particle_Swarm(self.func, L, U, 2, max_iter)[0])\\n x_gd.append(self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)[0])\\n x_bgd.append(self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)[0])\\n #print(x_pso)\\n for i in x_ibs[0]:\\n #print(self.Func(i)) \\n y_ibs.append(self.Func(i))\\n for i in x_gss[0]:\\n y_gss.append(self.Func(i)) \\n for i in x_pso[0]:\\n y_pso.append(self.Func(i)) \\n for i in x_gd[0]:\\n y_gd.append(self.Func(i)) \\n for i in x_bgd[0]:\\n y_bgd.append(self.Func(i)) \\n #print(y_gss)\\n\\n plt.plot(x_ibs[0], y_ibs, 'r.')\\n plt.plot(x_gss[0], y_gss, '.')\\n plt.plot(x_pso[0], y_pso, 'y.')\\n #plt.plot(x_gd[0], y_gd, 'y.')\\n #plt.plot(x_bgd[0], y_bgd, 'k.')\\n plt.xlabel('x')\\n plt.ylabel('y')\\n \\n plt.suptitle('Interval Bisection Search (Red) vs Golden Section Search (Blue) vs Particle swarm optimization (Green)')\\n #plt.axis([0, 100, 0.00000001, 1]) \\n plt.show()\\n plt.plot(x_gd[0], y_gd, 'r.')\\n plt.plot(x_bgd[0], y_bgd, 'k.')\\n plt.xlabel('x')\\n plt.ylabel('y') \\n plt.suptitle('Gradient Descent (Red) vs Batch Gradient Descent (Black) ')\\n \\n plt.show()\\n \\n start_time = timeit.default_timer()\\n ibs=self.I_bisection(L,U,minima[1],max_iter)\\n print(\\\" Execution time for Interval bisection Method is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n gss=self.gss(L,U,i,max_iter)\\n print(\\\" Execution time for Golden Section Search is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n pso=self.particle_Swarm(self.func, L, U, 2, max_iter)\\n print(\\\" Execution time for Particle swarm optimization is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n gd=self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)\\n print(\\\" Execution time for Gradient Descent is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n bgd=self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)\\n print(\\\" Execution time for Batch Gradient Descent is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n plt.plot(ibs[1], ibs[2], 'r.')\\n plt.text(ibs[1], ibs[2],\\\"IB\\\")\\n plt.plot(gss[1], gss[2], '.')\\n plt.text(gss[1], gss[2],\\\" GSS\\\")\\n plt.plot(pso[1], pso[2], 'y.')\\n plt.text(pso[1], pso[2],\\\" PSO\\\")\\n plt.plot(gd[1], gd[2], 'g.')\\n plt.text(gd[1], gd[2],\\\" GD \\\")\\n plt.plot(bgd[1],bgd[2], 'k.')\\n plt.text(bgd[1], bgd[2],\\\" Batch_GD\\\")\\n \\n plt.xlabel('Value of X')\\n plt.ylabel('NUmber of iteration') \\n plt.suptitle('Number of iterations vs minimum value of x')\\n \\n plt.show()\",\n \"def show_graph(self, symbol1, symbol2):\\n # Get the price data for the base coefficient calculation, tick data to calculate last coefficient and and the\\n # coefficient history data\\n symbol_1_price_data = self.__cor.get_price_data(symbol1)\\n symbol_2_price_data = self.__cor.get_price_data(symbol2)\\n symbol_1_ticks = self.__cor.get_ticks(symbol1, cache_only=True)\\n symbol_2_ticks = self.__cor.get_ticks(symbol2, cache_only=True)\\n history_data_short = \\\\\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\\n 'Timeframe': self.__config.get('monitor.calculations.short.from')})\\n history_data_med = \\\\\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\\n 'Timeframe': self.__config.get('monitor.calculations.medium.from')})\\n history_data_long = \\\\\\n self.__cor.get_coefficient_history({'Symbol 1': symbol1, 'Symbol 2': symbol2,\\n 'Timeframe': self.__config.get('monitor.calculations.long.from')})\\n # Display if we have any data\\n self.__log.debug(f\\\"Refreshing history graph {symbol1}:{symbol2}.\\\")\\n self.__graph.draw(prices=[symbol_1_price_data, symbol_2_price_data], ticks=[symbol_1_ticks, symbol_2_ticks],\\n history=[history_data_short, history_data_med, history_data_long], symbols=[symbol1, symbol2],\\n divergence_threshold=self.__cor.divergence_threshold,\\n monitor_inverse=self.__cor.monitor_inverse)\\n\\n # Un-hide and layout if hidden\\n if not self.__graph.IsShown():\\n self.__graph.Show()\\n self.__main_sizer.Layout()\",\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def scree_plot(self, ev):\\n plt.scatter(range(1,len(ev)+1), ev)\\n plt.plot(range(1,len(ev)+1), ev)\\n plt.title(\\\"Scree Plot\\\")\\n plt.xlabel(\\\"Factors\\\")\\n plt.ylabel(\\\"Eigenvalue\\\")\\n plt.grid()\\n plt.show()\",\n \"def plot(self):\\r\\n \\r\\n\\r\\n print(\\\"Printing decision surfaces of decision trees\\\")\\r\\n plot_colors = \\\"rb\\\"\\r\\n plot_step = 0.02\\r\\n n_classes = 2\\r\\n for _ in range (self.n_estimators):\\r\\n plt.subplot(2, 3, _ + 1)\\r\\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\\r\\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\\r\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\\r\\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\\r\\n Z = self.clfs[_].predict(np.c_[xx.ravel(), yy.ravel()])\\r\\n Z = np.array(Z)\\r\\n Z = Z.reshape(xx.shape)\\r\\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\\r\\n for i, color in zip(range(n_classes), plot_colors):\\r\\n if i == 0:\\r\\n idx = np.where(self.y == -1)\\r\\n if i == 1:\\r\\n idx = np.where(self.y == 1)\\r\\n for i in range (len(idx[0])):\\r\\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\\r\\n plt.suptitle(\\\"Decision surface of a decision tree using paired features\\\")\\r\\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\\r\\n plt.axis(\\\"tight\\\")\\r\\n\\r\\n plt.show()\\r\\n fig1 = plt\\r\\n\\r\\n # Figure 2\\r\\n print(\\\"Printing decision surface by combining the individual estimators\\\")\\r\\n plot_colors = \\\"rb\\\"\\r\\n plot_step = 0.02\\r\\n n_classes = 2\\r\\n x_min, x_max = self.X.iloc[:, 0].min() - 1, self.X.iloc[:, 0].max() + 1\\r\\n y_min, y_max = self.X.iloc[:, 1].min() - 1, self.X.iloc[:, 1].max() + 1\\r\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),np.arange(y_min, y_max, plot_step))\\r\\n plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)\\r\\n Z = config.Classifier_AB.predict(np.c_[xx.ravel(), yy.ravel()])\\r\\n Z = np.array(Z)\\r\\n Z = Z.reshape(xx.shape)\\r\\n cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu)\\r\\n for i, color in zip(range(n_classes), plot_colors):\\r\\n if i == 0:\\r\\n idx = np.where(self.y == -1)\\r\\n if i == 1:\\r\\n idx = np.where(self.y == 1)\\r\\n for i in range (len(idx[0])):\\r\\n plt.scatter(self.X.loc[idx[0][i]][0], self.X.loc[idx[0][i]][1],c=color,cmap=plt.cm.RdBu, edgecolor='black', s=15)\\r\\n plt.suptitle(\\\"Decision surface by combining individual estimators\\\")\\r\\n plt.legend(loc='lower right', borderpad=0, handletextpad=0)\\r\\n plt.axis(\\\"tight\\\")\\r\\n\\r\\n plt.show()\\r\\n fig2 = plt\\r\\n\\r\\n return [fig1,fig2]\",\n \"def SA_data_display(opt_df, all_df):\\n fig, axs = plt.subplots(2, 3)\\n\\n axs[0,0].set_title(\\\"Optimal rewire attempts for circularity\\\")\\n axs[0,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[0,0].set_xlabel(\\\"Time (s)\\\")\\n axs[0,0].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Percent waste (%)\\\"])\\n\\n axs[0,1].set_title(\\\"Optimal rewire attempts acceptance probability\\\")\\n axs[0,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[0,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,1].scatter(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Probability\\\"])\\n\\n axs[0,2].set_title(\\\"Optimal rewire attempts temperature decrease\\\")\\n axs[0,2].set_ylabel(\\\"Temperature\\\")\\n axs[0,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,2].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Temperature\\\"])\\n\\n axs[1,0].set_title(\\\"All rewire attempts for circularity\\\")\\n axs[1,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[1,0].set_xlabel(\\\"Time (s)\\\")\\n axs[1,0].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Percent waste (%)\\\"])\\n\\n axs[1,1].set_title(\\\"All rewire attempts acceptance probability\\\")\\n axs[1,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[1,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,1].scatter(all_df[\\\"Time (s)\\\"], all_df[\\\"Probability\\\"])\\n\\n axs[1,2].set_title(\\\"All rewire attempts temperature decrease\\\")\\n axs[1,2].set_ylabel(\\\"Temperature\\\")\\n axs[1,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,2].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Temperature\\\"])\\n\\n return plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6425327","0.6316091","0.6314955","0.60346085","0.5971509","0.59265935","0.585417","0.58146745","0.5805727","0.5739992","0.5732385","0.57270944","0.57151026","0.560639","0.5592231","0.5590342","0.55784935","0.5556301","0.55454224","0.55395085","0.5513448","0.5496705","0.54854643","0.5477498","0.54675835","0.54638535","0.5454411","0.5452887","0.544759","0.5437908","0.54331577","0.54161614","0.54065955","0.54060745","0.5393692","0.5388245","0.5385409","0.53851837","0.5379817","0.53795856","0.5377397","0.53769","0.53758484","0.5373367","0.53713006","0.53516096","0.53490925","0.5347839","0.5339373","0.5337444","0.53313124","0.5326452","0.5323745","0.5312251","0.531087","0.53075486","0.5304591","0.52989763","0.529677","0.5295606","0.5294231","0.52921516","0.5290227","0.52896124","0.52884734","0.52872854","0.5272362","0.5267035","0.52647775","0.5262251","0.5262213","0.5259424","0.5252105","0.5250641","0.5248936","0.52423424","0.5239197","0.52375394","0.52348083","0.5227948","0.5222489","0.5219832","0.52170736","0.52120936","0.520886","0.51912415","0.51908654","0.51893574","0.5186291","0.51828474","0.5181604","0.5180596","0.5180547","0.5177495","0.5176469","0.51729906","0.5168334","0.5166241","0.5161676","0.51553154"],"string":"[\n \"0.6425327\",\n \"0.6316091\",\n \"0.6314955\",\n \"0.60346085\",\n \"0.5971509\",\n \"0.59265935\",\n \"0.585417\",\n \"0.58146745\",\n \"0.5805727\",\n \"0.5739992\",\n \"0.5732385\",\n \"0.57270944\",\n \"0.57151026\",\n \"0.560639\",\n \"0.5592231\",\n \"0.5590342\",\n \"0.55784935\",\n \"0.5556301\",\n \"0.55454224\",\n \"0.55395085\",\n \"0.5513448\",\n \"0.5496705\",\n \"0.54854643\",\n \"0.5477498\",\n \"0.54675835\",\n \"0.54638535\",\n \"0.5454411\",\n \"0.5452887\",\n \"0.544759\",\n \"0.5437908\",\n \"0.54331577\",\n \"0.54161614\",\n \"0.54065955\",\n \"0.54060745\",\n \"0.5393692\",\n \"0.5388245\",\n \"0.5385409\",\n \"0.53851837\",\n \"0.5379817\",\n \"0.53795856\",\n \"0.5377397\",\n \"0.53769\",\n \"0.53758484\",\n \"0.5373367\",\n \"0.53713006\",\n \"0.53516096\",\n \"0.53490925\",\n \"0.5347839\",\n \"0.5339373\",\n \"0.5337444\",\n \"0.53313124\",\n \"0.5326452\",\n \"0.5323745\",\n \"0.5312251\",\n \"0.531087\",\n \"0.53075486\",\n \"0.5304591\",\n \"0.52989763\",\n \"0.529677\",\n \"0.5295606\",\n \"0.5294231\",\n \"0.52921516\",\n \"0.5290227\",\n \"0.52896124\",\n \"0.52884734\",\n \"0.52872854\",\n \"0.5272362\",\n \"0.5267035\",\n \"0.52647775\",\n \"0.5262251\",\n \"0.5262213\",\n \"0.5259424\",\n \"0.5252105\",\n \"0.5250641\",\n \"0.5248936\",\n \"0.52423424\",\n \"0.5239197\",\n \"0.52375394\",\n \"0.52348083\",\n \"0.5227948\",\n \"0.5222489\",\n \"0.5219832\",\n \"0.52170736\",\n \"0.52120936\",\n \"0.520886\",\n \"0.51912415\",\n \"0.51908654\",\n \"0.51893574\",\n \"0.5186291\",\n \"0.51828474\",\n \"0.5181604\",\n \"0.5180596\",\n \"0.5180547\",\n \"0.5177495\",\n \"0.5176469\",\n \"0.51729906\",\n \"0.5168334\",\n \"0.5166241\",\n \"0.5161676\",\n \"0.51553154\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5443678"},"document_rank":{"kind":"string","value":"29"}}},{"rowIdx":9284,"cells":{"query":{"kind":"string","value":"Plots the free energy differences evaluated for each pair of adjacent states for all methods. The layout is approximately 'nb' bars per subplot."},"document":{"kind":"string","value":"def plotdFvsLambda2(nb=10):\n x = numpy.arange(len(df_allk))\n if len(x) < nb:\n return\n xs = numpy.array_split(x, len(x)/nb+1)\n mnb = max([len(i) for i in xs])\n fig = pl.figure(figsize = (8,6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\n ndx = 1\n for x in xs:\n lines = tuple()\n ax = pl.subplot(len(xs), 1, ndx)\n for name in P.methods:\n y = [df_allk[i][name]/P.beta_report for i in x]\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.05*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\n lines += (line[0],)\n for dir in ['left', 'right', 'top', 'bottom']:\n if dir == 'left':\n ax.yaxis.set_ticks_position(dir)\n else:\n ax.spines[dir].set_color('none')\n pl.yticks(fontsize=10)\n ax.xaxis.set_ticks([])\n for i in x+0.5*width*len(P.methods):\n ax.annotate('$\\mathrm{%d-%d}$' % (i, i+1), xy=(i, 0), xycoords=('data', 'axes fraction'), xytext=(0, -2), size=10, textcoords='offset points', va='top', ha='center')\n pl.xlim(x[0], x[-1]+len(lines)*width + (mnb - len(x)))\n ndx += 1\n leg = ax.legend(lines, tuple(P.methods), loc=0, ncol=2, prop=FP(size=8), title='$\\mathrm{\\Delta G\\/%s\\/}\\mathit{vs.}\\/\\mathrm{lambda\\/pair}$' % P.units, fancybox=True)\n leg.get_frame().set_alpha(0.5)\n pl.savefig(os.path.join(P.output_directory, 'dF_state.pdf'), bbox_inches='tight')\n pl.close(fig)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\n df_decomposed = df.loc[df['block'] == 'decomposed']\n df_joint = df.loc[df['block'] == 'joint']\n ticklabels = []\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\n for i in range(len(num_sweeps)):\n ticklabels.append('K=%d\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\n fig = plt.figure(figsize=(fs*2.5, fs))\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax1.set_xticks(num_sweeps)\n ax1.set_xticklabels(ticklabels)\n ax1.tick_params(labelsize=fontsize)\n ax1.grid(alpha=0.4)\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax2.set_xticks(num_sweeps)\n ax2.set_xticklabels(ticklabels)\n ax2.tick_params(labelsize=fontsize)\n ax2.grid(alpha=0.4)\n ax2.legend(fontsize=fontsize)\n ax1.legend(fontsize=fontsize)\n ax1.set_ylabel(r'$\\log \\: p_\\theta(x, \\: z)$', fontsize=35)\n ax2.set_ylabel('ESS / L', fontsize=35)","def plot_variables(self, n, show=False, diagnostics=False):\n\n if diagnostics:\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\n else:\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\n\n plt.subplots_adjust(hspace = 0)\n end = len(n.history[\"det F\"])\n epochs = np.arange(end)\n a, = ax[0].plot(epochs, n.history[\"det F\"], label = 'Training data')\n b, = ax[0].plot(epochs, n.history[\"det test F\"], label = 'Test data')\n # ax[0].axhline(y=5,ls='--',color='k')\n ax[0].legend(frameon = False)\n ax[0].set_ylabel(r'$|{\\bf F}_{\\alpha\\beta}|$')\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\"det test F\"][-1])\n ax[1].plot(epochs, n.history[\"loss\"])\n ax[1].plot(epochs, n.history[\"test loss\"])\n # ax[1].set_xlabel('Number of epochs')\n ax[1].set_ylabel(r'$\\Lambda$')\n ax[1].set_xlim([0, len(epochs)]);\n \n if diagnostics:\n ax[2].plot(epochs, n.history[\"det C\"])\n ax[2].plot(epochs, n.history[\"det test C\"])\n # ax[2].set_xlabel('Number of epochs')\n ax[2].set_ylabel(r'$|{\\bf C}|$')\n ax[2].set_xlim([0, len(epochs)]);\n \n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,0]\n , color = 'C0', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"dμdθ\"])[:,0,1]\n , color = 'C0', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n \"\"\"\n\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,0]\n , color = 'C1', label=r'$\\theta_1$',alpha=0.5)\n \n \"\"\"\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\n ax[3].plot(epochs, np.array(n.history[\"test dμdθ\"])[:,0,1]\n , color = 'C1', ls='dashed', label=r'$\\theta_2$',alpha=0.5)\n ax[3].legend(frameon=False)\n \"\"\"\n\n ax[3].set_ylabel(r'$\\partial\\mu/\\partial\\theta$')\n # ax[3].set_xlabel('Number of epochs')\n ax[3].set_xlim([0, len(epochs)])\n\n # Mean of network output summary 1\n ax[4].plot(epochs, np.array(n.history[\"μ\"])[:,0],alpha=0.5)\n # Mean of test output network summary 1\n ax[4].plot(epochs, np.array(n.history[\"test μ\"])[:,0],alpha=0.5)\n ax[4].set_ylabel('μ')\n ax[4].set_xlabel('Number of epochs')\n ax[4].set_xlim([0, len(epochs)])\n \n\n print ('Maximum Fisher info on train data:',np.max(n.history[\"det F\"]))\n print ('Final Fisher info on train data:',(n.history[\"det F\"][-1]))\n \n print ('Maximum Fisher info on test data:',np.max(n.history[\"det test F\"]))\n print ('Final Fisher info on test data:',(n.history[\"det test F\"][-1]))\n\n if np.max(n.history[\"det test F\"]) == n.history[\"det test F\"][-1]:\n print ('Promising network found, possibly more epochs needed')\n\n plt.tight_layout()\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def plot_derivatives_divided(self, show=False):\n\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\n ax[2, 0].set_title('Difference between upper and lower training examples');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n ax[2, 0].legend(frameon=False)\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\n ax[2, 1].set_title('Difference between upper and lower test samples');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def main():\n # Load properties that will be needed\n store = [Storage.Storage(2), Storage.Storage(4)] \n pre_energy = [s.get(\"free_energy\") for s in store]\n post_energy = [s.get(\"post_energy\") for s in store]\n x_range = store[0].get(\"x_range\")\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\n y_range = store[0].get(\"y_range\")\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\n # Calculate step size\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \n # Set up the figure\n fig = plt.figure(1, figsize=(7.5,2.5)) \n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\n # Plot the results\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\n # Annotate the plots\n axe[0].set_title(\"4sXB step size\")\n axe[0].set_xlabel(\"Lattice spacing (nm)\") \n axe[0].set_ylabel(\"Step size (nm)\")\n axe[0].set_xlim((25.5, 39))\n axe[0].set_ylim((1, 8))\n axe[1].set_title(\"2sXB step size\")\n axe[1].set_xlabel(\"Lattice spacing (nm)\") \n axe[1].set_ylabel(\"Step size (nm)\")\n axe[1].set_xlim((25.5, 39))\n axe[1].set_ylim((1, 8))\n # Display the plots\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\n left=0.08, right=0.98,\n top=0.85, bottom=0.21)\n plt.show()","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def plot(self, nsteps_max=10):\r\n fig = plt.figure()\r\n ax1 = plt.subplot(221)\r\n ax2 = plt.subplot(222)\r\n ax3 = plt.subplot(224)\r\n\r\n if 'fig' in locals(): # assures tight layout even when plot is manually resized\r\n def onresize(event): plt.tight_layout()\r\n try: cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\r\n except: pass\r\n\r\n self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax1)\r\n\r\n if getattr(self.px_spec, 'ref_tree', None) is None:\r\n self.calc_px(method='LT', nsteps=nsteps_max, keep_hist=True)\r\n\r\n self.plot_bt(bt=self.px_spec.ref_tree, ax=ax2, title='Binary tree of stock prices; ' + self.specs)\r\n self.plot_bt(bt=self.px_spec.opt_tree, ax=ax3, title='Binary tree of option prices; ' + self.specs)\r\n # fig, ax = plt.subplots()\r\n # def onresize(event): fig.tight_layout()\r\n # cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\r\n # self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax)\r\n\r\n try: plt.tight_layout()\r\n except: pass\r\n plt.show()","def plot_2nd(self, mod = 'F'):\n if not mpl: raise \"Problem with matplotib: Plotting not possible.\"\n f = plt.figure(figsize=(5,4), dpi=100)\n \n A2 = []\n \n strainList= self.__structures.items()[0][1].strainList\n \n if len(strainList)<=5:\n kk=1\n ll=len(strainList)\n grid=[ll]\n elif len(strainList)%5 == 0:\n kk=len(strainList)/5\n ll=5\n grid=[5 for i in range(kk)]\n else:\n kk=len(strainList)/5+1\n ll=5\n grid=[5 for i in range(kk)]\n grid[-1]=len(strainList)%5\n \n \n n=1\n m=1\n for stype in strainList:\n atoms = self.get_atomsByStraintype(stype)\n self.__V0 = atoms[0].V0\n strainList = atoms[0].strainList\n if self.__thermodyn and mod == 'F':\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\n elif self.__thermodyn and mod=='E0':\n energy = [i.gsenergy for i in atoms]\n elif self.__thermodyn and mod=='Fvib':\n energy = [i.phenergy[-1] for i in atoms]\n else:\n energy = [i.gsenergy for i in atoms]\n \n strain = [i.eta for i in atoms]\n \n spl = '1'+str(len(strainList))+str(n)\n #plt.subplot(int(spl))\n #a = f.add_subplot(int(spl))\n if (n-1)%5==0: m=0\n \n \n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\n #print (kk,ll), ((n-1)/5,m)\n j = 0\n for i in [2,4,6]:\n ans = Energy()\n ans.energy = energy\n ans.strain = strain\n ans.V0 = self.__V0\n \n fitorder = i\n ans.set_2nd(fitorder)\n A2.append(ans.get_2nd())\n \n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\n \n try:\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\n except:\n continue\n a.plot(strains, dE, label=str(fitorder))\n a.set_title(stype)\n a.set_xlabel('strain')\n a.set_ylabel(r'$\\frac{d^2E}{d\\epsilon^2}$ in eV')\n \n j+=1\n \n n+=1\n m+=1\n \n a.legend(title='Order of fit')\n return f","def test_run_beta_diversity_through_plots(self):\r\n run_beta_diversity_through_plots(\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=False,\r\n status_update_callback=no_status_updates)\r\n\r\n unweighted_unifrac_dm_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_dm.txt')\r\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\r\n unweighted_unifrac_pc_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_pc.txt')\r\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\r\n weighted_unifrac_html_fp = join(self.test_out,\r\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def n27_and_sidebands():\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\n # n=26 through n=29\n folder = os.path.join(\"..\", \"..\", \"2018-09-06\")\n fname = \"1_dye_fscan.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n ax.axhline(0, color='grey')\n data.plot(x='fpoly', y='sig', label=\"MW Off\", c='k', ax=ax)\n # sidebands\n folder = os.path.join(\"..\", \"..\", \"2018-09-09\")\n fname = \"1_freq_dye.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n data['asig'] = data['sig'] - 0.3\n ax.axhline(-0.3, color='grey')\n data.plot(x='fpoly', y='asig', label=\"MW On\", c='k', ax=ax)\n # pretty figure\n ax.legend().remove()\n ax.set_ylabel(r\"$e^-$ Signal\")\n ax.set_yticks([])\n ax.set_xlabel(\"Frequency (GHz from Limit)\")\n ax.set_xticks([-4863, -4511, -4195, -3908])\n ax.text(-4400, -0.15, \"MW On\")\n ax.text(-4400, 0.3, \"MW Off\")\n # save\n fig.tight_layout()\n fig.savefig(\"n27_and_sidebands.pdf\")\n return","def plot_balance_list(balance_list, b_scale='linear', progress = False, n_lims = None):\n if n_lims == None:\n n_min = 0\n n_max=len(balance_list)\n else:\n n_min = n_lims[0]\n n_max = n_lims[1]\n ncols=2\n nrows=int(np.ceil((n_max-n_min)/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(22, 5*nrows))\n for n in range(n_min, n_max):\n ni = n-n_min \n i = int(np.floor(ni / ncols))\n j=ni % ncols\n r_p = []\n if progress: \n for k in range(len(balance_list[n])-1):\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\n\n axes[i,j].plot(balance_list[n], label='balance', color='b')#we put [1:] because want not to show drop in the beginning: TODO: understand fully and explain\n axes[i,j].set_title('Outer loop # '+ str(n))\n # axes[i,j].set_yscale('log')\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('balance norm')\n axes[i,j].legend()\n axes[i,j].set_yscale(b_scale)\n if progress: \n ax_2=axes[i,j].twinx()\n ax_2.plot(r_p, 'g')\n ax_2.set_yscale('log')\n ax_2.set_ylabel('relative change')","def vis_difference(self):\n print(self.init_vec)\n\n init = self.init_output.numpy()\n\n alphas = np.linspace(0, 1, 20)\n for i, alpha in enumerate(alphas):\n\n display.clear_output(wait=True)\n norm = [torch.linalg.norm(torch.tensor(\n self.init_vec + alpha*self.eigen[i]), axis=1).detach().numpy() for i in range(2)]\n\n diff = np.array([self.compute_difference(\n alpha, self.eigen[i]) for i in range(2)])\n\n fig = plt.figure(figsize=(14, 12), tight_layout=True)\n fig.suptitle(\"Latent direction variation\", fontsize=20)\n gs = gridspec.GridSpec(2, 2)\n\n ax_temp = plt.subplot(gs[0, :])\n ax_temp.scatter(\n init[:, 0], init[:, 1])\n ax_temp.set_title(\"Initial Dataset\")\n ax_temp.set_xlim(-1, 1)\n ax_temp.set_ylim(-1, 1)\n [s.set_visible(False) for s in ax_temp.spines.values()]\n\n for j in range(2):\n ax_temp = plt.subplot(gs[1, j])\n sc = ax_temp.quiver(\n init[:, 0], init[:, 1], diff[j, :, 0], diff[j, :, 1], norm[j])\n sc.set_clim(np.min(norm[j]), np.max(norm[j]))\n plt.colorbar(sc)\n ax_temp.set_title(\n \"Direction: {}, alpha: {}\".format(j+1, alpha))\n ax_temp.set_xlim(-1, 1)\n ax_temp.set_ylim(-1, 1)\n [s.set_visible(False) for s in ax_temp.spines.values()]\n\n plt.savefig(\"frames_dir/fig_{}\".format(i))\n plt.show()","def plotdFvsLambda1():\n x = numpy.arange(len(df_allk))\n if x[-1]<8:\n fig = pl.figure(figsize = (8,6))\n else:\n fig = pl.figure(figsize = (len(x),6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\n lines = tuple()\n for name in P.methods:\n y = [df_allk[i][name]/P.beta_report for i in x]\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\n lines += (line[0],)\n pl.xlabel('States', fontsize=12, color='#151B54')\n pl.ylabel('$\\Delta G$ '+P.units, fontsize=12, color='#151B54')\n pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)\n pl.yticks(fontsize=8)\n pl.xlim(x[0], x[-1]+len(lines)*width)\n ax = pl.gca()\n for dir in ['right', 'top', 'bottom']:\n ax.spines[dir].set_color('none')\n ax.yaxis.set_ticks_position('left')\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n\n leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)\n leg.get_frame().set_alpha(0.5)\n pl.title('The free energy change breakdown', fontsize = 12)\n pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')\n pl.close(fig)\n return","def _show_learning_rate():\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\n\n # Visualize c_prime\n c_prime_list = np.linspace(1, 100, num=11)\n x_label = f\"c'\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[0]\n x_list = c_prime_list\n\n # MNIST\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n # Visualize t0\n t0_list = np.linspace(1, 100, num=11)\n x_label = f\"t0\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[1]\n x_list = t0_list\n\n # MNIST\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n plt.show()","def plot_bs(self, show=False, density=True, pcolor=\"r\", mcolor=\"b\", lw=1.0, subtract = 0):\n cm = matplotlib.cm.jet\n\n if (subtract !=0):\n geqbispectra = subtract\n else:\n geqbispectra = np.zeros(np.shape(self.eqbispectra))\n\n if (density):\n \"\"\" also read the local overdensity value and plot line colors according to\n the density value, + = red, - = blue; adjust alpha accordingly\n \"\"\"\n if len(self.ds)<self.Nsubs:\n print (\"no density data\")\n return 0\n\n ads=np.abs(self.ds)\n meands=np.mean(self.ds)\n mads=np.max(ads)\n normds=np.array([ads[i]/mads for i in range(len(ads))])\n self.normds=normds\n\n cNorm = colors.Normalize(min(self.ds), vmax=max(self.ds))\n scalarMap = cmap.ScalarMappable(norm=cNorm, cmap=cm)\n scalarMap.set_array([])\n\n fig, ax = self.plt.subplots()\n\n for sub in range(self.Nsubs):\n #print sub\n if not(density):\n lplot=ax.plot(self.klist, self.fNLeq[sub])\n else:\n colorVal = scalarMap.to_rgba(self.ds[sub])\n lplot = ax.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=colorVal, alpha=normds[sub], linewidth=lw)\n \"\"\"\n if self.ds[sub]>meands:\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=pcolor, alpha=normds[sub], linewidth=lw)\n else:\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=mcolor, alpha=normds[sub], linewidth=lw)\n \"\"\"\n\n ax.set_xlabel(r\"$k {\\rm (h/Mpc)}$\")\n ax.set_ylabel(r\"${\\rm Q}(k)$\")\n ax.set_xscale('log')\n cbar = fig.colorbar(scalarMap, format='%.0e')\n #self.plt.yscale('log')\n if (show):\n self.plt.show()","def plot_explorer_panels(self, param_val, photonnumber, initial_index, final_index, qbt_index, osc_index):\n def fig_ax(index):\n return fig, axes_list_flattened[index]\n\n param_index = np.searchsorted(self.param_vals, param_val)\n param_val = self.param_vals[param_index]\n\n initial_bare = self.sweep.lookup.bare_index(initial_index, param_index)\n final_bare = self.sweep.lookup.bare_index(final_index, param_index)\n energy_ground = self.sweep.lookup.energy_dressed_index(0, param_index)\n energy_initial = self.sweep.lookup.energy_dressed_index(initial_index, param_index) - energy_ground\n energy_final = self.sweep.lookup.energy_dressed_index(final_index, param_index) - energy_ground\n qbt_subsys = self.sweep.hilbertspace[qbt_index]\n\n nrows = 3\n ncols = 2\n fig, axs = plt.subplots(ncols=ncols, nrows=nrows, figsize=self.figsize)\n axes_list_flattened = [elem for sublist in axs for elem in sublist]\n\n # Panel 1 ----------------------------------\n panels.display_bare_spectrum(self.sweep, qbt_subsys, param_val, fig_ax(0))\n\n # Panels 2 and 6----------------------------\n if type(qbt_subsys).__name__ in ['Transmon', 'Fluxonium']: # do not plot wavefunctions if multi-dimensional\n panels.display_bare_wavefunctions(self.sweep, qbt_subsys, param_val, fig_ax(1))\n panels.display_charge_matrixelems(self.sweep, initial_bare, qbt_subsys, param_val, fig_ax(5))\n\n # Panel 3 ----------------------------------\n panels.display_dressed_spectrum(self.sweep, initial_bare, final_bare, energy_initial, energy_final, param_val,\n fig_ax(2))\n\n # Panel 4 ----------------------------------\n panels.display_n_photon_qubit_transitions(self.sweep, photonnumber, initial_bare, param_val, fig_ax(3))\n\n # Panel 5 ----------------------------------\n panels.display_chi_01(self.sweep, qbt_index, osc_index, param_index, fig_ax(4))\n\n fig.tight_layout()\n return fig, axs","def test_run_beta_diversity_through_plots_even_sampling(self):\r\n\r\n run_beta_diversity_through_plots(\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n sampling_depth=20,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=False,\r\n status_update_callback=no_status_updates)\r\n\r\n unweighted_unifrac_dm_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_dm.txt')\r\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\r\n unweighted_unifrac_pc_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_pc.txt')\r\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\r\n weighted_unifrac_html_fp = join(self.test_out,\r\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def plot_overscan_diff(overscan, img, TITLE, OUT_DIR):\n fig = plt.figure(figsize=(20, 20))\n gs0 = gridspec.GridSpec(3, 3)\n\n for i, f in enumerate(img):\n x = f.dev_index % 3\n\n gs = gridspec.GridSpecFromSubplotSpec(\n 1, 2, wspace=0, subplot_spec=gs0[f.dev_index])\n ax2 = plt.subplot(gs[0, 0])\n for j in range(9, 17):\n plt.plot(overscan[i, j - 1] - overscan[i, 15] +\n 500 * (j - 8), label='seg' + str(j + 1))\n plt.legend(fontsize=6, loc='upper center', ncol=4)\n if(x != 0):\n ax2.set_yticklabels([])\n\n plt.grid()\n plt.xlim(0, 2100)\n plt.ylim(0, 4500)\n ax2.set_title(f.dev_name + ' (seg 10-17)')\n\n ax1 = plt.subplot(gs[0, 1])\n for j in range(1, 9):\n plt.plot(overscan[i, j - 1] - overscan[i, 7] +\n 500 * j, label='seg' + str(j - 1))\n plt.legend(fontsize=6, loc='upper center', ncol=4)\n if(x != 2):\n ax1.set_yticklabels([])\n if(x == 2):\n ax1.yaxis.tick_right()\n plt.grid()\n plt.xlim(0, 2100)\n plt.ylim(0, 4500)\n ax1.set_title(f.dev_name + ' (seg 0-7)')\n #\tax1.set_title('S-'+f[7:9]+' (seg 0-7)')\n\n fig.suptitle('Overscan (diff) ' + TITLE, y=0.94, size=20)\n plt.subplots_adjust(wspace=0.05)\n plt.savefig(OUT_DIR + TITLE + '_diff_spatial.png')\n plt.close(fig)","def plot_bus_load(self):\n stops = {key: 0 for key, _ in self.route.timetable().items()}\n for passenger in self.passengers:\n trip = self.passenger_trip(passenger)\n stops[trip[0][1]] += 1\n stops[trip[1][1]] -= 1\n prev = None\n for i, stop in enumerate(stops):\n if i > 0:\n stops[stop] += stops[prev]\n prev = stop\n fig, ax = plt.subplots()\n ax.step(range(len(stops)), list(stops.values()), where=\"post\")\n ax.set_xticks(range(len(stops)))\n ax.set_xticklabels(list(stops.keys()))\n return fig, ax","def plot(self):\n # plot the data for checking\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\n 3,2, figsize=(10,8))\n\n # Relative height\n self.board_reference.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\n self.board_intervention.plot(\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\n\n # Landuse\n self.board_reference.plot(\n column='landuse', legend=True, ax=ax3, cmap='viridis',\n scheme='equal_interval', k=11)\n self.board_intervention.plot(\n column='landuse', legend=True, ax=ax4, cmap='viridis',\n scheme='equal_interval', k=11)\n\n index = np.arange(7)\n xticks = self.PotTax_reference.index.values\n bar_width = 0.3\n\n # plot the initial and new situation comparison\n label = (\"reference: \" +\n str(round(self.PotTax_reference.sum().TFI, 2)))\n reference = ax5.bar(\n index, self.PotTax_reference.values.flatten(), bar_width,\n label=label, tick_label=xticks)\n label = (\"intervention: \" +\n str(round(self.PotTax_intervention.sum().TFI, 2)))\n intervention = ax5.bar(\n index+bar_width, self.PotTax_intervention.values.flatten(),\n bar_width, label=label, tick_label=xticks)\n ax5.set_ylabel(\"total value\")\n ax5.legend(loc='best')\n for tick in ax5.get_xticklabels():\n tick.set_rotation(90)\n\n # plot the percentage increase/decrease between the initial and new\n # situation\n data = self.PotTax_percentage.values.flatten()\n percentage = ax6.bar(\n index, data, bar_width, label=\"percentage\", tick_label=xticks)\n ax6.set_ylabel(\"increase (%)\")\n minimum = min(data)\n maximum = max(data)\n size = len(str(int(round(maximum))))\n maximum = int(str(maximum)[:1])\n maximum = (maximum + 1) * (10**(size-1))\n ax6.set_ylim([min(0, minimum), maximum])\n for tick in ax6.get_xticklabels():\n tick.set_rotation(90)","def plot_balance_list_output(balance_list, path, nframes=4):\n import matplotlib\n font = {'size' : 15, 'weight': 'normal'}\n matplotlib.rc('font', **font)\n\n nplots=len(balance_list)\n ncols=2\n nrows=int(np.ceil(nframes/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\n for n in range(nframes):\n i = int(np.floor(n / ncols))\n j=n % ncols\n r_p = []\n for k in range(len(balance_list[n])-1):\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\n\n axes[i,j].plot(balance_list[n], label='balance', color='b')\n axes[i,j].set_title('Outer loop # '+ str(n))\n # axes[i,j].set_yscale('log')\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('Balance norm')\n # axes[i,j].legend()\n axes[i,j].set_ylim([0, 10])\n # ax_2=axes[i,j].twinx()\n # ax_2.plot(r_p, 'g')\n # ax_2.set_yscale('log')\n # ax_2.set_ylabel('relative change')\n\n plt.savefig(path,transparent=True, dpi=400)","def test_run_beta_diversity_through_plots_parallel(self):\r\n run_beta_diversity_through_plots(\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=True,\r\n status_update_callback=no_status_updates)\r\n\r\n unweighted_unifrac_dm_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_dm.txt')\r\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\r\n unweighted_unifrac_pc_fp = join(\r\n self.test_out,\r\n 'unweighted_unifrac_pc.txt')\r\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\r\n weighted_unifrac_html_fp = join(self.test_out,\r\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def overview(self, minState=5):\n n = 600\n \n ### first plot: the RTOFFSETs and STATES\n plt.figure(10)\n plt.clf()\n plt.subplots_adjust(hspace=0.05, top=0.95, left=0.05,\n right=0.99, wspace=0.00, bottom=0.1)\n ax1 = plt.subplot(n+11)\n try:\n print self.insmode+' | pri:'+\\\n self.getKeyword('OCS PS ID')+' | sec:'+\\\n self.getKeyword('OCS SS ID')\n \n plt.title(self.filename+' | '+self.insmode+' | pri:'+\n self.getKeyword('OCS PS ID')+' | sec:'+\n self.getKeyword('OCS SS ID'))\n except:\n pass\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n self.raw['OPDC'].data.field('FUOFFSET')*1e3,\n color=(1.0, 0.5, 0.0), label=self.DLtrack+' (FUOFFSET)',\n linewidth=3, alpha=0.5)\n plt.legend(prop={'size':9})\n plt.ylabel('(mm)')\n plt.xlim(0)\n \n plt.subplot(n+12, sharex=ax1) # == DDL movements\n \n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n 1e3*self.raw['DOPDC'].data.field(self.DDLtrack),\n color=(0.0, 0.5, 1.0), linewidth=3, alpha=0.5,\n label=self.DDLtrack)\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n 1e3*self.raw['DOPDC'].data.field('PSP'),\n color=(0.0, 0.5, 1.0), linewidth=1, alpha=0.9,\n label='PSP', linestyle='dashed')\n plt.legend(prop={'size':9})\n plt.ylabel('(mm)')\n plt.xlim(0)\n \n plt.subplot(n+13, sharex=ax1) # == states\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n self.raw['OPDC'].data.field('STATE'),\n color=(1.0, 0.5, 0.0), label='OPDC')\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n self.raw['DOPDC'].data.field('STATE'),\n color=(0.0, 0.5, 1.0), label='DOPDC')\n plt.legend(prop={'size':9})\n plt.ylabel('STATES')\n yl=plt.ylim()\n plt.ylim(yl[0]-1, yl[1]+1)\n plt.xlim(0)\n ### fluxes\n plt.subplot(n+14, sharex=ax1)\n try:\n fsua_dark = self.fsu_calib[('FSUA', 'DARK')][0,0]\n fsub_dark = self.fsu_calib[('FSUB', 'DARK')][0,0]\n fsua_alldark = self.fsu_calib[('FSUA', 'DARK')].sum(axis=1)[0]\n fsub_alldark = self.fsu_calib[('FSUB', 'DARK')].sum(axis=1)[0]\n except:\n print 'WARNING: there are no FSUs calibrations in the header'\n fsua_dark = 0.0\n fsub_dark = 0.0\n fsua_alldark = 0.0\n fsub_alldark = 0.0\n\n M0 = 17.5\n fluxa = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]+\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\n fsua_alldark)/\\\n (4*self.getKeyword('ISS PRI FSU1 DIT'))\n print 'FLUX FSUA (avg, rms):', round(fluxa.mean(), 0), 'ADU/s',\\\n round(100*fluxa.std()/fluxa.mean(), 0), '%'\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\n round(M0-2.5*np.log10(fluxa.mean()),2)\n fluxb = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]+\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\n fsub_alldark)/\\\n (4*self.getKeyword('ISS PRI FSU2 DIT'))\n print 'FLUX FSUB (avg, rms):', round(fluxb.mean(), 0), 'ADU/s',\\\n round(100*fluxb.std()/fluxb.mean(), 0), '%'\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\n round(M0-2.5*np.log10(fluxb.mean()),2)\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\\n fluxa/1000, color='b', alpha=0.5, label='FSUA')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\\n fluxb/1000, color='r', alpha=0.5, label='FSUB')\n\n plt.ylim(1)\n plt.legend(prop={'size':9})\n plt.ylabel('flux - DARK (kADU)')\n plt.xlim(0)\n plt.subplot(n+15, sharex=ax1)\n try:\n # -- old data version\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUA'].data.field('OPDSNR'),\n color='b', alpha=0.5, label='FSUA SNR')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUB'].data.field('OPDSNR'),\n color='r', alpha=0.5, label='FSUB SNR')\n except:\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUA'].data.field(self.OPDSNR),\n color='b', alpha=0.5, label='FSUA SNR')\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n self.raw['IMAGING_DATA_FSUB'].data.field(self.OPDSNR),\n color='r', alpha=0.5, label='FSUB SNR')\n plt.legend(prop={'size':9})\n \n A = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,0])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,0]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,0])\n B = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,1])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,1]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,1])\n C = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,2])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,2]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,2])\n D = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\n self.fsu_calib[('FSUA', 'DARK')][0,3])/\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,3]-\n 2*self.fsu_calib[('FSUA', 'DARK')][0,3])\n snrABCD_a = ((A-C)**2+(B-D)**2)\n snrABCD_a /= ((A-C).std()**2+ (B-D).std()**2)\n #plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\n # snrABCD_a, color='b', alpha=0.5, linestyle='dashed')\n \n A = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,0])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,0]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,0])\n B = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,1])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,1]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,1])\n C = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,2])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,2]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,2])\n D = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\n self.fsu_calib[('FSUB', 'DARK')][0,3])/\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,3]-\n 2*self.fsu_calib[('FSUB', 'DARK')][0,3])\n \n snrABCD_b = ((A-C)**2+(B-D)**2)\n snrABCD_b /= ((A-C).std()**2+ (B-D).std()**2)\n #plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\n # snrABCD_b, color='r', alpha=0.5, linestyle='dashed') \n \n # -- SNR levels:\n #plt.hlines([self.getKeyword('INS OPDC OPEN'),\n # self.getKeyword('INS OPDC CLOSE'),\n # self.getKeyword('INS OPDC DETECTION')],\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\n # color=(1.0, 0.5, 0.0))\n #plt.hlines([self.getKeyword('INS DOPDC OPEN'),\n # self.getKeyword('INS DOPDC CLOSE'),\n # self.getKeyword('INS DOPDC DETECTION')],\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\n # color=(0.0, 0.5, 1.0))\n # -- plot thresholds\n plt.ylabel('SNR')\n plt.xlim(0)\n \n if self.getKeyword('OCS DET IMGNAME')=='PACMAN_OBJ_ASTRO_':\n # == dual FTK\n plt.subplot(n+16, sharex=ax1)\n plt.ylabel('PRIMET ($\\mu$m)')\n #met = interp1d(np.float_(self.raw['METROLOGY_DATA'].\\\n # data.field('TIME')),\\\n # self.raw['METROLOGY_DATA'].data.field('DELTAL'),\\\n # kind = 'linear', bounds_error=False, fill_value=0.0)\n met = lambda x: np.interp(x,\n np.float_(self.raw['METROLOGY_DATA'].data.field('TIME')),\n self.raw['METROLOGY_DATA'].data.field('DELTAL'))\n metro = met(self.raw['DOPDC'].data.field('TIME'))*1e6\n n_ = min(len(self.raw['DOPDC'].data.field('TIME')),\n len(self.raw['OPDC'].data.field('TIME')))\n\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n metro, color=(0.5,0.5,0.), label='A-B')\n\n w1 = np.where((self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'OPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\n except:\n print 'OPDC FTK stat: 0%'\n\n w1 = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'DOPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\n except:\n print 'DOPDC FTK stat: 0%'\n\n w = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\n try:\n print 'DUAL FTK stat:', round(100*len(w[0])/float(n_),1), '%'\n except:\n print 'DUAL FTK stat: 0%'\n\n plt.xlim(0)\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\n metro[w], '.g', linewidth=2,\n alpha=0.5, label='dual FTK')\n #plt.legend()\n if len(w[0])>10 and False:\n coef = np.polyfit(self.raw['DOPDC'].data.field('TIME')[w],\n metro[w], 2)\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\n np.polyval(coef, self.raw['DOPDC'].\n data.field('TIME')),\n color='g')\n plt.ylabel('metrology')\n\n print 'PRIMET drift (polyfit) :', 1e6*coef[1], 'um/s'\n slope, rms, synth = NoisySlope(self.raw['DOPDC'].\n data.field('TIME')[w],\n metro[w], 3e6)\n plt.figure(10)\n yl = plt.ylim()\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\n synth, color='r')\n plt.ylim(yl)\n print 'PRIMET drift (NoisySlope):',\\\n slope*1e6,'+/-', rms*1e6, 'um/s'\n else:\n # == scanning\n plt.subplot(n+16, sharex=ax1)\n fringesOPDC = \\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA1')[:,0]-\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA3')[:,0]\n \n fringesDOPDC =\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA1')[:,0]-\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA3')[:,0]\n \n plt.plot(self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('TIME'),\n scipy.signal.wiener(fringesOPDC/fringesOPDC.std()),\n color=(1.0, 0.5, 0.0), alpha=0.6,\n label=self.primary_fsu+'/OPDC')\n plt.plot(self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('TIME'),\n scipy.signal.wiener(fringesDOPDC/fringesDOPDC.std()),\n color=(0.0, 0.5, 1.0), alpha=0.6,\n label=self.secondary_fsu+'/DOPDC')\n plt.legend(prop={'size':9})\n plt.ylabel('A-C')\n plt.xlabel('time stamp ($\\mu$s)')\n return","def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\n \n energyType = arg[0] \n \n dummyRange = np.asarray(range(len(indices['E_tot1'])))\n \n fig = plt.figure(figsize=(16, 8))\n \n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\n if energyType == 'PV':\n multiplier = -1\n else:\n multiplier = 1\n \n ax1 = plt.subplot(2,1,1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\n \n plt.ylabel('Energy [kWh]')\n plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(24)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n ax2 = plt.subplot(2,1,2, sharex=ax1)\n \n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\n\n plt.ylabel('Energy Difference [kWh]')\n plt.legend()\n\n ax2.xaxis.set_major_locator(majorLocator)\n ax2.xaxis.set_major_formatter(majorFormatter)\n ax2.xaxis.set_minor_locator(minorLocator)\n# ax2.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which='both')\n \n return fig","def plot_all(show=True):\n fig, axes = plt.subplots(max_iterations, 1, figsize=(6, 12))\n for t in range(max_iterations):\n with open('results/%s/df_%d.pkl' % (id, t), 'rb') as f:\n df = pickle.load(f)\n with open('results/%s/w_%d.pkl' % (id, t), 'rb') as f:\n w = pickle.load(f)\n axes[t].hist2d(x=df['vision'], y=df['metab'], weights=w, density=True,\n bins=((xticks, yticks)), cmap='magma')\n axes[t].set_ylabel('max metabolism')\n axes[t].set_xticks(vision_domain)\n axes[t].set_yticks((2, 3, 4))\n axes[3].set_xlabel('max vision')\n fig.tight_layout()\n if show:\n plt.show()\n else:\n plt.savefig('results/%s/abc_results.pdf' % id)","def plot(self, noTLS, path_plots, interactive):\n fig = plt.figure(figsize=(10,12))\n ax1 = fig.add_subplot(4, 1, 1)\n ax2 = fig.add_subplot(4, 1, 2)\n ax3 = fig.add_subplot(4, 2, 5)\n ax4 = fig.add_subplot(4, 2, 6)\n ax5 = fig.add_subplot(4, 2, 7)\n ax6 = fig.add_subplot(4, 2, 8)\n\n # First panel: data from each sector\n colors = self._get_colors(self.nlc)\n for i, lci in enumerate(self.alllc):\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\n ax1.legend(fontsize='small', ncol=4)\n\n # Second panel: Detrended light curve\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\n color='black',\n label='Detrended')\n\n # Third panel: BLS\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\n mean_SR = np.mean(self.BLS.power)\n std_SR = np.std(self.BLS.power)\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\n SDE = (best_power - mean_SR)/std_SR\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\n for n in range(2, 10):\n if n*self.BLS.period_max <= max(self.BLS.period.value):\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n sx, ex = ax3.get_xlim()\n sy, ey = ax3.get_ylim()\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.2f\\nDepth = %.4f\\nDuration = %.2f d\\nSDE = %.3f' %\n (self.BLS.period_max, self.BLS.t0_max,\n self.BLS.depth_max, self.BLS.duration_max, SDE))\n\n\n # Fourth panel: lightcurve folded to the best period from the BLS\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\n marker='.', alpha=0.5)\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\n\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\n duration=self.BLS.duration_max,\n transit_time=self.BLS.t0_max)\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\n ax4.set_xlim(-l, l)\n h = max(lc_model.flux)\n l = min(lc_model.flux)\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\n del lc_model, lc_model_folded, r1, dt1\n\n\n if not noTLS:\n # Fifth panel: TLS periodogram\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\n for n in range(2, 10):\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.set_ylabel(r'SDE')\n ax5.set_xlabel('Period (days)')\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\n ax5.set_xlim(0, max(self.tls.periods))\n\n period_tls = self.tls.period\n T0_tls = self.tls.T0\n depth_tls = self.tls.depth\n duration_tls = self.tls.duration\n FAP_tls = self.tls.FAP\n\n sx, ex = ax5.get_xlim()\n sy, ey = ax5.get_ylim()\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.1f\\nDepth = %.4f\\nDuration = %.2f d\\nFAP = %.4f' %\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\n\n # Sixth panel: folded light curve to the best period from the TLS\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\n alpha=0.5, ls='None', markersize=0.7)\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\n x0=0.0, nbins=nbins, useBinCenter=True)\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\n ax6.set_xlim(0.5-l, 0.5+l)\n h = max(self.tls.model_folded_model)\n l = min(self.tls.model_folded_model)\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\n ax6.set_xlabel('Phase')\n ax6.set_ylabel('Relative flux')\n del r1, dt1\n\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\n if interactive:\n plt.show()\n plt.close('all')\n del fig","def runExpt_and_makePlots(n, d, grid_size, reps, tho_scale=0.1, is_classification=True):\n\n args = [n, d, grid_size, reps]\n df_std_signal, df_tho_signal = repeatexp(*args,\n is_classification=is_classification,\n tho_scale=tho_scale,\n no_signal=False)\n \n df_std_nosignal, df_tho_nosignal = repeatexp(*args,\n is_classification=is_classification,\n tho_scale=tho_scale,\n no_signal=True)\n\n f, ax = plt.subplots(2, 2, figsize=(8,10), sharex=True, sharey=False)\n sb.set_style('whitegrid')\n \n kw_params = {'x':'dataset',\n 'y':'performance',\n 'units':'perm'}\n \n sb.barplot(data=df_std_signal,\n ax=ax[0,0],\n **kw_params)\n ax[0,0].set_title('Standard, HAS Signal')\n \n sb.barplot(data=df_tho_signal,\n ax=ax[0,1],\n **kw_params)\n ax[0,1].set_title('Thresholdout, HAS Signal')\n\n sb.barplot(data=df_std_nosignal,\n ax=ax[1,0],\n **kw_params)\n ax[1,0].set_title('Standard, NO Signal')\n\n sb.barplot(data=df_tho_nosignal,\n ax=ax[1,1],\n **kw_params)\n ax[1,1].set_title('Thresholdout, NO Signal')\n \n return f, ax","def plot_derivatives(self, show=False):\n\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(0,self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].set_xscale('log')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[1, 0].set_xscale('log')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 0].set_title('Upper - lower input data: train sample');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 0].set_title('Numerical derivative: train sample');\n ax[3, 0].set_xlabel(r'$\\ell$')\n ax[3, 0].set_ylabel(r'$\\Delta C_\\ell / 2\\Delta \\theta$')\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 0].set_xscale('log')\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n ax[0, 1].set_xscale('log')\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n ax[1, 1].set_xscale('log')\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\n ax[2, 1].set_title('Upper - lower input data: test sample');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$C_\\ell (u) - C_\\ell (m) $')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n\n for i in range(Cl_lower.shape[0]):\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\n ax[3, 1].set_title('Numerical derivative: train sample');\n ax[3, 1].set_xlabel(r'$\\ell$')\n ax[3, 1].set_ylabel(r'$\\Delta C_\\ell / \\Delta \\theta $')\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[3, 1].set_xscale('log')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\n perf_list = ['54363310_1939750539', '540791114_1793842568']\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \".npy\") for i in range(len(perf_list))]\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\n num_samples = 10000\n # quantile indices\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\n plt.style.use('ggplot')\n labels = ['perf. A', 'perf. B']\n colors = ['blue', 'red']\n linestyles = ['dotted', 'dashed']\n grid = plt.GridSpec(2, 2)\n ax1 = plt.subplot(grid[1, 0])\n ax2 = plt.subplot(grid[1, 1])\n ax4 = plt.subplot(grid[0, :])\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\n ax4.set_title(\"Difference between MIDI and pYIN, two performances\")\n ax4.set_ylabel(\"Cents\")\n ax4.set_xlabel(\"Frames\")\n ax4.axhline(y=200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2, label=\"thresh.\")\n ax4.axhline(y=-200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2)\n ax4.legend(loc=\"upper right\")\n ax1.set_title(\"10k random sample of distances\")\n ax1.set_ylabel(r\"$|$Cents$|$\")\n ax1.set_xlabel(\"Frames sorted by distance\")\n ax2.set_title(\"Sample quantiles\")\n ax2.set_xlabel(\"Quantile indices\")\n # run analysis song by song\n for i, arr in enumerate(comparisons_list):\n # random sample so all arrays have the same size\n samples = np.random.choice(arr, num_samples, replace=True)\n # sort\n samples = np.sort(np.abs(samples))\n # discard the high values (might be due to misalignment, etc...)\n samples = samples[samples <= 200]\n samples = np.random.choice(samples, num_samples, replace=True)\n samples = np.sort(np.abs(samples))\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n # get the quantiles\n samples = samples[q_indices]\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n ax1.legend()\n ax2.legend()\n plt.tight_layout()\n plt.savefig(os.path.join(plots_dir_intonation, \"data processing pipeline.eps\"), format=\"eps\")\n plt.show()","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def plot_diff(self):\n if not(self.is_attribute(\"time\") & self.is_attribute(\"intensity_up\") & \n self.is_attribute(\"intensity_up_sigma\") &\n self.is_attribute(\"intensity_down\") & \n self.is_attribute(\"intensity_down_sigma\") &\n self.is_attribute(\"intensity_up_total\") &\n self.is_attribute(\"intensity_down_total\")):\n return\n fig, ax = plt.subplots()\n ax.set_title(\"Polarized intensity: I_up - I_down\")\n ax.set_xlabel(\"Time (microseconds)\")\n ax.set_ylabel('Intensity')\n \n np_time = numpy.array(self.time, dtype=float)\n np_up = numpy.array(self.intensity_up, dtype=float)\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\n np_down = numpy.array(self.intensity_down, dtype=float)\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\n np_diff = np_up - np_down\n np_diff_mod = np_up_mod - np_down_mod\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\n\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \"b:\")\n ax.plot(np_time, np_diff_mod, \"k-\",\n label=\"model\")\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\"ko\", alpha=0.2,\n label=\"experiment\")\n\n y_min_d, y_max_d = ax.get_ylim()\n param = y_min_d-(np_diff-np_diff_mod).max()\n\n ax.plot([np_time.min(), np_time.max()], [param, param], \"k:\")\n ax.plot(np_time, np_diff-np_diff_mod+param, \"r-\", alpha=0.7,\n label=\"difference\")\n ax.legend(loc='upper right')\n fig.tight_layout()\n return (fig, ax)","def show_derivative(self):\n for trace in self.plotWidget.plotDataItems:\n dt = float(trace.attrs['dt'])\n dtrace = np.diff(trace.data)\n x = pgplot.make_xvector(dtrace, dt)\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))","def plot_path_statistics( self, path_file=\"tse_ensemble.json\" ):\n from matplotlib import pyplot as plt\n with open(path_file,'r') as infile:\n data = json.load(infile)\n try:\n paths = data[\"transition_paths\"]\n except KeyError:\n paths = [data]\n total_product_indicator = np.zeros(len(paths[0][\"symbols\"]))\n total_reactant_indicator = np.zeros(len(paths[0][\"symbols\"]))\n self.nuc_mc.min_size_product = paths[0][\"min_size_product\"]\n self.nuc_mc.max_size_reactant = paths[0][\"max_size_reactant\"]\n for path in paths:\n product_indicator = []\n reactant_indicator = []\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\n\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\n\n total_reactant_indicator /= float( len(paths) )\n total_product_indicator /= float( len(paths) )\n\n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.plot( total_product_indicator, label=\"Product\" )\n ax.plot( total_reactant_indicator, label=\"Reactant\" )\n ax.set_xlabel( \"MC sweeps\" )\n ax.set_ylabel( \"Indicator\" )\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend( frameon=False, loc=\"best\" )\n return fig","def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\n other_program_name, **kw):\n\n #plot absolute error\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\n pan['absolute-difference'][field].values,\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\n ax_abs.set_ylabel('Absolute Difference ' + unit)\n #plot percentage error\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\n pan['percent-difference'][field].values,\n color='firebrick', zorder=-1)\n ax_per.set_ylabel('Percent Difference', color='firebrick')\n #set error axes legend\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\n #ax_per.get_legend().set_zorder(1)\n #plot full results profiles\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\n color=_colormap[1])[0],\n ax_mag.plot(pan['emf.fields-results'][field],\n color=_colormap[0])[0]]\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\n ax_mag.set_xlabel('Distance (ft)')","def simulationTwoDrugsDelayedTreatment(numTrials):\n \n numViruses = 100\n maxPop = 1000\n maxBirthProb = 0.1\n clearProb = 0.05\n resistances = {'guttagonol': False, 'grimpex': False}\n mutProb = 0.005\n delays = [300, 150, 75, 0]\n f, axarr = pylab.subplots(2, 2)\n x_plot = []\n\n for delay in delays:\n FinalPopSize = [0.0 for x in range(numTrials)]\n for trial in range(numTrials):\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\n patient = TreatedPatient(viruses, maxPop)\n for i in range(150):\n patient.update()\n patient.addPrescription('guttagonol')\n for j in range(150, 150+delay):\n patient.update()\n patient.addPrescription('grimpex')\n for k in range(150+delay, 300+delay):\n patient.update()\n FinalPopSize[trial] = patient.getTotalPop()\n x_plot.append(FinalPopSize)\n\n axarr[0, 0].hist(x_plot[0])\n axarr[0, 1].hist(x_plot[1])\n axarr[1, 0].hist(x_plot[2])\n axarr[1, 1].hist(x_plot[3])\n pylab.show()\n return x_plot","def noe_analysis():\n\n files = ['f34k_7p2_noe_heights.txt', 'dphs_7p4_noe_heights.txt']\n proteins = ['f34k','dphs']\n\n heights = [nmrfn.parse_noe(f) for f in files]\n heights = pd.concat(heights, axis=1, keys=proteins)\n\n results = [noe_calcs(heights[i]) for i in proteins]\n results = pd.concat(results, axis=1, keys=proteins)\n\n fig = plt.figure(figsize=(10,6))\n val = plt.subplot(211)\n dif = plt.subplot(212)\n \n seqmin = 6\n seqmax = 144\n noemin = 0.5\n noemax = 0.95\n\n dy = results.dphs.noe - results.f34k.noe\n dif_plot(val, dy.index, dy.ix[8:141], seqmin, seqmax)\n noe_plot(proteins, results, seqmin, seqmax, noemin, noemax, xax=False)\n\n s1 = plt.Rectangle((0, 0), 1, 1, fc=proteins['f34k'])\n s2 = plt.Rectangle((0, 0), 1, 1, fc=proteins['dphs'])\n val.legend([s1, s2], ['F34K', '∆+PHS'], loc=8)\n\n title = 'HN NOE: F34K pH 7.2 compared with ∆+PHS pH 7.4'\n savefile = 'f34k_7p2_noe_analysis.pdf'\n save_plot(title, savefile)","def compositePlots(self):\n if not self.master: return\n\n # get the HTML page\n page = [page for page in self.layout.pages if \"MeanState\" in page.name][0]\n \n models = []\n colors = []\n corr = {}\n std = {}\n cycle = {}\n has_cycle = False\n has_std = False\n for fname in glob.glob(os.path.join(self.output_path,\"*.nc\")):\n dataset = Dataset(fname)\n if \"MeanState\" not in dataset.groups: continue\n dset = dataset.groups[\"MeanState\"]\n models.append(dataset.getncattr(\"name\"))\n colors.append(dataset.getncattr(\"color\"))\n for region in self.regions:\n \n if not cycle.has_key(region): cycle[region] = []\n key = [v for v in dset.variables.keys() if (\"cycle_\" in v and region in v)]\n if len(key)>0:\n has_cycle = True\n cycle[region].append(Variable(filename=fname,groupname=\"MeanState\",variable_name=key[0]))\n\n if not std. has_key(region): std [region] = []\n if not corr. has_key(region): corr [region] = []\n\n key = []\n if \"scalars\" in dset.groups:\n key = [v for v in dset.groups[\"scalars\"].variables.keys() if (\"Spatial Distribution Score\" in v and region in v)]\n if len(key) > 0:\n has_std = True\n sds = dset.groups[\"scalars\"].variables[key[0]]\n corr[region].append(sds.getncattr(\"R\" ))\n std [region].append(sds.getncattr(\"std\"))\n\n # composite annual cycle plot\n if has_cycle and len(models) > 2:\n page.addFigure(\"Spatially integrated regional mean\",\n \"compcycle\",\n \"RNAME_compcycle.png\",\n side = \"ANNUAL CYCLE\",\n legend = False)\n\n for region in self.regions:\n if not cycle.has_key(region): continue\n fig,ax = plt.subplots(figsize=(6.8,2.8),tight_layout=True)\n for name,color,var in zip(models,colors,cycle[region]):\n dy = 0.05*(self.limits[\"cycle\"][region][\"max\"]-self.limits[\"cycle\"][region][\"min\"])\n var.plot(ax,lw=2,color=color,label=name,\n ticks = time_opts[\"cycle\"][\"ticks\"],\n ticklabels = time_opts[\"cycle\"][\"ticklabels\"],\n vmin = self.limits[\"cycle\"][region][\"min\"]-dy,\n vmax = self.limits[\"cycle\"][region][\"max\"]+dy)\n ylbl = time_opts[\"cycle\"][\"ylabel\"]\n if ylbl == \"unit\": ylbl = post.UnitStringToMatplotlib(var.unit)\n ax.set_ylabel(ylbl)\n fig.savefig(os.path.join(self.output_path,\"%s_compcycle.png\" % (region)))\n plt.close()\n\n # plot legends with model colors (sorted with Benchmark data on top)\n page.addFigure(\"Spatially integrated regional mean\",\n \"legend_compcycle\",\n \"legend_compcycle.png\",\n side = \"MODEL COLORS\",\n legend = False)\n def _alphabeticalBenchmarkFirst(key):\n key = key[0].upper()\n if key == \"BENCHMARK\": return 0\n return key\n tmp = sorted(zip(models,colors),key=_alphabeticalBenchmarkFirst)\n fig,ax = plt.subplots()\n for model,color in tmp:\n ax.plot(0,0,'o',mew=0,ms=8,color=color,label=model)\n handles,labels = ax.get_legend_handles_labels()\n plt.close()\n \n ncol = np.ceil(float(len(models))/11.).astype(int)\n if ncol > 0:\n fig,ax = plt.subplots(figsize=(3.*ncol,2.8),tight_layout=True)\n ax.legend(handles,labels,loc=\"upper right\",ncol=ncol,fontsize=10,numpoints=1)\n ax.axis('off')\n fig.savefig(os.path.join(self.output_path,\"legend_compcycle.png\"))\n fig.savefig(os.path.join(self.output_path,\"legend_spatial_variance.png\"))\n fig.savefig(os.path.join(self.output_path,\"legend_temporal_variance.png\"))\n plt.close()\n \n # spatial distribution Taylor plot\n if has_std:\n page.addFigure(\"Temporally integrated period mean\",\n \"spatial_variance\",\n \"RNAME_spatial_variance.png\",\n side = \"SPATIAL TAYLOR DIAGRAM\",\n legend = False)\n page.addFigure(\"Temporally integrated period mean\",\n \"legend_spatial_variance\",\n \"legend_spatial_variance.png\",\n side = \"MODEL COLORS\",\n legend = False) \n if \"Benchmark\" in models: colors.pop(models.index(\"Benchmark\"))\n for region in self.regions:\n if not (std.has_key(region) and corr.has_key(region)): continue\n if len(std[region]) != len(corr[region]): continue\n if len(std[region]) == 0: continue\n fig = plt.figure(figsize=(6.0,6.0))\n post.TaylorDiagram(np.asarray(std[region]),np.asarray(corr[region]),1.0,fig,colors)\n fig.savefig(os.path.join(self.output_path,\"%s_spatial_variance.png\" % region))\n plt.close()","def main():\n\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n\n for function in range(1, 21):\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\n\n col_name = 'F{}'.format(function)\n index = function-1\n\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\n\n success_rates.insert(index, col_name, results.SuccessRate)\n peak_ratios.insert(index, col_name, results.PeakRatio)\n\n for i in results.SimulationSwarms:\n\n x_axis = [k for k, _ in i.items()]\n y_axis = [v for _, v in i.items()]\n\n plt.subplot(4, 5, function) # subplot indexes from 1\n plt.plot(x_axis, y_axis, 'k-')\n\n plt.savefig('results/nmmso_benchmark.png')\n plt.show()\n\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\n print(convergence_rates_e1)\n print(convergence_rates_e4)\n print(success_rates)\n print(peak_ratios)\n\n # Table V from Fieldsend et al.\n table4 = pd.Series([\n peak_ratios.stack().median(),\n peak_ratios.stack().mean(),\n peak_ratios.stack().std()\n ])\n print(table4)\n\n # do we want to reproduce Fig. 3","def plotEnergiesOpt(monthlyData, optIdx):\n \n \n dummyRange = np.asarray(range(len(optIdx)))\n \n fig = plt.figure(figsize=(16, 8))\n \n plt.suptitle('Energy Comparison')\n ax1 = plt.subplot(1,1,1)\n plt.plot(monthlyData['H'][optIdx, dummyRange], label = 'H', color='r')\n plt.plot(monthlyData['C'][optIdx, dummyRange], label = 'C', color='b')\n plt.plot(monthlyData['L'][optIdx, dummyRange], label = 'L', color='g')\n plt.plot(monthlyData['PV'][optIdx, dummyRange], label = 'PV', color='c')\n plt.plot(monthlyData['E_HCL'][optIdx, dummyRange], label = 'HCL', color='m')\n plt.plot(monthlyData['E_tot'][optIdx, dummyRange], label = 'E_tot', color='k')\n plt.ylabel('Energy [kWh]')\n plt.xlim(0,288)\n\n# plt.legend()\n \n majorLocator = MultipleLocator(24)\n majorFormatter = FormatStrFormatter('%d')\n minorLocator = MultipleLocator(4)\n minorFormatter = FormatStrFormatter('%d')\n\n ax1.xaxis.set_major_locator(majorLocator)\n ax1.xaxis.set_major_formatter(majorFormatter)\n ax1.xaxis.set_minor_locator(minorLocator)\n# ax1.xaxis.set_minor_formatter(minorFormatter)\n plt.grid(True, which=u'major')\n \n # Shrink current axis by 20%\n box = ax1.get_position()\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n \n # Put a legend to the right of the current axis\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\n# \n\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\n# ax2 = plt.subplot(2,1,2, sharex=ax1)\n# plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\n# plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\n# plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\n# plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\n# plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\n# plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\n# plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\n# plt.ylabel('Energy Difference [kWh]')\n# plt.legend()\n#\n# ax2.xaxis.set_major_locator(majorLocator)\n# ax2.xaxis.set_major_formatter(majorFormatter)\n# ax2.xaxis.set_minor_locator(minorLocator)\n## ax2.xaxis.set_minor_formatter(minorFormatter)\n# plt.grid(True, which='both')\n# \n return fig","def momentum_kde2_paperplot(fields):\n plt.figure(figsize=(2.65, 2.5))\n ax = plt.axes([0.18, 0.17, 0.8, 0.8])\n colorList = [med_color, high_color]\n lw = 1.5\n i = 0\n meankx_2 = []\n meankx_3 = []\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \"E_{:.1e}.npy\".format(fields[0]))\n # ax.plot(k_ax, np.zeros(len(k_ax)), '-', linewidth=lw, color=eq_color, label='Equilibrium')\n # ax.plot(k_ax, np.zeros(len(k_ax)), '-', linewidth=lw, color=eq_color)\n ax.axhline(0, color='black', linestyle='--', linewidth=0.5)\n # ax.axvline(0, color='gray', linewidth=0.8, alpha=0.5)\n for ee in fields:\n ee_Vcm = ee/100\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n kdist_f0_2 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist_f0_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n kdist_2 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist' + '2_' + \"E_{:.1e}.npy\".format(ee))\n kdist_f0_3 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist_f0_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n kdist_3 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist' + '3_' + \"E_{:.1e}.npy\".format(ee))\n\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n meankx_2.append(utilities.mean_kx(chi_2_i, electron_df))\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n meankx_3.append(utilities.mean_kx(chi_3_i, electron_df))\n\n ax.plot(k_ax, kdist_2, '--', linewidth=lw, color=colorList[i], label='Cold '+r'{:.0f} '.format(ee/100)+r'$\\rm V cm^{-1}$')\n ax.plot(k_ax, kdist_3, '-', linewidth=lw,color=colorList[i], label='Warm '+r'{:.0f} '.format(ee/100)+r'$\\rm V cm^{-1}$')\n i = i + 1\n # ax.plot(k_ax, kdist_f0_3, '--', linewidth=lw, color='black', label=r'$f_0$')\n # ax.plot(meankx_2,np.mean(abs(kdist_2))*np.ones(len(meankx_3)), '-', linewidth=lw, color='black')\n # ax.plot(meankx_3,np.mean(abs(kdist_3))*np.ones(len(meankx_3)), '-', linewidth=lw, color='black')\n\n ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\n ax.locator_params(axis='y', nbins=6)\n ax.locator_params(axis='x', nbins=6)\n # ax.tick_params(direction='in')\n ax.set_xlim(-0.085, 0.081)\n\n plt.xlabel(r'$\\rm k_x \\, \\, (\\AA^{-1})$')\n plt.ylabel(r'Deviational occupation $\\rm \\Delta f_{\\mathbf{k}}$')\n # plt.grid(lw=0.8, linestyle='dotted')\n # plt.ylabel(r'$\\delta f_{\\mathbf{k}}/f_{\\mathbf{k}}^0$')\n # plt.ylim([-1,1])\n plt.legend(frameon=False,prop={'size':different_small_size})\n plt.savefig(pp.figureLoc+'momentum_KDE2.png', dpi=600)","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def plot_parameter_evolution(analyses, pdf=False):\n ncs = np.arange(11, 15)\n genes = set(analyses.gene)\n constructs = set(analyses.construct)\n long_labels = {'bac': 'bac', 'no_pr': 'no pr', 'no_sh': 'no sh'}\n gene_long = {'hb': 'hunchback', 'kn': 'knirps', 'sn': 'snail'}\n y_label = {'j': 'Normalized flux $j$',\n 'rho': 'Site occupation density $\\\\rho$', 'tau': 'Residence time $\\\\tau$ (s)', 'alpha_comb': 'Initiation rate $\\\\alpha$ (pol/min)'}\n\n # Add extra jiggle to be able to distinguish overlapping data points\n x_jiggle = 0.04\n x_shifts = np.array([-1, 0, 1]) * x_jiggle\n\n # Plot parameters\n capsize = 0\n markersize = 4\n lw = 1 # line width\n\n for gene in genes:\n grouped_data = analyses.groupby(by=['gene', 'construct', 'nc'])\n all_means = grouped_data.mean()\n all_stds = grouped_data.std(ddof=1)\n all_ps = analyses.groupby(by=['gene', 'nc']).first()\n\n for quantity in ['j', 'rho', 'tau', 'alpha_comb']:\n ymaxs = {'j': 0.36, 'rho': 0.27, 'tau': 103, 'alpha_comb': 12}\n num = 12\n set_figure_size(num=num, rows=1, page_width_frac=0.5, clear=True, height_factor=0.7)\n fig, ax = plt.subplots(1, 1, num=num, clear=True)\n avg_data, std_data = {}, {}\n for construct in constructs:\n if quantity in ['rho', 'j']:\n avg_data[construct] = all_means.loc[(\n gene, construct, slice(None)), quantity].values\n std_data[construct] = all_stds.loc[(\n gene, construct, slice(None)), quantity].values\n\n elif quantity in ['tau', 'alpha_comb']:\n avg_data[construct] = all_means.loc[(\n gene, construct, slice(None)), quantity].values\n std_data[construct] = np.sqrt(\n all_means.loc[(gene, construct, slice(None)), quantity + 'V'].values)\n\n # Prepare a marker generator and plot the data with errorbars\n marker_gen = itertools.cycle(markers_additivity)\n for i, construct in enumerate(constructs):\n m = next(marker_gen)\n plt.errorbar(\n ncs + x_shifts[i], avg_data[construct],\n yerr=std_data[construct],\n fmt='-' + m, color=colors_additivity[construct],\n capsize=capsize, label=long_labels[construct],\n markersize=markersize, lw=lw)\n\n # Adjust plot\n plt.xlabel('Nuclear cycle')\n plt.ylabel(y_label[quantity])\n plt.ylim(ymin=0, ymax=ymaxs[quantity])\n\n plt.xticks(ncs)\n plt.title(gene_long[gene])\n\n plt.tight_layout()\n plt.show()\n\n # Save figure\n figname = 'additivity_' + quantity + '_' + gene\n figpath = os.path.join(figures_folder, figname)\n fig.savefig(figpath + '.png', pad_inches=0, bbox_inches='tight')\n if pdf:\n fig.savefig(figpath + '.pdf', pad_inches=0, bbox_inches='tight')","def plotting(dataframe, prod_num):\n fig, axs = plt.subplots(2, sharex=True)\n axs[0].plot(dataframe['STU'])\n axs[1].plot(dataframe['STU'].diff().dropna())\n axs[0].set_title(\"Time Series of Product\" + f\"_{prod_num}\")\n axs[1].set_title(\"Differenced Time Series of Product\" + f\"_{prod_num}\")\n plt.savefig(\"Time Series of Product\" + f\"_{prod_num}\" + \".pdf\")","def plot_alleles(folder):\n\n abs_alt,perc_alt = parse_geno_file(folder,False)\n\n strain_matcher = re.compile('(.*) \\(.*\\)') ## regex to get strain name from radio button click\n strain_matcher2 = re.compile('(.*)-(.*)')\n \n fig, ax = plt.subplots()\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\n ax.set_ylabel('Alternate Allele Percentage (MC)')\n ax.set_xlabel('Alternate Allele Percentage (MC)')\n \n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\n\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\n\n #for strain in perc_alt.keys():\n #print strain\n \n #ylabel = plt.axes([1,1,0.08,0.08])\n\n def update1(strain):\n if strain not in [\"Rock-MZ\",\"Sand-MC\",\"Rock-MC\",\"Sand-MZ\",\"Rock-Sand\"]:\n match = re.match(strain_matcher,strain)\n strain = match.group(1)\n global base\n base = 'MC'\n else:\n match = re.match(strain_matcher2,strain)\n strain = match.group(1)\n #global base \n base = match.group(2)\n\n #print D\n if(D == \"%\"):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[strain])\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n else:\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[strain])\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n\n ax.relim()\n ax.autoscale()\n fig.canvas.draw_idle()\n global S \n #print S\n S = strain\n\n\n def update2(data):\n if(data == '%'):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n fig.canvas.draw_idle()\n if(data == 'Abs'):\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n fig.canvas.draw_idle()\n \n global D\n D = data\n\n radio1.on_clicked(update1)\n radio2.on_clicked(update2)\n plt.show()","def plateSeparatedPerformance():\n model_perfs = pickle.load(open(\"pickles/separatePlateTestModelPerformances.pkl\", \"rb\"))\n model_stds = pickle.load(open(\"pickles/separatePlateTestModelStds.pkl\", \"rb\"))\n null_YFP_performances = pickle.load(open(\"pickles/separatePlateTestYFPPerformances.pkl\", \"rb\"))\n null_YFP_stds = pickle.load(open(\"pickles/separatePlateTestYFPStds.pkl\", \"rb\"))\n null_DAPI_performances = pickle.load(open(\"pickles/separatePlateTestDAPIPerformances.pkl\", \"rb\"))\n null_DAPI_stds = pickle.load(open(\"pickles/separatePlateTestDAPIStds.pkl\", \"rb\"))\n fig, ax = plt.subplots()\n xlabels = [\"null\", \"DRW1\", \"DRW2\", \"DRW3\", \"DRW4\", \"DRW5\", \"DRW6\"]\n x = np.array([1, 2, 3, 4, 5, 6])\n width = .26\n rects = ax.bar(x, model_perfs, width, yerr=model_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\"red\", label=\"ML Model\", zorder=3)\n rects2 = ax.bar(x + width, null_YFP_performances, width, yerr=null_YFP_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\"gold\",label=\"Null YFP Model\", zorder=3)\n rects3 = ax.bar(x+ 2*width, null_DAPI_performances, width, yerr=null_DAPI_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\"blue\", label=\"Null DAPI Model\", zorder=3)\n autolabel(rects, ax, fontsize=8)\n autolabel(rects2, ax, fontsize=8)\n autolabel(rects3, ax, fontsize=8)\n plt.title(\"Pearson Performance by Drug Perturbation\",fontname=\"Times New Roman\", fontsize=14, y=1.0)\n ax.set_ylabel(\"Pearson Correlation Coefficient\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_xlabel(\"Drug\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_xticklabels(xlabels,fontsize=12, fontname=\"Times New Roman\")\n plt.yticks(fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylim((0,1))\n ax.yaxis.grid(True, linestyle='-', which='major', color='grey', alpha=.25, zorder=0)\n ax.xaxis.set_major_locator(plt.MaxNLocator(7))\n box = ax.get_position()\n ax.set_position([box.x0, box.y0, box.width, box.height * 0.85])\n ax.legend(loc='upper right', prop={\"family\":\"Times New Roman\", \"size\":10}, bbox_to_anchor=(1, 1.32))\n plt.gcf().subplots_adjust(top=.76)\n plt.savefig(\"matplotlib_figures/separatedPlatesPerformance.png\", dpi=300)","def multiple_bars(self, df, nrows, ncols, dict):\n fig, axs = plt.subplots(nrows=8, ncols=1, figsize=(6, 9.3), sharey=\"row\")\n\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\n\n indexes = df.index.tolist()\n df[\"index\"] = indexes\n df[\"effect_size\"] = df[\"index\"].apply(lambda x: x[0])\n df[\"sd\"] = df[\"index\"].apply(lambda x: x[1])\n df[\"group\"] = df[\"index\"].apply(lambda x: x[2])\n bar_width = 0.35\n # get an index to set the ticks for the x axis\n\n df_new = df.groupby(\"sd\")\n # for key, item in df_new:\n # print(df_new.get_group(key))\n for ax, (sd, dat) in zip(axs, df_new):\n n_groups = len(dat.index)\n index = np.arange(n_groups)\n\n # make barchart for permutation test\n bar1 = ax.bar(index, dat[\"perm\"], bar_width, color='b',\n label='Permutation test')\n # make barchart for t-test\n bar2 = ax.bar(index + bar_width, dat[\"t_test\"], bar_width, color='r',\n label='t-test')\n es = dat[\"effect_size\"].iloc[0]\n\n ax.set_ylabel(\"Error\")\n ax.set_xticks(index + bar_width / 2)\n ax.set_xticklabels(dict[\"xtickslabels\"])\n ax.set_xlabel(f\"Mean error for sd = {sd} per group size\")\n print(dat[\"sig\"])\n print(\"\\n\\n\")\n for rect, i in zip(bar1 + bar2, dat[\"sig\"]):\n height = rect.get_height()\n if i:\n ax.text(rect.get_x() + rect.get_width(), height, \"**\", ha='center', va='bottom')\n\n ax.legend()\n\n fig.suptitle(f\"Effect size = {es}\", y=1.0, fontsize = 15)\n fig.tight_layout()\n plt.show()","def show_dcr_results(dg):\n cycle = dg.fileDB['cycle'].values[0]\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\n # print(df_dsp.describe()) \n\n # compare DCR and A/E distributions\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\n \n elo, ehi, epb = 0, 25000, 100\n \n # aoe distribution\n # ylo, yhi, ypb = -1, 2, 0.1\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\n p0.set_ylabel('A/E', ha='right', y=1)\n\n # dcr distribution\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\n # ylo, yhi, ypb = -3, 2, 0.1\n ylo, yhi, ypb = 0.9, 1.08, 0.001\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\n p1.set_ylabel('DCR', ha='right', y=1)\n \n # plt.show()\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\n plt.cla()","def results():\n\n # # 1. tau_e graph\n # # ------------------------------------------------------------\n\n tau_es = np.load(datapath / \"tau_es.npy\", allow_pickle=True)\n\n # I want to plot tau_e against b for various Ns. Annoyingly this\n # means I have to do some index juggling.\n\n # This is all because of the way I set up datagen.DataSet... oh well.\n\n for i, N in enumerate(Ns):\n\n # values to plot against b for the specific N\n vals = []\n\n for j, b in enumerate(bs):\n\n k = Nb_to_ks[i][j]\n vals.append(tau_es[k])\n\n plt.plot(bs, vals, \"-\")\n\n plt.title(\"Auto-correlation e-folding timelag for \"\n \"variable temperatures, grid sizes\")\n\n plt.xlabel(\"$\\\\beta$\")\n plt.ylabel(\"$\\\\tau_e$\")\n\n plt.legend([f\"N={N}\" for N in Ns])\n\n plt.savefig(resultspath / \"tau_es.pdf\")\n # plt.show()\n plt.close()\n\n # 2. magnetisation graphs\n # ------------------------------------------------------------\n\n mags_list = [np.load(datapath / f\"mags-{k}.npy\") for k in range(kcount)]\n\n for i, N in enumerate(Ns):\n\n plt.title(f\"Square magnetisations N={N}\")\n plt.xlabel(\"t\")\n plt.ylabel(\"M\")\n\n for j, b in enumerate(bs):\n\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\n\n k = Nb_to_ks[i][j]\n vals = np.mean(mags_list[k]**2, axis=1)\n plt.plot(vals, color=(1 - c, 0, c))\n\n plt.savefig(resultspath / f\"mags-{N}.pdf\")\n # plt.show()\n plt.close()\n\n # 3. autoc graphs\n # ------------------------------------------------------------\n\n autocs_list = [\n np.load(datapath / f\"autocs-{k}.npy\") for k in range(kcount)]\n\n for i, N in enumerate(Ns):\n\n plt.figure(figsize=(8, 6))\n plt.axes(position=[.05, .05, .8, .9])\n\n plt.title(f\"Auto-correlation of $|M|$ with N={N}\")\n plt.xlabel(\"$ \\\\tau $\")\n plt.ylabel(\"$ A(\\\\tau) $\")\n\n for j, b in enumerate(bs):\n\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\n\n k = Nb_to_ks[i][j]\n autocs = np.load(datapath / f\"autocs-{k}.npy\")\n\n iternum = autocs.shape[0]\n sysnum = autocs.shape[1]\n vals = np.mean(autocs, axis=1)\n errs = np.std(autocs, axis=1, ddof=1) / np.sqrt(sysnum)\n\n plt.errorbar(range(iternum), vals, errs,\n color=(1 - c, 0, c), ecolor=(1 - c, 0, c, 0.4),\n elinewidth=1.5)\n\n # plt.plot(np.log(vals))\n\n plt.legend(bs, loc='center left', bbox_to_anchor=(1, 0.5))\n\n plt.savefig(resultspath / f\"autocs-{N}.pdf\")\n # plt.show()\n plt.close()","def plot_convergence(\n optimizers: list = [\"COBYLA\", \"SLSQP\", \"L-BFGS-B\", \"NELDER-MEAD\"],\n g2N: float = 0.2,\n maxit: int = 10000,\n varform: list = [\"ry\"],\n depth: int = 3,\n nrep: int = 10,\n dataprefix: str = \"data/miniBMN\",\n datasuffix: str = \"h5\",\n figprefix: str = \"figures/miniBMN\",\n ht: float = 0.0,\n up: int = 1000,\n):\n # setup parameters\n params = dict()\n params[\"l\"] = str(g2N).replace(\".\", \"\")\n params[\"d\"] = depth\n params[\"v\"] = \"-\".join(varform)\n params[\"m\"] = maxit\n params[\"n\"] = nrep\n params[\"f\"] = dataprefix\n params[\"s\"] = datasuffix\n assert type(optimizers).__name__ == \"list\"\n # collect data\n result = collect_data(optimizers, params)\n # get best runs\n gs = dict()\n for r in optimizers:\n gs[r] = result.loc[r].groupby(\"rep\").apply(min).energy\n gsdf = pd.DataFrame.from_dict(gs, dtype=float)\n print(gsdf.describe().T[[\"min\", \"max\", \"mean\", \"std\"]])\n # Plot\n # select the best runs for each optimizer\n fig, ax = plt.subplots()\n for o in optimizers:\n result.loc[o, gsdf[o].idxmin()].plot(\n x=\"counts\", y=\"energy\", xlim=[0, up], label=o, ax=ax\n )\n ax.axhline(ht, c=\"k\", ls=\"--\", lw=\"2\", label=\"HT\")\n ax.set_xlabel(\"iterations\")\n ax.set_ylabel(\"VQE energy\")\n ax.legend(loc=\"upper right\")\n filename = f\"{figprefix}_l{params['l']}_convergence_{params['v']}_depth{params['d']}_nr{params['n']}_max{params['m']}_xlim{up}\"\n plt.savefig(f\"{filename}.pdf\")\n plt.savefig(f\"{filename}.png\")\n plt.savefig(f\"{filename}.svg\")\n plt.close()","def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \n\n file_dir = 'SpectralCube_BeamLogs'\n basename = '/beamlog.image.restored.' + imagebase + field\n\n # use different basename for the Milky Way range\n if not glob.glob(file_dir + basename +'*.txt'):\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\n\n \n BEAM_THRESHOLD = []\n \n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\n plt_name1 = 'BmajStdev.png'\n saved_fig1 = fig_dir+'/'+plt_name1\n\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\n plt_name2 = 'BminStdev.png'\n saved_fig2 = fig_dir+'/'+plt_name2\n\n title3 = 'Maximum ratio of beam area'\n plt_name3 = 'max_ratioBA.png'\n saved_fig3 = fig_dir+'/'+plt_name3\n\n title4 = 'Minimum ratio of beam area' \n plt_name4 = 'min_ratioBA.png'\n saved_fig4 = fig_dir+'/'+plt_name4\n \n params = {'axes.labelsize': 10,\n 'axes.titlesize': 10,\n 'font.size':10}\n\n pylab.rcParams.update(params)\n\n beamXPOS, beamYPOS = BeamPosition()\n fig1, ax1 = plt.subplots()\n fig2, ax2 = plt.subplots()\n fig3, ax3 = plt.subplots()\n fig4, ax4 = plt.subplots()\n \n for i in range(0,36):\n bnum = n[i]\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\n BEAM_THRESHOLD.append(beam_threshold)\n\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\n\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\n\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n ax1.set_xlim(0,0.7)\n ax1.set_ylim(0,1.4)\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax1.set_title(title1)\n\n ax2.set_xlim(0,0.7)\n ax2.set_ylim(0,1.4)\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax2.set_title(title2)\n\n ax3.set_xlim(0,0.7)\n ax3.set_ylim(0,1.4)\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax3.set_title(title3)\n plt.colorbar(maxplot, ax=ax3)\n\n ax4.set_xlim(0,0.7)\n ax4.set_ylim(0,1.4)\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax4.set_title(title4)\n plt.colorbar(minplot, ax=ax4)\n\n fig1.savefig(saved_fig1, bbox_inches='tight')\n fig2.savefig(saved_fig2, bbox_inches='tight')\n fig3.savefig(saved_fig3, bbox_inches='tight')\n fig4.savefig(saved_fig4, bbox_inches='tight')\n\n plt.close('all')\n\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD","def plot(self):\n t = np.linspace(0, self.days, self.days + 1)\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\n ax1.plot(t, self.S, label=\"Susceptible\", color='r')\n ax1.set_ylabel(\"Number of Susceptible People\")\n ax1.set_title(\"Strong Infecitous Model SEIRV Simulation\")\n ax3.plot(t, self.I, label=\"Active Cases\", color='b')\n ax3.set_ylabel(\"Active Cases\")\n ax2.plot(t, self.E, label=\"Exposed\", color='c')\n ax2.set_ylabel(\"# of Exposed\")\n ax4.plot(t, self.R, label=\"Recovered\", color='m')\n ax5.set_xlabel(\"Days\")\n ax4.set_ylabel('Number of Recovered')\n ax5.plot(t, self.V, label=\"Vaccinated\")\n ax5.set_ylabel(\"# Vaccinated\")\n ax1.legend()\n ax2.legend()\n ax3.legend()\n ax4.legend()\n plt.show()\n return fig","def plot_results(self):\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))","def plot(self):\n # get data without totals\n data = self.woe_report[self.woe_report.index != 'total']\n # setup panel\n fig, axs = plt.subplots(1, 3, figsize=(12, 3))\n plt.subplots_adjust(wspace=0.3)\n # first chart\n data['P(Hi|A)'].plot(ax=axs[0], linewidth=3, alpha=0.7)\n data['P(Hi|Ā)'].plot(ax=axs[0], linewidth=3, alpha=0.7)\n axs[0].set_title('Probability distribution')\n axs[0].set_xlabel(data.index.name)\n axs[0].set_ylabel('probability')\n axs[0].legend(['P(Hi|A)', 'P(Hi|Ā)'])\n # second chart\n data['weight-of-evidence'].plot(ax=axs[1], linewidth=3, alpha=0.7)\n axs[1].set_title('WoE')\n axs[1].set_xlabel(data.index.name)\n axs[1].set_ylabel('WoE')\n # third chart\n data['information-value'].plot(ax=axs[2], linewidth=3, alpha=0.7)\n axs[2].set_title('Information value')\n axs[2].set_ylabel('IV')","def convergence():\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n # point spread and point total subplots\n subplots = [\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\n (True, [200.5], league.totals, 'probability total > 200.5'),\n ]\n\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\n\n # train margin-dependent Elo model\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, values)\n\n line = lines[-1]\n\n for label2 in label2_list:\n\n # evaluation times and labels\n times = np.arange(league.times.size)[::1000]\n labels1 = times.size * [label1]\n labels2 = times.size * [label2]\n\n # observed win probability\n prob = melo.probability(times, labels1, labels2, lines=line)\n ax.plot(times, prob)\n\n # true (analytic) win probability\n if ax.is_first_row():\n prob = skellam.sf(line, int(label1), int(label2))\n ax.axhline(prob, color='k')\n else:\n prob = poisson.sf(line, int(label1) + int(label2))\n ax.axhline(prob, color='k')\n\n # axes labels\n if ax.is_last_row():\n ax.set_xlabel('Iterations')\n ax.set_ylabel(ylabel)\n\n set_tight(w_pad=.5)","def plot_comparison_section(t, obs, syn, syn_decon, syn_lw):\n\n fig, ax = plt.subplots(1, 2, sharex=True, sharey=True, figsize=(8, 8))\n\n for ir in range(obs.shape[0]):\n # Observed + Standard deconvolution\n if ir == 0:\n label_obs = 'Obs'\n label_syn = 'Syn'\n label_syn_decon = 'Inv'\n else:\n label_obs = None\n label_syn = None\n label_syn_decon = None\n\n ax[0].plot(t, ir + obs[ir, :], 'k', label=label_obs)\n ax[0].plot(t, ir + syn[ir, :], c=(0.85, 0.2, 0.2), label=label_syn)\n ax[0].plot(t, ir + syn_decon[ir, :], c=(0.2, 0.2, 0.85),\n label=label_syn_decon)\n ax[0].set_xlabel('Time in [s]')\n ax[0].set_ylabel('Amplitude')\n ax[0].set_title('Waterlevel')\n\n # Observed + Landweber iterative deconvolution\n ax[1].plot(t, ir + obs[ir, :], 'k')\n ax[1].plot(t, ir + syn[ir, :], c=(0.85, 0.2, 0.2))\n ax[1].plot(t, ir + syn_lw[ir, :], c=(0.2, 0.2, 0.85))\n ax[1].set_xlabel('Time in [s]')\n ax[1].set_title('Landweber')\n ax[1].set_xlim([np.min(t), np.max(t)])\n ax[1].set_ylim([-1, syn_lw.shape[0] + 1.5])\n\n plt.figlegend(frameon=True, fancybox=False, loc='lower center', ncol=3,\n framealpha=1, edgecolor='k', facecolor='w',\n bbox_to_anchor=(0.52, 0.925))\n plt.tight_layout()\n\n plt.show(block=False)","def plotBondEnergy(self, phys, forces, step):\r\n self.plotQuantity(step, phys.app.energies.getTable(2), 'bondenergy')","def plot(self, num_levels=10):\n if num_levels == -1:\n num_levels = len(self.energies())\n print(self.energies(num_levels))\n figure(figsize=(20, 5))\n subplot(1, num_levels + 1, 1)\n self.plot_potential()\n #xlabel('$\\phi$')\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\n subplot(1, num_levels + 1, ii + 2)\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\"None\",aspect='auto')\n imshow(psi2D.real, interpolation=\"None\", aspect='auto')\n xlabel(ii)","def animate(self, i):\n self.advance_animation(0.01)\n self.get_status()\n self.ax2.clear()\n self.ax3.clear()\n self.ax2.plot(np.ones(len(self.healthy))*self.total_beds, 'k--')\n samples = range(0, len(self.healthy))\n self.ax2.stackplot(samples, self.sick, self.healthy, self.recovered, self.dead, labels=['Sick: ' +str(self.sick[-1]),'Healthy: '+str(self.healthy[-1]),'Recovered: '+str(self.recovered[-1]), 'Dead: '+str(self.dead[-1])], colors=['orangered','forestgreen', 'deepskyblue', 'black'])\n #self.ax2.legend(bbox_to_anchor=(1.04,0), loc=\"lower left\", borderaxespad=0)\n self.ax2.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=2, fancybox=True, fontsize=6, shadow=True)\n self.ax2.xaxis.set_ticks([])\n self.ax2.set_ylim(0, self.n+30)\n self.ax3.plot(samples, self.healthy,'forestgreen', label = 'Healthy')\n self.ax3.plot(samples, self.sick, 'orangered', label = 'Sick')\n self.ax3.plot(samples, self.recovered, 'deepskyblue', label = 'Recovered')\n self.ax3.plot(samples, self.dead, 'black', label = 'Dead')\n self.ax3.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=2, fancybox=True, fontsize=6, shadow=True)\n self.ax3.set_ylim(0, self.n+30)\n self.ax3.xaxis.set_ticks([])\n self.ax2.yaxis.set_ticks([])\n self.ax2.set_xlabel('Change over time')\n self.ax3.set_xlabel('Change over time')\n self.ax.set_title('Social Distancing Followed By '+str(self.social_dist)+'% People.')\n self.ax2.set_title('Stacked area graph for each category', fontsize = 8)\n self.ax3.set_title('Percentage graph for each category', fontsize = 8)\n self.exit_animate()","def plot_effect_sizes(self, plot_opts=dict()):\n \n if self.ndim == 1:\n fig, axes = plt.subplots(nrows=self.K, ncols=1, \n sharex=True, \n figsize=(6, 6*self.K))\n \n dmodel_color = plot_opts.get('dmodel_color', '#cc7d21')\n for i, kernel_name in enumerate(self.kernel_dict.keys()):\n summary = self.results[kernel_name].summary(b=self.b)\n# xmin, xmax = summary['es_interval'] \n pdf = summary['es_Disc']\n d_bma = summary['es_BMA'] \n xrange = summary['es_range'] \n n_interp = len(pdf)\n \n axes[i].plot(xrange, pdf, c=dmodel_color, label=r'$M_D$', \n linewidth=1.0, linestyle='--')\n axes[i].fill_between(xrange, pdf, np.zeros((n_interp)), \n alpha=0.3, color=dmodel_color)\n axes[i].axvline(x=0, linewidth=1.0, label=r'$M_C$', color='k', \n linestyle='--') \n axes[i].plot(xrange, d_bma, c='k', label=r'BMA', linewidth=1.0)\n axes[i].fill_between(xrange, d_bma, np.zeros((n_interp)), \n alpha=0.3, color='k')\n axes[i].set_xlim([np.min(xrange), np.max(xrange)])\n axes[i].set_ylabel('Probability density')\n axes[i].set_xlim([xrange[0], xrange[-1]])\n axes[i].set_title('{:s} kernel'.format(kernel_name))\n \n axes[-1].legend(loc='best')\n \n return fig, axes\n else:\n raise NotImplementedError('Effect size plot for D>1 is not implemented')\n # TODO: Part of this code is available in the Dutch elections example.","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def notebook_01():\n\n freq_list, volt_list = las.load_freq_volt()\n\n n_steps, n_det, n_f, _ = np.shape(volt_list)\n\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\n\n # print(np.shape(y_sym_mat_o))\n # print(np.shape(y_sym_mat_i))\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\n # print(mu_o, sigma_o)\n # print(mu_i, sigma_i)\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\n\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\n\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\n\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\n\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\n\n\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\n\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n fp.fit_params_FH_data(ff.f_b_field)\n\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)","def plot(self):\n\t\tself.plotOfLoopVoltage()","def plot_tsnes():\n # Two environments (for main paper figure. All for final figure)\n ENVS = [\n \"BipedalWalker-v3\",\n #\"LunarLander-v2\",\n #\"Pendulum-v0\"\n \"Acrobot-v1\",\n #\"CartPole-v1\"\n ]\n ALGO_TYPES = [\n \"stablebaselines\",\n \"stablebaselines\",\n \"wann\",\n \"wann\",\n ]\n ALGO_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMAES\",\n ]\n ALGO_PRETTY_NAMES = [\n \"A2C\",\n \"PPO\",\n \"NEAT\",\n \"CMA-ES\"\n ]\n\n REWARD_SCALES = {\n \"Pendulum-v0\": [-1600, -200],\n \"Acrobot-v1\": [-500, -100],\n \"LunarLander-v2\": [-230, 200],\n \"BipedalWalker-v3\": [-100, 300],\n \"CartPole-v1\": [0, 500]\n }\n\n figure, axs = pyplot.subplots(\n figsize=[6.4 * 2, 4.8],\n nrows=2,\n ncols=4,\n gridspec_kw={'hspace': 0, 'wspace': 0},\n )\n\n for plot_i in range(2):\n env = ENVS[plot_i]\n reward_scale = REWARD_SCALES[env]\n for algo_i in range(len(ALGO_TYPES)):\n column_idx = (algo_i % 2) + plot_i * 2\n row_idx = 0 if algo_i <= 1 else 1\n ax = axs[row_idx, column_idx]\n algo_type = ALGO_TYPES[algo_i]\n algo_name = ALGO_NAMES[algo_i]\n algo_pretty_name = ALGO_PRETTY_NAMES[algo_i]\n\n experiment_glob = \"experiments/{}_{}_{}_*\".format(algo_type, env, algo_name)\n experiment_paths = glob(experiment_glob)\n tsnes = []\n rewards = []\n for experiment_path in experiment_paths:\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n population_tsnes = []\n population_rewards = []\n for path in pivector_paths:\n data = np.load(path)\n population_tsnes.append(data[\"tsne\"])\n population_rewards.append(data[\"average_episodic_reward\"])\n data.close()\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n tsnes = np.concatenate(tsnes, axis=0)\n rewards = np.concatenate(rewards, axis=0)\n\n # Min-max normalization\n rewards = (rewards - reward_scale[0]) / (reward_scale[1] - reward_scale[0])\n\n scatter = ax.scatter(\n tsnes[:, 0],\n tsnes[:, 1],\n c=rewards,\n cmap=\"plasma\",\n s=1,\n vmin=0,\n vmax=1\n )\n\n ax.text(0.98, 0.98, algo_pretty_name, horizontalalignment=\"right\", verticalalignment=\"top\", transform=ax.transAxes)\n ax.set_xticks([])\n ax.set_yticks([])\n # Hide spines, the outer edges\n ax.spines[\"top\"].set_alpha(0.2)\n ax.spines[\"bottom\"].set_alpha(0.2)\n ax.spines[\"left\"].set_alpha(0.2)\n ax.spines[\"right\"].set_alpha(0.2)\n # Hide edge spines and bolden mid-spines\n if row_idx == 0:\n ax.spines[\"top\"].set_visible(False)\n else:\n ax.spines[\"bottom\"].set_visible(False)\n if column_idx == 0:\n ax.spines[\"left\"].set_visible(False)\n elif column_idx == 1:\n ax.spines[\"right\"].set_alpha(1.0)\n elif column_idx == 2:\n ax.spines[\"left\"].set_alpha(1.0)\n elif column_idx == 3:\n ax.spines[\"right\"].set_visible(False)\n\n # Add titles\n if row_idx == 0 and (column_idx == 0 or column_idx == 2):\n ax.set_title(env.split(\"-\")[0], x=1.0)\n\n cbaxes = figure.add_axes([0.4, 0.94, 0.2, 0.02])\n cbar = figure.colorbar(scatter, orientation=\"horizontal\", cax=cbaxes)\n cbar.set_ticks([0.0, 0.5, 1.0])\n cbar.set_ticklabels([\"Min\", \"Reward\", \"Max\"])\n cbar.ax.xaxis.set_ticks_position('top')\n cbar.ax.xaxis.set_label_position('top')\n cbar.ax.tick_params(labelsize=\"small\", length=0)\n figure.tight_layout()\n figure.savefig(\"figures/tsnes.png\", dpi=200, bbox_inches=\"tight\", pad_inches=0.0)","def plot(self, n_confs):\n \n import pandas as pd\n import numpy as np\n import matplotlib as mpl\n mpl.use('Agg')\n import matplotlib.pyplot as plt\n import csv\n \n n_iter = len(self.plot_data)\n \n data = np.ndarray((n_iter, n_confs+1))\n data[:,0] = [i[0] for i in self.plot_data]\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\n\n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n df.to_csv(f\"{self.plot_name}.tab\", sep=\"\\t\", quoting=csv.QUOTE_NONE) \n\n d = data[:,1:].reshape(-1)\n d = d[~np.isnan(d)]\n mine = d.min() - 0.01\n for i in range(n_confs): \n data[:,i+1] -= mine\n \n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n \n colors = (0,0,0)\n area = 10\n \n # Plot\n fig = plt.figure(figsize=(15, 15))\n ax = fig.add_subplot(1,1,1)\n for i in range(n_confs):\n ax.plot('iter', f'c{i+1}', data=df)\n ax.set_yscale('log')\n\n plt.xlabel('iter')\n plt.ylabel('loss')\n plt.savefig(f'{self.plot_name}.png')","def metaplot_powersum_test():\n all_psums = []\n for i in range(1,4+1):\n print \"starting on\",i\n plt.subplot(2,2,i)\n all_psums.append(plot_powersum_test(G=1000*int(10**(i-1)),trials=10000/int(10**(i-1))))\n plt.show()\n return all_psums","def plot_figures(compare_df, compare_df_without_1_5, over_3, over_6, ppm, \n color_prob, color_count, edgecolor): \n # Create a gridspec to plot in\n fig = plt.figure()\n gs = fig.add_gridspec(2,4)\n ax1 = fig.add_subplot(gs[0,:])\n ax2 = fig.add_subplot(gs[1,:2])\n ax3 = fig.add_subplot(gs[1,2])\n ax4 = fig.add_subplot(gs[1,3])\n \n ##### Plot the total count\n compare_df.plot(kind=\"bar\", ax=ax1,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor )\n ax1.set_title(\"a) Temperature count in AR5 working group reports and special reports until 2020\")\n \n #### Plot without the 1.5 special report\n compare_df_without_1_5.plot(kind=\"bar\", ax=ax2, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax2.set_title(\"b) Excluding special report on 1.5°C warming\")\n plt.setp(ax2.xaxis.get_majorticklabels(), fontsize=6)\n \n #### Plot 3\n over_3.plot(kind=\"bar\", ax=ax3, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax3.set_title(\"c) 3°C and above\")\n plt.setp(ax3.xaxis.get_majorticklabels(), color=\"white\")\n \n #### Plot only 6 degrees and above\n over_6.plot(kind=\"bar\", ax=ax4, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\n ax4.set_title(\"d) 6°C and above\")\n plt.setp(ax4.xaxis.get_majorticklabels(), color=\"white\")\n \n # make nicer\n i = 0\n for ax in [ax1, ax2, ax3, ax4]:\n ax.set_ylabel(\"Percentage [%]\")\n if i == 0:\n plot_nicer(ax)\n else: \n plot_nicer(ax, with_legend=False)\n plt.setp(ax.xaxis.get_majorticklabels(), rotation=0)\n i +=1\n \n fig=plt.gcf()\n fig.set_size_inches(12,6)\n fig.tight_layout()\n plt.savefig(\"Figures\" + os.sep + \"warming_count_\"+str(ppm)+\".png\",dpi=200, bbox_inches=\"tight\")\n plt.close()","def get_energy(edr, annealing_times, energy_type = 'Potential', out_fig = 'energy_distribution.svg'): # Could be Total-Energy\n fig, ax = plt.subplots(figsize = (16,9))\n data = pd.DataFrame()\n xvg_tmp_file = tempfile.NamedTemporaryFile(suffix='.xvg')\n energy = []\n iterator = range(0, len(annealing_times)-1, 2)\n\n for state, index in tqdm.tqdm(enumerate(iterator), total=len(iterator)):#enumerate(iterator):# # the calculation is per pair of times, beetween the first to time the temperature was keep constant, then the system was heated and repeated again.\n run = tools.run(f\"export GMX_MAXBACKUP=-1; echo {energy_type} | gmx energy -f {edr} -b {annealing_times[index]} -e {annealing_times[index + 1]} -o {xvg_tmp_file.name} | grep \\'{energy_type.replace('-',' ')}\\'\")\n energy.append(float(run.stdout.split()[-5]))\n \"\"\"\n Energy Average Err.Est. RMSD Tot-Drift\n -------------------------------------------------------------------------------\n Potential -1.30028e+06 -- 1682.1 -2422.24 (kJ/mol)\n Total Energy -952595 -- 2606.81 -3688.3 (kJ/mol)\n \"\"\"\n # Getting the histograms and checking for the same len in all intervals\n if state == 0:\n data[state] = xvg.XVG(xvg_tmp_file.name).data[:,1]\n else:\n xvg_data = xvg.XVG(xvg_tmp_file.name).data[:,1]\n if xvg_data.shape[0] > data.shape[0]:\n data[state] = xvg_data[:data.shape[0]]\n else:\n data = data.iloc[:xvg_data.shape[0]]\n data[state] = xvg_data\n\n\n print(data)\n sns.histplot(data = data, element='poly', stat = 'probability', axes = ax)\n ax.set(\n xlabel = f'{energy_type} [kJ/mol]',\n ylabel = 'Probability',\n title = f'Distribution of {energy_type}')\n # plt.show()\n fig.savefig(out_fig)\n return energy","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def plotResults(times, result, args, calculate_nT = True, order_SD = False, nSkipp = 1, showProgress = False):\n t1 = time.time()\n times = times[::nSkipp]\n\n if 'omegaArgs' in args:\n wList = args['omega'](times, args['omegaArgs'])\n fList = args['f0']/wList**2 - args['f0']/args['omegaArgs'][0]**2\n else:\n wList = args['omega'](times, args)\n fList = args['f0']/wList**2 - args['f0']/args['w0']**2\n\n masterList = [[],[],[],[]]\n nStates = len(result.states[::nSkipp])\n progress = 0\n for psi in result.states[::nSkipp]:\n alpha, xi, nBar, nT = getParams(psi, calculate_nT = calculate_nT, order_SD = order_SD)\n masterList[0].append(np.abs(alpha))\n masterList[1].append(np.abs(xi))\n masterList[2].append(nBar)\n masterList[3].append(nT)\n if showProgress:\n progress += 1\n print('\\r', \"Progress:\", round(100*progress/nStates), \"%, processing time:\", round(time.time() - t1), \"s\", end = '')\n\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5)\n fig.set_size_inches(15.5, 7.5, forward=True)\n ax1.plot(times, masterList[0], label = r'$|\\alpha |$')\n ax1.legend()\n ax2.plot(times, masterList[1], label = \"r\")\n ax2.legend()\n ax3.plot(times, masterList[2], label = \"nBar\")\n if calculate_nT:\n ax3.plot(times, masterList[3], label = \"nT\")\n ax3.legend()\n ax4.plot(times, wList, label = \"w(t)\")\n ax4.legend()\n ax5.plot(times, fList, label = r'$10^{-15} F/\\hbar$ in N/(Js)')\n ax5.legend()\n plt.show()\n return(0)","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1,MC_runs,1):\n Mi=M*i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\n elif option == 'Put':\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n \n # plotting\n plt.figure(figsize=(8,6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n #The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def plot_n_scenarios(*args):\n if not all([isinstance(a, Scenario) for a in args]):\n raise ValueError(\"all inputs must be Scenario objects\")\n # Build dictionaries of calculated data for each scenario\n scenario_numbers = [a.info[\"id\"] for a in args]\n first_id = scenario_numbers[0]\n scenarios = {id: scen for (id, scen) in zip(scenario_numbers, args)}\n grid = {id: scenario.state.get_grid() for id, scenario in scenarios.items()}\n plant = {k: v.plant for k, v in grid.items()}\n # First scenario is chosen to set fuel colors\n type2color = ModelImmutables(args[0].info[\"grid_model\"]).plants[\"type2color\"]\n carbon_by_type, energy_by_type, type2color = {}, {}\n for id, scenario in scenarios.items():\n # Calculate raw numbers\n annual_plant_energy = scenario.state.get_pg().sum()\n raw_energy_by_type = annual_plant_energy.groupby(plant[id].type).sum()\n annual_plant_carbon = generate_emissions_stats(scenario).sum()\n raw_carbon_by_type = annual_plant_carbon.groupby(plant[id].type).sum()\n # Drop fuels with zero energy (e.g. all offshore_wind scaled to 0 MW)\n energy_by_type[id] = raw_energy_by_type[raw_energy_by_type != 0]\n carbon_by_type[id] = raw_carbon_by_type[raw_energy_by_type != 0]\n # Carbon multiplier is inverse of carbon intensity, to scale bar heights\n carbon_multiplier = energy_by_type[first_id].sum() / carbon_by_type[first_id].sum()\n\n # Determine the fuel types with generation in either scenario\n fuels = list(set.union(*[set(v.index) for v in energy_by_type.values()]))\n # Fill zeros in scenarios without a fuel when it's present in another\n for id in scenario_numbers:\n energy_by_type[id] = energy_by_type[id].reindex(fuels, fill_value=0)\n carbon_by_type[id] = carbon_by_type[id].reindex(fuels, fill_value=0)\n # Re-order according to plotting preferences\n fuels = [f for f in all_possible if f in fuels]\n # Re-assess subsets\n renewable_fuels = [f for f in possible_renewable if f in fuels]\n clean_fuels = [f for f in possible_clean if f in fuels]\n carbon_fuels = [f for f in possible_carbon if f in fuels]\n dropped_fuels = (set(possible_clean) | set(possible_carbon)) - (\n set(clean_fuels) | set(carbon_fuels)\n )\n print(\"no energy in any grid(s), dropping: %s\" % \", \".join(dropped_fuels))\n\n fuel_series = {\n f: sum(\n [\n [energy_by_type[s][f], carbon_by_type[s][f] * carbon_multiplier]\n for s in scenario_numbers\n ],\n [],\n )\n for f in fuels\n }\n num_bars = 2 * len(scenario_numbers)\n ind = np.arange(num_bars)\n width = 0.5\n line_alpha = 0.25\n line_offsets = np.array((0.25, 0.75))\n\n # Strart plotting\n fig = plt.figure(figsize=(10, 8))\n ax = fig.add_subplot(111)\n # Plot bars\n patches = {}\n bottom = np.zeros(num_bars)\n for i, f in enumerate(fuels):\n patches[i] = plt.bar(\n ind, fuel_series[f], width, bottom=bottom, color=type2color[f]\n )\n bottom += fuel_series[f]\n # Plot lines\n for i, fuel in enumerate(carbon_fuels):\n for j, s in enumerate(scenario_numbers):\n cumulative_energy = sum(\n [energy_by_type[s][carbon_fuels[k]] for k in range(i + 1)]\n )\n cumulative_scaled_carbon = carbon_multiplier * sum(\n [carbon_by_type[s][carbon_fuels[k]] for k in range(i + 1)]\n )\n ys = (cumulative_energy, cumulative_scaled_carbon)\n xs = line_offsets + 2 * j\n plt.plot(xs, ys, \"k-\", alpha=line_alpha)\n\n # Labeling\n energy_fmt = \"{0:,.0f} TWh\\n{1:.0f}% renewable\\n{2:.0f}% carbon-free\\n\"\n carbon_fmt = \"{0:,.0f} million\\ntons CO2\\n\"\n energy_total = {s: energy_by_type[s].sum() for s in scenarios}\n for j, s in enumerate(scenario_numbers):\n carbon_total = carbon_by_type[s].sum()\n renewable_energy = sum([energy_by_type[s][f] for f in renewable_fuels])\n clean_energy = sum([energy_by_type[s][f] for f in clean_fuels])\n renewable_share = renewable_energy / energy_total[s] * 100\n clean_share = clean_energy / energy_total[s] * 100\n annotation_str = energy_fmt.format(\n energy_total[s] / 1e6, renewable_share, clean_share\n )\n annotation_x = 2 * (j - 0.08)\n plt.annotate(xy=(annotation_x, energy_total[s]), s=annotation_str)\n annotation_str = carbon_fmt.format(carbon_total / 1e6)\n annotation_x = 2 * (j - 0.08) + 1\n annotation_y = carbon_total * carbon_multiplier\n plt.annotate(xy=(annotation_x, annotation_y), s=annotation_str)\n\n # Plot formatting\n plt.ylim((0, max(energy_total.values()) * 1.2))\n labels = sum([[\"%s Energy\" % id, \"%s Carbon\" % id] for id in scenario_numbers], [])\n plt.xticks(ind, labels)\n plt.yticks([], [])\n ax.tick_params(axis=\"x\", labelsize=12)\n # Invert default legend order to match stack ordering\n plt.legend(\n handles=(patches[i] for i in range(len(fuels) - 1, -1, -1)),\n labels=fuels[::-1],\n fontsize=12,\n bbox_to_anchor=(1.02, 1),\n loc=\"upper left\",\n )\n plt.tight_layout()\n plt.show()","def SA_data_display(opt_df, all_df):\n fig, axs = plt.subplots(2, 3)\n\n axs[0,0].set_title(\"Optimal rewire attempts for circularity\")\n axs[0,0].set_ylabel(\"Percent waste %\")\n axs[0,0].set_xlabel(\"Time (s)\")\n axs[0,0].plot(opt_df[\"Time (s)\"], opt_df[\"Percent waste (%)\"])\n\n axs[0,1].set_title(\"Optimal rewire attempts acceptance probability\")\n axs[0,1].set_ylabel(\"Acceptance Probability\")\n axs[0,1].set_xlabel(\"Time (s)\") # time??\n axs[0,1].scatter(opt_df[\"Time (s)\"], opt_df[\"Probability\"])\n\n axs[0,2].set_title(\"Optimal rewire attempts temperature decrease\")\n axs[0,2].set_ylabel(\"Temperature\")\n axs[0,2].set_xlabel(\"Time (s)\") # time??\n axs[0,2].plot(opt_df[\"Time (s)\"], opt_df[\"Temperature\"])\n\n axs[1,0].set_title(\"All rewire attempts for circularity\")\n axs[1,0].set_ylabel(\"Percent waste %\")\n axs[1,0].set_xlabel(\"Time (s)\")\n axs[1,0].plot(all_df[\"Time (s)\"], all_df[\"Percent waste (%)\"])\n\n axs[1,1].set_title(\"All rewire attempts acceptance probability\")\n axs[1,1].set_ylabel(\"Acceptance Probability\")\n axs[1,1].set_xlabel(\"Time (s)\") # time??\n axs[1,1].scatter(all_df[\"Time (s)\"], all_df[\"Probability\"])\n\n axs[1,2].set_title(\"All rewire attempts temperature decrease\")\n axs[1,2].set_ylabel(\"Temperature\")\n axs[1,2].set_xlabel(\"Time (s)\") # time??\n axs[1,2].plot(all_df[\"Time (s)\"], all_df[\"Temperature\"])\n\n return plt.show()","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def show_calculations(self):\n self.view.set_sum(self.model.get_sum())\n self.view.set_diff(self.model.get_diff())","def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \n cum_step_q = []\n steps_mean = np.array(step_cache_qlearning).mean()\n steps_std = np.array(step_cache_qlearning).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_qlearning:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_q.append(normalized_step)\n cur_step = 0\n count = 0\n \n cum_step_SARSA = []\n steps_mean = np.array(step_cache_SARSA).mean()\n steps_std = np.array(step_cache_SARSA).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_SARSA:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_SARSA.append(normalized_step)\n cur_step = 0\n count = 0 \n # prepare the graph \n plt.plot(cum_step_q, label = \"q_learning\")\n plt.plot(cum_step_SARSA, label = \"SARSA\")\n plt.ylabel('Number of iterations')\n plt.xlabel('Batches of Episodes (sample size 10) ')\n plt.title(\"Q-Learning/SARSA Iteration number untill game ends\")\n plt.legend(loc='lower right', ncol=2, mode=\"expand\", borderaxespad=0.)\n plt.show()\n plt.savefig('number_steps.png')","def plot_series_and_differences(series, ax, num_diff, title=''):\n plt.xticks(rotation=40)\n ax[0].plot(series.index, series)\n ax[0].set_title('Raw series: {}'.format(title))\n ax[0].set_xticklabels(labels=series.index.date, rotation=45)\n for i in range(1, num_diff+1):\n diff = series.diff(i)\n ax[i].plot(series.index, diff)\n ax[i].set_title('Difference # {}'.format(str(i)))\n ax[i].set_xticklabels(labels=series.index.date, rotation=45)","def plot_dispatch_comm(pv, demand, E, week=30,flag=False):\n\n sliced_index = (pv.index.week==week)\n pv_sliced = pv[sliced_index]\n demand_sliced = demand[sliced_index]\n self_consumption = E['inv2load'][sliced_index]\n \n direct_self_consumption = np.minimum(pv_sliced,demand_sliced)# E['inv2load'][sliced_index]\n indirect_self_consumption = self_consumption-direct_self_consumption\n res_pv_sliced = E['res_pv'][sliced_index]\n grid2load_sliced = E['grid2load'][sliced_index]\n store2inv_sliced = E['store2inv'][sliced_index]\n LevelOfCharge = E['LevelOfCharge'][sliced_index]\n inv2grid = E['inv2grid'][sliced_index]\n grid2load = E['grid2load'][sliced_index]\n aux=np.maximum(0,self_consumption)\n\n fig, axes = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(17, 4*3), frameon=False,\n gridspec_kw={'height_ratios': [3, 1, 1], 'hspace': 0.04})\n\n #fig, ax = plt.subplots(figsize=(17, 4))\n axes[0].plot(demand_sliced.index, demand_sliced, color='black', lw=2,label='demand')\n \n if flag:\n axes[0].plot(pv_sliced.index, pv_sliced, color='green', lw=2,label='pv')\n axes[0].plot(direct_self_consumption.index, direct_self_consumption, color='yellow', lw=2,label='DSC')\n axes[0].plot(indirect_self_consumption.index, indirect_self_consumption, color='orange', lw=2,label='ISC')\n axes[0].plot(grid2load_sliced.index, grid2load_sliced, color='red', lw=2,label='grid')\n\n else:\n axes[0].fill_between(direct_self_consumption.index, 0, direct_self_consumption, color='orange', alpha=.8, label='DSC')\n axes[0].fill_between(pv_sliced.index, self_consumption, pv_sliced ,where=pv_sliced<demand_sliced, color='blue', hatch='//',\n alpha=.3,label='ISC')\n axes[0].fill_between(pv_sliced.index, direct_self_consumption, pv_sliced , color='gold', alpha=.3,label='Excess PV')\n\n axes[0].fill_between(grid2load_sliced.index,self_consumption,demand_sliced,color='red',alpha=.2, label='grid2load')\n axes[0].set_ylim([0, axes[0].get_ylim()[1] ])\n axes[0].set_ylabel('Power (kW)')\n\n axes[1].fill_between(LevelOfCharge.index, 0, LevelOfCharge, color='grey', alpha=.2, label='SOC')\n axes[1].set_ylabel('State of Charge (kWh)')\n\n axes[2].fill_between(inv2grid.index, 0, inv2grid, color='green', alpha=.2,label='injected2grid')\n axes[2].fill_between(inv2grid.index, 0, -grid2load, color='red', alpha=.2,label='grid drawn')\n axes[2].set_ylabel('In/out from grid (kW)')\n axes[0].legend()\n axes[1].legend()\n axes[2].legend()\n return","def plot_dispatch(pv, demand, E, week=30):\n\n sliced_index = (pv.index.week==week)\n pv_sliced = pv[sliced_index]\n demand_sliced = demand[sliced_index]\n self_consumption = E['inv2load'][sliced_index]\n \n direct_self_consumption = np.minimum(pv_sliced,demand_sliced)# E['inv2load'][sliced_index]\n indirect_self_consumption = self_consumption-direct_self_consumption\n res_pv_sliced = E['res_pv'][sliced_index]\n grid2load_sliced = E['grid2load'][sliced_index]\n store2inv_sliced = E['store2inv'][sliced_index]\n LevelOfCharge = E['LevelOfCharge'][sliced_index]\n inv2grid = E['inv2grid'][sliced_index]\n grid2load = E['grid2load'][sliced_index]\n aux=np.maximum(0,self_consumption)\n\n fig, axes = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(17, 4*3), frameon=False,\n gridspec_kw={'height_ratios': [3, 1, 1], 'hspace': 0.04})\n\n #fig, ax = plt.subplots(figsize=(17, 4))\n axes[0].plot(demand_sliced.index, demand_sliced, color='black', lw=2,label='demand')\n axes[0].plot(pv_sliced.index, pv_sliced, color='black',ls='--', lw=2,label='PV')\n axes[0].fill_between(direct_self_consumption.index, 0, direct_self_consumption, color='orange', alpha=.8, label='DSC')\n axes[0].fill_between(pv_sliced.index, self_consumption, pv_sliced , where=pv_sliced<demand_sliced,color='blue', hatch='//',\n alpha=.3,label='ISC')\n axes[0].fill_between(pv_sliced.index, direct_self_consumption, pv_sliced ,where=pv_sliced>demand_sliced, color='gold', alpha=.3,label='Excess PV')\n\n axes[0].fill_between(grid2load_sliced.index,self_consumption,demand_sliced,color='red',alpha=.2, label='grid2load')\n \n\n #axes[0].plot(grid2load_sliced.index, grid2load_sliced, color='red', ls=\":\", lw=1)\n axes[0].set_ylim([0, axes[0].get_ylim()[1] ])\n axes[0].set_ylabel('Power (kW)')\n\n axes[1].fill_between(LevelOfCharge.index, 0, LevelOfCharge, color='grey', alpha=.2, label='SOC')\n axes[1].set_ylabel('State of Charge (kWh)')\n\n axes[2].fill_between(inv2grid.index, 0, inv2grid, color='green', alpha=.2,label='injected2grid')\n axes[2].fill_between(inv2grid.index, 0, -grid2load, color='red', alpha=.2,label='grid drawn')\n axes[2].set_ylabel('In/out from grid (kW)')\n axes[0].legend()\n axes[1].legend()\n axes[2].legend()\n return","def plot_ncmc_work(self, filename):\n with PdfPages(filename) as pdf:\n for envname in self.get_environments():\n modname = 'NCMCEngine'\n work = dict()\n for direction in ['delete', 'insert']:\n varname = '/' + envname + '/' + modname + '/' + 'work_' + direction\n try:\n # TODO: For now, we analyze all but the last sample, so that this can be run on active simulations.\n # Later, we should find some way to omit the last sample only if it is nonsensical.\n work[direction] = self._ncfile[varname][:-1,:]\n print('Found %s' % varname)\n except Exception as e:\n pass\n\n def plot_work_trajectories(pdf, work, title=\"\"):\n \"\"\"Generate figures for the specified switching legs.\n \"\"\"\n plt.figure(figsize=(12, 8))\n\n nrows = 2\n ncols = 6\n workcols = 2\n for (row, direction) in enumerate(['delete', 'insert']):\n #\n # Plot work vs step\n #\n\n col = 0\n plt.subplot2grid((nrows,ncols), (row, col), colspan=(ncols-workcols))\n\n # Plot average work distribution in think solid line\n plt.plot(work[direction].mean(0), 'k-', linewidth=1.0, alpha=1.0)\n # Plot bundle of work trajectories in transparent lines\n plt.plot(work[direction].T, 'k-', linewidth=0.5, alpha=0.3)\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\n workvals = np.ravel(np.abs(work[direction]))\n worklim = np.percentile(workvals, 98)\n nsteps = work[direction].shape[1]\n plt.axis([0, nsteps, -worklim, +worklim])\n # Label plot\n if row == 1: plt.xlabel('steps')\n plt.ylabel('work / kT')\n plt.title(\"%s NCMC in environment '%s' : %s\" % (title, envname, direction))\n plt.legend(['average work', 'NCMC attempts'])\n\n #\n # Plot work histogram\n #\n\n col = ncols - workcols\n plt.subplot2grid((nrows,ncols), (row, col), colspan=workcols)\n\n # Plot average work distribution in think solid line\n #nbins = 40\n workvals = work[direction][:-1,-1]\n #plt.hist(workvals, nbins)\n if workvals.std() != 0.0:\n sns.distplot(workvals, rug=True)\n else:\n print('workvals has stddev of zero')\n print(workvals)\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\n #worklim = np.percentile(workvals, 98)\n #oldaxis = plt.axis()\n #plt.axis([-worklim, +worklim, 0, oldaxis[3]])\n # Label plot\n if row == 1: plt.xlabel('work / kT')\n plt.title(\"total %s work\" % direction)\n\n pdf.savefig() # saves the current figure into a pdf page\n plt.close()\n\n if len(work) > 0:\n # Plot work for all chemical transformations.\n plot_work_trajectories(pdf, work, title='(all transformations)')\n\n # Plot work separated out for each chemical transformation\n #[niterations, nsteps] = work.shape\n #transformations = dict()\n #for iteration in range(niterations):\n # plot_work_trajectories(pdf, work, title='(all transformations)')","def eda_plot():\n\n df1 = pd.read_csv('eda_malware.csv')\n df2 = pd.read_csv('eda_random.csv')\n df3 = pd.read_csv('eda_popular.csv')\n\n df = pd.concat([df1, df2, df3], ignore_index=True)\n df['label'].replace([0,1],['Benign','Malware'],inplace=True)\n\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB', '#97C1A9']\n # b vs. m: node types counts\n f1 = pd.crosstab(df['label'], df['node_types_counts'])\n\n f1 = pd.DataFrame({\"3 Types\": [1, 4], \"4 Types\": [1, 407], \"5 Types\": [245, 5768], \"6 Types\": [39, 1113], \"7 Types\": [83, 487], \"8 Types\": [154, 368], \"9 Types\": [103, 286]}).rename(index={0:'Benign', 1:'Malware'})\n f1.plot(kind='bar', color=colors)\n fig = plt.gcf()\n plt.legend(loc='upper left')\n plt.title('Benign vs. Malicious: Number of Node Types')\n fig.savefig('bv_node_types.png')\n\n # for a better look, limit type 5 malware to 2k counts only\n f1 = pd.DataFrame({\"3 Types\": [1, 4], \"4 Types\": [1, 407], \"5 Types\": [245, 2000], \"6 Types\": [39, 1113], \"7 Types\": [83, 487], \"8 Types\": [154, 368], \"9 Types\": [103, 286]}).rename(index={0:'Benign', 1:'Malware'})\n f1.plot(kind='bar', color=colors)\n fig = plt.gcf()\n plt.legend(loc='upper left')\n plt.title('Benign vs. Malicious: Number of Node Types')\n fig.savefig('bv_node_types1.png')\n\n # node types\n # for malware: extract node types info for node types counts > 5, and sum up each types counts\n node_types = df[(df['label'] == 'Malware') & (df['node_types_counts'] >= 5)]['node_types'] #series\n lst = [ast.literal_eval(s) for s in node_types]\n\n c = Counter()\n for d in lst:\n c.update(d)\n\n df_nt = pd.DataFrame(dict(c).items(), columns=['node_types', 'counts'])\n df_nt = df_nt.sort_values(by=['counts'])\n\n sizes = [215060, 2823059, 3135725, 5641356, 10679709, 16547701]\n labels = ['Others', 'static,Node', 'public,static,Node', 'Node', 'external,Node', 'public,Node']\n\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB']\n\n fig1, ax1 = plt.subplots(figsize=(7, 7))\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\n shadow=False, startangle=90, colors=colors)\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n plt.title('Malware: Top Node Types and Its Counts', y=1.05)\n\n plt.show()\n fig1.savefig('counts_pie_m.png')\n\n # for benign: extract node types info for node types counts, and sum up each types counts\n node_types = df[(df['label'] == 'Benign')]['node_types'] #series\n lst = [ast.literal_eval(s) for s in node_types]\n\n c = Counter()\n for d in lst:\n c.update(d)\n\n df_nt = pd.DataFrame(dict(c).items(), columns=['node_types', 'counts'])\n df_nt = df_nt.sort_values(by=['counts'])\n\n sizes = [77967, 2892033, 2964924, 5287258, 6478196, 20364339]\n labels = ['Others', 'staticNode', 'public,staticNode', 'external,Node', 'Node', 'public,Node']\n\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB']\n\n fig1, ax1 = plt.subplots(figsize=(7, 7))\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\n shadow=False, startangle=90, colors=colors)\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n plt.title('Benign: Top Node Types and Its Counts', y=1.05)\n\n plt.show()\n fig1.savefig('counts_pie_b.png')\n\n # benign vs malware: counts\n sizes = [8435, 802]\n labels = ['Benign', 'Malware']\n\n colors = ['#EAB6AB','#D9E6F3']\n\n fig1, ax1 = plt.subplots(figsize=(7, 7))\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\n shadow=False, startangle=90, colors=colors)\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n plt.title('Number of Benign vs. Malware', y=1.05)\n\n plt.show()\n fig1.savefig('bm_counts.png')\n\n # number of edges vs number of nodes\n groups = df.groupby('label')\n colors = ['#FFAEA5', '#A2E1DB']\n\n # Plot\n fig, ax = plt.subplots()\n ax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n for name, group in groups:\n if name == 'Benign':\n c = colors[0]\n else:\n c = colors[1]\n ax.plot(group.number_edges, group.number_nodes, marker='o', linestyle='', ms=4, label=name, c=c)\n ax.legend()\n ax.set_xlabel('Number of Edges')\n ax.set_ylabel('Number of Nodes')\n ax.set_title('Benign & Malware: Number of Edges vs. Number of Nodes', y=1.05)\n\n plt.show()\n fig.savefig('bm_edges_nodes.png')","def plot_evolution(self, layer, sublayer, figures=[], axes=[]):\n if figures==[]:\n figures.append(plt.figure(\"Basis evolution per recording (euclidean distance between sets of basis)\"))\n distance_legend = [\"Base N: \"+str(i) for i in range(len(self.basis[layer][sublayer]))]\n axes.append(figures[0].add_subplot('111'))\n axes[0].plot(self.basis_distance[layer][sublayer])\n axes[0].legend(tuple(distance_legend))\n axes[0].set_xlabel(\"Recording Number\")\n \n evolution_parameters=np.array([self.noise_history[layer][sublayer], \n self.learning_history[layer][sublayer],\n self.sparsity_history[layer][sublayer],\n self.sensitivity_history[layer][sublayer]]).transpose()\n evolution_legend = (\"Noise\",\"Learning step\",\"Sparsity\",\"Sensitivity\")\n figures.append(plt.figure(\"Network parameter evolution per recording\"))\n axes.append(figures[1].add_subplot('111'))\n axes[1].plot(evolution_parameters)\n axes[1].legend(tuple(evolution_legend))\n axes[1].set_xlabel(\"Recording Number\")\n else:\n \n axes[0].clear()\n distance_legend = [\"Base N: \"+str(i) for i in range(len(self.basis[layer][sublayer]))] \n axes[0].plot(self.basis_distance[layer][sublayer])\n axes[0].legend(tuple(distance_legend))\n axes[0].set_xlabel(\"Recording Number\")\n \n axes[1].clear()\n evolution_parameters=np.array([self.noise_history[layer][sublayer], \n self.learning_history[layer][sublayer],\n self.sparsity_history[layer][sublayer],\n self.sensitivity_history[layer][sublayer]]).transpose()\n evolution_legend = (\"Noise\",\"Learning step\",\"Sparsity\",\"Sensitivity\")\n axes[1].plot(evolution_parameters)\n axes[1].legend(tuple(evolution_legend))\n axes[1].set_xlabel(\"Recording Number\")\n return figures, axes","def basic_stats_and_plots():\n \n basename = sys.argv[1]\n ops = (\"two_opt\", \"twoh_opt\", \"three_opt\", \"three_opt_broad\", \"swap\", \"swap_adj\")\n opfs = {\n \"two_opt\": tsp.two_opt,\n \"twoh_opt\": tsp.twoh_opt,\n \"three_opt\": tsp.three_opt,\n \"three_opt_broad\": tsp.three_opt_broad,\n \"swap\": tsp.swap_two,\n \"swap_adj\": tsp.swap_adj\n }\n \n lengths = range(6, 11)\n for length in lengths:\n stddev = []\n gini = []\n nneighbours = []\n prop_unique = []\n for op in ops:\n filename = os.path.join(basename,\n \"tsp_length_%d_%s\" % (length, op),\n \"TP_row0.dat\")\n print op, length\n x = np.genfromtxt(filename)\n # stats to get:\n stddev.append(np.std(x))\n gini.append(random_walks.gini_coeff(x))\n nneighbours.append(np.sum(x > 0))\n mu, sigma = rw_experiment_with_op(length, opfs[op])\n prop_unique.append((mu, sigma))\n\n gini_barchart(length, gini, ops)\n stddev_barchart(length, stddev, ops)\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)","def plot_compartments(self, compartments, show=True, save_path=None, names=None):\n print 'Copying voltages and recovery variables for debugging...'\n # Note if they have already been copied then the following functions won't\n # do a copy\n v = self.get_voltages()\n\n # Check for infinities\n x, y = np.where(np.isinf(np.array(v)))\n print \"Bad compartments found \", y\n _, naning = np.where(np.isnan(np.array(v)))\n print \"Nans found:\", naning\n # If none found, yay and set tmax to whole range\n if len(x) == 0:\n t_max = v.shape[0]\n else:\n t_max = x[0] - 1\n print \"Voltage shape\", v.shape\n\n m, n, h = self.get_recovery_variables()\n f, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, sharex=True)\n neighbours = self.neuron_collection.get_neighbour_idx(compartments[1])\n\n ax1.set_title('Compartments ' + str(compartments))\n ax1.set_ylabel('Voltage /mV')\n ax2.set_ylabel('m')\n ax3.set_ylabel('n')\n ax4.set_ylabel('h')\n ax4.set_xlabel('Step')\n ax5.axis('off')\n for index, i in enumerate(np.append(compartments, neighbours)):\n\n p_v = v[:t_max, i]\n p_m = m[:t_max, i]\n p_n = n[:t_max, i]\n p_h = h[:t_max, i]\n\n if index < len(names):\n label = names[index]\n else:\n label = \"c_idx:\" + str(i)\n\n ax1.plot(p_v, label=label)\n ax2.plot(p_m, label=label)\n ax3.plot(p_n, label=label)\n ax4.plot(p_h, label=label)\n ax1.set_ylim(-50, 200)\n ax2.set_ylim(0, 1)\n ax3.set_ylim(0, 1)\n ax4.set_ylim(0, 1)\n\n handles, labels = ax1.get_legend_handles_labels()\n f.legend(handles, labels, loc='lower center', ncol=3, borderaxespad=2)\n\n if save_path is not None:\n #fig.tight_layout()\n plt.savefig(save_path)\n print \"Saved figure to \" + save_path\n if show:\n plt.show()\n if not show:\n plt.clf()","def _run():\n\n temperatures_kelvins = _create_temperature_grid()\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\n second_derivs_kelvins_pt01 = numpy.gradient(\n numpy.absolute(first_derivs_kelvins_pt01)\n )\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(first_derivs_kelvins_pt01)\n )\n\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(second_derivs_kelvins_pt01)\n )\n\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\n\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n temperature_handle = axes_object.plot(\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n second_deriv_handle = axes_object.plot(\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n first_deriv_handle = axes_object.plot(\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n this_min_index = numpy.argmin(second_derivs_unitless)\n second_derivs_unitless[\n (this_min_index - 10):(this_min_index + 10)\n ] = second_derivs_unitless[this_min_index]\n\n tfp_handle = axes_object.plot(\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n axes_object.set_yticks([0])\n axes_object.set_xticks([], [])\n\n x_label_string = r'$x$-coordinate (increasing to the right)'\n axes_object.set_xlabel(x_label_string)\n\n legend_handles = [\n temperature_handle, first_deriv_handle, second_deriv_handle,\n tfp_handle\n ]\n\n legend_strings = [\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\n ]\n\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\n\n print 'Saving figure to file: \"{0:s}\"...'.format(OUTPUT_FILE_NAME)\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\n pyplot.close()","def energy_kde_paperplot(fields,df):\n plt.figure()\n i = 0\n colorList = ['dodgerblue','tomato']\n lw = 2\n\n meanE_2 = []\n meanE_3 = []\n mup = np.min(df['energy [eV]']) - pp.mu\n chi_0 = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(fields[0]))\n g_en_axis, _, _, _, _, _, _, _, _, _, _, _, _, _ = \\\n occupation_plotter.occupation_v_energy_sep(chi_0, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), np.zeros(len(g_en_axis)), '-', color='black', lineWidth=lw,label='Equilibrium')\n\n for ee in fields:\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \"E_{:.1e}.npy\".format(ee))\n # meanE_2 = utilities.mean_energy(chi_2_i,df)\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\n occupation_plotter.occupation_v_energy_sep(chi_2_i, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,'--',color = colorList[i],lineWidth=lw,label=r'Low Field {:.0f} '.format(ee/100)+r'$V \\, cm^{-1}$')\n print(integrate.trapz(g_chiax,g_en_axis))\n\n # plt.plot(meanE_2-np.min(df['energy [eV]']),0,'.')\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \"E_{:.1e}.npy\".format(ee))\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\n occupation_plotter.occupation_v_energy_sep(chi_3_i, df['energy [eV]'].values, df)\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,color = colorList[i],lineWidth=lw,label=r'Full Drift {:.0f} '.format(ee/100)+r'$V \\, cm^{-1}$')\n print(integrate.trapz(g_chiax,g_en_axis))\n\n i = i + 1\n # plt.plot(g_en_axis - np.min(df['energy [eV]']), g_f0ax, '--', color='black', lineWidth=lw,label=r'$f_0$')\n\n plt.legend()\n # plt.ylim([-0.02, 0.015])\n plt.xlabel(r'Energy above CBM ($eV$)')\n plt.ylabel(r'Deviational occupation $\\delta f_{\\mathbf{k}}$ (norm.)')\n # plt.ylabel(r'$\\delta f_{\\mathbf{k}}/f_{\\mathbf{k}}^0$')\n plt.savefig(pp.figureLoc+'energy_KDE.png', bbox_inches='tight',dpi=600)\n\n plt.figure()\n plt.plot(g_en_axis,g_chiax)\n\n plt.figure()\n Z, xedges, yedges = np.histogram2d(df['kx [1/A]']*chi_3_i,df['ky [1/A]']*chi_3_i)\n plt.pcolormesh(xedges, yedges, Z.T)\n\n from scipy.stats.kde import gaussian_kde\n g_inds,_,_ = utilities.gaas_split_valleys(df,False)\n g_df = df.loc[g_inds]\n\n x = g_df['kx [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\n y = g_df['ky [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\n\n # y = g_df['energy [eV]']*(chi_3_i[g_inds]+g_df['k_FD'])\n k = gaussian_kde(np.vstack([x, y]))\n xi, yi = np.mgrid[x.min():x.max():x.size ** 0.5 * 1j, y.min():y.max():y.size ** 0.5 * 1j]\n zi = k(np.vstack([xi.flatten(), yi.flatten()]))\n\n fig = plt.figure(figsize=(7, 8))\n ax1 = fig.add_subplot(211)\n ax2 = fig.add_subplot(212)\n\n # alpha=0.5 will make the plots semitransparent\n ax1.pcolormesh(xi, yi, zi.reshape(xi.shape), alpha=0.5)\n ax2.contourf(xi, yi, zi.reshape(xi.shape), alpha=0.5)\n\n ax1.set_xlim(x.min(), x.max())\n ax1.set_ylim(y.min(), y.max())\n ax2.set_xlim(x.min(), x.max())\n ax2.set_ylim(y.min(), y.max())","def plot_all(self):\n self.plot_ramps()\n self.plot_groupdq()","def n27_and_stark():\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\n # n=27 without static field.\n folder = os.path.join(\"..\", \"..\", \"2018-09-09\")\n fname = \"11_freq_diode.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n data['afpoly'] = data['fpoly'] + 4511\n ax.axhline(0, color='grey')\n data.plot(x='afpoly', y='sig', c='k', ax=ax)\n # n=27 with static field.\n fname = \"10_freq_diode.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n data['afpoly'] = data['fpoly'] + 4511\n data['asig'] = data['sig'] + 0.15\n ax.axhline(0.15, color='grey')\n data.plot(x='afpoly', y='asig', c='k', ax=ax)\n # text\n ax.text(-5.5, 0.2, \"3 V/cm\", horizontalalignment='right')\n ax.text(-5.5, 0.01, \"0 V/cm\", horizontalalignment='right')\n # pretty figure\n ax.legend().remove()\n ax.set_ylabel(r\"$e^-$ Signal\")\n ax.set_yticks([])\n ax.set_xlabel(r\"Frequency (GHz from $3d_{5/2} \\rightarrow 27f$)\")\n ax.set_xlim(-8, 7)\n # save\n fig.tight_layout()\n fig.savefig('n27_and_stark.pdf')\n return","def figure_1():\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n\n # Draw common plots\n print(exp_list)\n data = get_data(exp_list[0])\n plt.figure(num=\"state 1\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"cmd\"],\n **FORMATTING[\"command\"]\n )\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 0],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_1$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"state 2\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 1],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_2$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"control\")\n plt.ylabel(r\"$u$\")\n plt.xlabel(\"Time, sec\")\n\n def general_figures(exp):\n data = get_data(exp)\n plt.figure(num=\"state 1\")\n ax = plt.gca()\n ax.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 0],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"state 2\")\n plt.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 1],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"control\")\n plt.plot(\n data[\"time\"], data[\"control\"],\n **FORMATTING[exp],\n )\n\n for exp in exp_list:\n general_figures(exp)\n\n # Estimation error\n for exp in exp_list:\n data = get_data(exp)\n error = nla.norm(\n data[\"state\"][\"adaptive_system\"] - data[\"real_param\"],\n axis=1\n )\n plt.figure(num=\"Estimation error\")\n plt.plot(data[\"time\"], error, **FORMATTING[exp])\n plt.xlabel(\"Time, sec\")\n plt.ylabel(\"Error norm\")\n\n # Real parameter\n data = get_data(exp_list[0])\n plt.plot(data[\"time\"], data[\"real_param\"].squeeze())\n\n\n exp_list.remove(\"mrac-nullagent\")\n\n def eig_figures(exp, minmax):\n data = get_data(exp)\n if minmax == \"min\":\n eig = np.min(data[\"eigs\"], axis=1)\n elif minmax == \"max\":\n eig = np.max(data[\"eigs\"], axis=1)\n plt.plot(data[\"time\"], eig, **FORMATTING[exp])\n\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\"Eigenvalues\", sharex=True)\n\n plt.subplot(211)\n plt.ticklabel_format(style=\"sci\", scilimits=(0, 0), useOffset=True)\n for exp in exp_list:\n eig_figures(exp, \"min\")\n plt.ylabel(r\"Minimum $\\lambda$\")\n plt.legend()\n\n plt.subplot(212)\n for exp in exp_list:\n eig_figures(exp, \"max\")\n plt.ylabel(r\"Maximum $\\lambda$\")\n plt.xlabel(\"Time, sec\")\n\n # Saving\n def savefig(name):\n path = os.path.join(args.save_dir, name + \".\" + args.save_ext)\n plt.savefig(path, bbox_inches=\"tight\")\n\n plt.figure(num=\"state 1\")\n plt.legend()\n savefig(\"state-1\")\n\n plt.figure(num=\"state 2\")\n plt.legend()\n savefig(\"state-2\")\n\n plt.figure(num=\"control\")\n plt.legend()\n savefig(\"control\")\n\n plt.figure(num=\"Eigenvalues\")\n savefig(\"eigs\")\n\n plt.figure(num=\"Estimation error\")\n plt.legend()\n savefig(\"estim-error\")\n\n plt.show()","def plot_test_objective_multi(df, exp_config, output_dir, show):\n output_file_name = f\"{inspect.stack()[0][3]}.{FILE_EXTENSION}\"\n output_path = os.path.join(output_dir, output_file_name)\n\n plt.figure()\n\n for exp_name, exp_df in df.items():\n\n if \"rep\" in exp_config[\"data\"][exp_name]:\n\n exp_dfs = exp_df\n\n T = np.linspace(0, exp_config[\"t_max\"], 50000)\n\n y_list = []\n for i, df_i in enumerate(exp_dfs):\n\n df_i = process_for_test_objective(\n df_i.sort_values(\"timestamp_end\"),\n mode=MODE,\n max_budget=exp_config[\"max_budget\"],\n )\n x = df_i.loc[df_i[\"max_idx\"]][\"timestamp_end\"].values\n y = df_i.loc[df_i[\"max_idx\"]][exp_config[\"test_objective\"]].values\n\n f = interp1d(x, y, kind=\"previous\", fill_value=\"extrapolate\")\n y = exp_config.get(\"best_objective\", 1) - f(T)\n y_list.append(y)\n\n y_list = np.asarray(y_list)\n y_mean = y_list.mean(axis=0)\n y_std = y_list.std(axis=0)\n y_se = y_std / np.sqrt(y_list.shape[0])\n\n plt.plot(\n T,\n y_mean,\n label=exp_config[\"data\"][exp_name][\"label\"],\n color=exp_config[\"data\"][exp_name][\"color\"],\n linestyle=exp_config[\"data\"][exp_name].get(\"linestyle\", \"-\"),\n )\n plt.fill_between(\n T,\n y_mean - 1.96 * y_se,\n y_mean + 1.96 * y_se,\n facecolor=exp_config[\"data\"][exp_name][\"color\"],\n alpha=0.3,\n )\n\n else:\n\n exp_df = process_for_test_objective(\n exp_df.sort_values(\"timestamp_end\"),\n mode=MODE,\n max_budget=exp_config[\"max_budget\"],\n )\n x = exp_df.loc[exp_df[\"max_idx\"]][\"timestamp_end\"].values\n y = exp_df.loc[exp_df[\"max_idx\"]][exp_config[\"test_objective\"]].values\n\n idx = np.unique(x, return_index=True, axis=0)[1]\n\n x = x[idx]\n y = y[idx]\n\n x = np.clip(np.concatenate([x, [exp_config[\"t_max\"]]]), 0, exp_config[\"t_max\"])\n y = np.clip(exp_config.get(\"best_objective\", 1) - np.concatenate([y, [y[-1]]]), 0, 1)\n \n area = aulc(x, y)\n exp_config[\"data\"][exp_name][\"AULC\"] = area\n \n plt.step(\n x[:],\n y[:],\n where=\"post\",\n label=exp_config[\"data\"][exp_name][\"label\"],\n color=exp_config[\"data\"][exp_name][\"color\"],\n marker=exp_config[\"data\"][exp_name].get(\"marker\", None),\n markevery=len(x) // 5,\n linestyle=exp_config[\"data\"][exp_name].get(\"linestyle\", \"-\"),\n )\n\n ax = plt.gca()\n ticker_freq = exp_config[\"t_max\"] / 5\n ax.xaxis.set_major_locator(ticker.MultipleLocator(ticker_freq))\n ax.xaxis.set_major_formatter(minute_major_formatter)\n\n if exp_config.get(\"title\") and PRINT_TITLE:\n plt.title(exp_config.get(\"title\"))\n\n # if MODE == \"min\":\n # plt.legend(loc=\"upper right\")\n # else:\n # plt.legend(loc=\"lower right\")\n plt.legend(loc=exp_config.get(\"legend\", \"best\"))\n\n plt.ylabel(\"Test Regret\")\n plt.xlabel(\"Search time (min.)\")\n\n if exp_config.get(\"ylim\"):\n plt.ylim(*exp_config.get(\"ylim\"))\n\n if exp_config.get(\"xlim\"):\n plt.xlim(*exp_config.get(\"xlim\"))\n else:\n plt.xlim(0, exp_config[\"t_max\"])\n\n if exp_config.get(\"yscale\"):\n plt.yscale(exp_config.get(\"yscale\"))\n\n plt.grid(which=\"minor\", color=\"gray\", linestyle=\":\")\n plt.grid(which=\"major\", linestyle=\"-\")\n plt.tight_layout()\n plt.savefig(output_path, dpi=360)\n if show:\n plt.show()\n plt.close()","def plot_dist_evolution(arr, nbins=20, fracs=np.array([0.1, 0.2, 0.3, 0.4]), last=0.5):\n fracs = fracs\n\n last = last\n last_subset = arr[int(last * arr.shape[0]) :]\n\n for ff in fracs:\n\n subset = arr[: int(ff * arr.shape[0])]\n\n pl.hist(\n subset, nbins, histtype=\"step\", density=True, label=\"f=0.0--{}\".format(ff)\n )\n\n pl.hist(\n last_subset,\n nbins,\n histtype=\"step\",\n density=True,\n label=\"f={}--1.0\".format(last),\n )\n\n pl.legend(loc=\"best\", ncol=3)\n\n pl.show()\n\n return None","def Te_ne_P_panel(**kwargs):\n\n GR = glo.global_results()\n gal_indices = np.arange(GR.N_gal)\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n for gal_index in gal_indices:\n fig = plt.figure(figsize=(15,7),constrained_layout=False)\n gal_ob = gal.galaxy(GR=GR, gal_index=gal_index)\n cell_data = gal_ob.cell_data.get_dataframe()\n\n gs1 = fig.add_gridspec(nrows=1, ncols=3, wspace=0.0, hspace=0.0)\n\n ax = fig.add_subplot(gs1[0,0])\n h = np.histogram(np.log10(cell_data.Te_mw),bins=100)\n bin_size = (h[1][1]-h[1][0])/2\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\n ax.set_xlabel('log mass-weighted T$_{e}$ per cell')\n ax.set_ylabel('Mass fraction')\n\n ax = fig.add_subplot(gs1[0,1])\n h = np.histogram(np.log10(cell_data.ne_mw_grid),bins=100)\n bin_size = (h[1][1]-h[1][0])/2\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\n ax.set_xlabel('log mass-weighted n$_{e}$ per cell')\n ax.set_ylabel('Mass fraction')\n\n ax = fig.add_subplot(gs1[0,2])\n h = np.histogram(np.log10(cell_data.P_HII),bins=100)\n bin_size = (h[1][1]-h[1][0])/2\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\n ax.set_xlabel('log mass-weighted P$_{HII}$ per cell')\n ax.set_ylabel('Mass fraction')\n\n plt.tight_layout()\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'cell_data/pressure/'): os.mkdir(p.d_plot + 'cell_data/pressure/')\n plt.savefig(p.d_plot + 'cell_data/pressure/G%i' % gal_index, dpi=250, facecolor='w')\n plt.close()","def app_SN_last_24h_plots(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting con_last_24h_plots')\n\n for df, direc in zip(dfs, phase_dirs):\n df = self.data_processor.create_24h_subset(df)\n self.plotter.plot_SN_separate_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True\n )\n self.plotter.plot_SN_separate_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True\n )\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True,\n )\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True,\n )\n\n print('Done\\n')","def plot_energy(self, color=['r','g','b','c','m','y','k'], mod = 'E0'):\n if not mpl: raise \"Problem with matplotib: Plotting not possible.\"\n f = plt.figure(figsize=(5,4), dpi=100)\n a = f.add_subplot(111)\n strainList= self.__structures.items()[0][1].strainList\n \n if len(strainList)<=5:\n kk=1\n ll=len(strainList)\n grid=[ll]\n elif len(strainList)%5 == 0:\n kk=len(strainList)/5\n ll=5\n grid=[5 for i in range(kk)]\n else:\n kk=len(strainList)/5+1\n ll=5\n grid=[5 for i in range(kk)]\n grid[-1]=len(strainList)%5\n \n \n n=1\n m=1\n j=0\n for stype in strainList:\n \n spl = '1'+str(len(strainList))+str(n)\n if (n-1)%5==0: m=0\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\n \n \n \n fi=open(stype+'.energy','w')\n \n #self.search_for_failed()\n atoms = self.get_atomsByStraintype(stype)\n if self.__thermodyn and mod=='F':\n energy = [i.gsenergy+i.phenergy[100] for i in atoms]\n elif self.__thermodyn and mod=='E0':\n energy = [i.gsenergy for i in atoms]\n elif self.__thermodyn and mod=='Fvib':\n energy = [i.phenergy[100] for i in atoms]\n else:\n energy = [i.gsenergy for i in atoms]\n strain = [i.eta for i in atoms]\n \n ii=0\n for (e,s) in zip(energy,strain):\n if e==0.: \n energy.pop(ii); strain.pop(ii)\n ii-=1\n ii+=1\n #print stype, energy, [i.scale for i in atoms]\n plt.plot(strain, energy, '%s*'%color[j%7])\n \n k=0\n for st in strain:\n fi.write('%s %s \\n'%(st,energy[k]))\n k+=1\n fi.close()\n \n poly = np.poly1d(np.polyfit(strain,energy,self.__fitorder[j]))\n xp = np.linspace(min(strain), max(strain), 100)\n a.plot(xp, poly(xp),color[j%7],label=stype)\n \n a.set_title(stype)\n \n j+=1\n \n n+=1\n m+=1\n \n a.set_xlabel('strain')\n a.set_ylabel(r'energy in eV')\n #a.legend(title='Strain type:')\n \n return f","def plot_exp1():\n legend = ['unweighted', 'weighted']\n labels = ['Degree','Closeness','Current-flow closeness','Betweenness','Current-flow betweenness','Load','Eigenvector','PageRank','HITS authorities','HITS hubs']\n\n # classification\n d = [[0.52500000000000002,0.49444444444444446], # Degree\n [0.57499999999999996,0.57499999999999996], # Closeness\n [0.56944444444444442,0.58333333333333337], # Current-flow closeness\n [0.36388888888888887,0.36944444444444446], # Betweenness\n [0.23333333333333334,0.20833333333333334], # Current-flow betweenness\n [0.35555555555555557,0.36666666666666664], # Load\n [0.49722222222222223,0.45555555555555555], # Eigenvector\n [0.52777777777777779,0.51111111111111107], # PageRank\n [0.49722222222222223,0.45555555555555555], # HITS authorities\n [0.49722222222222223,0.45555555555555555]] # HITS hubs\n ys = {0:'0.0',.1:'0.1',.2:'0.2', .3:'0.3',.4:'0.4',.5:'0.5',.6:'0.6'}\n fig = plotter.tikz_barchart(d, labels, scale = 3.5, yscale=2.8, color='black', legend=legend, legend_sep=1.0, tick=False, y_tics=ys)\n data.write_to_file(fig,'../../masteroppgave/report/imgs/tikz/dependency_eval_class.tex',mode='w')\n\n # retrieval\n d = [[0.18149811054435275,0.18821229318222113], # Degree\n [0.17184314735361236,0.18216618328598347], # Closeness\n [0.14606637651984622,0.13586098100141117], # Betweenness\n [0.17399729543537901,0.17613717518129621], # Current-flow closeness\n [0.042019078720146409,0.042019078720146409], # Current-flow betweenness\n [0.14700372822743263,0.15104493506838745], # Load\n [0.19854658693196564,0.17540014008712554], # Eigenvector\n [0.17725358882165362,0.17252331100724849], # PageRank\n [0.19854658693196564,0.17540014008712554], # HITS authorities\n [0.19854658693196564,0.17540014008712554]] # HITS hubs\n ys = {0:'0.0',.05:'0.05', .1:'0.1',.15:'0.15', .2:'0.2'}\n fig = plotter.tikz_barchart(d, labels, scale = 3.5, yscale=8, color='black', legend=legend, legend_sep=1.0, tick=False, grid_step=0.05, y_tics=ys)\n data.write_to_file(fig,'../../masteroppgave/report/imgs/tikz/dependency_eval_retr.tex',mode='w')","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1, MC_runs, 1):\n Mi = M * i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\n elif option == 'Put':\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n\n # plotting\n plt.figure(figsize=(8, 6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n # The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def plot(self):\n\n fig, ax = plt.subplots()\n\n for run in self.runs:\n # Load datasets\n data_measure = run.get_dataset(\"stats-collect_link_congestion-raw-*.csv\")\n data_sp = run.get_dataset(\"stats-collect_link_congestion-sp-*.csv\")\n\n # Extract link congestion information\n data_measure = data_measure['msgs']\n data_sp = data_sp['msgs']\n\n # Compute ECDF and plot it\n ecdf_measure = sm.distributions.ECDF(data_measure)\n ecdf_sp = sm.distributions.ECDF(data_sp)\n\n variable_label = \"\"\n size = run.orig.settings.get('size', None)\n if size is not None:\n variable_label = \" (n=%d)\" % size\n\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\n label=\"U-Sphere%s\" % variable_label)\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\n label=u\"Klasični usmerjevalni protokol%s\" % variable_label)\n\n ax.set_xlabel('Obremenjenost povezave')\n ax.set_ylabel('Kumulativna verjetnost')\n ax.grid()\n ax.axis((28, None, 0.99, 1.0005))\n self.convert_axes_to_bw(ax)\n\n legend = ax.legend(loc='lower right')\n if self.settings.GRAPH_TRANSPARENCY:\n legend.get_frame().set_alpha(0.8)\n fig.savefig(self.get_figure_filename())","def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\n \n # Determine dimensions of plot grid\n nrows = len(perp_list) + 1\n ncols = len(data_list)\n \n # Configure axes\n axes = []\n fig = plt.figure(figsize = (16, 3 * nrows))\n \n # Generate plots of starting points (first two columns for high-dimensional)\n for index, dat in enumerate(data_list):\n X, labs = dat\n \n # Check whether original data should be plotted in 3D, and adjust axes accordingly\n if plot_3d:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_axis_off()\n else:\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n axes[-1].set_title(\"\\n\".join(wrap(title_list[index], 35))) \n \n # Based on function input, generate either perplexity plots of interim iteration plots\n if perp_plot:\n # Generate plots of t-SNE output for different perplexities\n for perp in range(len(perp_list)):\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \"fastest\", df = df)\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(perp_list[perp]))\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')\n else:\n # Generate plots of t-SNE output for different iterations\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \"fastest\", \\\n df = df)\n for step in range(len(step_list)):\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\n axes[-1].set_title(\"Perplexity = \" + str(step_plot_perp) + \", Step = \" + str(step_list[step]))\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\n edgecolor = None, alpha = 0.8,\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\n axes[-1].set_xticklabels([])\n axes[-1].set_yticklabels([])\n axes[-1].xaxis.set_ticks_position('none')\n axes[-1].yaxis.set_ticks_position('none')","def plot_hist_snfit_meta(self): \n \n self.read_meta()\n self.read_snfit_results()\n\n \n self.diff_x0 = []\n self.diff_x0_err = []\n self.diff_x1 = []\n self.diff_x1_err = [] \n self.diff_c = []\n self.diff_c_err = [] \n self.diff_mb = []\n self.diff_mb_err = [] \n self.diff_cov_x0_x1 = []\n self.diff_cov_x0_c = []\n self.diff_cov_x1_c = []\n self.diff_cov_mb_x1 = []\n self.diff_cov_mb_c = []\n\n for i in range (len(self.sn_name)):\n for j in range (len(self.meta_sn_name_list)):\n if self.sn_name[i] == self.meta_sn_name_list[j]:\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \n self.diff_c.append(self.c[i] - self.meta_c[j])\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\n# self.diff_cov_x0_x1.append()\n# self.diff_cov_x0_c.append()\n# self.diff_cov_x1_c.append()\n# self.diff_cov_mb_x1.append()\n# self.diff_cov_mb_c.append()\n else:\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\n\n\n fig = plt.figure(figsize=(8.,8.)) \n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x0,25,label='$\\Delta$ X0')\n ax0_2.hist(self.diff_x0_err,25,label='$\\Delta$ X0 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x1,25,label='$\\Delta$ X1')\n ax0_2.hist(self.diff_x1_err,25,label='$\\Delta$ X1 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_c,25,label='$\\Delta$ Color')\n ax0_2.hist(self.diff_c_err,25,label='$\\Delta$ Color error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n\n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_mb,50,label='$\\Delta$ mb')\n ax0_2.hist(self.diff_mb_err,50,label='$\\Delta$ mb error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()"],"string":"[\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\\n df_decomposed = df.loc[df['block'] == 'decomposed']\\n df_joint = df.loc[df['block'] == 'joint']\\n ticklabels = []\\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\\n for i in range(len(num_sweeps)):\\n ticklabels.append('K=%d\\\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\\n fig = plt.figure(figsize=(fs*2.5, fs))\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax1.set_xticks(num_sweeps)\\n ax1.set_xticklabels(ticklabels)\\n ax1.tick_params(labelsize=fontsize)\\n ax1.grid(alpha=0.4)\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax2.set_xticks(num_sweeps)\\n ax2.set_xticklabels(ticklabels)\\n ax2.tick_params(labelsize=fontsize)\\n ax2.grid(alpha=0.4)\\n ax2.legend(fontsize=fontsize)\\n ax1.legend(fontsize=fontsize)\\n ax1.set_ylabel(r'$\\\\log \\\\: p_\\\\theta(x, \\\\: z)$', fontsize=35)\\n ax2.set_ylabel('ESS / L', fontsize=35)\",\n \"def plot_variables(self, n, show=False, diagnostics=False):\\n\\n if diagnostics:\\n fig, ax = plt.subplots(5, 1, sharex = True, figsize = (10, 10))\\n else:\\n fig, ax = plt.subplots(2, 1, sharex = True, figsize = (10, 10))\\n\\n plt.subplots_adjust(hspace = 0)\\n end = len(n.history[\\\"det F\\\"])\\n epochs = np.arange(end)\\n a, = ax[0].plot(epochs, n.history[\\\"det F\\\"], label = 'Training data')\\n b, = ax[0].plot(epochs, n.history[\\\"det test F\\\"], label = 'Test data')\\n # ax[0].axhline(y=5,ls='--',color='k')\\n ax[0].legend(frameon = False)\\n ax[0].set_ylabel(r'$|{\\\\bf F}_{\\\\alpha\\\\beta}|$')\\n ax[0].set_title('Final Fisher info on test data: %.3f'%n.history[\\\"det test F\\\"][-1])\\n ax[1].plot(epochs, n.history[\\\"loss\\\"])\\n ax[1].plot(epochs, n.history[\\\"test loss\\\"])\\n # ax[1].set_xlabel('Number of epochs')\\n ax[1].set_ylabel(r'$\\\\Lambda$')\\n ax[1].set_xlim([0, len(epochs)]);\\n \\n if diagnostics:\\n ax[2].plot(epochs, n.history[\\\"det C\\\"])\\n ax[2].plot(epochs, n.history[\\\"det test C\\\"])\\n # ax[2].set_xlabel('Number of epochs')\\n ax[2].set_ylabel(r'$|{\\\\bf C}|$')\\n ax[2].set_xlim([0, len(epochs)]);\\n \\n # Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,0]\\n , color = 'C0', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"dμdθ\\\"])[:,0,1]\\n , color = 'C0', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n \\\"\\\"\\\"\\n\\n # Test Derivative of first summary wrt to theta1 theta1 is 3rd dimension index 0\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,0]\\n , color = 'C1', label=r'$\\\\theta_1$',alpha=0.5)\\n \\n \\\"\\\"\\\"\\n # Test Derivative of first summary wrt to theta2 theta2 is 3rd dimension index 1\\n ax[3].plot(epochs, np.array(n.history[\\\"test dμdθ\\\"])[:,0,1]\\n , color = 'C1', ls='dashed', label=r'$\\\\theta_2$',alpha=0.5)\\n ax[3].legend(frameon=False)\\n \\\"\\\"\\\"\\n\\n ax[3].set_ylabel(r'$\\\\partial\\\\mu/\\\\partial\\\\theta$')\\n # ax[3].set_xlabel('Number of epochs')\\n ax[3].set_xlim([0, len(epochs)])\\n\\n # Mean of network output summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],alpha=0.5)\\n # Mean of test output network summary 1\\n ax[4].plot(epochs, np.array(n.history[\\\"test μ\\\"])[:,0],alpha=0.5)\\n ax[4].set_ylabel('μ')\\n ax[4].set_xlabel('Number of epochs')\\n ax[4].set_xlim([0, len(epochs)])\\n \\n\\n print ('Maximum Fisher info on train data:',np.max(n.history[\\\"det F\\\"]))\\n print ('Final Fisher info on train data:',(n.history[\\\"det F\\\"][-1]))\\n \\n print ('Maximum Fisher info on test data:',np.max(n.history[\\\"det test F\\\"]))\\n print ('Final Fisher info on test data:',(n.history[\\\"det test F\\\"][-1]))\\n\\n if np.max(n.history[\\\"det test F\\\"]) == n.history[\\\"det test F\\\"][-1]:\\n print ('Promising network found, possibly more epochs needed')\\n\\n plt.tight_layout()\\n plt.savefig(f'{self.figuredir}variables_vs_epochs_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def plot_derivatives_divided(self, show=False):\\n\\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\\n ax[2, 0].set_title('Difference between upper and lower training examples');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n ax[2, 0].legend(frameon=False)\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\\n ax[2, 1].set_title('Difference between upper and lower test samples');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def main():\\n # Load properties that will be needed\\n store = [Storage.Storage(2), Storage.Storage(4)] \\n pre_energy = [s.get(\\\"free_energy\\\") for s in store]\\n post_energy = [s.get(\\\"post_energy\\\") for s in store]\\n x_range = store[0].get(\\\"x_range\\\")\\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\\n y_range = store[0].get(\\\"y_range\\\")\\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\\n # Calculate step size\\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \\n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \\n # Set up the figure\\n fig = plt.figure(1, figsize=(7.5,2.5)) \\n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\\n # Plot the results\\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\\n # Annotate the plots\\n axe[0].set_title(\\\"4sXB step size\\\")\\n axe[0].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[0].set_ylabel(\\\"Step size (nm)\\\")\\n axe[0].set_xlim((25.5, 39))\\n axe[0].set_ylim((1, 8))\\n axe[1].set_title(\\\"2sXB step size\\\")\\n axe[1].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[1].set_ylabel(\\\"Step size (nm)\\\")\\n axe[1].set_xlim((25.5, 39))\\n axe[1].set_ylim((1, 8))\\n # Display the plots\\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\\n left=0.08, right=0.98,\\n top=0.85, bottom=0.21)\\n plt.show()\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def plot(self, nsteps_max=10):\\r\\n fig = plt.figure()\\r\\n ax1 = plt.subplot(221)\\r\\n ax2 = plt.subplot(222)\\r\\n ax3 = plt.subplot(224)\\r\\n\\r\\n if 'fig' in locals(): # assures tight layout even when plot is manually resized\\r\\n def onresize(event): plt.tight_layout()\\r\\n try: cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\\r\\n except: pass\\r\\n\\r\\n self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax1)\\r\\n\\r\\n if getattr(self.px_spec, 'ref_tree', None) is None:\\r\\n self.calc_px(method='LT', nsteps=nsteps_max, keep_hist=True)\\r\\n\\r\\n self.plot_bt(bt=self.px_spec.ref_tree, ax=ax2, title='Binary tree of stock prices; ' + self.specs)\\r\\n self.plot_bt(bt=self.px_spec.opt_tree, ax=ax3, title='Binary tree of option prices; ' + self.specs)\\r\\n # fig, ax = plt.subplots()\\r\\n # def onresize(event): fig.tight_layout()\\r\\n # cid = fig.canvas.mpl_connect('resize_event', onresize) # tighten layout on resize event\\r\\n # self.plot_px_convergence(nsteps_max=nsteps_max, ax=ax)\\r\\n\\r\\n try: plt.tight_layout()\\r\\n except: pass\\r\\n plt.show()\",\n \"def plot_2nd(self, mod = 'F'):\\n if not mpl: raise \\\"Problem with matplotib: Plotting not possible.\\\"\\n f = plt.figure(figsize=(5,4), dpi=100)\\n \\n A2 = []\\n \\n strainList= self.__structures.items()[0][1].strainList\\n \\n if len(strainList)<=5:\\n kk=1\\n ll=len(strainList)\\n grid=[ll]\\n elif len(strainList)%5 == 0:\\n kk=len(strainList)/5\\n ll=5\\n grid=[5 for i in range(kk)]\\n else:\\n kk=len(strainList)/5+1\\n ll=5\\n grid=[5 for i in range(kk)]\\n grid[-1]=len(strainList)%5\\n \\n \\n n=1\\n m=1\\n for stype in strainList:\\n atoms = self.get_atomsByStraintype(stype)\\n self.__V0 = atoms[0].V0\\n strainList = atoms[0].strainList\\n if self.__thermodyn and mod == 'F':\\n energy = [i.gsenergy+i.phenergy[-1] for i in atoms]\\n elif self.__thermodyn and mod=='E0':\\n energy = [i.gsenergy for i in atoms]\\n elif self.__thermodyn and mod=='Fvib':\\n energy = [i.phenergy[-1] for i in atoms]\\n else:\\n energy = [i.gsenergy for i in atoms]\\n \\n strain = [i.eta for i in atoms]\\n \\n spl = '1'+str(len(strainList))+str(n)\\n #plt.subplot(int(spl))\\n #a = f.add_subplot(int(spl))\\n if (n-1)%5==0: m=0\\n \\n \\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\\n #print (kk,ll), ((n-1)/5,m)\\n j = 0\\n for i in [2,4,6]:\\n ans = Energy()\\n ans.energy = energy\\n ans.strain = strain\\n ans.V0 = self.__V0\\n \\n fitorder = i\\n ans.set_2nd(fitorder)\\n A2.append(ans.get_2nd())\\n \\n strains = sorted(map(float,A2[j+3*(n-1)].keys()))\\n \\n try:\\n dE = [A2[j+3*(n-1)][str(s)] for s in strains]\\n except:\\n continue\\n a.plot(strains, dE, label=str(fitorder))\\n a.set_title(stype)\\n a.set_xlabel('strain')\\n a.set_ylabel(r'$\\\\frac{d^2E}{d\\\\epsilon^2}$ in eV')\\n \\n j+=1\\n \\n n+=1\\n m+=1\\n \\n a.legend(title='Order of fit')\\n return f\",\n \"def test_run_beta_diversity_through_plots(self):\\r\\n run_beta_diversity_through_plots(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=False,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n unweighted_unifrac_dm_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_dm.txt')\\r\\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\\r\\n unweighted_unifrac_pc_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_pc.txt')\\r\\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\\r\\n weighted_unifrac_html_fp = join(self.test_out,\\r\\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def n27_and_sidebands():\\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\\n # n=26 through n=29\\n folder = os.path.join(\\\"..\\\", \\\"..\\\", \\\"2018-09-06\\\")\\n fname = \\\"1_dye_fscan.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n ax.axhline(0, color='grey')\\n data.plot(x='fpoly', y='sig', label=\\\"MW Off\\\", c='k', ax=ax)\\n # sidebands\\n folder = os.path.join(\\\"..\\\", \\\"..\\\", \\\"2018-09-09\\\")\\n fname = \\\"1_freq_dye.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n data['asig'] = data['sig'] - 0.3\\n ax.axhline(-0.3, color='grey')\\n data.plot(x='fpoly', y='asig', label=\\\"MW On\\\", c='k', ax=ax)\\n # pretty figure\\n ax.legend().remove()\\n ax.set_ylabel(r\\\"$e^-$ Signal\\\")\\n ax.set_yticks([])\\n ax.set_xlabel(\\\"Frequency (GHz from Limit)\\\")\\n ax.set_xticks([-4863, -4511, -4195, -3908])\\n ax.text(-4400, -0.15, \\\"MW On\\\")\\n ax.text(-4400, 0.3, \\\"MW Off\\\")\\n # save\\n fig.tight_layout()\\n fig.savefig(\\\"n27_and_sidebands.pdf\\\")\\n return\",\n \"def plot_balance_list(balance_list, b_scale='linear', progress = False, n_lims = None):\\n if n_lims == None:\\n n_min = 0\\n n_max=len(balance_list)\\n else:\\n n_min = n_lims[0]\\n n_max = n_lims[1]\\n ncols=2\\n nrows=int(np.ceil((n_max-n_min)/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(22, 5*nrows))\\n for n in range(n_min, n_max):\\n ni = n-n_min \\n i = int(np.floor(ni / ncols))\\n j=ni % ncols\\n r_p = []\\n if progress: \\n for k in range(len(balance_list[n])-1):\\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\\n\\n axes[i,j].plot(balance_list[n], label='balance', color='b')#we put [1:] because want not to show drop in the beginning: TODO: understand fully and explain\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n # axes[i,j].set_yscale('log')\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('balance norm')\\n axes[i,j].legend()\\n axes[i,j].set_yscale(b_scale)\\n if progress: \\n ax_2=axes[i,j].twinx()\\n ax_2.plot(r_p, 'g')\\n ax_2.set_yscale('log')\\n ax_2.set_ylabel('relative change')\",\n \"def vis_difference(self):\\n print(self.init_vec)\\n\\n init = self.init_output.numpy()\\n\\n alphas = np.linspace(0, 1, 20)\\n for i, alpha in enumerate(alphas):\\n\\n display.clear_output(wait=True)\\n norm = [torch.linalg.norm(torch.tensor(\\n self.init_vec + alpha*self.eigen[i]), axis=1).detach().numpy() for i in range(2)]\\n\\n diff = np.array([self.compute_difference(\\n alpha, self.eigen[i]) for i in range(2)])\\n\\n fig = plt.figure(figsize=(14, 12), tight_layout=True)\\n fig.suptitle(\\\"Latent direction variation\\\", fontsize=20)\\n gs = gridspec.GridSpec(2, 2)\\n\\n ax_temp = plt.subplot(gs[0, :])\\n ax_temp.scatter(\\n init[:, 0], init[:, 1])\\n ax_temp.set_title(\\\"Initial Dataset\\\")\\n ax_temp.set_xlim(-1, 1)\\n ax_temp.set_ylim(-1, 1)\\n [s.set_visible(False) for s in ax_temp.spines.values()]\\n\\n for j in range(2):\\n ax_temp = plt.subplot(gs[1, j])\\n sc = ax_temp.quiver(\\n init[:, 0], init[:, 1], diff[j, :, 0], diff[j, :, 1], norm[j])\\n sc.set_clim(np.min(norm[j]), np.max(norm[j]))\\n plt.colorbar(sc)\\n ax_temp.set_title(\\n \\\"Direction: {}, alpha: {}\\\".format(j+1, alpha))\\n ax_temp.set_xlim(-1, 1)\\n ax_temp.set_ylim(-1, 1)\\n [s.set_visible(False) for s in ax_temp.spines.values()]\\n\\n plt.savefig(\\\"frames_dir/fig_{}\\\".format(i))\\n plt.show()\",\n \"def plotdFvsLambda1():\\n x = numpy.arange(len(df_allk))\\n if x[-1]<8:\\n fig = pl.figure(figsize = (8,6))\\n else:\\n fig = pl.figure(figsize = (len(x),6))\\n width = 1./(len(P.methods)+1)\\n elw = 30*width\\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\\n lines = tuple()\\n for name in P.methods:\\n y = [df_allk[i][name]/P.beta_report for i in x]\\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\\n lines += (line[0],)\\n pl.xlabel('States', fontsize=12, color='#151B54')\\n pl.ylabel('$\\\\Delta G$ '+P.units, fontsize=12, color='#151B54')\\n pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)\\n pl.yticks(fontsize=8)\\n pl.xlim(x[0], x[-1]+len(lines)*width)\\n ax = pl.gca()\\n for dir in ['right', 'top', 'bottom']:\\n ax.spines[dir].set_color('none')\\n ax.yaxis.set_ticks_position('left')\\n for tick in ax.get_xticklines():\\n tick.set_visible(False)\\n\\n leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)\\n leg.get_frame().set_alpha(0.5)\\n pl.title('The free energy change breakdown', fontsize = 12)\\n pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')\\n pl.close(fig)\\n return\",\n \"def _show_learning_rate():\\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\\n\\n # Visualize c_prime\\n c_prime_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"c'\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[0]\\n x_list = c_prime_list\\n\\n # MNIST\\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n # Visualize t0\\n t0_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"t0\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[1]\\n x_list = t0_list\\n\\n # MNIST\\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n plt.show()\",\n \"def plot_bs(self, show=False, density=True, pcolor=\\\"r\\\", mcolor=\\\"b\\\", lw=1.0, subtract = 0):\\n cm = matplotlib.cm.jet\\n\\n if (subtract !=0):\\n geqbispectra = subtract\\n else:\\n geqbispectra = np.zeros(np.shape(self.eqbispectra))\\n\\n if (density):\\n \\\"\\\"\\\" also read the local overdensity value and plot line colors according to\\n the density value, + = red, - = blue; adjust alpha accordingly\\n \\\"\\\"\\\"\\n if len(self.ds)<self.Nsubs:\\n print (\\\"no density data\\\")\\n return 0\\n\\n ads=np.abs(self.ds)\\n meands=np.mean(self.ds)\\n mads=np.max(ads)\\n normds=np.array([ads[i]/mads for i in range(len(ads))])\\n self.normds=normds\\n\\n cNorm = colors.Normalize(min(self.ds), vmax=max(self.ds))\\n scalarMap = cmap.ScalarMappable(norm=cNorm, cmap=cm)\\n scalarMap.set_array([])\\n\\n fig, ax = self.plt.subplots()\\n\\n for sub in range(self.Nsubs):\\n #print sub\\n if not(density):\\n lplot=ax.plot(self.klist, self.fNLeq[sub])\\n else:\\n colorVal = scalarMap.to_rgba(self.ds[sub])\\n lplot = ax.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=colorVal, alpha=normds[sub], linewidth=lw)\\n \\\"\\\"\\\"\\n if self.ds[sub]>meands:\\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=pcolor, alpha=normds[sub], linewidth=lw)\\n else:\\n self.plt.plot(self.klist[1:-1], self.eqbispectra[sub][1:-1]-geqbispectra[sub][1:-1], color=mcolor, alpha=normds[sub], linewidth=lw)\\n \\\"\\\"\\\"\\n\\n ax.set_xlabel(r\\\"$k {\\\\rm (h/Mpc)}$\\\")\\n ax.set_ylabel(r\\\"${\\\\rm Q}(k)$\\\")\\n ax.set_xscale('log')\\n cbar = fig.colorbar(scalarMap, format='%.0e')\\n #self.plt.yscale('log')\\n if (show):\\n self.plt.show()\",\n \"def plot_explorer_panels(self, param_val, photonnumber, initial_index, final_index, qbt_index, osc_index):\\n def fig_ax(index):\\n return fig, axes_list_flattened[index]\\n\\n param_index = np.searchsorted(self.param_vals, param_val)\\n param_val = self.param_vals[param_index]\\n\\n initial_bare = self.sweep.lookup.bare_index(initial_index, param_index)\\n final_bare = self.sweep.lookup.bare_index(final_index, param_index)\\n energy_ground = self.sweep.lookup.energy_dressed_index(0, param_index)\\n energy_initial = self.sweep.lookup.energy_dressed_index(initial_index, param_index) - energy_ground\\n energy_final = self.sweep.lookup.energy_dressed_index(final_index, param_index) - energy_ground\\n qbt_subsys = self.sweep.hilbertspace[qbt_index]\\n\\n nrows = 3\\n ncols = 2\\n fig, axs = plt.subplots(ncols=ncols, nrows=nrows, figsize=self.figsize)\\n axes_list_flattened = [elem for sublist in axs for elem in sublist]\\n\\n # Panel 1 ----------------------------------\\n panels.display_bare_spectrum(self.sweep, qbt_subsys, param_val, fig_ax(0))\\n\\n # Panels 2 and 6----------------------------\\n if type(qbt_subsys).__name__ in ['Transmon', 'Fluxonium']: # do not plot wavefunctions if multi-dimensional\\n panels.display_bare_wavefunctions(self.sweep, qbt_subsys, param_val, fig_ax(1))\\n panels.display_charge_matrixelems(self.sweep, initial_bare, qbt_subsys, param_val, fig_ax(5))\\n\\n # Panel 3 ----------------------------------\\n panels.display_dressed_spectrum(self.sweep, initial_bare, final_bare, energy_initial, energy_final, param_val,\\n fig_ax(2))\\n\\n # Panel 4 ----------------------------------\\n panels.display_n_photon_qubit_transitions(self.sweep, photonnumber, initial_bare, param_val, fig_ax(3))\\n\\n # Panel 5 ----------------------------------\\n panels.display_chi_01(self.sweep, qbt_index, osc_index, param_index, fig_ax(4))\\n\\n fig.tight_layout()\\n return fig, axs\",\n \"def test_run_beta_diversity_through_plots_even_sampling(self):\\r\\n\\r\\n run_beta_diversity_through_plots(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n sampling_depth=20,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=False,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n unweighted_unifrac_dm_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_dm.txt')\\r\\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\\r\\n unweighted_unifrac_pc_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_pc.txt')\\r\\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\\r\\n weighted_unifrac_html_fp = join(self.test_out,\\r\\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def plot_overscan_diff(overscan, img, TITLE, OUT_DIR):\\n fig = plt.figure(figsize=(20, 20))\\n gs0 = gridspec.GridSpec(3, 3)\\n\\n for i, f in enumerate(img):\\n x = f.dev_index % 3\\n\\n gs = gridspec.GridSpecFromSubplotSpec(\\n 1, 2, wspace=0, subplot_spec=gs0[f.dev_index])\\n ax2 = plt.subplot(gs[0, 0])\\n for j in range(9, 17):\\n plt.plot(overscan[i, j - 1] - overscan[i, 15] +\\n 500 * (j - 8), label='seg' + str(j + 1))\\n plt.legend(fontsize=6, loc='upper center', ncol=4)\\n if(x != 0):\\n ax2.set_yticklabels([])\\n\\n plt.grid()\\n plt.xlim(0, 2100)\\n plt.ylim(0, 4500)\\n ax2.set_title(f.dev_name + ' (seg 10-17)')\\n\\n ax1 = plt.subplot(gs[0, 1])\\n for j in range(1, 9):\\n plt.plot(overscan[i, j - 1] - overscan[i, 7] +\\n 500 * j, label='seg' + str(j - 1))\\n plt.legend(fontsize=6, loc='upper center', ncol=4)\\n if(x != 2):\\n ax1.set_yticklabels([])\\n if(x == 2):\\n ax1.yaxis.tick_right()\\n plt.grid()\\n plt.xlim(0, 2100)\\n plt.ylim(0, 4500)\\n ax1.set_title(f.dev_name + ' (seg 0-7)')\\n #\\tax1.set_title('S-'+f[7:9]+' (seg 0-7)')\\n\\n fig.suptitle('Overscan (diff) ' + TITLE, y=0.94, size=20)\\n plt.subplots_adjust(wspace=0.05)\\n plt.savefig(OUT_DIR + TITLE + '_diff_spatial.png')\\n plt.close(fig)\",\n \"def plot_bus_load(self):\\n stops = {key: 0 for key, _ in self.route.timetable().items()}\\n for passenger in self.passengers:\\n trip = self.passenger_trip(passenger)\\n stops[trip[0][1]] += 1\\n stops[trip[1][1]] -= 1\\n prev = None\\n for i, stop in enumerate(stops):\\n if i > 0:\\n stops[stop] += stops[prev]\\n prev = stop\\n fig, ax = plt.subplots()\\n ax.step(range(len(stops)), list(stops.values()), where=\\\"post\\\")\\n ax.set_xticks(range(len(stops)))\\n ax.set_xticklabels(list(stops.keys()))\\n return fig, ax\",\n \"def plot(self):\\n # plot the data for checking\\n fig, [[ax1,ax2],[ax3,ax4], [ax5,ax6]] = plt.subplots(\\n 3,2, figsize=(10,8))\\n\\n # Relative height\\n self.board_reference.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax1)\\n self.board_intervention.plot(\\n column='z_reference', cmap='GnBu_r', legend=True, ax=ax2)\\n\\n # Landuse\\n self.board_reference.plot(\\n column='landuse', legend=True, ax=ax3, cmap='viridis',\\n scheme='equal_interval', k=11)\\n self.board_intervention.plot(\\n column='landuse', legend=True, ax=ax4, cmap='viridis',\\n scheme='equal_interval', k=11)\\n\\n index = np.arange(7)\\n xticks = self.PotTax_reference.index.values\\n bar_width = 0.3\\n\\n # plot the initial and new situation comparison\\n label = (\\\"reference: \\\" +\\n str(round(self.PotTax_reference.sum().TFI, 2)))\\n reference = ax5.bar(\\n index, self.PotTax_reference.values.flatten(), bar_width,\\n label=label, tick_label=xticks)\\n label = (\\\"intervention: \\\" +\\n str(round(self.PotTax_intervention.sum().TFI, 2)))\\n intervention = ax5.bar(\\n index+bar_width, self.PotTax_intervention.values.flatten(),\\n bar_width, label=label, tick_label=xticks)\\n ax5.set_ylabel(\\\"total value\\\")\\n ax5.legend(loc='best')\\n for tick in ax5.get_xticklabels():\\n tick.set_rotation(90)\\n\\n # plot the percentage increase/decrease between the initial and new\\n # situation\\n data = self.PotTax_percentage.values.flatten()\\n percentage = ax6.bar(\\n index, data, bar_width, label=\\\"percentage\\\", tick_label=xticks)\\n ax6.set_ylabel(\\\"increase (%)\\\")\\n minimum = min(data)\\n maximum = max(data)\\n size = len(str(int(round(maximum))))\\n maximum = int(str(maximum)[:1])\\n maximum = (maximum + 1) * (10**(size-1))\\n ax6.set_ylim([min(0, minimum), maximum])\\n for tick in ax6.get_xticklabels():\\n tick.set_rotation(90)\",\n \"def plot_balance_list_output(balance_list, path, nframes=4):\\n import matplotlib\\n font = {'size' : 15, 'weight': 'normal'}\\n matplotlib.rc('font', **font)\\n\\n nplots=len(balance_list)\\n ncols=2\\n nrows=int(np.ceil(nframes/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\\n for n in range(nframes):\\n i = int(np.floor(n / ncols))\\n j=n % ncols\\n r_p = []\\n for k in range(len(balance_list[n])-1):\\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\\n\\n axes[i,j].plot(balance_list[n], label='balance', color='b')\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n # axes[i,j].set_yscale('log')\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('Balance norm')\\n # axes[i,j].legend()\\n axes[i,j].set_ylim([0, 10])\\n # ax_2=axes[i,j].twinx()\\n # ax_2.plot(r_p, 'g')\\n # ax_2.set_yscale('log')\\n # ax_2.set_ylabel('relative change')\\n\\n plt.savefig(path,transparent=True, dpi=400)\",\n \"def test_run_beta_diversity_through_plots_parallel(self):\\r\\n run_beta_diversity_through_plots(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=True,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n unweighted_unifrac_dm_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_dm.txt')\\r\\n weighted_unifrac_dm_fp = join(self.test_out, 'weighted_unifrac_dm.txt')\\r\\n unweighted_unifrac_pc_fp = join(\\r\\n self.test_out,\\r\\n 'unweighted_unifrac_pc.txt')\\r\\n weighted_unifrac_pc_fp = join(self.test_out, 'weighted_unifrac_pc.txt')\\r\\n weighted_unifrac_html_fp = join(self.test_out,\\r\\n 'weighted_unifrac_emperor_pcoa_plot', 'index.html')\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(unweighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_pc_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_html_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def overview(self, minState=5):\\n n = 600\\n \\n ### first plot: the RTOFFSETs and STATES\\n plt.figure(10)\\n plt.clf()\\n plt.subplots_adjust(hspace=0.05, top=0.95, left=0.05,\\n right=0.99, wspace=0.00, bottom=0.1)\\n ax1 = plt.subplot(n+11)\\n try:\\n print self.insmode+' | pri:'+\\\\\\n self.getKeyword('OCS PS ID')+' | sec:'+\\\\\\n self.getKeyword('OCS SS ID')\\n \\n plt.title(self.filename+' | '+self.insmode+' | pri:'+\\n self.getKeyword('OCS PS ID')+' | sec:'+\\n self.getKeyword('OCS SS ID'))\\n except:\\n pass\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n self.raw['OPDC'].data.field('FUOFFSET')*1e3,\\n color=(1.0, 0.5, 0.0), label=self.DLtrack+' (FUOFFSET)',\\n linewidth=3, alpha=0.5)\\n plt.legend(prop={'size':9})\\n plt.ylabel('(mm)')\\n plt.xlim(0)\\n \\n plt.subplot(n+12, sharex=ax1) # == DDL movements\\n \\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n 1e3*self.raw['DOPDC'].data.field(self.DDLtrack),\\n color=(0.0, 0.5, 1.0), linewidth=3, alpha=0.5,\\n label=self.DDLtrack)\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n 1e3*self.raw['DOPDC'].data.field('PSP'),\\n color=(0.0, 0.5, 1.0), linewidth=1, alpha=0.9,\\n label='PSP', linestyle='dashed')\\n plt.legend(prop={'size':9})\\n plt.ylabel('(mm)')\\n plt.xlim(0)\\n \\n plt.subplot(n+13, sharex=ax1) # == states\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n self.raw['OPDC'].data.field('STATE'),\\n color=(1.0, 0.5, 0.0), label='OPDC')\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n self.raw['DOPDC'].data.field('STATE'),\\n color=(0.0, 0.5, 1.0), label='DOPDC')\\n plt.legend(prop={'size':9})\\n plt.ylabel('STATES')\\n yl=plt.ylim()\\n plt.ylim(yl[0]-1, yl[1]+1)\\n plt.xlim(0)\\n ### fluxes\\n plt.subplot(n+14, sharex=ax1)\\n try:\\n fsua_dark = self.fsu_calib[('FSUA', 'DARK')][0,0]\\n fsub_dark = self.fsu_calib[('FSUB', 'DARK')][0,0]\\n fsua_alldark = self.fsu_calib[('FSUA', 'DARK')].sum(axis=1)[0]\\n fsub_alldark = self.fsu_calib[('FSUB', 'DARK')].sum(axis=1)[0]\\n except:\\n print 'WARNING: there are no FSUs calibrations in the header'\\n fsua_dark = 0.0\\n fsub_dark = 0.0\\n fsua_alldark = 0.0\\n fsub_alldark = 0.0\\n\\n M0 = 17.5\\n fluxa = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]+\\n self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\\n fsua_alldark)/\\\\\\n (4*self.getKeyword('ISS PRI FSU1 DIT'))\\n print 'FLUX FSUA (avg, rms):', round(fluxa.mean(), 0), 'ADU/s',\\\\\\n round(100*fluxa.std()/fluxa.mean(), 0), '%'\\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\\\\n round(M0-2.5*np.log10(fluxa.mean()),2)\\n fluxb = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]+\\n self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\\n fsub_alldark)/\\\\\\n (4*self.getKeyword('ISS PRI FSU2 DIT'))\\n print 'FLUX FSUB (avg, rms):', round(fluxb.mean(), 0), 'ADU/s',\\\\\\n round(100*fluxb.std()/fluxb.mean(), 0), '%'\\n print ' -> pseudo mag = '+str(M0)+' - 2.5*log10(flux) =',\\\\\\n round(M0-2.5*np.log10(fluxb.mean()),2)\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\\\\\n fluxa/1000, color='b', alpha=0.5, label='FSUA')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\\\\\n fluxb/1000, color='r', alpha=0.5, label='FSUB')\\n\\n plt.ylim(1)\\n plt.legend(prop={'size':9})\\n plt.ylabel('flux - DARK (kADU)')\\n plt.xlim(0)\\n plt.subplot(n+15, sharex=ax1)\\n try:\\n # -- old data version\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUA'].data.field('OPDSNR'),\\n color='b', alpha=0.5, label='FSUA SNR')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUB'].data.field('OPDSNR'),\\n color='r', alpha=0.5, label='FSUB SNR')\\n except:\\n plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUA'].data.field(self.OPDSNR),\\n color='b', alpha=0.5, label='FSUA SNR')\\n plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n self.raw['IMAGING_DATA_FSUB'].data.field(self.OPDSNR),\\n color='r', alpha=0.5, label='FSUB SNR')\\n plt.legend(prop={'size':9})\\n \\n A = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA1')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,0])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,0]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,0])\\n B = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA2')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,1])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,1]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,1])\\n C = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA3')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,2])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,2]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,2])\\n D = (self.raw['IMAGING_DATA_FSUA'].data.field('DATA4')[:,0]-\\n self.fsu_calib[('FSUA', 'DARK')][0,3])/\\\\\\n (self.fsu_calib[('FSUA', 'FLAT')][0,3]-\\n 2*self.fsu_calib[('FSUA', 'DARK')][0,3])\\n snrABCD_a = ((A-C)**2+(B-D)**2)\\n snrABCD_a /= ((A-C).std()**2+ (B-D).std()**2)\\n #plt.plot(self.raw['IMAGING_DATA_FSUA'].data.field('TIME'),\\n # snrABCD_a, color='b', alpha=0.5, linestyle='dashed')\\n \\n A = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA1')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,0])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,0]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,0])\\n B = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA2')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,1])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,1]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,1])\\n C = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA3')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,2])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,2]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,2])\\n D = (self.raw['IMAGING_DATA_FSUB'].data.field('DATA4')[:,0]-\\n self.fsu_calib[('FSUB', 'DARK')][0,3])/\\\\\\n (self.fsu_calib[('FSUB', 'FLAT')][0,3]-\\n 2*self.fsu_calib[('FSUB', 'DARK')][0,3])\\n \\n snrABCD_b = ((A-C)**2+(B-D)**2)\\n snrABCD_b /= ((A-C).std()**2+ (B-D).std()**2)\\n #plt.plot(self.raw['IMAGING_DATA_FSUB'].data.field('TIME'),\\n # snrABCD_b, color='r', alpha=0.5, linestyle='dashed') \\n \\n # -- SNR levels:\\n #plt.hlines([self.getKeyword('INS OPDC OPEN'),\\n # self.getKeyword('INS OPDC CLOSE'),\\n # self.getKeyword('INS OPDC DETECTION')],\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\\n # color=(1.0, 0.5, 0.0))\\n #plt.hlines([self.getKeyword('INS DOPDC OPEN'),\\n # self.getKeyword('INS DOPDC CLOSE'),\\n # self.getKeyword('INS DOPDC DETECTION')],\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').min(),\\n # self.raw['IMAGING_DATA_FSUB'].data.field('TIME').max(),\\n # color=(0.0, 0.5, 1.0))\\n # -- plot thresholds\\n plt.ylabel('SNR')\\n plt.xlim(0)\\n \\n if self.getKeyword('OCS DET IMGNAME')=='PACMAN_OBJ_ASTRO_':\\n # == dual FTK\\n plt.subplot(n+16, sharex=ax1)\\n plt.ylabel('PRIMET ($\\\\mu$m)')\\n #met = interp1d(np.float_(self.raw['METROLOGY_DATA'].\\\\\\n # data.field('TIME')),\\\\\\n # self.raw['METROLOGY_DATA'].data.field('DELTAL'),\\\\\\n # kind = 'linear', bounds_error=False, fill_value=0.0)\\n met = lambda x: np.interp(x,\\n np.float_(self.raw['METROLOGY_DATA'].data.field('TIME')),\\n self.raw['METROLOGY_DATA'].data.field('DELTAL'))\\n metro = met(self.raw['DOPDC'].data.field('TIME'))*1e6\\n n_ = min(len(self.raw['DOPDC'].data.field('TIME')),\\n len(self.raw['OPDC'].data.field('TIME')))\\n\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n metro, color=(0.5,0.5,0.), label='A-B')\\n\\n w1 = np.where((self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'OPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\\n except:\\n print 'OPDC FTK stat: 0%'\\n\\n w1 = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'DOPDC FTK stat:', round(100*len(w1[0])/float(n_), 1), '%'\\n except:\\n print 'DOPDC FTK stat: 0%'\\n\\n w = np.where((self.raw['DOPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['DOPDC'].data.field('STATE')[:n_]<=7)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]>=minState)*\\\\\\n (self.raw['OPDC'].data.field('STATE')[:n_]<=7))\\n try:\\n print 'DUAL FTK stat:', round(100*len(w[0])/float(n_),1), '%'\\n except:\\n print 'DUAL FTK stat: 0%'\\n\\n plt.xlim(0)\\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\\n metro[w], '.g', linewidth=2,\\n alpha=0.5, label='dual FTK')\\n #plt.legend()\\n if len(w[0])>10 and False:\\n coef = np.polyfit(self.raw['DOPDC'].data.field('TIME')[w],\\n metro[w], 2)\\n plt.plot(self.raw['DOPDC'].data.field('TIME'),\\n np.polyval(coef, self.raw['DOPDC'].\\n data.field('TIME')),\\n color='g')\\n plt.ylabel('metrology')\\n\\n print 'PRIMET drift (polyfit) :', 1e6*coef[1], 'um/s'\\n slope, rms, synth = NoisySlope(self.raw['DOPDC'].\\n data.field('TIME')[w],\\n metro[w], 3e6)\\n plt.figure(10)\\n yl = plt.ylim()\\n plt.plot(self.raw['DOPDC'].data.field('TIME')[w],\\n synth, color='r')\\n plt.ylim(yl)\\n print 'PRIMET drift (NoisySlope):',\\\\\\n slope*1e6,'+/-', rms*1e6, 'um/s'\\n else:\\n # == scanning\\n plt.subplot(n+16, sharex=ax1)\\n fringesOPDC = \\\\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA1')[:,0]-\\\\\\n self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('DATA3')[:,0]\\n \\n fringesDOPDC =\\\\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA1')[:,0]-\\\\\\n self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('DATA3')[:,0]\\n \\n plt.plot(self.raw['IMAGING_DATA_'+self.primary_fsu].data.field('TIME'),\\n scipy.signal.wiener(fringesOPDC/fringesOPDC.std()),\\n color=(1.0, 0.5, 0.0), alpha=0.6,\\n label=self.primary_fsu+'/OPDC')\\n plt.plot(self.raw['IMAGING_DATA_'+self.secondary_fsu].data.field('TIME'),\\n scipy.signal.wiener(fringesDOPDC/fringesDOPDC.std()),\\n color=(0.0, 0.5, 1.0), alpha=0.6,\\n label=self.secondary_fsu+'/DOPDC')\\n plt.legend(prop={'size':9})\\n plt.ylabel('A-C')\\n plt.xlabel('time stamp ($\\\\mu$s)')\\n return\",\n \"def plotResultsComparison(monthlyData1, monthlyData2, indices, arg):\\n \\n energyType = arg[0] \\n \\n dummyRange = np.asarray(range(len(indices['E_tot1'])))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n# plt.suptitle('Heating Demand (COP=' + str(usedEfficiencies['H_COP']) + ')')\\n if energyType == 'PV':\\n multiplier = -1\\n else:\\n multiplier = 1\\n \\n ax1 = plt.subplot(2,1,1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange], label = 'Results1', color='b')\\n plt.plot(multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = 'Results2', color='g')\\n \\n plt.ylabel('Energy [kWh]')\\n plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(24)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n ax2 = plt.subplot(2,1,2, sharex=ax1)\\n \\n plt.plot(multiplier*monthlyData1[energyType][indices['E_tot1'], dummyRange]-multiplier*monthlyData2[energyType][indices['E_tot2'], dummyRange], label = '1-2', color='b')\\n\\n plt.ylabel('Energy Difference [kWh]')\\n plt.legend()\\n\\n ax2.xaxis.set_major_locator(majorLocator)\\n ax2.xaxis.set_major_formatter(majorFormatter)\\n ax2.xaxis.set_minor_locator(minorLocator)\\n# ax2.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which='both')\\n \\n return fig\",\n \"def plot_all(show=True):\\n fig, axes = plt.subplots(max_iterations, 1, figsize=(6, 12))\\n for t in range(max_iterations):\\n with open('results/%s/df_%d.pkl' % (id, t), 'rb') as f:\\n df = pickle.load(f)\\n with open('results/%s/w_%d.pkl' % (id, t), 'rb') as f:\\n w = pickle.load(f)\\n axes[t].hist2d(x=df['vision'], y=df['metab'], weights=w, density=True,\\n bins=((xticks, yticks)), cmap='magma')\\n axes[t].set_ylabel('max metabolism')\\n axes[t].set_xticks(vision_domain)\\n axes[t].set_yticks((2, 3, 4))\\n axes[3].set_xlabel('max vision')\\n fig.tight_layout()\\n if show:\\n plt.show()\\n else:\\n plt.savefig('results/%s/abc_results.pdf' % id)\",\n \"def plot(self, noTLS, path_plots, interactive):\\n fig = plt.figure(figsize=(10,12))\\n ax1 = fig.add_subplot(4, 1, 1)\\n ax2 = fig.add_subplot(4, 1, 2)\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax4 = fig.add_subplot(4, 2, 6)\\n ax5 = fig.add_subplot(4, 2, 7)\\n ax6 = fig.add_subplot(4, 2, 8)\\n\\n # First panel: data from each sector\\n colors = self._get_colors(self.nlc)\\n for i, lci in enumerate(self.alllc):\\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\\n ax1.legend(fontsize='small', ncol=4)\\n\\n # Second panel: Detrended light curve\\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\\n color='black',\\n label='Detrended')\\n\\n # Third panel: BLS\\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\\n mean_SR = np.mean(self.BLS.power)\\n std_SR = np.std(self.BLS.power)\\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\\n SDE = (best_power - mean_SR)/std_SR\\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\\n for n in range(2, 10):\\n if n*self.BLS.period_max <= max(self.BLS.period.value):\\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n sx, ex = ax3.get_xlim()\\n sy, ey = ax3.get_ylim()\\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.2f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nSDE = %.3f' %\\n (self.BLS.period_max, self.BLS.t0_max,\\n self.BLS.depth_max, self.BLS.duration_max, SDE))\\n\\n\\n # Fourth panel: lightcurve folded to the best period from the BLS\\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\\n marker='.', alpha=0.5)\\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n\\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\\n duration=self.BLS.duration_max,\\n transit_time=self.BLS.t0_max)\\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\\n ax4.set_xlim(-l, l)\\n h = max(lc_model.flux)\\n l = min(lc_model.flux)\\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n del lc_model, lc_model_folded, r1, dt1\\n\\n\\n if not noTLS:\\n # Fifth panel: TLS periodogram\\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\\n for n in range(2, 10):\\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.set_ylabel(r'SDE')\\n ax5.set_xlabel('Period (days)')\\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\\n ax5.set_xlim(0, max(self.tls.periods))\\n\\n period_tls = self.tls.period\\n T0_tls = self.tls.T0\\n depth_tls = self.tls.depth\\n duration_tls = self.tls.duration\\n FAP_tls = self.tls.FAP\\n\\n sx, ex = ax5.get_xlim()\\n sy, ey = ax5.get_ylim()\\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.1f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nFAP = %.4f' %\\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\\n\\n # Sixth panel: folded light curve to the best period from the TLS\\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\\n alpha=0.5, ls='None', markersize=0.7)\\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\\n x0=0.0, nbins=nbins, useBinCenter=True)\\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\\n ax6.set_xlim(0.5-l, 0.5+l)\\n h = max(self.tls.model_folded_model)\\n l = min(self.tls.model_folded_model)\\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n ax6.set_xlabel('Phase')\\n ax6.set_ylabel('Relative flux')\\n del r1, dt1\\n\\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\\n if interactive:\\n plt.show()\\n plt.close('all')\\n del fig\",\n \"def runExpt_and_makePlots(n, d, grid_size, reps, tho_scale=0.1, is_classification=True):\\n\\n args = [n, d, grid_size, reps]\\n df_std_signal, df_tho_signal = repeatexp(*args,\\n is_classification=is_classification,\\n tho_scale=tho_scale,\\n no_signal=False)\\n \\n df_std_nosignal, df_tho_nosignal = repeatexp(*args,\\n is_classification=is_classification,\\n tho_scale=tho_scale,\\n no_signal=True)\\n\\n f, ax = plt.subplots(2, 2, figsize=(8,10), sharex=True, sharey=False)\\n sb.set_style('whitegrid')\\n \\n kw_params = {'x':'dataset',\\n 'y':'performance',\\n 'units':'perm'}\\n \\n sb.barplot(data=df_std_signal,\\n ax=ax[0,0],\\n **kw_params)\\n ax[0,0].set_title('Standard, HAS Signal')\\n \\n sb.barplot(data=df_tho_signal,\\n ax=ax[0,1],\\n **kw_params)\\n ax[0,1].set_title('Thresholdout, HAS Signal')\\n\\n sb.barplot(data=df_std_nosignal,\\n ax=ax[1,0],\\n **kw_params)\\n ax[1,0].set_title('Standard, NO Signal')\\n\\n sb.barplot(data=df_tho_nosignal,\\n ax=ax[1,1],\\n **kw_params)\\n ax[1,1].set_title('Thresholdout, NO Signal')\\n \\n return f, ax\",\n \"def plot_derivatives(self, show=False):\\n\\n fig, ax = plt.subplots(4, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(0,self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].set_xscale('log')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[1, 0].set_xscale('log')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 0].set_title('Upper - lower input data: train sample');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 0].set_title('Numerical derivative: train sample');\\n ax[3, 0].set_xlabel(r'$\\\\ell$')\\n ax[3, 0].set_ylabel(r'$\\\\Delta C_\\\\ell / 2\\\\Delta \\\\theta$')\\n ax[3, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 0].set_xscale('log')\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n ax[0, 1].set_xscale('log')\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n ax[1, 1].set_xscale('log')\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]))\\n ax[2, 1].set_title('Upper - lower input data: test sample');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$C_\\\\ell (u) - C_\\\\ell (m) $')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[3, 1].plot(ells, (Cl_upper[i]-Cl_lower[i])/(2*delta_theta[i]))\\n ax[3, 1].set_title('Numerical derivative: train sample');\\n ax[3, 1].set_xlabel(r'$\\\\ell$')\\n ax[3, 1].set_ylabel(r'$\\\\Delta C_\\\\ell / \\\\Delta \\\\theta $')\\n ax[3, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[3, 1].set_xscale('log')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\\n perf_list = ['54363310_1939750539', '540791114_1793842568']\\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \\\".npy\\\") for i in range(len(perf_list))]\\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\\n num_samples = 10000\\n # quantile indices\\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\\n plt.style.use('ggplot')\\n labels = ['perf. A', 'perf. B']\\n colors = ['blue', 'red']\\n linestyles = ['dotted', 'dashed']\\n grid = plt.GridSpec(2, 2)\\n ax1 = plt.subplot(grid[1, 0])\\n ax2 = plt.subplot(grid[1, 1])\\n ax4 = plt.subplot(grid[0, :])\\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\\n ax4.set_title(\\\"Difference between MIDI and pYIN, two performances\\\")\\n ax4.set_ylabel(\\\"Cents\\\")\\n ax4.set_xlabel(\\\"Frames\\\")\\n ax4.axhline(y=200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2, label=\\\"thresh.\\\")\\n ax4.axhline(y=-200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2)\\n ax4.legend(loc=\\\"upper right\\\")\\n ax1.set_title(\\\"10k random sample of distances\\\")\\n ax1.set_ylabel(r\\\"$|$Cents$|$\\\")\\n ax1.set_xlabel(\\\"Frames sorted by distance\\\")\\n ax2.set_title(\\\"Sample quantiles\\\")\\n ax2.set_xlabel(\\\"Quantile indices\\\")\\n # run analysis song by song\\n for i, arr in enumerate(comparisons_list):\\n # random sample so all arrays have the same size\\n samples = np.random.choice(arr, num_samples, replace=True)\\n # sort\\n samples = np.sort(np.abs(samples))\\n # discard the high values (might be due to misalignment, etc...)\\n samples = samples[samples <= 200]\\n samples = np.random.choice(samples, num_samples, replace=True)\\n samples = np.sort(np.abs(samples))\\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n # get the quantiles\\n samples = samples[q_indices]\\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n ax1.legend()\\n ax2.legend()\\n plt.tight_layout()\\n plt.savefig(os.path.join(plots_dir_intonation, \\\"data processing pipeline.eps\\\"), format=\\\"eps\\\")\\n plt.show()\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plot_diff(self):\\n if not(self.is_attribute(\\\"time\\\") & self.is_attribute(\\\"intensity_up\\\") & \\n self.is_attribute(\\\"intensity_up_sigma\\\") &\\n self.is_attribute(\\\"intensity_down\\\") & \\n self.is_attribute(\\\"intensity_down_sigma\\\") &\\n self.is_attribute(\\\"intensity_up_total\\\") &\\n self.is_attribute(\\\"intensity_down_total\\\")):\\n return\\n fig, ax = plt.subplots()\\n ax.set_title(\\\"Polarized intensity: I_up - I_down\\\")\\n ax.set_xlabel(\\\"Time (microseconds)\\\")\\n ax.set_ylabel('Intensity')\\n \\n np_time = numpy.array(self.time, dtype=float)\\n np_up = numpy.array(self.intensity_up, dtype=float)\\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\\n np_down = numpy.array(self.intensity_down, dtype=float)\\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\\n np_diff = np_up - np_down\\n np_diff_mod = np_up_mod - np_down_mod\\n np_sdiff = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\\n\\n ax.plot([np_time.min(), np_time.max()], [0., 0.], \\\"b:\\\")\\n ax.plot(np_time, np_diff_mod, \\\"k-\\\",\\n label=\\\"model\\\")\\n ax.errorbar(np_time, np_diff, yerr=np_sdiff, fmt=\\\"ko\\\", alpha=0.2,\\n label=\\\"experiment\\\")\\n\\n y_min_d, y_max_d = ax.get_ylim()\\n param = y_min_d-(np_diff-np_diff_mod).max()\\n\\n ax.plot([np_time.min(), np_time.max()], [param, param], \\\"k:\\\")\\n ax.plot(np_time, np_diff-np_diff_mod+param, \\\"r-\\\", alpha=0.7,\\n label=\\\"difference\\\")\\n ax.legend(loc='upper right')\\n fig.tight_layout()\\n return (fig, ax)\",\n \"def show_derivative(self):\\n for trace in self.plotWidget.plotDataItems:\\n dt = float(trace.attrs['dt'])\\n dtrace = np.diff(trace.data)\\n x = pgplot.make_xvector(dtrace, dt)\\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))\",\n \"def plot_path_statistics( self, path_file=\\\"tse_ensemble.json\\\" ):\\n from matplotlib import pyplot as plt\\n with open(path_file,'r') as infile:\\n data = json.load(infile)\\n try:\\n paths = data[\\\"transition_paths\\\"]\\n except KeyError:\\n paths = [data]\\n total_product_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n total_reactant_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n self.nuc_mc.min_size_product = paths[0][\\\"min_size_product\\\"]\\n self.nuc_mc.max_size_reactant = paths[0][\\\"max_size_reactant\\\"]\\n for path in paths:\\n product_indicator = []\\n reactant_indicator = []\\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\\n\\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\\n\\n total_reactant_indicator /= float( len(paths) )\\n total_product_indicator /= float( len(paths) )\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.plot( total_product_indicator, label=\\\"Product\\\" )\\n ax.plot( total_reactant_indicator, label=\\\"Reactant\\\" )\\n ax.set_xlabel( \\\"MC sweeps\\\" )\\n ax.set_ylabel( \\\"Indicator\\\" )\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend( frameon=False, loc=\\\"best\\\" )\\n return fig\",\n \"def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\\n other_program_name, **kw):\\n\\n #plot absolute error\\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\\n pan['absolute-difference'][field].values,\\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\\n ax_abs.set_ylabel('Absolute Difference ' + unit)\\n #plot percentage error\\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\\n pan['percent-difference'][field].values,\\n color='firebrick', zorder=-1)\\n ax_per.set_ylabel('Percent Difference', color='firebrick')\\n #set error axes legend\\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\\n #ax_per.get_legend().set_zorder(1)\\n #plot full results profiles\\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\\n color=_colormap[1])[0],\\n ax_mag.plot(pan['emf.fields-results'][field],\\n color=_colormap[0])[0]]\\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\\n ax_mag.set_xlabel('Distance (ft)')\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n \\n numViruses = 100\\n maxPop = 1000\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n resistances = {'guttagonol': False, 'grimpex': False}\\n mutProb = 0.005\\n delays = [300, 150, 75, 0]\\n f, axarr = pylab.subplots(2, 2)\\n x_plot = []\\n\\n for delay in delays:\\n FinalPopSize = [0.0 for x in range(numTrials)]\\n for trial in range(numTrials):\\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\\n patient = TreatedPatient(viruses, maxPop)\\n for i in range(150):\\n patient.update()\\n patient.addPrescription('guttagonol')\\n for j in range(150, 150+delay):\\n patient.update()\\n patient.addPrescription('grimpex')\\n for k in range(150+delay, 300+delay):\\n patient.update()\\n FinalPopSize[trial] = patient.getTotalPop()\\n x_plot.append(FinalPopSize)\\n\\n axarr[0, 0].hist(x_plot[0])\\n axarr[0, 1].hist(x_plot[1])\\n axarr[1, 0].hist(x_plot[2])\\n axarr[1, 1].hist(x_plot[3])\\n pylab.show()\\n return x_plot\",\n \"def noe_analysis():\\n\\n files = ['f34k_7p2_noe_heights.txt', 'dphs_7p4_noe_heights.txt']\\n proteins = ['f34k','dphs']\\n\\n heights = [nmrfn.parse_noe(f) for f in files]\\n heights = pd.concat(heights, axis=1, keys=proteins)\\n\\n results = [noe_calcs(heights[i]) for i in proteins]\\n results = pd.concat(results, axis=1, keys=proteins)\\n\\n fig = plt.figure(figsize=(10,6))\\n val = plt.subplot(211)\\n dif = plt.subplot(212)\\n \\n seqmin = 6\\n seqmax = 144\\n noemin = 0.5\\n noemax = 0.95\\n\\n dy = results.dphs.noe - results.f34k.noe\\n dif_plot(val, dy.index, dy.ix[8:141], seqmin, seqmax)\\n noe_plot(proteins, results, seqmin, seqmax, noemin, noemax, xax=False)\\n\\n s1 = plt.Rectangle((0, 0), 1, 1, fc=proteins['f34k'])\\n s2 = plt.Rectangle((0, 0), 1, 1, fc=proteins['dphs'])\\n val.legend([s1, s2], ['F34K', '∆+PHS'], loc=8)\\n\\n title = 'HN NOE: F34K pH 7.2 compared with ∆+PHS pH 7.4'\\n savefile = 'f34k_7p2_noe_analysis.pdf'\\n save_plot(title, savefile)\",\n \"def compositePlots(self):\\n if not self.master: return\\n\\n # get the HTML page\\n page = [page for page in self.layout.pages if \\\"MeanState\\\" in page.name][0]\\n \\n models = []\\n colors = []\\n corr = {}\\n std = {}\\n cycle = {}\\n has_cycle = False\\n has_std = False\\n for fname in glob.glob(os.path.join(self.output_path,\\\"*.nc\\\")):\\n dataset = Dataset(fname)\\n if \\\"MeanState\\\" not in dataset.groups: continue\\n dset = dataset.groups[\\\"MeanState\\\"]\\n models.append(dataset.getncattr(\\\"name\\\"))\\n colors.append(dataset.getncattr(\\\"color\\\"))\\n for region in self.regions:\\n \\n if not cycle.has_key(region): cycle[region] = []\\n key = [v for v in dset.variables.keys() if (\\\"cycle_\\\" in v and region in v)]\\n if len(key)>0:\\n has_cycle = True\\n cycle[region].append(Variable(filename=fname,groupname=\\\"MeanState\\\",variable_name=key[0]))\\n\\n if not std. has_key(region): std [region] = []\\n if not corr. has_key(region): corr [region] = []\\n\\n key = []\\n if \\\"scalars\\\" in dset.groups:\\n key = [v for v in dset.groups[\\\"scalars\\\"].variables.keys() if (\\\"Spatial Distribution Score\\\" in v and region in v)]\\n if len(key) > 0:\\n has_std = True\\n sds = dset.groups[\\\"scalars\\\"].variables[key[0]]\\n corr[region].append(sds.getncattr(\\\"R\\\" ))\\n std [region].append(sds.getncattr(\\\"std\\\"))\\n\\n # composite annual cycle plot\\n if has_cycle and len(models) > 2:\\n page.addFigure(\\\"Spatially integrated regional mean\\\",\\n \\\"compcycle\\\",\\n \\\"RNAME_compcycle.png\\\",\\n side = \\\"ANNUAL CYCLE\\\",\\n legend = False)\\n\\n for region in self.regions:\\n if not cycle.has_key(region): continue\\n fig,ax = plt.subplots(figsize=(6.8,2.8),tight_layout=True)\\n for name,color,var in zip(models,colors,cycle[region]):\\n dy = 0.05*(self.limits[\\\"cycle\\\"][region][\\\"max\\\"]-self.limits[\\\"cycle\\\"][region][\\\"min\\\"])\\n var.plot(ax,lw=2,color=color,label=name,\\n ticks = time_opts[\\\"cycle\\\"][\\\"ticks\\\"],\\n ticklabels = time_opts[\\\"cycle\\\"][\\\"ticklabels\\\"],\\n vmin = self.limits[\\\"cycle\\\"][region][\\\"min\\\"]-dy,\\n vmax = self.limits[\\\"cycle\\\"][region][\\\"max\\\"]+dy)\\n ylbl = time_opts[\\\"cycle\\\"][\\\"ylabel\\\"]\\n if ylbl == \\\"unit\\\": ylbl = post.UnitStringToMatplotlib(var.unit)\\n ax.set_ylabel(ylbl)\\n fig.savefig(os.path.join(self.output_path,\\\"%s_compcycle.png\\\" % (region)))\\n plt.close()\\n\\n # plot legends with model colors (sorted with Benchmark data on top)\\n page.addFigure(\\\"Spatially integrated regional mean\\\",\\n \\\"legend_compcycle\\\",\\n \\\"legend_compcycle.png\\\",\\n side = \\\"MODEL COLORS\\\",\\n legend = False)\\n def _alphabeticalBenchmarkFirst(key):\\n key = key[0].upper()\\n if key == \\\"BENCHMARK\\\": return 0\\n return key\\n tmp = sorted(zip(models,colors),key=_alphabeticalBenchmarkFirst)\\n fig,ax = plt.subplots()\\n for model,color in tmp:\\n ax.plot(0,0,'o',mew=0,ms=8,color=color,label=model)\\n handles,labels = ax.get_legend_handles_labels()\\n plt.close()\\n \\n ncol = np.ceil(float(len(models))/11.).astype(int)\\n if ncol > 0:\\n fig,ax = plt.subplots(figsize=(3.*ncol,2.8),tight_layout=True)\\n ax.legend(handles,labels,loc=\\\"upper right\\\",ncol=ncol,fontsize=10,numpoints=1)\\n ax.axis('off')\\n fig.savefig(os.path.join(self.output_path,\\\"legend_compcycle.png\\\"))\\n fig.savefig(os.path.join(self.output_path,\\\"legend_spatial_variance.png\\\"))\\n fig.savefig(os.path.join(self.output_path,\\\"legend_temporal_variance.png\\\"))\\n plt.close()\\n \\n # spatial distribution Taylor plot\\n if has_std:\\n page.addFigure(\\\"Temporally integrated period mean\\\",\\n \\\"spatial_variance\\\",\\n \\\"RNAME_spatial_variance.png\\\",\\n side = \\\"SPATIAL TAYLOR DIAGRAM\\\",\\n legend = False)\\n page.addFigure(\\\"Temporally integrated period mean\\\",\\n \\\"legend_spatial_variance\\\",\\n \\\"legend_spatial_variance.png\\\",\\n side = \\\"MODEL COLORS\\\",\\n legend = False) \\n if \\\"Benchmark\\\" in models: colors.pop(models.index(\\\"Benchmark\\\"))\\n for region in self.regions:\\n if not (std.has_key(region) and corr.has_key(region)): continue\\n if len(std[region]) != len(corr[region]): continue\\n if len(std[region]) == 0: continue\\n fig = plt.figure(figsize=(6.0,6.0))\\n post.TaylorDiagram(np.asarray(std[region]),np.asarray(corr[region]),1.0,fig,colors)\\n fig.savefig(os.path.join(self.output_path,\\\"%s_spatial_variance.png\\\" % region))\\n plt.close()\",\n \"def main():\\n\\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n\\n for function in range(1, 21):\\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\\n\\n col_name = 'F{}'.format(function)\\n index = function-1\\n\\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\\n\\n success_rates.insert(index, col_name, results.SuccessRate)\\n peak_ratios.insert(index, col_name, results.PeakRatio)\\n\\n for i in results.SimulationSwarms:\\n\\n x_axis = [k for k, _ in i.items()]\\n y_axis = [v for _, v in i.items()]\\n\\n plt.subplot(4, 5, function) # subplot indexes from 1\\n plt.plot(x_axis, y_axis, 'k-')\\n\\n plt.savefig('results/nmmso_benchmark.png')\\n plt.show()\\n\\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\\n print(convergence_rates_e1)\\n print(convergence_rates_e4)\\n print(success_rates)\\n print(peak_ratios)\\n\\n # Table V from Fieldsend et al.\\n table4 = pd.Series([\\n peak_ratios.stack().median(),\\n peak_ratios.stack().mean(),\\n peak_ratios.stack().std()\\n ])\\n print(table4)\\n\\n # do we want to reproduce Fig. 3\",\n \"def plotEnergiesOpt(monthlyData, optIdx):\\n \\n \\n dummyRange = np.asarray(range(len(optIdx)))\\n \\n fig = plt.figure(figsize=(16, 8))\\n \\n plt.suptitle('Energy Comparison')\\n ax1 = plt.subplot(1,1,1)\\n plt.plot(monthlyData['H'][optIdx, dummyRange], label = 'H', color='r')\\n plt.plot(monthlyData['C'][optIdx, dummyRange], label = 'C', color='b')\\n plt.plot(monthlyData['L'][optIdx, dummyRange], label = 'L', color='g')\\n plt.plot(monthlyData['PV'][optIdx, dummyRange], label = 'PV', color='c')\\n plt.plot(monthlyData['E_HCL'][optIdx, dummyRange], label = 'HCL', color='m')\\n plt.plot(monthlyData['E_tot'][optIdx, dummyRange], label = 'E_tot', color='k')\\n plt.ylabel('Energy [kWh]')\\n plt.xlim(0,288)\\n\\n# plt.legend()\\n \\n majorLocator = MultipleLocator(24)\\n majorFormatter = FormatStrFormatter('%d')\\n minorLocator = MultipleLocator(4)\\n minorFormatter = FormatStrFormatter('%d')\\n\\n ax1.xaxis.set_major_locator(majorLocator)\\n ax1.xaxis.set_major_formatter(majorFormatter)\\n ax1.xaxis.set_minor_locator(minorLocator)\\n# ax1.xaxis.set_minor_formatter(minorFormatter)\\n plt.grid(True, which=u'major')\\n \\n # Shrink current axis by 20%\\n box = ax1.get_position()\\n ax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\\n \\n # Put a legend to the right of the current axis\\n ax1.legend(loc='upper left', bbox_to_anchor=(1, 1.05))\\n# \\n\\n plt.xticks(range(0,288,24),('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))\\n# ax2 = plt.subplot(2,1,2, sharex=ax1)\\n# plt.plot(multiplier*monthlyData[energyType][indices['H'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for H', color='r')\\n# plt.plot(multiplier*monthlyData[energyType][indices['C'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for C', color='b')\\n# plt.plot(multiplier*monthlyData[energyType][indices['L'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for L', color='g')\\n# plt.plot(multiplier*monthlyData[energyType][indices['PV'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for PV', color='c')\\n# plt.plot(multiplier*monthlyData[energyType][indices['E_HCL'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for HCL', color='m')\\n# plt.plot(multiplier*monthlyData[energyType][indices['E_tot'], dummyRange]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'optimized for E_tot', color='k')\\n# plt.plot(multiplier*monthlyData[energyType][indices['45'],:]-multiplier*monthlyData[energyType][indices[energyType], dummyRange], label = 'fixed at 45 deg', color='y')\\n# plt.ylabel('Energy Difference [kWh]')\\n# plt.legend()\\n#\\n# ax2.xaxis.set_major_locator(majorLocator)\\n# ax2.xaxis.set_major_formatter(majorFormatter)\\n# ax2.xaxis.set_minor_locator(minorLocator)\\n## ax2.xaxis.set_minor_formatter(minorFormatter)\\n# plt.grid(True, which='both')\\n# \\n return fig\",\n \"def momentum_kde2_paperplot(fields):\\n plt.figure(figsize=(2.65, 2.5))\\n ax = plt.axes([0.18, 0.17, 0.8, 0.8])\\n colorList = [med_color, high_color]\\n lw = 1.5\\n i = 0\\n meankx_2 = []\\n meankx_3 = []\\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \\\"E_{:.1e}.npy\\\".format(fields[0]))\\n # ax.plot(k_ax, np.zeros(len(k_ax)), '-', linewidth=lw, color=eq_color, label='Equilibrium')\\n # ax.plot(k_ax, np.zeros(len(k_ax)), '-', linewidth=lw, color=eq_color)\\n ax.axhline(0, color='black', linestyle='--', linewidth=0.5)\\n # ax.axvline(0, color='gray', linewidth=0.8, alpha=0.5)\\n for ee in fields:\\n ee_Vcm = ee/100\\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n kdist_f0_2 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist_f0_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n kdist_2 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n kdist_f0_3 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist_f0_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n kdist_3 = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_dist' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n\\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n meankx_2.append(utilities.mean_kx(chi_2_i, electron_df))\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n meankx_3.append(utilities.mean_kx(chi_3_i, electron_df))\\n\\n ax.plot(k_ax, kdist_2, '--', linewidth=lw, color=colorList[i], label='Cold '+r'{:.0f} '.format(ee/100)+r'$\\\\rm V cm^{-1}$')\\n ax.plot(k_ax, kdist_3, '-', linewidth=lw,color=colorList[i], label='Warm '+r'{:.0f} '.format(ee/100)+r'$\\\\rm V cm^{-1}$')\\n i = i + 1\\n # ax.plot(k_ax, kdist_f0_3, '--', linewidth=lw, color='black', label=r'$f_0$')\\n # ax.plot(meankx_2,np.mean(abs(kdist_2))*np.ones(len(meankx_3)), '-', linewidth=lw, color='black')\\n # ax.plot(meankx_3,np.mean(abs(kdist_3))*np.ones(len(meankx_3)), '-', linewidth=lw, color='black')\\n\\n ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))\\n ax.locator_params(axis='y', nbins=6)\\n ax.locator_params(axis='x', nbins=6)\\n # ax.tick_params(direction='in')\\n ax.set_xlim(-0.085, 0.081)\\n\\n plt.xlabel(r'$\\\\rm k_x \\\\, \\\\, (\\\\AA^{-1})$')\\n plt.ylabel(r'Deviational occupation $\\\\rm \\\\Delta f_{\\\\mathbf{k}}$')\\n # plt.grid(lw=0.8, linestyle='dotted')\\n # plt.ylabel(r'$\\\\delta f_{\\\\mathbf{k}}/f_{\\\\mathbf{k}}^0$')\\n # plt.ylim([-1,1])\\n plt.legend(frameon=False,prop={'size':different_small_size})\\n plt.savefig(pp.figureLoc+'momentum_KDE2.png', dpi=600)\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def plot_parameter_evolution(analyses, pdf=False):\\n ncs = np.arange(11, 15)\\n genes = set(analyses.gene)\\n constructs = set(analyses.construct)\\n long_labels = {'bac': 'bac', 'no_pr': 'no pr', 'no_sh': 'no sh'}\\n gene_long = {'hb': 'hunchback', 'kn': 'knirps', 'sn': 'snail'}\\n y_label = {'j': 'Normalized flux $j$',\\n 'rho': 'Site occupation density $\\\\\\\\rho$', 'tau': 'Residence time $\\\\\\\\tau$ (s)', 'alpha_comb': 'Initiation rate $\\\\\\\\alpha$ (pol/min)'}\\n\\n # Add extra jiggle to be able to distinguish overlapping data points\\n x_jiggle = 0.04\\n x_shifts = np.array([-1, 0, 1]) * x_jiggle\\n\\n # Plot parameters\\n capsize = 0\\n markersize = 4\\n lw = 1 # line width\\n\\n for gene in genes:\\n grouped_data = analyses.groupby(by=['gene', 'construct', 'nc'])\\n all_means = grouped_data.mean()\\n all_stds = grouped_data.std(ddof=1)\\n all_ps = analyses.groupby(by=['gene', 'nc']).first()\\n\\n for quantity in ['j', 'rho', 'tau', 'alpha_comb']:\\n ymaxs = {'j': 0.36, 'rho': 0.27, 'tau': 103, 'alpha_comb': 12}\\n num = 12\\n set_figure_size(num=num, rows=1, page_width_frac=0.5, clear=True, height_factor=0.7)\\n fig, ax = plt.subplots(1, 1, num=num, clear=True)\\n avg_data, std_data = {}, {}\\n for construct in constructs:\\n if quantity in ['rho', 'j']:\\n avg_data[construct] = all_means.loc[(\\n gene, construct, slice(None)), quantity].values\\n std_data[construct] = all_stds.loc[(\\n gene, construct, slice(None)), quantity].values\\n\\n elif quantity in ['tau', 'alpha_comb']:\\n avg_data[construct] = all_means.loc[(\\n gene, construct, slice(None)), quantity].values\\n std_data[construct] = np.sqrt(\\n all_means.loc[(gene, construct, slice(None)), quantity + 'V'].values)\\n\\n # Prepare a marker generator and plot the data with errorbars\\n marker_gen = itertools.cycle(markers_additivity)\\n for i, construct in enumerate(constructs):\\n m = next(marker_gen)\\n plt.errorbar(\\n ncs + x_shifts[i], avg_data[construct],\\n yerr=std_data[construct],\\n fmt='-' + m, color=colors_additivity[construct],\\n capsize=capsize, label=long_labels[construct],\\n markersize=markersize, lw=lw)\\n\\n # Adjust plot\\n plt.xlabel('Nuclear cycle')\\n plt.ylabel(y_label[quantity])\\n plt.ylim(ymin=0, ymax=ymaxs[quantity])\\n\\n plt.xticks(ncs)\\n plt.title(gene_long[gene])\\n\\n plt.tight_layout()\\n plt.show()\\n\\n # Save figure\\n figname = 'additivity_' + quantity + '_' + gene\\n figpath = os.path.join(figures_folder, figname)\\n fig.savefig(figpath + '.png', pad_inches=0, bbox_inches='tight')\\n if pdf:\\n fig.savefig(figpath + '.pdf', pad_inches=0, bbox_inches='tight')\",\n \"def plotting(dataframe, prod_num):\\n fig, axs = plt.subplots(2, sharex=True)\\n axs[0].plot(dataframe['STU'])\\n axs[1].plot(dataframe['STU'].diff().dropna())\\n axs[0].set_title(\\\"Time Series of Product\\\" + f\\\"_{prod_num}\\\")\\n axs[1].set_title(\\\"Differenced Time Series of Product\\\" + f\\\"_{prod_num}\\\")\\n plt.savefig(\\\"Time Series of Product\\\" + f\\\"_{prod_num}\\\" + \\\".pdf\\\")\",\n \"def plot_alleles(folder):\\n\\n abs_alt,perc_alt = parse_geno_file(folder,False)\\n\\n strain_matcher = re.compile('(.*) \\\\(.*\\\\)') ## regex to get strain name from radio button click\\n strain_matcher2 = re.compile('(.*)-(.*)')\\n \\n fig, ax = plt.subplots()\\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\\n ax.set_ylabel('Alternate Allele Percentage (MC)')\\n ax.set_xlabel('Alternate Allele Percentage (MC)')\\n \\n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\\n\\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\\n\\n #for strain in perc_alt.keys():\\n #print strain\\n \\n #ylabel = plt.axes([1,1,0.08,0.08])\\n\\n def update1(strain):\\n if strain not in [\\\"Rock-MZ\\\",\\\"Sand-MC\\\",\\\"Rock-MC\\\",\\\"Sand-MZ\\\",\\\"Rock-Sand\\\"]:\\n match = re.match(strain_matcher,strain)\\n strain = match.group(1)\\n global base\\n base = 'MC'\\n else:\\n match = re.match(strain_matcher2,strain)\\n strain = match.group(1)\\n #global base \\n base = match.group(2)\\n\\n #print D\\n if(D == \\\"%\\\"):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[strain])\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n else:\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[strain])\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n\\n ax.relim()\\n ax.autoscale()\\n fig.canvas.draw_idle()\\n global S \\n #print S\\n S = strain\\n\\n\\n def update2(data):\\n if(data == '%'):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n fig.canvas.draw_idle()\\n if(data == 'Abs'):\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n fig.canvas.draw_idle()\\n \\n global D\\n D = data\\n\\n radio1.on_clicked(update1)\\n radio2.on_clicked(update2)\\n plt.show()\",\n \"def plateSeparatedPerformance():\\n model_perfs = pickle.load(open(\\\"pickles/separatePlateTestModelPerformances.pkl\\\", \\\"rb\\\"))\\n model_stds = pickle.load(open(\\\"pickles/separatePlateTestModelStds.pkl\\\", \\\"rb\\\"))\\n null_YFP_performances = pickle.load(open(\\\"pickles/separatePlateTestYFPPerformances.pkl\\\", \\\"rb\\\"))\\n null_YFP_stds = pickle.load(open(\\\"pickles/separatePlateTestYFPStds.pkl\\\", \\\"rb\\\"))\\n null_DAPI_performances = pickle.load(open(\\\"pickles/separatePlateTestDAPIPerformances.pkl\\\", \\\"rb\\\"))\\n null_DAPI_stds = pickle.load(open(\\\"pickles/separatePlateTestDAPIStds.pkl\\\", \\\"rb\\\"))\\n fig, ax = plt.subplots()\\n xlabels = [\\\"null\\\", \\\"DRW1\\\", \\\"DRW2\\\", \\\"DRW3\\\", \\\"DRW4\\\", \\\"DRW5\\\", \\\"DRW6\\\"]\\n x = np.array([1, 2, 3, 4, 5, 6])\\n width = .26\\n rects = ax.bar(x, model_perfs, width, yerr=model_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\\\"red\\\", label=\\\"ML Model\\\", zorder=3)\\n rects2 = ax.bar(x + width, null_YFP_performances, width, yerr=null_YFP_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\\\"gold\\\",label=\\\"Null YFP Model\\\", zorder=3)\\n rects3 = ax.bar(x+ 2*width, null_DAPI_performances, width, yerr=null_DAPI_stds, capsize=3, error_kw=dict(lw=.2, capsize=1, capthick=1), color=\\\"blue\\\", label=\\\"Null DAPI Model\\\", zorder=3)\\n autolabel(rects, ax, fontsize=8)\\n autolabel(rects2, ax, fontsize=8)\\n autolabel(rects3, ax, fontsize=8)\\n plt.title(\\\"Pearson Performance by Drug Perturbation\\\",fontname=\\\"Times New Roman\\\", fontsize=14, y=1.0)\\n ax.set_ylabel(\\\"Pearson Correlation Coefficient\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xlabel(\\\"Drug\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xticklabels(xlabels,fontsize=12, fontname=\\\"Times New Roman\\\")\\n plt.yticks(fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylim((0,1))\\n ax.yaxis.grid(True, linestyle='-', which='major', color='grey', alpha=.25, zorder=0)\\n ax.xaxis.set_major_locator(plt.MaxNLocator(7))\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0, box.width, box.height * 0.85])\\n ax.legend(loc='upper right', prop={\\\"family\\\":\\\"Times New Roman\\\", \\\"size\\\":10}, bbox_to_anchor=(1, 1.32))\\n plt.gcf().subplots_adjust(top=.76)\\n plt.savefig(\\\"matplotlib_figures/separatedPlatesPerformance.png\\\", dpi=300)\",\n \"def multiple_bars(self, df, nrows, ncols, dict):\\n fig, axs = plt.subplots(nrows=8, ncols=1, figsize=(6, 9.3), sharey=\\\"row\\\")\\n\\n fig.subplots_adjust(left=0.03, right=0.97, hspace=0.3, wspace=0.05)\\n\\n indexes = df.index.tolist()\\n df[\\\"index\\\"] = indexes\\n df[\\\"effect_size\\\"] = df[\\\"index\\\"].apply(lambda x: x[0])\\n df[\\\"sd\\\"] = df[\\\"index\\\"].apply(lambda x: x[1])\\n df[\\\"group\\\"] = df[\\\"index\\\"].apply(lambda x: x[2])\\n bar_width = 0.35\\n # get an index to set the ticks for the x axis\\n\\n df_new = df.groupby(\\\"sd\\\")\\n # for key, item in df_new:\\n # print(df_new.get_group(key))\\n for ax, (sd, dat) in zip(axs, df_new):\\n n_groups = len(dat.index)\\n index = np.arange(n_groups)\\n\\n # make barchart for permutation test\\n bar1 = ax.bar(index, dat[\\\"perm\\\"], bar_width, color='b',\\n label='Permutation test')\\n # make barchart for t-test\\n bar2 = ax.bar(index + bar_width, dat[\\\"t_test\\\"], bar_width, color='r',\\n label='t-test')\\n es = dat[\\\"effect_size\\\"].iloc[0]\\n\\n ax.set_ylabel(\\\"Error\\\")\\n ax.set_xticks(index + bar_width / 2)\\n ax.set_xticklabels(dict[\\\"xtickslabels\\\"])\\n ax.set_xlabel(f\\\"Mean error for sd = {sd} per group size\\\")\\n print(dat[\\\"sig\\\"])\\n print(\\\"\\\\n\\\\n\\\")\\n for rect, i in zip(bar1 + bar2, dat[\\\"sig\\\"]):\\n height = rect.get_height()\\n if i:\\n ax.text(rect.get_x() + rect.get_width(), height, \\\"**\\\", ha='center', va='bottom')\\n\\n ax.legend()\\n\\n fig.suptitle(f\\\"Effect size = {es}\\\", y=1.0, fontsize = 15)\\n fig.tight_layout()\\n plt.show()\",\n \"def show_dcr_results(dg):\\n cycle = dg.fileDB['cycle'].values[0]\\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\\n # print(df_dsp.describe()) \\n\\n # compare DCR and A/E distributions\\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\\n \\n elo, ehi, epb = 0, 25000, 100\\n \\n # aoe distribution\\n # ylo, yhi, ypb = -1, 2, 0.1\\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p0.set_ylabel('A/E', ha='right', y=1)\\n\\n # dcr distribution\\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\\n # ylo, yhi, ypb = -3, 2, 0.1\\n ylo, yhi, ypb = 0.9, 1.08, 0.001\\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p1.set_ylabel('DCR', ha='right', y=1)\\n \\n # plt.show()\\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\\n plt.cla()\",\n \"def results():\\n\\n # # 1. tau_e graph\\n # # ------------------------------------------------------------\\n\\n tau_es = np.load(datapath / \\\"tau_es.npy\\\", allow_pickle=True)\\n\\n # I want to plot tau_e against b for various Ns. Annoyingly this\\n # means I have to do some index juggling.\\n\\n # This is all because of the way I set up datagen.DataSet... oh well.\\n\\n for i, N in enumerate(Ns):\\n\\n # values to plot against b for the specific N\\n vals = []\\n\\n for j, b in enumerate(bs):\\n\\n k = Nb_to_ks[i][j]\\n vals.append(tau_es[k])\\n\\n plt.plot(bs, vals, \\\"-\\\")\\n\\n plt.title(\\\"Auto-correlation e-folding timelag for \\\"\\n \\\"variable temperatures, grid sizes\\\")\\n\\n plt.xlabel(\\\"$\\\\\\\\beta$\\\")\\n plt.ylabel(\\\"$\\\\\\\\tau_e$\\\")\\n\\n plt.legend([f\\\"N={N}\\\" for N in Ns])\\n\\n plt.savefig(resultspath / \\\"tau_es.pdf\\\")\\n # plt.show()\\n plt.close()\\n\\n # 2. magnetisation graphs\\n # ------------------------------------------------------------\\n\\n mags_list = [np.load(datapath / f\\\"mags-{k}.npy\\\") for k in range(kcount)]\\n\\n for i, N in enumerate(Ns):\\n\\n plt.title(f\\\"Square magnetisations N={N}\\\")\\n plt.xlabel(\\\"t\\\")\\n plt.ylabel(\\\"M\\\")\\n\\n for j, b in enumerate(bs):\\n\\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\\n\\n k = Nb_to_ks[i][j]\\n vals = np.mean(mags_list[k]**2, axis=1)\\n plt.plot(vals, color=(1 - c, 0, c))\\n\\n plt.savefig(resultspath / f\\\"mags-{N}.pdf\\\")\\n # plt.show()\\n plt.close()\\n\\n # 3. autoc graphs\\n # ------------------------------------------------------------\\n\\n autocs_list = [\\n np.load(datapath / f\\\"autocs-{k}.npy\\\") for k in range(kcount)]\\n\\n for i, N in enumerate(Ns):\\n\\n plt.figure(figsize=(8, 6))\\n plt.axes(position=[.05, .05, .8, .9])\\n\\n plt.title(f\\\"Auto-correlation of $|M|$ with N={N}\\\")\\n plt.xlabel(\\\"$ \\\\\\\\tau $\\\")\\n plt.ylabel(\\\"$ A(\\\\\\\\tau) $\\\")\\n\\n for j, b in enumerate(bs):\\n\\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\\n\\n k = Nb_to_ks[i][j]\\n autocs = np.load(datapath / f\\\"autocs-{k}.npy\\\")\\n\\n iternum = autocs.shape[0]\\n sysnum = autocs.shape[1]\\n vals = np.mean(autocs, axis=1)\\n errs = np.std(autocs, axis=1, ddof=1) / np.sqrt(sysnum)\\n\\n plt.errorbar(range(iternum), vals, errs,\\n color=(1 - c, 0, c), ecolor=(1 - c, 0, c, 0.4),\\n elinewidth=1.5)\\n\\n # plt.plot(np.log(vals))\\n\\n plt.legend(bs, loc='center left', bbox_to_anchor=(1, 0.5))\\n\\n plt.savefig(resultspath / f\\\"autocs-{N}.pdf\\\")\\n # plt.show()\\n plt.close()\",\n \"def plot_convergence(\\n optimizers: list = [\\\"COBYLA\\\", \\\"SLSQP\\\", \\\"L-BFGS-B\\\", \\\"NELDER-MEAD\\\"],\\n g2N: float = 0.2,\\n maxit: int = 10000,\\n varform: list = [\\\"ry\\\"],\\n depth: int = 3,\\n nrep: int = 10,\\n dataprefix: str = \\\"data/miniBMN\\\",\\n datasuffix: str = \\\"h5\\\",\\n figprefix: str = \\\"figures/miniBMN\\\",\\n ht: float = 0.0,\\n up: int = 1000,\\n):\\n # setup parameters\\n params = dict()\\n params[\\\"l\\\"] = str(g2N).replace(\\\".\\\", \\\"\\\")\\n params[\\\"d\\\"] = depth\\n params[\\\"v\\\"] = \\\"-\\\".join(varform)\\n params[\\\"m\\\"] = maxit\\n params[\\\"n\\\"] = nrep\\n params[\\\"f\\\"] = dataprefix\\n params[\\\"s\\\"] = datasuffix\\n assert type(optimizers).__name__ == \\\"list\\\"\\n # collect data\\n result = collect_data(optimizers, params)\\n # get best runs\\n gs = dict()\\n for r in optimizers:\\n gs[r] = result.loc[r].groupby(\\\"rep\\\").apply(min).energy\\n gsdf = pd.DataFrame.from_dict(gs, dtype=float)\\n print(gsdf.describe().T[[\\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\"]])\\n # Plot\\n # select the best runs for each optimizer\\n fig, ax = plt.subplots()\\n for o in optimizers:\\n result.loc[o, gsdf[o].idxmin()].plot(\\n x=\\\"counts\\\", y=\\\"energy\\\", xlim=[0, up], label=o, ax=ax\\n )\\n ax.axhline(ht, c=\\\"k\\\", ls=\\\"--\\\", lw=\\\"2\\\", label=\\\"HT\\\")\\n ax.set_xlabel(\\\"iterations\\\")\\n ax.set_ylabel(\\\"VQE energy\\\")\\n ax.legend(loc=\\\"upper right\\\")\\n filename = f\\\"{figprefix}_l{params['l']}_convergence_{params['v']}_depth{params['d']}_nr{params['n']}_max{params['m']}_xlim{up}\\\"\\n plt.savefig(f\\\"{filename}.pdf\\\")\\n plt.savefig(f\\\"{filename}.png\\\")\\n plt.savefig(f\\\"{filename}.svg\\\")\\n plt.close()\",\n \"def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \\n\\n file_dir = 'SpectralCube_BeamLogs'\\n basename = '/beamlog.image.restored.' + imagebase + field\\n\\n # use different basename for the Milky Way range\\n if not glob.glob(file_dir + basename +'*.txt'):\\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\\n\\n \\n BEAM_THRESHOLD = []\\n \\n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\\n plt_name1 = 'BmajStdev.png'\\n saved_fig1 = fig_dir+'/'+plt_name1\\n\\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\\n plt_name2 = 'BminStdev.png'\\n saved_fig2 = fig_dir+'/'+plt_name2\\n\\n title3 = 'Maximum ratio of beam area'\\n plt_name3 = 'max_ratioBA.png'\\n saved_fig3 = fig_dir+'/'+plt_name3\\n\\n title4 = 'Minimum ratio of beam area' \\n plt_name4 = 'min_ratioBA.png'\\n saved_fig4 = fig_dir+'/'+plt_name4\\n \\n params = {'axes.labelsize': 10,\\n 'axes.titlesize': 10,\\n 'font.size':10}\\n\\n pylab.rcParams.update(params)\\n\\n beamXPOS, beamYPOS = BeamPosition()\\n fig1, ax1 = plt.subplots()\\n fig2, ax2 = plt.subplots()\\n fig3, ax3 = plt.subplots()\\n fig4, ax4 = plt.subplots()\\n \\n for i in range(0,36):\\n bnum = n[i]\\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\\n BEAM_THRESHOLD.append(beam_threshold)\\n\\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\\n\\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\\n\\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n ax1.set_xlim(0,0.7)\\n ax1.set_ylim(0,1.4)\\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax1.set_title(title1)\\n\\n ax2.set_xlim(0,0.7)\\n ax2.set_ylim(0,1.4)\\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax2.set_title(title2)\\n\\n ax3.set_xlim(0,0.7)\\n ax3.set_ylim(0,1.4)\\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax3.set_title(title3)\\n plt.colorbar(maxplot, ax=ax3)\\n\\n ax4.set_xlim(0,0.7)\\n ax4.set_ylim(0,1.4)\\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax4.set_title(title4)\\n plt.colorbar(minplot, ax=ax4)\\n\\n fig1.savefig(saved_fig1, bbox_inches='tight')\\n fig2.savefig(saved_fig2, bbox_inches='tight')\\n fig3.savefig(saved_fig3, bbox_inches='tight')\\n fig4.savefig(saved_fig4, bbox_inches='tight')\\n\\n plt.close('all')\\n\\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD\",\n \"def plot(self):\\n t = np.linspace(0, self.days, self.days + 1)\\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(nrows=5, sharex='all')\\n ax1.plot(t, self.S, label=\\\"Susceptible\\\", color='r')\\n ax1.set_ylabel(\\\"Number of Susceptible People\\\")\\n ax1.set_title(\\\"Strong Infecitous Model SEIRV Simulation\\\")\\n ax3.plot(t, self.I, label=\\\"Active Cases\\\", color='b')\\n ax3.set_ylabel(\\\"Active Cases\\\")\\n ax2.plot(t, self.E, label=\\\"Exposed\\\", color='c')\\n ax2.set_ylabel(\\\"# of Exposed\\\")\\n ax4.plot(t, self.R, label=\\\"Recovered\\\", color='m')\\n ax5.set_xlabel(\\\"Days\\\")\\n ax4.set_ylabel('Number of Recovered')\\n ax5.plot(t, self.V, label=\\\"Vaccinated\\\")\\n ax5.set_ylabel(\\\"# Vaccinated\\\")\\n ax1.legend()\\n ax2.legend()\\n ax3.legend()\\n ax4.legend()\\n plt.show()\\n return fig\",\n \"def plot_results(self):\\n experiment_utils.plot_exp_metric_comparison(self.experiments(reverse_sort=False))\",\n \"def plot(self):\\n # get data without totals\\n data = self.woe_report[self.woe_report.index != 'total']\\n # setup panel\\n fig, axs = plt.subplots(1, 3, figsize=(12, 3))\\n plt.subplots_adjust(wspace=0.3)\\n # first chart\\n data['P(Hi|A)'].plot(ax=axs[0], linewidth=3, alpha=0.7)\\n data['P(Hi|Ā)'].plot(ax=axs[0], linewidth=3, alpha=0.7)\\n axs[0].set_title('Probability distribution')\\n axs[0].set_xlabel(data.index.name)\\n axs[0].set_ylabel('probability')\\n axs[0].legend(['P(Hi|A)', 'P(Hi|Ā)'])\\n # second chart\\n data['weight-of-evidence'].plot(ax=axs[1], linewidth=3, alpha=0.7)\\n axs[1].set_title('WoE')\\n axs[1].set_xlabel(data.index.name)\\n axs[1].set_ylabel('WoE')\\n # third chart\\n data['information-value'].plot(ax=axs[2], linewidth=3, alpha=0.7)\\n axs[2].set_title('Information value')\\n axs[2].set_ylabel('IV')\",\n \"def convergence():\\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n # point spread and point total subplots\\n subplots = [\\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\\n (True, [200.5], league.totals, 'probability total > 200.5'),\\n ]\\n\\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, values)\\n\\n line = lines[-1]\\n\\n for label2 in label2_list:\\n\\n # evaluation times and labels\\n times = np.arange(league.times.size)[::1000]\\n labels1 = times.size * [label1]\\n labels2 = times.size * [label2]\\n\\n # observed win probability\\n prob = melo.probability(times, labels1, labels2, lines=line)\\n ax.plot(times, prob)\\n\\n # true (analytic) win probability\\n if ax.is_first_row():\\n prob = skellam.sf(line, int(label1), int(label2))\\n ax.axhline(prob, color='k')\\n else:\\n prob = poisson.sf(line, int(label1) + int(label2))\\n ax.axhline(prob, color='k')\\n\\n # axes labels\\n if ax.is_last_row():\\n ax.set_xlabel('Iterations')\\n ax.set_ylabel(ylabel)\\n\\n set_tight(w_pad=.5)\",\n \"def plot_comparison_section(t, obs, syn, syn_decon, syn_lw):\\n\\n fig, ax = plt.subplots(1, 2, sharex=True, sharey=True, figsize=(8, 8))\\n\\n for ir in range(obs.shape[0]):\\n # Observed + Standard deconvolution\\n if ir == 0:\\n label_obs = 'Obs'\\n label_syn = 'Syn'\\n label_syn_decon = 'Inv'\\n else:\\n label_obs = None\\n label_syn = None\\n label_syn_decon = None\\n\\n ax[0].plot(t, ir + obs[ir, :], 'k', label=label_obs)\\n ax[0].plot(t, ir + syn[ir, :], c=(0.85, 0.2, 0.2), label=label_syn)\\n ax[0].plot(t, ir + syn_decon[ir, :], c=(0.2, 0.2, 0.85),\\n label=label_syn_decon)\\n ax[0].set_xlabel('Time in [s]')\\n ax[0].set_ylabel('Amplitude')\\n ax[0].set_title('Waterlevel')\\n\\n # Observed + Landweber iterative deconvolution\\n ax[1].plot(t, ir + obs[ir, :], 'k')\\n ax[1].plot(t, ir + syn[ir, :], c=(0.85, 0.2, 0.2))\\n ax[1].plot(t, ir + syn_lw[ir, :], c=(0.2, 0.2, 0.85))\\n ax[1].set_xlabel('Time in [s]')\\n ax[1].set_title('Landweber')\\n ax[1].set_xlim([np.min(t), np.max(t)])\\n ax[1].set_ylim([-1, syn_lw.shape[0] + 1.5])\\n\\n plt.figlegend(frameon=True, fancybox=False, loc='lower center', ncol=3,\\n framealpha=1, edgecolor='k', facecolor='w',\\n bbox_to_anchor=(0.52, 0.925))\\n plt.tight_layout()\\n\\n plt.show(block=False)\",\n \"def plotBondEnergy(self, phys, forces, step):\\r\\n self.plotQuantity(step, phys.app.energies.getTable(2), 'bondenergy')\",\n \"def plot(self, num_levels=10):\\n if num_levels == -1:\\n num_levels = len(self.energies())\\n print(self.energies(num_levels))\\n figure(figsize=(20, 5))\\n subplot(1, num_levels + 1, 1)\\n self.plot_potential()\\n #xlabel('$\\\\phi$')\\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\\n subplot(1, num_levels + 1, ii + 2)\\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\\\"None\\\",aspect='auto')\\n imshow(psi2D.real, interpolation=\\\"None\\\", aspect='auto')\\n xlabel(ii)\",\n \"def animate(self, i):\\n self.advance_animation(0.01)\\n self.get_status()\\n self.ax2.clear()\\n self.ax3.clear()\\n self.ax2.plot(np.ones(len(self.healthy))*self.total_beds, 'k--')\\n samples = range(0, len(self.healthy))\\n self.ax2.stackplot(samples, self.sick, self.healthy, self.recovered, self.dead, labels=['Sick: ' +str(self.sick[-1]),'Healthy: '+str(self.healthy[-1]),'Recovered: '+str(self.recovered[-1]), 'Dead: '+str(self.dead[-1])], colors=['orangered','forestgreen', 'deepskyblue', 'black'])\\n #self.ax2.legend(bbox_to_anchor=(1.04,0), loc=\\\"lower left\\\", borderaxespad=0)\\n self.ax2.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=2, fancybox=True, fontsize=6, shadow=True)\\n self.ax2.xaxis.set_ticks([])\\n self.ax2.set_ylim(0, self.n+30)\\n self.ax3.plot(samples, self.healthy,'forestgreen', label = 'Healthy')\\n self.ax3.plot(samples, self.sick, 'orangered', label = 'Sick')\\n self.ax3.plot(samples, self.recovered, 'deepskyblue', label = 'Recovered')\\n self.ax3.plot(samples, self.dead, 'black', label = 'Dead')\\n self.ax3.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05), ncol=2, fancybox=True, fontsize=6, shadow=True)\\n self.ax3.set_ylim(0, self.n+30)\\n self.ax3.xaxis.set_ticks([])\\n self.ax2.yaxis.set_ticks([])\\n self.ax2.set_xlabel('Change over time')\\n self.ax3.set_xlabel('Change over time')\\n self.ax.set_title('Social Distancing Followed By '+str(self.social_dist)+'% People.')\\n self.ax2.set_title('Stacked area graph for each category', fontsize = 8)\\n self.ax3.set_title('Percentage graph for each category', fontsize = 8)\\n self.exit_animate()\",\n \"def plot_effect_sizes(self, plot_opts=dict()):\\n \\n if self.ndim == 1:\\n fig, axes = plt.subplots(nrows=self.K, ncols=1, \\n sharex=True, \\n figsize=(6, 6*self.K))\\n \\n dmodel_color = plot_opts.get('dmodel_color', '#cc7d21')\\n for i, kernel_name in enumerate(self.kernel_dict.keys()):\\n summary = self.results[kernel_name].summary(b=self.b)\\n# xmin, xmax = summary['es_interval'] \\n pdf = summary['es_Disc']\\n d_bma = summary['es_BMA'] \\n xrange = summary['es_range'] \\n n_interp = len(pdf)\\n \\n axes[i].plot(xrange, pdf, c=dmodel_color, label=r'$M_D$', \\n linewidth=1.0, linestyle='--')\\n axes[i].fill_between(xrange, pdf, np.zeros((n_interp)), \\n alpha=0.3, color=dmodel_color)\\n axes[i].axvline(x=0, linewidth=1.0, label=r'$M_C$', color='k', \\n linestyle='--') \\n axes[i].plot(xrange, d_bma, c='k', label=r'BMA', linewidth=1.0)\\n axes[i].fill_between(xrange, d_bma, np.zeros((n_interp)), \\n alpha=0.3, color='k')\\n axes[i].set_xlim([np.min(xrange), np.max(xrange)])\\n axes[i].set_ylabel('Probability density')\\n axes[i].set_xlim([xrange[0], xrange[-1]])\\n axes[i].set_title('{:s} kernel'.format(kernel_name))\\n \\n axes[-1].legend(loc='best')\\n \\n return fig, axes\\n else:\\n raise NotImplementedError('Effect size plot for D>1 is not implemented')\\n # TODO: Part of this code is available in the Dutch elections example.\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def notebook_01():\\n\\n freq_list, volt_list = las.load_freq_volt()\\n\\n n_steps, n_det, n_f, _ = np.shape(volt_list)\\n\\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\\n\\n # print(np.shape(y_sym_mat_o))\\n # print(np.shape(y_sym_mat_i))\\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\\n # print(mu_o, sigma_o)\\n # print(mu_i, sigma_i)\\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\\n\\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\\n\\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\\n\\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\\n\\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\\n\\n\\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\\n\\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n fp.fit_params_FH_data(ff.f_b_field)\\n\\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def plot_tsnes():\\n # Two environments (for main paper figure. All for final figure)\\n ENVS = [\\n \\\"BipedalWalker-v3\\\",\\n #\\\"LunarLander-v2\\\",\\n #\\\"Pendulum-v0\\\"\\n \\\"Acrobot-v1\\\",\\n #\\\"CartPole-v1\\\"\\n ]\\n ALGO_TYPES = [\\n \\\"stablebaselines\\\",\\n \\\"stablebaselines\\\",\\n \\\"wann\\\",\\n \\\"wann\\\",\\n ]\\n ALGO_NAMES = [\\n \\\"A2C\\\",\\n \\\"PPO\\\",\\n \\\"NEAT\\\",\\n \\\"CMAES\\\",\\n ]\\n ALGO_PRETTY_NAMES = [\\n \\\"A2C\\\",\\n \\\"PPO\\\",\\n \\\"NEAT\\\",\\n \\\"CMA-ES\\\"\\n ]\\n\\n REWARD_SCALES = {\\n \\\"Pendulum-v0\\\": [-1600, -200],\\n \\\"Acrobot-v1\\\": [-500, -100],\\n \\\"LunarLander-v2\\\": [-230, 200],\\n \\\"BipedalWalker-v3\\\": [-100, 300],\\n \\\"CartPole-v1\\\": [0, 500]\\n }\\n\\n figure, axs = pyplot.subplots(\\n figsize=[6.4 * 2, 4.8],\\n nrows=2,\\n ncols=4,\\n gridspec_kw={'hspace': 0, 'wspace': 0},\\n )\\n\\n for plot_i in range(2):\\n env = ENVS[plot_i]\\n reward_scale = REWARD_SCALES[env]\\n for algo_i in range(len(ALGO_TYPES)):\\n column_idx = (algo_i % 2) + plot_i * 2\\n row_idx = 0 if algo_i <= 1 else 1\\n ax = axs[row_idx, column_idx]\\n algo_type = ALGO_TYPES[algo_i]\\n algo_name = ALGO_NAMES[algo_i]\\n algo_pretty_name = ALGO_PRETTY_NAMES[algo_i]\\n\\n experiment_glob = \\\"experiments/{}_{}_{}_*\\\".format(algo_type, env, algo_name)\\n experiment_paths = glob(experiment_glob)\\n tsnes = []\\n rewards = []\\n for experiment_path in experiment_paths:\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n population_tsnes = []\\n population_rewards = []\\n for path in pivector_paths:\\n data = np.load(path)\\n population_tsnes.append(data[\\\"tsne\\\"])\\n population_rewards.append(data[\\\"average_episodic_reward\\\"])\\n data.close()\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n tsnes = np.concatenate(tsnes, axis=0)\\n rewards = np.concatenate(rewards, axis=0)\\n\\n # Min-max normalization\\n rewards = (rewards - reward_scale[0]) / (reward_scale[1] - reward_scale[0])\\n\\n scatter = ax.scatter(\\n tsnes[:, 0],\\n tsnes[:, 1],\\n c=rewards,\\n cmap=\\\"plasma\\\",\\n s=1,\\n vmin=0,\\n vmax=1\\n )\\n\\n ax.text(0.98, 0.98, algo_pretty_name, horizontalalignment=\\\"right\\\", verticalalignment=\\\"top\\\", transform=ax.transAxes)\\n ax.set_xticks([])\\n ax.set_yticks([])\\n # Hide spines, the outer edges\\n ax.spines[\\\"top\\\"].set_alpha(0.2)\\n ax.spines[\\\"bottom\\\"].set_alpha(0.2)\\n ax.spines[\\\"left\\\"].set_alpha(0.2)\\n ax.spines[\\\"right\\\"].set_alpha(0.2)\\n # Hide edge spines and bolden mid-spines\\n if row_idx == 0:\\n ax.spines[\\\"top\\\"].set_visible(False)\\n else:\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n if column_idx == 0:\\n ax.spines[\\\"left\\\"].set_visible(False)\\n elif column_idx == 1:\\n ax.spines[\\\"right\\\"].set_alpha(1.0)\\n elif column_idx == 2:\\n ax.spines[\\\"left\\\"].set_alpha(1.0)\\n elif column_idx == 3:\\n ax.spines[\\\"right\\\"].set_visible(False)\\n\\n # Add titles\\n if row_idx == 0 and (column_idx == 0 or column_idx == 2):\\n ax.set_title(env.split(\\\"-\\\")[0], x=1.0)\\n\\n cbaxes = figure.add_axes([0.4, 0.94, 0.2, 0.02])\\n cbar = figure.colorbar(scatter, orientation=\\\"horizontal\\\", cax=cbaxes)\\n cbar.set_ticks([0.0, 0.5, 1.0])\\n cbar.set_ticklabels([\\\"Min\\\", \\\"Reward\\\", \\\"Max\\\"])\\n cbar.ax.xaxis.set_ticks_position('top')\\n cbar.ax.xaxis.set_label_position('top')\\n cbar.ax.tick_params(labelsize=\\\"small\\\", length=0)\\n figure.tight_layout()\\n figure.savefig(\\\"figures/tsnes.png\\\", dpi=200, bbox_inches=\\\"tight\\\", pad_inches=0.0)\",\n \"def plot(self, n_confs):\\n \\n import pandas as pd\\n import numpy as np\\n import matplotlib as mpl\\n mpl.use('Agg')\\n import matplotlib.pyplot as plt\\n import csv\\n \\n n_iter = len(self.plot_data)\\n \\n data = np.ndarray((n_iter, n_confs+1))\\n data[:,0] = [i[0] for i in self.plot_data]\\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\\n\\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n df.to_csv(f\\\"{self.plot_name}.tab\\\", sep=\\\"\\\\t\\\", quoting=csv.QUOTE_NONE) \\n\\n d = data[:,1:].reshape(-1)\\n d = d[~np.isnan(d)]\\n mine = d.min() - 0.01\\n for i in range(n_confs): \\n data[:,i+1] -= mine\\n \\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n \\n colors = (0,0,0)\\n area = 10\\n \\n # Plot\\n fig = plt.figure(figsize=(15, 15))\\n ax = fig.add_subplot(1,1,1)\\n for i in range(n_confs):\\n ax.plot('iter', f'c{i+1}', data=df)\\n ax.set_yscale('log')\\n\\n plt.xlabel('iter')\\n plt.ylabel('loss')\\n plt.savefig(f'{self.plot_name}.png')\",\n \"def metaplot_powersum_test():\\n all_psums = []\\n for i in range(1,4+1):\\n print \\\"starting on\\\",i\\n plt.subplot(2,2,i)\\n all_psums.append(plot_powersum_test(G=1000*int(10**(i-1)),trials=10000/int(10**(i-1))))\\n plt.show()\\n return all_psums\",\n \"def plot_figures(compare_df, compare_df_without_1_5, over_3, over_6, ppm, \\n color_prob, color_count, edgecolor): \\n # Create a gridspec to plot in\\n fig = plt.figure()\\n gs = fig.add_gridspec(2,4)\\n ax1 = fig.add_subplot(gs[0,:])\\n ax2 = fig.add_subplot(gs[1,:2])\\n ax3 = fig.add_subplot(gs[1,2])\\n ax4 = fig.add_subplot(gs[1,3])\\n \\n ##### Plot the total count\\n compare_df.plot(kind=\\\"bar\\\", ax=ax1,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor )\\n ax1.set_title(\\\"a) Temperature count in AR5 working group reports and special reports until 2020\\\")\\n \\n #### Plot without the 1.5 special report\\n compare_df_without_1_5.plot(kind=\\\"bar\\\", ax=ax2, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax2.set_title(\\\"b) Excluding special report on 1.5°C warming\\\")\\n plt.setp(ax2.xaxis.get_majorticklabels(), fontsize=6)\\n \\n #### Plot 3\\n over_3.plot(kind=\\\"bar\\\", ax=ax3, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax3.set_title(\\\"c) 3°C and above\\\")\\n plt.setp(ax3.xaxis.get_majorticklabels(), color=\\\"white\\\")\\n \\n #### Plot only 6 degrees and above\\n over_6.plot(kind=\\\"bar\\\", ax=ax4, width=0.1, legend=False,zorder=5, color=[color_prob, color_count], edgecolor=edgecolor)\\n ax4.set_title(\\\"d) 6°C and above\\\")\\n plt.setp(ax4.xaxis.get_majorticklabels(), color=\\\"white\\\")\\n \\n # make nicer\\n i = 0\\n for ax in [ax1, ax2, ax3, ax4]:\\n ax.set_ylabel(\\\"Percentage [%]\\\")\\n if i == 0:\\n plot_nicer(ax)\\n else: \\n plot_nicer(ax, with_legend=False)\\n plt.setp(ax.xaxis.get_majorticklabels(), rotation=0)\\n i +=1\\n \\n fig=plt.gcf()\\n fig.set_size_inches(12,6)\\n fig.tight_layout()\\n plt.savefig(\\\"Figures\\\" + os.sep + \\\"warming_count_\\\"+str(ppm)+\\\".png\\\",dpi=200, bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def get_energy(edr, annealing_times, energy_type = 'Potential', out_fig = 'energy_distribution.svg'): # Could be Total-Energy\\n fig, ax = plt.subplots(figsize = (16,9))\\n data = pd.DataFrame()\\n xvg_tmp_file = tempfile.NamedTemporaryFile(suffix='.xvg')\\n energy = []\\n iterator = range(0, len(annealing_times)-1, 2)\\n\\n for state, index in tqdm.tqdm(enumerate(iterator), total=len(iterator)):#enumerate(iterator):# # the calculation is per pair of times, beetween the first to time the temperature was keep constant, then the system was heated and repeated again.\\n run = tools.run(f\\\"export GMX_MAXBACKUP=-1; echo {energy_type} | gmx energy -f {edr} -b {annealing_times[index]} -e {annealing_times[index + 1]} -o {xvg_tmp_file.name} | grep \\\\'{energy_type.replace('-',' ')}\\\\'\\\")\\n energy.append(float(run.stdout.split()[-5]))\\n \\\"\\\"\\\"\\n Energy Average Err.Est. RMSD Tot-Drift\\n -------------------------------------------------------------------------------\\n Potential -1.30028e+06 -- 1682.1 -2422.24 (kJ/mol)\\n Total Energy -952595 -- 2606.81 -3688.3 (kJ/mol)\\n \\\"\\\"\\\"\\n # Getting the histograms and checking for the same len in all intervals\\n if state == 0:\\n data[state] = xvg.XVG(xvg_tmp_file.name).data[:,1]\\n else:\\n xvg_data = xvg.XVG(xvg_tmp_file.name).data[:,1]\\n if xvg_data.shape[0] > data.shape[0]:\\n data[state] = xvg_data[:data.shape[0]]\\n else:\\n data = data.iloc[:xvg_data.shape[0]]\\n data[state] = xvg_data\\n\\n\\n print(data)\\n sns.histplot(data = data, element='poly', stat = 'probability', axes = ax)\\n ax.set(\\n xlabel = f'{energy_type} [kJ/mol]',\\n ylabel = 'Probability',\\n title = f'Distribution of {energy_type}')\\n # plt.show()\\n fig.savefig(out_fig)\\n return energy\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def plotResults(times, result, args, calculate_nT = True, order_SD = False, nSkipp = 1, showProgress = False):\\n t1 = time.time()\\n times = times[::nSkipp]\\n\\n if 'omegaArgs' in args:\\n wList = args['omega'](times, args['omegaArgs'])\\n fList = args['f0']/wList**2 - args['f0']/args['omegaArgs'][0]**2\\n else:\\n wList = args['omega'](times, args)\\n fList = args['f0']/wList**2 - args['f0']/args['w0']**2\\n\\n masterList = [[],[],[],[]]\\n nStates = len(result.states[::nSkipp])\\n progress = 0\\n for psi in result.states[::nSkipp]:\\n alpha, xi, nBar, nT = getParams(psi, calculate_nT = calculate_nT, order_SD = order_SD)\\n masterList[0].append(np.abs(alpha))\\n masterList[1].append(np.abs(xi))\\n masterList[2].append(nBar)\\n masterList[3].append(nT)\\n if showProgress:\\n progress += 1\\n print('\\\\r', \\\"Progress:\\\", round(100*progress/nStates), \\\"%, processing time:\\\", round(time.time() - t1), \\\"s\\\", end = '')\\n\\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5)\\n fig.set_size_inches(15.5, 7.5, forward=True)\\n ax1.plot(times, masterList[0], label = r'$|\\\\alpha |$')\\n ax1.legend()\\n ax2.plot(times, masterList[1], label = \\\"r\\\")\\n ax2.legend()\\n ax3.plot(times, masterList[2], label = \\\"nBar\\\")\\n if calculate_nT:\\n ax3.plot(times, masterList[3], label = \\\"nT\\\")\\n ax3.legend()\\n ax4.plot(times, wList, label = \\\"w(t)\\\")\\n ax4.legend()\\n ax5.plot(times, fList, label = r'$10^{-15} F/\\\\hbar$ in N/(Js)')\\n ax5.legend()\\n plt.show()\\n return(0)\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1,MC_runs,1):\\n Mi=M*i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\\n elif option == 'Put':\\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n \\n # plotting\\n plt.figure(figsize=(8,6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n #The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def plot_n_scenarios(*args):\\n if not all([isinstance(a, Scenario) for a in args]):\\n raise ValueError(\\\"all inputs must be Scenario objects\\\")\\n # Build dictionaries of calculated data for each scenario\\n scenario_numbers = [a.info[\\\"id\\\"] for a in args]\\n first_id = scenario_numbers[0]\\n scenarios = {id: scen for (id, scen) in zip(scenario_numbers, args)}\\n grid = {id: scenario.state.get_grid() for id, scenario in scenarios.items()}\\n plant = {k: v.plant for k, v in grid.items()}\\n # First scenario is chosen to set fuel colors\\n type2color = ModelImmutables(args[0].info[\\\"grid_model\\\"]).plants[\\\"type2color\\\"]\\n carbon_by_type, energy_by_type, type2color = {}, {}\\n for id, scenario in scenarios.items():\\n # Calculate raw numbers\\n annual_plant_energy = scenario.state.get_pg().sum()\\n raw_energy_by_type = annual_plant_energy.groupby(plant[id].type).sum()\\n annual_plant_carbon = generate_emissions_stats(scenario).sum()\\n raw_carbon_by_type = annual_plant_carbon.groupby(plant[id].type).sum()\\n # Drop fuels with zero energy (e.g. all offshore_wind scaled to 0 MW)\\n energy_by_type[id] = raw_energy_by_type[raw_energy_by_type != 0]\\n carbon_by_type[id] = raw_carbon_by_type[raw_energy_by_type != 0]\\n # Carbon multiplier is inverse of carbon intensity, to scale bar heights\\n carbon_multiplier = energy_by_type[first_id].sum() / carbon_by_type[first_id].sum()\\n\\n # Determine the fuel types with generation in either scenario\\n fuels = list(set.union(*[set(v.index) for v in energy_by_type.values()]))\\n # Fill zeros in scenarios without a fuel when it's present in another\\n for id in scenario_numbers:\\n energy_by_type[id] = energy_by_type[id].reindex(fuels, fill_value=0)\\n carbon_by_type[id] = carbon_by_type[id].reindex(fuels, fill_value=0)\\n # Re-order according to plotting preferences\\n fuels = [f for f in all_possible if f in fuels]\\n # Re-assess subsets\\n renewable_fuels = [f for f in possible_renewable if f in fuels]\\n clean_fuels = [f for f in possible_clean if f in fuels]\\n carbon_fuels = [f for f in possible_carbon if f in fuels]\\n dropped_fuels = (set(possible_clean) | set(possible_carbon)) - (\\n set(clean_fuels) | set(carbon_fuels)\\n )\\n print(\\\"no energy in any grid(s), dropping: %s\\\" % \\\", \\\".join(dropped_fuels))\\n\\n fuel_series = {\\n f: sum(\\n [\\n [energy_by_type[s][f], carbon_by_type[s][f] * carbon_multiplier]\\n for s in scenario_numbers\\n ],\\n [],\\n )\\n for f in fuels\\n }\\n num_bars = 2 * len(scenario_numbers)\\n ind = np.arange(num_bars)\\n width = 0.5\\n line_alpha = 0.25\\n line_offsets = np.array((0.25, 0.75))\\n\\n # Strart plotting\\n fig = plt.figure(figsize=(10, 8))\\n ax = fig.add_subplot(111)\\n # Plot bars\\n patches = {}\\n bottom = np.zeros(num_bars)\\n for i, f in enumerate(fuels):\\n patches[i] = plt.bar(\\n ind, fuel_series[f], width, bottom=bottom, color=type2color[f]\\n )\\n bottom += fuel_series[f]\\n # Plot lines\\n for i, fuel in enumerate(carbon_fuels):\\n for j, s in enumerate(scenario_numbers):\\n cumulative_energy = sum(\\n [energy_by_type[s][carbon_fuels[k]] for k in range(i + 1)]\\n )\\n cumulative_scaled_carbon = carbon_multiplier * sum(\\n [carbon_by_type[s][carbon_fuels[k]] for k in range(i + 1)]\\n )\\n ys = (cumulative_energy, cumulative_scaled_carbon)\\n xs = line_offsets + 2 * j\\n plt.plot(xs, ys, \\\"k-\\\", alpha=line_alpha)\\n\\n # Labeling\\n energy_fmt = \\\"{0:,.0f} TWh\\\\n{1:.0f}% renewable\\\\n{2:.0f}% carbon-free\\\\n\\\"\\n carbon_fmt = \\\"{0:,.0f} million\\\\ntons CO2\\\\n\\\"\\n energy_total = {s: energy_by_type[s].sum() for s in scenarios}\\n for j, s in enumerate(scenario_numbers):\\n carbon_total = carbon_by_type[s].sum()\\n renewable_energy = sum([energy_by_type[s][f] for f in renewable_fuels])\\n clean_energy = sum([energy_by_type[s][f] for f in clean_fuels])\\n renewable_share = renewable_energy / energy_total[s] * 100\\n clean_share = clean_energy / energy_total[s] * 100\\n annotation_str = energy_fmt.format(\\n energy_total[s] / 1e6, renewable_share, clean_share\\n )\\n annotation_x = 2 * (j - 0.08)\\n plt.annotate(xy=(annotation_x, energy_total[s]), s=annotation_str)\\n annotation_str = carbon_fmt.format(carbon_total / 1e6)\\n annotation_x = 2 * (j - 0.08) + 1\\n annotation_y = carbon_total * carbon_multiplier\\n plt.annotate(xy=(annotation_x, annotation_y), s=annotation_str)\\n\\n # Plot formatting\\n plt.ylim((0, max(energy_total.values()) * 1.2))\\n labels = sum([[\\\"%s Energy\\\" % id, \\\"%s Carbon\\\" % id] for id in scenario_numbers], [])\\n plt.xticks(ind, labels)\\n plt.yticks([], [])\\n ax.tick_params(axis=\\\"x\\\", labelsize=12)\\n # Invert default legend order to match stack ordering\\n plt.legend(\\n handles=(patches[i] for i in range(len(fuels) - 1, -1, -1)),\\n labels=fuels[::-1],\\n fontsize=12,\\n bbox_to_anchor=(1.02, 1),\\n loc=\\\"upper left\\\",\\n )\\n plt.tight_layout()\\n plt.show()\",\n \"def SA_data_display(opt_df, all_df):\\n fig, axs = plt.subplots(2, 3)\\n\\n axs[0,0].set_title(\\\"Optimal rewire attempts for circularity\\\")\\n axs[0,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[0,0].set_xlabel(\\\"Time (s)\\\")\\n axs[0,0].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Percent waste (%)\\\"])\\n\\n axs[0,1].set_title(\\\"Optimal rewire attempts acceptance probability\\\")\\n axs[0,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[0,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,1].scatter(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Probability\\\"])\\n\\n axs[0,2].set_title(\\\"Optimal rewire attempts temperature decrease\\\")\\n axs[0,2].set_ylabel(\\\"Temperature\\\")\\n axs[0,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[0,2].plot(opt_df[\\\"Time (s)\\\"], opt_df[\\\"Temperature\\\"])\\n\\n axs[1,0].set_title(\\\"All rewire attempts for circularity\\\")\\n axs[1,0].set_ylabel(\\\"Percent waste %\\\")\\n axs[1,0].set_xlabel(\\\"Time (s)\\\")\\n axs[1,0].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Percent waste (%)\\\"])\\n\\n axs[1,1].set_title(\\\"All rewire attempts acceptance probability\\\")\\n axs[1,1].set_ylabel(\\\"Acceptance Probability\\\")\\n axs[1,1].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,1].scatter(all_df[\\\"Time (s)\\\"], all_df[\\\"Probability\\\"])\\n\\n axs[1,2].set_title(\\\"All rewire attempts temperature decrease\\\")\\n axs[1,2].set_ylabel(\\\"Temperature\\\")\\n axs[1,2].set_xlabel(\\\"Time (s)\\\") # time??\\n axs[1,2].plot(all_df[\\\"Time (s)\\\"], all_df[\\\"Temperature\\\"])\\n\\n return plt.show()\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def show_calculations(self):\\n self.view.set_sum(self.model.get_sum())\\n self.view.set_diff(self.model.get_diff())\",\n \"def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \\n cum_step_q = []\\n steps_mean = np.array(step_cache_qlearning).mean()\\n steps_std = np.array(step_cache_qlearning).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_qlearning:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_q.append(normalized_step)\\n cur_step = 0\\n count = 0\\n \\n cum_step_SARSA = []\\n steps_mean = np.array(step_cache_SARSA).mean()\\n steps_std = np.array(step_cache_SARSA).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_SARSA:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_SARSA.append(normalized_step)\\n cur_step = 0\\n count = 0 \\n # prepare the graph \\n plt.plot(cum_step_q, label = \\\"q_learning\\\")\\n plt.plot(cum_step_SARSA, label = \\\"SARSA\\\")\\n plt.ylabel('Number of iterations')\\n plt.xlabel('Batches of Episodes (sample size 10) ')\\n plt.title(\\\"Q-Learning/SARSA Iteration number untill game ends\\\")\\n plt.legend(loc='lower right', ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\n plt.show()\\n plt.savefig('number_steps.png')\",\n \"def plot_series_and_differences(series, ax, num_diff, title=''):\\n plt.xticks(rotation=40)\\n ax[0].plot(series.index, series)\\n ax[0].set_title('Raw series: {}'.format(title))\\n ax[0].set_xticklabels(labels=series.index.date, rotation=45)\\n for i in range(1, num_diff+1):\\n diff = series.diff(i)\\n ax[i].plot(series.index, diff)\\n ax[i].set_title('Difference # {}'.format(str(i)))\\n ax[i].set_xticklabels(labels=series.index.date, rotation=45)\",\n \"def plot_dispatch_comm(pv, demand, E, week=30,flag=False):\\n\\n sliced_index = (pv.index.week==week)\\n pv_sliced = pv[sliced_index]\\n demand_sliced = demand[sliced_index]\\n self_consumption = E['inv2load'][sliced_index]\\n \\n direct_self_consumption = np.minimum(pv_sliced,demand_sliced)# E['inv2load'][sliced_index]\\n indirect_self_consumption = self_consumption-direct_self_consumption\\n res_pv_sliced = E['res_pv'][sliced_index]\\n grid2load_sliced = E['grid2load'][sliced_index]\\n store2inv_sliced = E['store2inv'][sliced_index]\\n LevelOfCharge = E['LevelOfCharge'][sliced_index]\\n inv2grid = E['inv2grid'][sliced_index]\\n grid2load = E['grid2load'][sliced_index]\\n aux=np.maximum(0,self_consumption)\\n\\n fig, axes = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(17, 4*3), frameon=False,\\n gridspec_kw={'height_ratios': [3, 1, 1], 'hspace': 0.04})\\n\\n #fig, ax = plt.subplots(figsize=(17, 4))\\n axes[0].plot(demand_sliced.index, demand_sliced, color='black', lw=2,label='demand')\\n \\n if flag:\\n axes[0].plot(pv_sliced.index, pv_sliced, color='green', lw=2,label='pv')\\n axes[0].plot(direct_self_consumption.index, direct_self_consumption, color='yellow', lw=2,label='DSC')\\n axes[0].plot(indirect_self_consumption.index, indirect_self_consumption, color='orange', lw=2,label='ISC')\\n axes[0].plot(grid2load_sliced.index, grid2load_sliced, color='red', lw=2,label='grid')\\n\\n else:\\n axes[0].fill_between(direct_self_consumption.index, 0, direct_self_consumption, color='orange', alpha=.8, label='DSC')\\n axes[0].fill_between(pv_sliced.index, self_consumption, pv_sliced ,where=pv_sliced<demand_sliced, color='blue', hatch='//',\\n alpha=.3,label='ISC')\\n axes[0].fill_between(pv_sliced.index, direct_self_consumption, pv_sliced , color='gold', alpha=.3,label='Excess PV')\\n\\n axes[0].fill_between(grid2load_sliced.index,self_consumption,demand_sliced,color='red',alpha=.2, label='grid2load')\\n axes[0].set_ylim([0, axes[0].get_ylim()[1] ])\\n axes[0].set_ylabel('Power (kW)')\\n\\n axes[1].fill_between(LevelOfCharge.index, 0, LevelOfCharge, color='grey', alpha=.2, label='SOC')\\n axes[1].set_ylabel('State of Charge (kWh)')\\n\\n axes[2].fill_between(inv2grid.index, 0, inv2grid, color='green', alpha=.2,label='injected2grid')\\n axes[2].fill_between(inv2grid.index, 0, -grid2load, color='red', alpha=.2,label='grid drawn')\\n axes[2].set_ylabel('In/out from grid (kW)')\\n axes[0].legend()\\n axes[1].legend()\\n axes[2].legend()\\n return\",\n \"def plot_dispatch(pv, demand, E, week=30):\\n\\n sliced_index = (pv.index.week==week)\\n pv_sliced = pv[sliced_index]\\n demand_sliced = demand[sliced_index]\\n self_consumption = E['inv2load'][sliced_index]\\n \\n direct_self_consumption = np.minimum(pv_sliced,demand_sliced)# E['inv2load'][sliced_index]\\n indirect_self_consumption = self_consumption-direct_self_consumption\\n res_pv_sliced = E['res_pv'][sliced_index]\\n grid2load_sliced = E['grid2load'][sliced_index]\\n store2inv_sliced = E['store2inv'][sliced_index]\\n LevelOfCharge = E['LevelOfCharge'][sliced_index]\\n inv2grid = E['inv2grid'][sliced_index]\\n grid2load = E['grid2load'][sliced_index]\\n aux=np.maximum(0,self_consumption)\\n\\n fig, axes = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(17, 4*3), frameon=False,\\n gridspec_kw={'height_ratios': [3, 1, 1], 'hspace': 0.04})\\n\\n #fig, ax = plt.subplots(figsize=(17, 4))\\n axes[0].plot(demand_sliced.index, demand_sliced, color='black', lw=2,label='demand')\\n axes[0].plot(pv_sliced.index, pv_sliced, color='black',ls='--', lw=2,label='PV')\\n axes[0].fill_between(direct_self_consumption.index, 0, direct_self_consumption, color='orange', alpha=.8, label='DSC')\\n axes[0].fill_between(pv_sliced.index, self_consumption, pv_sliced , where=pv_sliced<demand_sliced,color='blue', hatch='//',\\n alpha=.3,label='ISC')\\n axes[0].fill_between(pv_sliced.index, direct_self_consumption, pv_sliced ,where=pv_sliced>demand_sliced, color='gold', alpha=.3,label='Excess PV')\\n\\n axes[0].fill_between(grid2load_sliced.index,self_consumption,demand_sliced,color='red',alpha=.2, label='grid2load')\\n \\n\\n #axes[0].plot(grid2load_sliced.index, grid2load_sliced, color='red', ls=\\\":\\\", lw=1)\\n axes[0].set_ylim([0, axes[0].get_ylim()[1] ])\\n axes[0].set_ylabel('Power (kW)')\\n\\n axes[1].fill_between(LevelOfCharge.index, 0, LevelOfCharge, color='grey', alpha=.2, label='SOC')\\n axes[1].set_ylabel('State of Charge (kWh)')\\n\\n axes[2].fill_between(inv2grid.index, 0, inv2grid, color='green', alpha=.2,label='injected2grid')\\n axes[2].fill_between(inv2grid.index, 0, -grid2load, color='red', alpha=.2,label='grid drawn')\\n axes[2].set_ylabel('In/out from grid (kW)')\\n axes[0].legend()\\n axes[1].legend()\\n axes[2].legend()\\n return\",\n \"def plot_ncmc_work(self, filename):\\n with PdfPages(filename) as pdf:\\n for envname in self.get_environments():\\n modname = 'NCMCEngine'\\n work = dict()\\n for direction in ['delete', 'insert']:\\n varname = '/' + envname + '/' + modname + '/' + 'work_' + direction\\n try:\\n # TODO: For now, we analyze all but the last sample, so that this can be run on active simulations.\\n # Later, we should find some way to omit the last sample only if it is nonsensical.\\n work[direction] = self._ncfile[varname][:-1,:]\\n print('Found %s' % varname)\\n except Exception as e:\\n pass\\n\\n def plot_work_trajectories(pdf, work, title=\\\"\\\"):\\n \\\"\\\"\\\"Generate figures for the specified switching legs.\\n \\\"\\\"\\\"\\n plt.figure(figsize=(12, 8))\\n\\n nrows = 2\\n ncols = 6\\n workcols = 2\\n for (row, direction) in enumerate(['delete', 'insert']):\\n #\\n # Plot work vs step\\n #\\n\\n col = 0\\n plt.subplot2grid((nrows,ncols), (row, col), colspan=(ncols-workcols))\\n\\n # Plot average work distribution in think solid line\\n plt.plot(work[direction].mean(0), 'k-', linewidth=1.0, alpha=1.0)\\n # Plot bundle of work trajectories in transparent lines\\n plt.plot(work[direction].T, 'k-', linewidth=0.5, alpha=0.3)\\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\\n workvals = np.ravel(np.abs(work[direction]))\\n worklim = np.percentile(workvals, 98)\\n nsteps = work[direction].shape[1]\\n plt.axis([0, nsteps, -worklim, +worklim])\\n # Label plot\\n if row == 1: plt.xlabel('steps')\\n plt.ylabel('work / kT')\\n plt.title(\\\"%s NCMC in environment '%s' : %s\\\" % (title, envname, direction))\\n plt.legend(['average work', 'NCMC attempts'])\\n\\n #\\n # Plot work histogram\\n #\\n\\n col = ncols - workcols\\n plt.subplot2grid((nrows,ncols), (row, col), colspan=workcols)\\n\\n # Plot average work distribution in think solid line\\n #nbins = 40\\n workvals = work[direction][:-1,-1]\\n #plt.hist(workvals, nbins)\\n if workvals.std() != 0.0:\\n sns.distplot(workvals, rug=True)\\n else:\\n print('workvals has stddev of zero')\\n print(workvals)\\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\\n #worklim = np.percentile(workvals, 98)\\n #oldaxis = plt.axis()\\n #plt.axis([-worklim, +worklim, 0, oldaxis[3]])\\n # Label plot\\n if row == 1: plt.xlabel('work / kT')\\n plt.title(\\\"total %s work\\\" % direction)\\n\\n pdf.savefig() # saves the current figure into a pdf page\\n plt.close()\\n\\n if len(work) > 0:\\n # Plot work for all chemical transformations.\\n plot_work_trajectories(pdf, work, title='(all transformations)')\\n\\n # Plot work separated out for each chemical transformation\\n #[niterations, nsteps] = work.shape\\n #transformations = dict()\\n #for iteration in range(niterations):\\n # plot_work_trajectories(pdf, work, title='(all transformations)')\",\n \"def eda_plot():\\n\\n df1 = pd.read_csv('eda_malware.csv')\\n df2 = pd.read_csv('eda_random.csv')\\n df3 = pd.read_csv('eda_popular.csv')\\n\\n df = pd.concat([df1, df2, df3], ignore_index=True)\\n df['label'].replace([0,1],['Benign','Malware'],inplace=True)\\n\\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB', '#97C1A9']\\n # b vs. m: node types counts\\n f1 = pd.crosstab(df['label'], df['node_types_counts'])\\n\\n f1 = pd.DataFrame({\\\"3 Types\\\": [1, 4], \\\"4 Types\\\": [1, 407], \\\"5 Types\\\": [245, 5768], \\\"6 Types\\\": [39, 1113], \\\"7 Types\\\": [83, 487], \\\"8 Types\\\": [154, 368], \\\"9 Types\\\": [103, 286]}).rename(index={0:'Benign', 1:'Malware'})\\n f1.plot(kind='bar', color=colors)\\n fig = plt.gcf()\\n plt.legend(loc='upper left')\\n plt.title('Benign vs. Malicious: Number of Node Types')\\n fig.savefig('bv_node_types.png')\\n\\n # for a better look, limit type 5 malware to 2k counts only\\n f1 = pd.DataFrame({\\\"3 Types\\\": [1, 4], \\\"4 Types\\\": [1, 407], \\\"5 Types\\\": [245, 2000], \\\"6 Types\\\": [39, 1113], \\\"7 Types\\\": [83, 487], \\\"8 Types\\\": [154, 368], \\\"9 Types\\\": [103, 286]}).rename(index={0:'Benign', 1:'Malware'})\\n f1.plot(kind='bar', color=colors)\\n fig = plt.gcf()\\n plt.legend(loc='upper left')\\n plt.title('Benign vs. Malicious: Number of Node Types')\\n fig.savefig('bv_node_types1.png')\\n\\n # node types\\n # for malware: extract node types info for node types counts > 5, and sum up each types counts\\n node_types = df[(df['label'] == 'Malware') & (df['node_types_counts'] >= 5)]['node_types'] #series\\n lst = [ast.literal_eval(s) for s in node_types]\\n\\n c = Counter()\\n for d in lst:\\n c.update(d)\\n\\n df_nt = pd.DataFrame(dict(c).items(), columns=['node_types', 'counts'])\\n df_nt = df_nt.sort_values(by=['counts'])\\n\\n sizes = [215060, 2823059, 3135725, 5641356, 10679709, 16547701]\\n labels = ['Others', 'static,Node', 'public,static,Node', 'Node', 'external,Node', 'public,Node']\\n\\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB']\\n\\n fig1, ax1 = plt.subplots(figsize=(7, 7))\\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\\n shadow=False, startangle=90, colors=colors)\\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\\n plt.title('Malware: Top Node Types and Its Counts', y=1.05)\\n\\n plt.show()\\n fig1.savefig('counts_pie_m.png')\\n\\n # for benign: extract node types info for node types counts, and sum up each types counts\\n node_types = df[(df['label'] == 'Benign')]['node_types'] #series\\n lst = [ast.literal_eval(s) for s in node_types]\\n\\n c = Counter()\\n for d in lst:\\n c.update(d)\\n\\n df_nt = pd.DataFrame(dict(c).items(), columns=['node_types', 'counts'])\\n df_nt = df_nt.sort_values(by=['counts'])\\n\\n sizes = [77967, 2892033, 2964924, 5287258, 6478196, 20364339]\\n labels = ['Others', 'staticNode', 'public,staticNode', 'external,Node', 'Node', 'public,Node']\\n\\n colors = ['#EAB6AB','#D9E6F3','#CBAACB','#CCE2CB', '#FFAEA5', '#A2E1DB']\\n\\n fig1, ax1 = plt.subplots(figsize=(7, 7))\\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\\n shadow=False, startangle=90, colors=colors)\\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\\n plt.title('Benign: Top Node Types and Its Counts', y=1.05)\\n\\n plt.show()\\n fig1.savefig('counts_pie_b.png')\\n\\n # benign vs malware: counts\\n sizes = [8435, 802]\\n labels = ['Benign', 'Malware']\\n\\n colors = ['#EAB6AB','#D9E6F3']\\n\\n fig1, ax1 = plt.subplots(figsize=(7, 7))\\n ax1.pie(sizes, labels=labels, autopct='%1.1f%%',\\n shadow=False, startangle=90, colors=colors)\\n ax1.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\\n plt.title('Number of Benign vs. Malware', y=1.05)\\n\\n plt.show()\\n fig1.savefig('bm_counts.png')\\n\\n # number of edges vs number of nodes\\n groups = df.groupby('label')\\n colors = ['#FFAEA5', '#A2E1DB']\\n\\n # Plot\\n fig, ax = plt.subplots()\\n ax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n for name, group in groups:\\n if name == 'Benign':\\n c = colors[0]\\n else:\\n c = colors[1]\\n ax.plot(group.number_edges, group.number_nodes, marker='o', linestyle='', ms=4, label=name, c=c)\\n ax.legend()\\n ax.set_xlabel('Number of Edges')\\n ax.set_ylabel('Number of Nodes')\\n ax.set_title('Benign & Malware: Number of Edges vs. Number of Nodes', y=1.05)\\n\\n plt.show()\\n fig.savefig('bm_edges_nodes.png')\",\n \"def plot_evolution(self, layer, sublayer, figures=[], axes=[]):\\n if figures==[]:\\n figures.append(plt.figure(\\\"Basis evolution per recording (euclidean distance between sets of basis)\\\"))\\n distance_legend = [\\\"Base N: \\\"+str(i) for i in range(len(self.basis[layer][sublayer]))]\\n axes.append(figures[0].add_subplot('111'))\\n axes[0].plot(self.basis_distance[layer][sublayer])\\n axes[0].legend(tuple(distance_legend))\\n axes[0].set_xlabel(\\\"Recording Number\\\")\\n \\n evolution_parameters=np.array([self.noise_history[layer][sublayer], \\n self.learning_history[layer][sublayer],\\n self.sparsity_history[layer][sublayer],\\n self.sensitivity_history[layer][sublayer]]).transpose()\\n evolution_legend = (\\\"Noise\\\",\\\"Learning step\\\",\\\"Sparsity\\\",\\\"Sensitivity\\\")\\n figures.append(plt.figure(\\\"Network parameter evolution per recording\\\"))\\n axes.append(figures[1].add_subplot('111'))\\n axes[1].plot(evolution_parameters)\\n axes[1].legend(tuple(evolution_legend))\\n axes[1].set_xlabel(\\\"Recording Number\\\")\\n else:\\n \\n axes[0].clear()\\n distance_legend = [\\\"Base N: \\\"+str(i) for i in range(len(self.basis[layer][sublayer]))] \\n axes[0].plot(self.basis_distance[layer][sublayer])\\n axes[0].legend(tuple(distance_legend))\\n axes[0].set_xlabel(\\\"Recording Number\\\")\\n \\n axes[1].clear()\\n evolution_parameters=np.array([self.noise_history[layer][sublayer], \\n self.learning_history[layer][sublayer],\\n self.sparsity_history[layer][sublayer],\\n self.sensitivity_history[layer][sublayer]]).transpose()\\n evolution_legend = (\\\"Noise\\\",\\\"Learning step\\\",\\\"Sparsity\\\",\\\"Sensitivity\\\")\\n axes[1].plot(evolution_parameters)\\n axes[1].legend(tuple(evolution_legend))\\n axes[1].set_xlabel(\\\"Recording Number\\\")\\n return figures, axes\",\n \"def basic_stats_and_plots():\\n \\n basename = sys.argv[1]\\n ops = (\\\"two_opt\\\", \\\"twoh_opt\\\", \\\"three_opt\\\", \\\"three_opt_broad\\\", \\\"swap\\\", \\\"swap_adj\\\")\\n opfs = {\\n \\\"two_opt\\\": tsp.two_opt,\\n \\\"twoh_opt\\\": tsp.twoh_opt,\\n \\\"three_opt\\\": tsp.three_opt,\\n \\\"three_opt_broad\\\": tsp.three_opt_broad,\\n \\\"swap\\\": tsp.swap_two,\\n \\\"swap_adj\\\": tsp.swap_adj\\n }\\n \\n lengths = range(6, 11)\\n for length in lengths:\\n stddev = []\\n gini = []\\n nneighbours = []\\n prop_unique = []\\n for op in ops:\\n filename = os.path.join(basename,\\n \\\"tsp_length_%d_%s\\\" % (length, op),\\n \\\"TP_row0.dat\\\")\\n print op, length\\n x = np.genfromtxt(filename)\\n # stats to get:\\n stddev.append(np.std(x))\\n gini.append(random_walks.gini_coeff(x))\\n nneighbours.append(np.sum(x > 0))\\n mu, sigma = rw_experiment_with_op(length, opfs[op])\\n prop_unique.append((mu, sigma))\\n\\n gini_barchart(length, gini, ops)\\n stddev_barchart(length, stddev, ops)\\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)\",\n \"def plot_compartments(self, compartments, show=True, save_path=None, names=None):\\n print 'Copying voltages and recovery variables for debugging...'\\n # Note if they have already been copied then the following functions won't\\n # do a copy\\n v = self.get_voltages()\\n\\n # Check for infinities\\n x, y = np.where(np.isinf(np.array(v)))\\n print \\\"Bad compartments found \\\", y\\n _, naning = np.where(np.isnan(np.array(v)))\\n print \\\"Nans found:\\\", naning\\n # If none found, yay and set tmax to whole range\\n if len(x) == 0:\\n t_max = v.shape[0]\\n else:\\n t_max = x[0] - 1\\n print \\\"Voltage shape\\\", v.shape\\n\\n m, n, h = self.get_recovery_variables()\\n f, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, sharex=True)\\n neighbours = self.neuron_collection.get_neighbour_idx(compartments[1])\\n\\n ax1.set_title('Compartments ' + str(compartments))\\n ax1.set_ylabel('Voltage /mV')\\n ax2.set_ylabel('m')\\n ax3.set_ylabel('n')\\n ax4.set_ylabel('h')\\n ax4.set_xlabel('Step')\\n ax5.axis('off')\\n for index, i in enumerate(np.append(compartments, neighbours)):\\n\\n p_v = v[:t_max, i]\\n p_m = m[:t_max, i]\\n p_n = n[:t_max, i]\\n p_h = h[:t_max, i]\\n\\n if index < len(names):\\n label = names[index]\\n else:\\n label = \\\"c_idx:\\\" + str(i)\\n\\n ax1.plot(p_v, label=label)\\n ax2.plot(p_m, label=label)\\n ax3.plot(p_n, label=label)\\n ax4.plot(p_h, label=label)\\n ax1.set_ylim(-50, 200)\\n ax2.set_ylim(0, 1)\\n ax3.set_ylim(0, 1)\\n ax4.set_ylim(0, 1)\\n\\n handles, labels = ax1.get_legend_handles_labels()\\n f.legend(handles, labels, loc='lower center', ncol=3, borderaxespad=2)\\n\\n if save_path is not None:\\n #fig.tight_layout()\\n plt.savefig(save_path)\\n print \\\"Saved figure to \\\" + save_path\\n if show:\\n plt.show()\\n if not show:\\n plt.clf()\",\n \"def _run():\\n\\n temperatures_kelvins = _create_temperature_grid()\\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\\n second_derivs_kelvins_pt01 = numpy.gradient(\\n numpy.absolute(first_derivs_kelvins_pt01)\\n )\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(first_derivs_kelvins_pt01)\\n )\\n\\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(second_derivs_kelvins_pt01)\\n )\\n\\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\\n\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n temperature_handle = axes_object.plot(\\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n second_deriv_handle = axes_object.plot(\\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n first_deriv_handle = axes_object.plot(\\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n this_min_index = numpy.argmin(second_derivs_unitless)\\n second_derivs_unitless[\\n (this_min_index - 10):(this_min_index + 10)\\n ] = second_derivs_unitless[this_min_index]\\n\\n tfp_handle = axes_object.plot(\\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n axes_object.set_yticks([0])\\n axes_object.set_xticks([], [])\\n\\n x_label_string = r'$x$-coordinate (increasing to the right)'\\n axes_object.set_xlabel(x_label_string)\\n\\n legend_handles = [\\n temperature_handle, first_deriv_handle, second_deriv_handle,\\n tfp_handle\\n ]\\n\\n legend_strings = [\\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\\n ]\\n\\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\\n\\n print 'Saving figure to file: \\\"{0:s}\\\"...'.format(OUTPUT_FILE_NAME)\\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\\n pyplot.close()\",\n \"def energy_kde_paperplot(fields,df):\\n plt.figure()\\n i = 0\\n colorList = ['dodgerblue','tomato']\\n lw = 2\\n\\n meanE_2 = []\\n meanE_3 = []\\n mup = np.min(df['energy [eV]']) - pp.mu\\n chi_0 = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(fields[0]))\\n g_en_axis, _, _, _, _, _, _, _, _, _, _, _, _, _ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_0, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), np.zeros(len(g_en_axis)), '-', color='black', lineWidth=lw,label='Equilibrium')\\n\\n for ee in fields:\\n chi_2_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n # meanE_2 = utilities.mean_energy(chi_2_i,df)\\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_2_i, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,'--',color = colorList[i],lineWidth=lw,label=r'Low Field {:.0f} '.format(ee/100)+r'$V \\\\, cm^{-1}$')\\n print(integrate.trapz(g_chiax,g_en_axis))\\n\\n # plt.plot(meanE_2-np.min(df['energy [eV]']),0,'.')\\n chi_3_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '3_' + \\\"E_{:.1e}.npy\\\".format(ee))\\n g_en_axis, g_ftot, g_chiax, g_f0ax, _, _, _, _, _, _, _, _,_,_ = \\\\\\n occupation_plotter.occupation_v_energy_sep(chi_3_i, df['energy [eV]'].values, df)\\n plt.plot(g_en_axis - np.min(df['energy [eV]']), g_chiax,color = colorList[i],lineWidth=lw,label=r'Full Drift {:.0f} '.format(ee/100)+r'$V \\\\, cm^{-1}$')\\n print(integrate.trapz(g_chiax,g_en_axis))\\n\\n i = i + 1\\n # plt.plot(g_en_axis - np.min(df['energy [eV]']), g_f0ax, '--', color='black', lineWidth=lw,label=r'$f_0$')\\n\\n plt.legend()\\n # plt.ylim([-0.02, 0.015])\\n plt.xlabel(r'Energy above CBM ($eV$)')\\n plt.ylabel(r'Deviational occupation $\\\\delta f_{\\\\mathbf{k}}$ (norm.)')\\n # plt.ylabel(r'$\\\\delta f_{\\\\mathbf{k}}/f_{\\\\mathbf{k}}^0$')\\n plt.savefig(pp.figureLoc+'energy_KDE.png', bbox_inches='tight',dpi=600)\\n\\n plt.figure()\\n plt.plot(g_en_axis,g_chiax)\\n\\n plt.figure()\\n Z, xedges, yedges = np.histogram2d(df['kx [1/A]']*chi_3_i,df['ky [1/A]']*chi_3_i)\\n plt.pcolormesh(xedges, yedges, Z.T)\\n\\n from scipy.stats.kde import gaussian_kde\\n g_inds,_,_ = utilities.gaas_split_valleys(df,False)\\n g_df = df.loc[g_inds]\\n\\n x = g_df['kx [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n y = g_df['ky [1/A]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n\\n # y = g_df['energy [eV]']*(chi_3_i[g_inds]+g_df['k_FD'])\\n k = gaussian_kde(np.vstack([x, y]))\\n xi, yi = np.mgrid[x.min():x.max():x.size ** 0.5 * 1j, y.min():y.max():y.size ** 0.5 * 1j]\\n zi = k(np.vstack([xi.flatten(), yi.flatten()]))\\n\\n fig = plt.figure(figsize=(7, 8))\\n ax1 = fig.add_subplot(211)\\n ax2 = fig.add_subplot(212)\\n\\n # alpha=0.5 will make the plots semitransparent\\n ax1.pcolormesh(xi, yi, zi.reshape(xi.shape), alpha=0.5)\\n ax2.contourf(xi, yi, zi.reshape(xi.shape), alpha=0.5)\\n\\n ax1.set_xlim(x.min(), x.max())\\n ax1.set_ylim(y.min(), y.max())\\n ax2.set_xlim(x.min(), x.max())\\n ax2.set_ylim(y.min(), y.max())\",\n \"def plot_all(self):\\n self.plot_ramps()\\n self.plot_groupdq()\",\n \"def n27_and_stark():\\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\\n # n=27 without static field.\\n folder = os.path.join(\\\"..\\\", \\\"..\\\", \\\"2018-09-09\\\")\\n fname = \\\"11_freq_diode.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n data['afpoly'] = data['fpoly'] + 4511\\n ax.axhline(0, color='grey')\\n data.plot(x='afpoly', y='sig', c='k', ax=ax)\\n # n=27 with static field.\\n fname = \\\"10_freq_diode.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n data['afpoly'] = data['fpoly'] + 4511\\n data['asig'] = data['sig'] + 0.15\\n ax.axhline(0.15, color='grey')\\n data.plot(x='afpoly', y='asig', c='k', ax=ax)\\n # text\\n ax.text(-5.5, 0.2, \\\"3 V/cm\\\", horizontalalignment='right')\\n ax.text(-5.5, 0.01, \\\"0 V/cm\\\", horizontalalignment='right')\\n # pretty figure\\n ax.legend().remove()\\n ax.set_ylabel(r\\\"$e^-$ Signal\\\")\\n ax.set_yticks([])\\n ax.set_xlabel(r\\\"Frequency (GHz from $3d_{5/2} \\\\rightarrow 27f$)\\\")\\n ax.set_xlim(-8, 7)\\n # save\\n fig.tight_layout()\\n fig.savefig('n27_and_stark.pdf')\\n return\",\n \"def figure_1():\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n\\n # Draw common plots\\n print(exp_list)\\n data = get_data(exp_list[0])\\n plt.figure(num=\\\"state 1\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"cmd\\\"],\\n **FORMATTING[\\\"command\\\"]\\n )\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 0],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_1$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"state 2\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 1],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_2$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.ylabel(r\\\"$u$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n def general_figures(exp):\\n data = get_data(exp)\\n plt.figure(num=\\\"state 1\\\")\\n ax = plt.gca()\\n ax.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"control\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"control\\\"],\\n **FORMATTING[exp],\\n )\\n\\n for exp in exp_list:\\n general_figures(exp)\\n\\n # Estimation error\\n for exp in exp_list:\\n data = get_data(exp)\\n error = nla.norm(\\n data[\\\"state\\\"][\\\"adaptive_system\\\"] - data[\\\"real_param\\\"],\\n axis=1\\n )\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.plot(data[\\\"time\\\"], error, **FORMATTING[exp])\\n plt.xlabel(\\\"Time, sec\\\")\\n plt.ylabel(\\\"Error norm\\\")\\n\\n # Real parameter\\n data = get_data(exp_list[0])\\n plt.plot(data[\\\"time\\\"], data[\\\"real_param\\\"].squeeze())\\n\\n\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n def eig_figures(exp, minmax):\\n data = get_data(exp)\\n if minmax == \\\"min\\\":\\n eig = np.min(data[\\\"eigs\\\"], axis=1)\\n elif minmax == \\\"max\\\":\\n eig = np.max(data[\\\"eigs\\\"], axis=1)\\n plt.plot(data[\\\"time\\\"], eig, **FORMATTING[exp])\\n\\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\\\"Eigenvalues\\\", sharex=True)\\n\\n plt.subplot(211)\\n plt.ticklabel_format(style=\\\"sci\\\", scilimits=(0, 0), useOffset=True)\\n for exp in exp_list:\\n eig_figures(exp, \\\"min\\\")\\n plt.ylabel(r\\\"Minimum $\\\\lambda$\\\")\\n plt.legend()\\n\\n plt.subplot(212)\\n for exp in exp_list:\\n eig_figures(exp, \\\"max\\\")\\n plt.ylabel(r\\\"Maximum $\\\\lambda$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n # Saving\\n def savefig(name):\\n path = os.path.join(args.save_dir, name + \\\".\\\" + args.save_ext)\\n plt.savefig(path, bbox_inches=\\\"tight\\\")\\n\\n plt.figure(num=\\\"state 1\\\")\\n plt.legend()\\n savefig(\\\"state-1\\\")\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.legend()\\n savefig(\\\"state-2\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.legend()\\n savefig(\\\"control\\\")\\n\\n plt.figure(num=\\\"Eigenvalues\\\")\\n savefig(\\\"eigs\\\")\\n\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.legend()\\n savefig(\\\"estim-error\\\")\\n\\n plt.show()\",\n \"def plot_test_objective_multi(df, exp_config, output_dir, show):\\n output_file_name = f\\\"{inspect.stack()[0][3]}.{FILE_EXTENSION}\\\"\\n output_path = os.path.join(output_dir, output_file_name)\\n\\n plt.figure()\\n\\n for exp_name, exp_df in df.items():\\n\\n if \\\"rep\\\" in exp_config[\\\"data\\\"][exp_name]:\\n\\n exp_dfs = exp_df\\n\\n T = np.linspace(0, exp_config[\\\"t_max\\\"], 50000)\\n\\n y_list = []\\n for i, df_i in enumerate(exp_dfs):\\n\\n df_i = process_for_test_objective(\\n df_i.sort_values(\\\"timestamp_end\\\"),\\n mode=MODE,\\n max_budget=exp_config[\\\"max_budget\\\"],\\n )\\n x = df_i.loc[df_i[\\\"max_idx\\\"]][\\\"timestamp_end\\\"].values\\n y = df_i.loc[df_i[\\\"max_idx\\\"]][exp_config[\\\"test_objective\\\"]].values\\n\\n f = interp1d(x, y, kind=\\\"previous\\\", fill_value=\\\"extrapolate\\\")\\n y = exp_config.get(\\\"best_objective\\\", 1) - f(T)\\n y_list.append(y)\\n\\n y_list = np.asarray(y_list)\\n y_mean = y_list.mean(axis=0)\\n y_std = y_list.std(axis=0)\\n y_se = y_std / np.sqrt(y_list.shape[0])\\n\\n plt.plot(\\n T,\\n y_mean,\\n label=exp_config[\\\"data\\\"][exp_name][\\\"label\\\"],\\n color=exp_config[\\\"data\\\"][exp_name][\\\"color\\\"],\\n linestyle=exp_config[\\\"data\\\"][exp_name].get(\\\"linestyle\\\", \\\"-\\\"),\\n )\\n plt.fill_between(\\n T,\\n y_mean - 1.96 * y_se,\\n y_mean + 1.96 * y_se,\\n facecolor=exp_config[\\\"data\\\"][exp_name][\\\"color\\\"],\\n alpha=0.3,\\n )\\n\\n else:\\n\\n exp_df = process_for_test_objective(\\n exp_df.sort_values(\\\"timestamp_end\\\"),\\n mode=MODE,\\n max_budget=exp_config[\\\"max_budget\\\"],\\n )\\n x = exp_df.loc[exp_df[\\\"max_idx\\\"]][\\\"timestamp_end\\\"].values\\n y = exp_df.loc[exp_df[\\\"max_idx\\\"]][exp_config[\\\"test_objective\\\"]].values\\n\\n idx = np.unique(x, return_index=True, axis=0)[1]\\n\\n x = x[idx]\\n y = y[idx]\\n\\n x = np.clip(np.concatenate([x, [exp_config[\\\"t_max\\\"]]]), 0, exp_config[\\\"t_max\\\"])\\n y = np.clip(exp_config.get(\\\"best_objective\\\", 1) - np.concatenate([y, [y[-1]]]), 0, 1)\\n \\n area = aulc(x, y)\\n exp_config[\\\"data\\\"][exp_name][\\\"AULC\\\"] = area\\n \\n plt.step(\\n x[:],\\n y[:],\\n where=\\\"post\\\",\\n label=exp_config[\\\"data\\\"][exp_name][\\\"label\\\"],\\n color=exp_config[\\\"data\\\"][exp_name][\\\"color\\\"],\\n marker=exp_config[\\\"data\\\"][exp_name].get(\\\"marker\\\", None),\\n markevery=len(x) // 5,\\n linestyle=exp_config[\\\"data\\\"][exp_name].get(\\\"linestyle\\\", \\\"-\\\"),\\n )\\n\\n ax = plt.gca()\\n ticker_freq = exp_config[\\\"t_max\\\"] / 5\\n ax.xaxis.set_major_locator(ticker.MultipleLocator(ticker_freq))\\n ax.xaxis.set_major_formatter(minute_major_formatter)\\n\\n if exp_config.get(\\\"title\\\") and PRINT_TITLE:\\n plt.title(exp_config.get(\\\"title\\\"))\\n\\n # if MODE == \\\"min\\\":\\n # plt.legend(loc=\\\"upper right\\\")\\n # else:\\n # plt.legend(loc=\\\"lower right\\\")\\n plt.legend(loc=exp_config.get(\\\"legend\\\", \\\"best\\\"))\\n\\n plt.ylabel(\\\"Test Regret\\\")\\n plt.xlabel(\\\"Search time (min.)\\\")\\n\\n if exp_config.get(\\\"ylim\\\"):\\n plt.ylim(*exp_config.get(\\\"ylim\\\"))\\n\\n if exp_config.get(\\\"xlim\\\"):\\n plt.xlim(*exp_config.get(\\\"xlim\\\"))\\n else:\\n plt.xlim(0, exp_config[\\\"t_max\\\"])\\n\\n if exp_config.get(\\\"yscale\\\"):\\n plt.yscale(exp_config.get(\\\"yscale\\\"))\\n\\n plt.grid(which=\\\"minor\\\", color=\\\"gray\\\", linestyle=\\\":\\\")\\n plt.grid(which=\\\"major\\\", linestyle=\\\"-\\\")\\n plt.tight_layout()\\n plt.savefig(output_path, dpi=360)\\n if show:\\n plt.show()\\n plt.close()\",\n \"def plot_dist_evolution(arr, nbins=20, fracs=np.array([0.1, 0.2, 0.3, 0.4]), last=0.5):\\n fracs = fracs\\n\\n last = last\\n last_subset = arr[int(last * arr.shape[0]) :]\\n\\n for ff in fracs:\\n\\n subset = arr[: int(ff * arr.shape[0])]\\n\\n pl.hist(\\n subset, nbins, histtype=\\\"step\\\", density=True, label=\\\"f=0.0--{}\\\".format(ff)\\n )\\n\\n pl.hist(\\n last_subset,\\n nbins,\\n histtype=\\\"step\\\",\\n density=True,\\n label=\\\"f={}--1.0\\\".format(last),\\n )\\n\\n pl.legend(loc=\\\"best\\\", ncol=3)\\n\\n pl.show()\\n\\n return None\",\n \"def Te_ne_P_panel(**kwargs):\\n\\n GR = glo.global_results()\\n gal_indices = np.arange(GR.N_gal)\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n for gal_index in gal_indices:\\n fig = plt.figure(figsize=(15,7),constrained_layout=False)\\n gal_ob = gal.galaxy(GR=GR, gal_index=gal_index)\\n cell_data = gal_ob.cell_data.get_dataframe()\\n\\n gs1 = fig.add_gridspec(nrows=1, ncols=3, wspace=0.0, hspace=0.0)\\n\\n ax = fig.add_subplot(gs1[0,0])\\n h = np.histogram(np.log10(cell_data.Te_mw),bins=100)\\n bin_size = (h[1][1]-h[1][0])/2\\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\\n ax.set_xlabel('log mass-weighted T$_{e}$ per cell')\\n ax.set_ylabel('Mass fraction')\\n\\n ax = fig.add_subplot(gs1[0,1])\\n h = np.histogram(np.log10(cell_data.ne_mw_grid),bins=100)\\n bin_size = (h[1][1]-h[1][0])/2\\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\\n ax.set_xlabel('log mass-weighted n$_{e}$ per cell')\\n ax.set_ylabel('Mass fraction')\\n\\n ax = fig.add_subplot(gs1[0,2])\\n h = np.histogram(np.log10(cell_data.P_HII),bins=100)\\n bin_size = (h[1][1]-h[1][0])/2\\n ax.fill_between(h[1][0:-1] + bin_size,h[0],color='orange', step='pre',alpha=0.6,label='G%i' % gal_index)\\n ax.set_xlabel('log mass-weighted P$_{HII}$ per cell')\\n ax.set_ylabel('Mass fraction')\\n\\n plt.tight_layout()\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'cell_data/pressure/'): os.mkdir(p.d_plot + 'cell_data/pressure/')\\n plt.savefig(p.d_plot + 'cell_data/pressure/G%i' % gal_index, dpi=250, facecolor='w')\\n plt.close()\",\n \"def app_SN_last_24h_plots(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting con_last_24h_plots')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n df = self.data_processor.create_24h_subset(df)\\n self.plotter.plot_SN_separate_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True\\n )\\n self.plotter.plot_SN_separate_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True\\n )\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True,\\n )\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True,\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_energy(self, color=['r','g','b','c','m','y','k'], mod = 'E0'):\\n if not mpl: raise \\\"Problem with matplotib: Plotting not possible.\\\"\\n f = plt.figure(figsize=(5,4), dpi=100)\\n a = f.add_subplot(111)\\n strainList= self.__structures.items()[0][1].strainList\\n \\n if len(strainList)<=5:\\n kk=1\\n ll=len(strainList)\\n grid=[ll]\\n elif len(strainList)%5 == 0:\\n kk=len(strainList)/5\\n ll=5\\n grid=[5 for i in range(kk)]\\n else:\\n kk=len(strainList)/5+1\\n ll=5\\n grid=[5 for i in range(kk)]\\n grid[-1]=len(strainList)%5\\n \\n \\n n=1\\n m=1\\n j=0\\n for stype in strainList:\\n \\n spl = '1'+str(len(strainList))+str(n)\\n if (n-1)%5==0: m=0\\n a = plt.subplot2grid((kk,ll), ((n-1)/5,m), colspan=1)\\n \\n \\n \\n fi=open(stype+'.energy','w')\\n \\n #self.search_for_failed()\\n atoms = self.get_atomsByStraintype(stype)\\n if self.__thermodyn and mod=='F':\\n energy = [i.gsenergy+i.phenergy[100] for i in atoms]\\n elif self.__thermodyn and mod=='E0':\\n energy = [i.gsenergy for i in atoms]\\n elif self.__thermodyn and mod=='Fvib':\\n energy = [i.phenergy[100] for i in atoms]\\n else:\\n energy = [i.gsenergy for i in atoms]\\n strain = [i.eta for i in atoms]\\n \\n ii=0\\n for (e,s) in zip(energy,strain):\\n if e==0.: \\n energy.pop(ii); strain.pop(ii)\\n ii-=1\\n ii+=1\\n #print stype, energy, [i.scale for i in atoms]\\n plt.plot(strain, energy, '%s*'%color[j%7])\\n \\n k=0\\n for st in strain:\\n fi.write('%s %s \\\\n'%(st,energy[k]))\\n k+=1\\n fi.close()\\n \\n poly = np.poly1d(np.polyfit(strain,energy,self.__fitorder[j]))\\n xp = np.linspace(min(strain), max(strain), 100)\\n a.plot(xp, poly(xp),color[j%7],label=stype)\\n \\n a.set_title(stype)\\n \\n j+=1\\n \\n n+=1\\n m+=1\\n \\n a.set_xlabel('strain')\\n a.set_ylabel(r'energy in eV')\\n #a.legend(title='Strain type:')\\n \\n return f\",\n \"def plot_exp1():\\n legend = ['unweighted', 'weighted']\\n labels = ['Degree','Closeness','Current-flow closeness','Betweenness','Current-flow betweenness','Load','Eigenvector','PageRank','HITS authorities','HITS hubs']\\n\\n # classification\\n d = [[0.52500000000000002,0.49444444444444446], # Degree\\n [0.57499999999999996,0.57499999999999996], # Closeness\\n [0.56944444444444442,0.58333333333333337], # Current-flow closeness\\n [0.36388888888888887,0.36944444444444446], # Betweenness\\n [0.23333333333333334,0.20833333333333334], # Current-flow betweenness\\n [0.35555555555555557,0.36666666666666664], # Load\\n [0.49722222222222223,0.45555555555555555], # Eigenvector\\n [0.52777777777777779,0.51111111111111107], # PageRank\\n [0.49722222222222223,0.45555555555555555], # HITS authorities\\n [0.49722222222222223,0.45555555555555555]] # HITS hubs\\n ys = {0:'0.0',.1:'0.1',.2:'0.2', .3:'0.3',.4:'0.4',.5:'0.5',.6:'0.6'}\\n fig = plotter.tikz_barchart(d, labels, scale = 3.5, yscale=2.8, color='black', legend=legend, legend_sep=1.0, tick=False, y_tics=ys)\\n data.write_to_file(fig,'../../masteroppgave/report/imgs/tikz/dependency_eval_class.tex',mode='w')\\n\\n # retrieval\\n d = [[0.18149811054435275,0.18821229318222113], # Degree\\n [0.17184314735361236,0.18216618328598347], # Closeness\\n [0.14606637651984622,0.13586098100141117], # Betweenness\\n [0.17399729543537901,0.17613717518129621], # Current-flow closeness\\n [0.042019078720146409,0.042019078720146409], # Current-flow betweenness\\n [0.14700372822743263,0.15104493506838745], # Load\\n [0.19854658693196564,0.17540014008712554], # Eigenvector\\n [0.17725358882165362,0.17252331100724849], # PageRank\\n [0.19854658693196564,0.17540014008712554], # HITS authorities\\n [0.19854658693196564,0.17540014008712554]] # HITS hubs\\n ys = {0:'0.0',.05:'0.05', .1:'0.1',.15:'0.15', .2:'0.2'}\\n fig = plotter.tikz_barchart(d, labels, scale = 3.5, yscale=8, color='black', legend=legend, legend_sep=1.0, tick=False, grid_step=0.05, y_tics=ys)\\n data.write_to_file(fig,'../../masteroppgave/report/imgs/tikz/dependency_eval_retr.tex',mode='w')\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1, MC_runs, 1):\\n Mi = M * i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\\n elif option == 'Put':\\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n\\n # plotting\\n plt.figure(figsize=(8, 6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n # The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def plot(self):\\n\\n fig, ax = plt.subplots()\\n\\n for run in self.runs:\\n # Load datasets\\n data_measure = run.get_dataset(\\\"stats-collect_link_congestion-raw-*.csv\\\")\\n data_sp = run.get_dataset(\\\"stats-collect_link_congestion-sp-*.csv\\\")\\n\\n # Extract link congestion information\\n data_measure = data_measure['msgs']\\n data_sp = data_sp['msgs']\\n\\n # Compute ECDF and plot it\\n ecdf_measure = sm.distributions.ECDF(data_measure)\\n ecdf_sp = sm.distributions.ECDF(data_sp)\\n\\n variable_label = \\\"\\\"\\n size = run.orig.settings.get('size', None)\\n if size is not None:\\n variable_label = \\\" (n=%d)\\\" % size\\n\\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\\n label=\\\"U-Sphere%s\\\" % variable_label)\\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\\n label=u\\\"Klasični usmerjevalni protokol%s\\\" % variable_label)\\n\\n ax.set_xlabel('Obremenjenost povezave')\\n ax.set_ylabel('Kumulativna verjetnost')\\n ax.grid()\\n ax.axis((28, None, 0.99, 1.0005))\\n self.convert_axes_to_bw(ax)\\n\\n legend = ax.legend(loc='lower right')\\n if self.settings.GRAPH_TRANSPARENCY:\\n legend.get_frame().set_alpha(0.8)\\n fig.savefig(self.get_figure_filename())\",\n \"def compare_plots(data_list, title_list, perp_list = [5, 30, 100], step_list = [10, 50, 1000], \\\\\\n perp_plot = True, step_plot_perp = 30, verbose = False, plot_3d = False, \\\\\\n cdict = {1: 'red', 2: 'mediumspringgreen', 3: 'royalblue'}, df = 1):\\n \\n # Determine dimensions of plot grid\\n nrows = len(perp_list) + 1\\n ncols = len(data_list)\\n \\n # Configure axes\\n axes = []\\n fig = plt.figure(figsize = (16, 3 * nrows))\\n \\n # Generate plots of starting points (first two columns for high-dimensional)\\n for index, dat in enumerate(data_list):\\n X, labs = dat\\n \\n # Check whether original data should be plotted in 3D, and adjust axes accordingly\\n if plot_3d:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index, projection = '3d'))\\n axes[-1].scatter(xs = X[:, 0], ys = X[:, 1], zs = X[:, 2], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_axis_off()\\n else:\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index))\\n plt.scatter(x = X[:, 0], y = X[:, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n axes[-1].set_title(\\\"\\\\n\\\".join(wrap(title_list[index], 35))) \\n \\n # Based on function input, generate either perplexity plots of interim iteration plots\\n if perp_plot:\\n # Generate plots of t-SNE output for different perplexities\\n for perp in range(len(perp_list)):\\n low_d = tsne(X = X, perplexity = perp_list[perp], verbose = verbose, optim = \\\"fastest\\\", df = df)\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (perp + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(perp_list[perp]))\\n plt.scatter(x = low_d[-1, :, 0], y = low_d[-1, :, 1], edgecolor = None, alpha = 0.8, \\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\\n else:\\n # Generate plots of t-SNE output for different iterations\\n low_d = tsne(X = X, perplexity = step_plot_perp, niter = np.max(step_list), verbose = verbose, optim = \\\"fastest\\\", \\\\\\n df = df)\\n for step in range(len(step_list)):\\n axes.append(fig.add_subplot(nrows, ncols, 1 + index + (step + 1) * ncols))\\n axes[-1].set_title(\\\"Perplexity = \\\" + str(step_plot_perp) + \\\", Step = \\\" + str(step_list[step]))\\n plt.scatter(x = low_d[step_list[step], :, 0], y = low_d[step_list[step], :, 1], \\\\\\n edgecolor = None, alpha = 0.8,\\\\\\n c = np.array(list(map(lambda x: cdict[x], labs))))\\n axes[-1].set_xticklabels([])\\n axes[-1].set_yticklabels([])\\n axes[-1].xaxis.set_ticks_position('none')\\n axes[-1].yaxis.set_ticks_position('none')\",\n \"def plot_hist_snfit_meta(self): \\n \\n self.read_meta()\\n self.read_snfit_results()\\n\\n \\n self.diff_x0 = []\\n self.diff_x0_err = []\\n self.diff_x1 = []\\n self.diff_x1_err = [] \\n self.diff_c = []\\n self.diff_c_err = [] \\n self.diff_mb = []\\n self.diff_mb_err = [] \\n self.diff_cov_x0_x1 = []\\n self.diff_cov_x0_c = []\\n self.diff_cov_x1_c = []\\n self.diff_cov_mb_x1 = []\\n self.diff_cov_mb_c = []\\n\\n for i in range (len(self.sn_name)):\\n for j in range (len(self.meta_sn_name_list)):\\n if self.sn_name[i] == self.meta_sn_name_list[j]:\\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \\n self.diff_c.append(self.c[i] - self.meta_c[j])\\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \\n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\\n# self.diff_cov_x0_x1.append()\\n# self.diff_cov_x0_c.append()\\n# self.diff_cov_x1_c.append()\\n# self.diff_cov_mb_x1.append()\\n# self.diff_cov_mb_c.append()\\n else:\\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\\n\\n\\n fig = plt.figure(figsize=(8.,8.)) \\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x0,25,label='$\\\\Delta$ X0')\\n ax0_2.hist(self.diff_x0_err,25,label='$\\\\Delta$ X0 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x1,25,label='$\\\\Delta$ X1')\\n ax0_2.hist(self.diff_x1_err,25,label='$\\\\Delta$ X1 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_c,25,label='$\\\\Delta$ Color')\\n ax0_2.hist(self.diff_c_err,25,label='$\\\\Delta$ Color error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n\\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_mb,50,label='$\\\\Delta$ mb')\\n ax0_2.hist(self.diff_mb_err,50,label='$\\\\Delta$ mb error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6250733","0.6131744","0.61037934","0.6092076","0.60732573","0.59801644","0.59770113","0.5963969","0.59115875","0.58646387","0.5833313","0.58220226","0.5787901","0.57865995","0.5741407","0.5739193","0.57294893","0.57286334","0.5718547","0.57135636","0.5679305","0.5664708","0.5647784","0.5643514","0.56236506","0.5604072","0.557861","0.5566563","0.5537968","0.5537442","0.5532975","0.55239064","0.5514026","0.55067414","0.550376","0.5501042","0.54945856","0.5485498","0.54709476","0.5468128","0.54669213","0.5455653","0.54390126","0.54339683","0.5431853","0.543137","0.5424594","0.5422854","0.54189306","0.5417886","0.54140216","0.5412692","0.5406342","0.5398736","0.53947353","0.53902555","0.5389637","0.53808767","0.5371814","0.5368932","0.536212","0.5361658","0.535933","0.53519267","0.534601","0.5339352","0.5331059","0.5327753","0.5323266","0.5310417","0.53078794","0.5306778","0.5302075","0.5294841","0.5291162","0.52907336","0.52876264","0.5282512","0.5280209","0.5279004","0.527331","0.5269765","0.52533734","0.52520937","0.52515876","0.52474093","0.5244913","0.52380997","0.5237851","0.5219802","0.52188146","0.52170336","0.52086747","0.5208213","0.52055717","0.52052814","0.5204698","0.52012223","0.5200022","0.5199627"],"string":"[\n \"0.6250733\",\n \"0.6131744\",\n \"0.61037934\",\n \"0.6092076\",\n \"0.60732573\",\n \"0.59801644\",\n \"0.59770113\",\n \"0.5963969\",\n \"0.59115875\",\n \"0.58646387\",\n \"0.5833313\",\n \"0.58220226\",\n \"0.5787901\",\n \"0.57865995\",\n \"0.5741407\",\n \"0.5739193\",\n \"0.57294893\",\n \"0.57286334\",\n \"0.5718547\",\n \"0.57135636\",\n \"0.5679305\",\n \"0.5664708\",\n \"0.5647784\",\n \"0.5643514\",\n \"0.56236506\",\n \"0.5604072\",\n \"0.557861\",\n \"0.5566563\",\n \"0.5537968\",\n \"0.5537442\",\n \"0.5532975\",\n \"0.55239064\",\n \"0.5514026\",\n \"0.55067414\",\n \"0.550376\",\n \"0.5501042\",\n \"0.54945856\",\n \"0.5485498\",\n \"0.54709476\",\n \"0.5468128\",\n \"0.54669213\",\n \"0.5455653\",\n \"0.54390126\",\n \"0.54339683\",\n \"0.5431853\",\n \"0.543137\",\n \"0.5424594\",\n \"0.5422854\",\n \"0.54189306\",\n \"0.5417886\",\n \"0.54140216\",\n \"0.5412692\",\n \"0.5406342\",\n \"0.5398736\",\n \"0.53947353\",\n \"0.53902555\",\n \"0.5389637\",\n \"0.53808767\",\n \"0.5371814\",\n \"0.5368932\",\n \"0.536212\",\n \"0.5361658\",\n \"0.535933\",\n \"0.53519267\",\n \"0.534601\",\n \"0.5339352\",\n \"0.5331059\",\n \"0.5327753\",\n \"0.5323266\",\n \"0.5310417\",\n \"0.53078794\",\n \"0.5306778\",\n \"0.5302075\",\n \"0.5294841\",\n \"0.5291162\",\n \"0.52907336\",\n \"0.52876264\",\n \"0.5282512\",\n \"0.5280209\",\n \"0.5279004\",\n \"0.527331\",\n \"0.5269765\",\n \"0.52533734\",\n \"0.52520937\",\n \"0.52515876\",\n \"0.52474093\",\n \"0.5244913\",\n \"0.52380997\",\n \"0.5237851\",\n \"0.5219802\",\n \"0.52188146\",\n \"0.52170336\",\n \"0.52086747\",\n \"0.5208213\",\n \"0.52055717\",\n \"0.52052814\",\n \"0.5204698\",\n \"0.52012223\",\n \"0.5200022\",\n \"0.5199627\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62457854"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":9285,"cells":{"query":{"kind":"string","value":"Plots the ave_dhdl array as a function of the lambda value. If (TI and TICUBIC in methods) plots the TI integration area and the TICUBIC interpolation curve, elif (only one of them in methods) plots the integration area of the method."},"document":{"kind":"string","value":"def plotTI():\n min_dl = dlam[dlam != 0].min()\n S = int(0.4/min_dl)\n fig = pl.figure(figsize = (8,6))\n ax = fig.add_subplot(1,1,1)\n ax.spines['bottom'].set_position('zero')\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n\n for k, spine in ax.spines.items():\n spine.set_zorder(12.2)\n\n xs, ndx, dx = [0], 0, 0.001\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\n min_y, max_y = 0, 0\n\n lines = tuple()\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\n lv_names2 = []\n for j in range(n_components):\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\n\n for j in range(n_components):\n\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n\n # Get the coordinates.\n lj = lchange[:,j]\n x = lv[:,j][lj]\n y = y[lj]/P.beta_report\n\n if 'TI' in P.methods:\n # Plot the TI integration area.\n ss = 'TI'\n for i in range(len(x)-1):\n min_y = min(y.min(), min_y)\n max_y = max(y.max(), max_y)\n #pl.plot(x,y)\n if i%2==0:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\n\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\n # Plot the TI-CUBIC interpolation curve.\n ss += ' and TI-CUBIC'\n xnew = numpy.arange(0, 1+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\n\n else:\n # Plot the TI-CUBIC integration area.\n ss = 'TI-CUBIC'\n for i in range(len(x)-1):\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n ynew[0], ynew[-1] = y[i], y[i+1]\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n if i%2==0:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\n\n # Store the abscissa values and update the subplot index.\n xs += (x+ndx).tolist()[1:]\n ndx += 1\n\n # Make sure the tick labels are not overcrowded.\n xs = numpy.array(xs)\n dl_mat = numpy.array([xs-i for i in xs])\n ri = range(len(xs))\n\n def getInd(r=ri, z=[0]):\n primo = r[0]\n min_dl=ndx*0.02*2**(primo>10)\n if dl_mat[primo].max()<min_dl:\n return z\n for i in r:\n for j in range(len(xs)):\n if dl_mat[i,j]>min_dl:\n z.append(j)\n return getInd(ri[j:], z)\n\n xt = [i if (i in getInd()) else '' for i in range(K)]\n pl.xticks(xs[1:], xt[1:], fontsize=10)\n pl.yticks(fontsize=10)\n #ax = pl.gca()\n #for label in ax.get_xticklabels():\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\n\n # Remove the abscissa ticks and set up the axes limits.\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n pl.xlim(0, ndx)\n min_y *= 1.01\n max_y *= 1.01\n pl.ylim(min_y, max_y)\n\n for i,j in zip(xs[1:], xt[1:]):\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\n if ndx>1:\n lenticks = len(ax.get_ymajorticklabels()) - 1\n if min_y<0: lenticks -= 1\n if lenticks < 5:\n from matplotlib.ticker import AutoMinorLocator as AML\n ax.yaxis.set_minor_locator(AML())\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\n pl.ylabel(r'$\\mathrm{\\langle{\\frac{ \\partial U } { \\partial \\lambda }}\\rangle_{\\lambda}\\/%s}$' % P.units, fontsize=20, color='#151B54')\n pl.annotate('$\\mathit{\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\n if not P.software.title()=='Sire':\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\n for l in lege.legendHandles:\n l.set_linewidth(10)\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\n pl.close(fig)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plotdFvsLambda1():\n x = numpy.arange(len(df_allk))\n if x[-1]<8:\n fig = pl.figure(figsize = (8,6))\n else:\n fig = pl.figure(figsize = (len(x),6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\n lines = tuple()\n for name in P.methods:\n y = [df_allk[i][name]/P.beta_report for i in x]\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\n lines += (line[0],)\n pl.xlabel('States', fontsize=12, color='#151B54')\n pl.ylabel('$\\Delta G$ '+P.units, fontsize=12, color='#151B54')\n pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)\n pl.yticks(fontsize=8)\n pl.xlim(x[0], x[-1]+len(lines)*width)\n ax = pl.gca()\n for dir in ['right', 'top', 'bottom']:\n ax.spines[dir].set_color('none')\n ax.yaxis.set_ticks_position('left')\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n\n leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)\n leg.get_frame().set_alpha(0.5)\n pl.title('The free energy change breakdown', fontsize = 12)\n pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')\n pl.close(fig)\n return","def deap_plot_hyp(stats, colour=\"blue\"):\n plt.ion()\n # plot hypervolumes\n hyp = []\n for gen in stats:\n hyp.append(gen['hypervolume'])\n plt.figure()\n plt.plot(hyp, color=colour)\n plt.xlabel(\"Function Evaluations\")\n plt.ylabel(\"Hypervolume\")","def plot_el(df, el, D, widths, lmbdas, to_pdf, is_sparse):\n df_cut = df[df.elect == el]\n fig, ax = plt.subplots(figsize=(8, 6))\n ymax = 0.0\n\n for d in widths:\n lbl = \"%i nm\" % d\n sel = np.array(df_cut[[\"lmbda\", D]][df_cut.d == d])\n\n if el == \"Carbon\":\n Nl = len(lmbdas)\n eb = [1.0/i for i in range(1, Nl+1)]\n plt.errorbar(sel[:, 0], sel[:, 1] * 1e9, yerr=eb, \\\n fmt=\"D-\", lw=4, ms=10, mew=0, label=lbl)\n else:\n plt.plot(sel[:, 0], sel[:, 1] * 1e9, \\\n \"D-\", lw=4, ms=10, mew=0, label=lbl)\n\n ymax_temp = (max(sel[:, 1] * 1e9) // 10 + 1) * 10 # round to 10s\n if ymax_temp > ymax: ymax = ymax_temp\n plt.ylim([0.0, ymax])\n\n plt.xlim([lmbdas[0]-1, lmbdas[-1]+1])\n plt.xticks([4, 8, 12, 16, 20, 24])\n plt.yticks(np.arange(0.0, ymax+1, 5))\n plt.xlabel(\"$\\lambda$\")\n ylbl = \"Normal\" if len(D) == 2 else \"Parralel\"\n plt.ylabel(\"$D_{\\mathrm{%s}} \\; (10^{-9} \\; \\mathrm{m^2/s}) $\" % ylbl)\n\n plt.legend(loc=\"best\", fontsize=22)\n# if el == \"Carbon\" and D == \"Dx\":\n# plt.legend(loc=2, fontsize=22)\n# if el == \"Carbon\" and D == \"Dyz\":\n# plt.legend(loc=(0.5, 0.5), fontsize=22)\n\n plt.grid()\n plt.title(el)\n fmt = \"pdf\" if to_pdf else \"png\"\n sp = \"_sp\" if is_sparse else \"\"\n plotname = \"%s/%s_%s%s.%s\" % \\\n (default_path, D, el.lower(), sp, fmt)\n# plotname = default_path + D + \"_\" + el.lower() + fmt\n plt.savefig(plotname, bbox_inches='tight')","def investigate4DRepeatability():\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\n avgs = [1,2,4,8,16,32]\n\n #Temporal with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptemptilt = d[-1]-d[-2]\n figtemptilt = d[-1]\n\n #Dynamic with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\n #Make progressive averaging plot\n plt.figure('DynamicTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdyntilt = d[-1]-d[-2]\n figdyntilt = d[-1]\n \n #Temporal with fringes nulled\n fn = glob.glob(parentdir+'Nulled/17*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalNulledFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptempnull = d[-1]-d[-2]\n figtempnull = d[-1]\n \n #Dynamic with fringes nulled\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\n 'SolarBFlat/Repeatability/'\n 'Nulled/170103_Processed.fits')\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\n #Make progressive averaging plot\n plt.figure('DynamicNulledFigure')\n for i in [0,1,3,7,15,31]:\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(i+1))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdynnull = d[-1][0]-d[-1][1]\n figdynnull = d[-1][0]\n\n #Make comparative repeatability plots with 32 averages\n plt.figure('CompareRepeatability')\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Repeatability - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make comparative figure plots with 32 averages\n plt.figure('CompareFigure')\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Figure - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make parroting repeatability plots\n fig = plt.figure('Parroting')\n fig.add_subplot(2,2,1)\n plt.imshow(repdyntilt)\n plt.title('Dynamic Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,2)\n plt.imshow(reptemptilt)\n plt.title('Temporal Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,3)\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\n plt.imshow(repdyntilt-res)\n plt.title('Dynamic Repeatability Filtered')\n plt.colorbar()\n fig.add_subplot(2,2,4)\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\n plt.imshow(reptemptilt-res)\n plt.title('Temporal Repeatability Filtered')\n plt.colorbar()","def test_2d_plot(self):\n db = pd.HDFStore('test.h5')\n df_iv = db['iv']\n dates = df_iv[df_iv['dte'] == 30]['date']\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\n db.close()\n\n print df_iv.sort_values('impl_vol').head()\n\n plt.plot(dates, impl_vols)\n plt.xlabel('date')\n plt.ylabel('impl_vols')\n plt.show()","def plot_tild_integrands(self):\n fig, ax = plt.subplots()\n lambdas = self.get_lambdas()\n thermal_average, standard_error = self.get_tild_integrands()\n ax.plot(lambdas, thermal_average, marker=\"o\")\n ax.fill_between(\n lambdas,\n thermal_average - standard_error,\n thermal_average + standard_error,\n alpha=0.3,\n )\n ax.set_xlabel(\"Lambda\")\n ax.set_ylabel(\"dF/dLambda\")\n return fig, ax","def _plot_dists_figure_2a(self, indexes = None, domain=None, two_landes=None, yrange=None, long=None, vline=None, params=None, different_stat =None, nolegend =None):\n\n bstat_stat = 'mean'\n bstat_er = 'se'\n\n\n if two_landes is None:\n two_landes = False\n\n if nolegend is None:\n nolegend = False\n\n if different_stat is None:\n different_stat = False\n elif not isinstance(different_stat, str):\n different_stat = 'var'\n\n if indexes == None:\n indexes = self.indexes\n\n if int is None:\n long = False\n\n if int:\n manyb = True\n bstats = ['dist','dist_guess']\n else:\n manyb = False\n bstats = ['dist']\n\n if different_stat:\n bstats = [different_stat]\n\n if vline is None:\n vline = False\n\n if params is None:\n params = False\n\n indexes = indexes[:2]\n\n\n undertext_params = [['N', 'U'], ['shift_s0', 'sigma_0_del'], ['f1', 's1', 's2']]\n if not params:\n undertext_params = []\n params = []\n else:\n params =undertext_params\n\n\n fewticks = False\n the_colors = ['darkgreen', 'blue','cyan','limegreen']\n the_colors_different = ['blue', 'cyan', 'darkgreen','limegreen']\n\n data_classes = [self.data_classes[indi] for indi in indexes]\n\n if self.data_classes[0].units_s0:\n myunits = self.name_class.units\n delti = False\n myunits = ' in trait SD'\n else:\n myunits = r' (units $\\delta =\\omega/\\sqrt{2N}$)'\n # myunits = r' (units $\\delta$)'\n delti = True\n\n\n plot_dict = dict()\n plot_dict['xlabel'] = 'Generations after shift'\n plot_dict['savedir'] = os.path.join(self.base_dir)\n plot_dict['domain'] = domain\n plot_dict['yrange'] = yrange\n\n plotspecs = dict()\n if int:\n plotspecs['fsize'] = (22, 5)\n else:\n plotspecs['fsize'] = (26, 14)\n plotspecs['fsize'] = (26, 14)\n\n if different_stat:\n plotspecs['fsize'] = (26, 8)\n\n plotspecs['dpi'] = 200\n plotspecs['linewidth'] = 3.5\n\n plotspecs['ticksize'] = 34\n\n # plotspecs['nxticks'] = 3\n\n if fewticks:\n plotspecs['nxticks'] = 2\n plotspecs['nyticks'] = 2\n\n plotspecs['linewidth'] = 8\n\n _mylabel = ''\n\n #if bstats[0] == 'dist':\n plotspecs['legend_loc'] = (0.98, 0.98)\n plotspecs['legend_anchor'] = 'upper right'\n if not delti:\n plot_dict['ylabel'] = 'Distance from optimum ' + myunits + ' \\n'\n else:\n plot_dict['ylabel'] = myunits\n if different_stat:\n if different_stat == 'var':\n plot_dict['ylabel'] = 'Variance'\n plotspecs['ylabelspace'] = 1\n elif different_stat == 'skewness':\n plot_dict['ylabel'] = 'Skewness ' + r'($\\mu_{3}(t)/\\sigma^3 (t)$)'\n else:\n plot_dict['ylabel'] = different_stat\n\n\n plotspecs['axis_font'] = {'fontname': 'Arial', 'size': '46'}\n plotspecs['legend_font'] = {'size': '42'}\n\n #\n # plotspecs['text_loc'] = [0.62, 0.5]\n # plotspecs['text_color'] = 'indianred'\n # plotspecs['text_size'] = 40\n\n\n if vline:\n #vlines = [data_classes[0].phase_2_time, data_classes[0].phase_3_time]\n vlines = [data_classes[0].get_phase_two_time()]\n plot_dict['vlines'] = vlines\n plotspecs['vlinecolor'] = 'black'\n plotspecs['vlineswidth'] = 4\n\n\n if fewticks:\n plotspecs['nyticks'] = 2\n\n plot_dict['plotspecs'] = plotspecs\n\n x = []\n y = []\n yer = []\n ynames = []\n linestyles = []\n colors = []\n len_y = 0\n\n\n col_num = 0\n for bstati in bstats:\n first_data_class = True\n for data_class in data_classes:\n if bstati not in data_class._bstats:\n print(bstati + \"not in\" + str(data_class.index))\n return\n\n _mylabel += bstati\n\n for data_class in data_classes:\n data = data_class.read_bstats(bstati)\n times = sorted(data[bstati].keys())\n yi = [data[bstati][tim][bstat_stat] for tim in times]\n\n style = '-'\n if different_stat:\n coli = the_colors_different[col_num]\n else:\n coli = the_colors[col_num]\n\n name = ''\n lib = ''\n if manyb:\n nametemp = self.name_class.yname(bstati).split(\"(units\")\n name += nametemp[0]\n if bstati in self._theory_stats:\n name = 'Simulations'\n if len(data_classes) == 2:\n if first_data_class:\n name = 'Simulations Lande'\n else:\n name = 'Simulations non-Lande'\n if params is None:\n\n if len(data_classes) > 1:\n name += ' I:' + str(data_class.index)\n lib += str(data_class.index)\n else:\n for param in params:\n try:\n name += param + ' = ' + '{0:.2f}'.format(data_class.param_dict[param]) + ' '\n lib += param + '{0:.0f}'.format(data_class.param_dict[param]) + '_'\n except KeyError:\n print('KeyError: ' + param)\n\n if bstati == 'dist_guess':\n if int:\n name = 'Closed form approximation'\n name = 'Quasi static approximation: ' + r'$\\mu_3 (t)/(2\\sigma^2 (t))$'\n style = '--'\n\n if not (bstati == 'dist_guess' and first_data_class and len(data_classes) == 2):\n col_num += 1\n linestyles.append(style)\n colors.append(coli)\n len_y+=1\n x.append(times)\n y.append(yi)\n ynames.append(name)\n _mylabel = _mylabel + lib\n first_data_class = False\n\n for bstati in bstats:\n first_data_class = True\n for data_class in data_classes:\n if different_stat:\n coli = the_colors_different[-1]\n else:\n coli = the_colors[-1]\n if first_data_class:\n style = '--'\n else:\n style = '-'\n if first_data_class or two_landes:\n if bstati =='var' or bstati == 'skewness' or bstati == 'mu3' or bstati in self._theory_stats and bstati != 'dist_guess':\n if bstati =='var':\n times = x[0]\n var_0 = data_class.param_dict['var_0']\n var_0 = 1.0\n yi = [var_0 for _ in times]\n ynami = 'Equilibrium variance'\n elif bstati == 'skewness' or bstati == 'mu3':\n times = x[0]\n mu0 = 0\n yi = [mu0 for _ in times]\n if bstati == 'skewness':\n ynami = 'Equilibrium skewness'\n else:\n ynami = 'Equilibrium third moment'\n\n elif bstati in self._theory_stats:\n times, yi = self.theory_stat(data_class, bstati)\n ynami = self.name_class.theory_yname(bstati)\n\n x.append(times)\n y.append(yi)\n len_y += 1\n ynames.append(ynami)\n colors.append(coli)\n linestyles.append(style)\n\n first_data_class = False\n\n plot_dict['x'] = x\n plot_dict['y'] = y\n plot_dict['colors'] = colors\n\n\n\n if len(_mylabel) < 30:\n plot_dict['label'] = _mylabel + '_many_cl'\n else:\n plot_dict['label'] = \"_\".join(bstats)\n\n # List with [text_top, text_bottom] containing relevant parameters\n undertext = []\n for listi in undertext_params:\n text_list = self._plot_text(index_list=indexes, params_list=listi)\n if text_list:\n text_string = ', '.join(text_list)\n undertext.append(text_string)\n if len(ynames) > 1 and not nolegend:\n plot_dict['ynames'] = ynames\n\n plot_dict['undertext'] = undertext\n plot_dict['linestyles'] = linestyles\n\n plot_many_y(**plot_dict)","def evidence_tuning_plots(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\",\n x_name=\"Mean Predicted\",\n y_name=\"Empirical Probability\"):\n\n def lineplot(x, y, trials, methods, **kwargs):\n \"\"\"method_lineplot.\n\n Args:\n y:\n methods:\n kwargs:\n \"\"\"\n uniq_methods = set(methods.values)\n method_order = sorted(uniq_methods)\n\n method_new_names = [f\"$\\lambda={i:0.4f}$\" for i in method_order]\n method_df = []\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\n method_new_names)):\n lines_y = y[methods == method]\n lines_x = x[methods == method]\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\n\n to_append = [{x_name : x,\n y_name: y,\n \"Method\": method_new_name,\n \"Trial\" : trial}\n for i, (x,y) in enumerate(zip(xx,yy))]\n method_df.extend(to_append)\n method_df = pd.DataFrame(method_df)\n x = np.linspace(0,1,100)\n plt.plot(x, x, linestyle='--', color=\"black\")\n sns.lineplot(x=x_name, y=y_name, hue=\"Method\",\n alpha=0.8,\n hue_order=method_new_names, data=method_df,)\n # estimator=None, units = \"Trial\")\n\n df = df.copy()\n # Query methods that have evidence_new_reg_2.0\n df = df[[\"evidence\" in i for i in\n df['method_name']]].reset_index()\n\n # Get the regularizer and reset coeff\n coeff = [float(i.split(\"evidence_new_reg_\")[1]) for i in df['method_name']]\n df[\"method_name\"] = coeff\n df[\"Data\"] = convert_dataset_names(df[\"dataset\"])\n df[\"Method\"] = df[\"method_name\"]\n\n g = sns.FacetGrid(df, col=\"Data\", height=6, sharex = False, sharey = False)\n g.map(lineplot, x_input, y_input, \"trial_number\",\n methods=df[\"Method\"]).add_legend()","def makeaplot(events,\n sensitivities,\n hrf_estimates,\n roi_pair,\n fn=True):\n import matplotlib.pyplot as plt\n\n # take the mean and transpose the sensitivities\n sensitivities_stacked = mv.vstack(sensitivities)\n\n if bilateral:\n sensitivities_stacked.sa['bilat_ROIs_str'] = map(lambda p: '_'.join(p),\n sensitivities_stacked.sa.bilat_ROIs)\n mean_sens = mv.mean_group_sample(['bilat_ROIs_str'])(sensitivities_stacked)\n else:\n sensitivities_stacked.sa['all_ROIs_str'] = map(lambda p: '_'.join(p),\n sensitivities_stacked.sa.all_ROIs)\n mean_sens = mv.mean_group_sample(['all_ROIs_str'])(sensitivities_stacked)\n\n mean_sens_transposed = mean_sens.get_mapped(mv.TransposeMapper())\n\n # some parameters\n # get the conditions\n block_design = sorted(np.unique(events['trial_type']))\n reorder = [0, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11]\n block_design = [block_design[i] for i in reorder]\n # end indices to chunk timeseries into runs\n run_startidx = np.array([0, 157, 313, 469])\n run_endidx = np.array([156, 312, 468, 624])\n\n runs = np.unique(mean_sens_transposed.sa.chunks)\n\n for j in range(len(hrf_estimates.fa.bilat_ROIs_str)):\n comparison = hrf_estimates.fa.bilat_ROIs[j][0]\n if (roi_pair[0] in comparison) and (roi_pair[1] in comparison):\n roi_pair_idx = j\n roi_betas_ds = hrf_estimates[:, roi_pair_idx]\n roi_sens_ds = mean_sens_transposed[:, roi_pair_idx]\n\n for run in runs:\n fig, ax = plt.subplots(1, 1, figsize=[18, 10])\n colors = ['#7b241c', '#e74c3c', '#154360', '#3498db', '#145a32', '#27ae60',\n '#9a7d0a', '#f4d03f', '#5b2c6f', '#a569bd', '#616a6b', '#ccd1d1']\n plt.suptitle('Timecourse of sensitivities, {} versus {}, run {}'.format(roi_pair[0],\n roi_pair[1],\n run + 1),\n fontsize='large')\n plt.xlim([0, max(mean_sens_transposed.sa.time_coords)])\n plt.ylim([-5, 7])\n plt.xlabel('Time in sec')\n plt.legend(loc=1)\n plt.grid(True)\n # for each stimulus, plot a color band on top of the plot\n for stimulus in block_design:\n onsets = events[events['trial_type'] == stimulus]['onset'].values\n durations = events[events['trial_type'] == stimulus]['duration'].values\n stimulation_end = np.sum([onsets, durations], axis=0)\n r_height = 1\n color = colors[0]\n y = 6\n\n # get the beta corresponding to the stimulus to later use in label\n beta = roi_betas_ds.samples[hrf_estimates.sa.condition == stimulus.replace(\" \", \"\"), 0]\n\n for i in range(len(onsets)):\n r_width = durations[i]\n x = stimulation_end[i]\n rectangle = plt.Rectangle((x, y),\n r_width,\n r_height,\n fc=color,\n alpha=0.5,\n label='_'*i + stimulus.replace(\" \", \"\") + '(' + str('%.2f' % beta) + ')')\n plt.gca().add_patch(rectangle)\n plt.legend(loc=1)\n del colors[0]\n\n times = roi_sens_ds.sa.time_coords[run_startidx[run]:run_endidx[run]]\n\n ax.plot(times, roi_sens_ds.samples[run_startidx[run]:run_endidx[run]], '-', color='black', lw=1.0)\n glm_model = hrf_estimates.a.model.results_[0.0].predicted[run_startidx[run]:run_endidx[run], roi_pair_idx]\n ax.plot(times, glm_model, '-', color='#7b241c', lw=1.0)\n model_fit = hrf_estimates.a.model.results_[0.0].R2[roi_pair_idx]\n plt.title('R squared: %.2f' % model_fit)\n if fn:\n plt.savefig(results_dir + 'timecourse_localizer_glm_sens_{}_vs_{}_run-{}.svg'.format(roi_pair[0], roi_pair[1], run + 1))","def plot_DA(filename):\n\n # Set up an array of redshift values.\n dz = 0.1\n z = numpy.arange(0., 10. + dz, dz)\n\n # Set up a cosmology dictionary, with an array of matter density values.\n cosmo = {}\n dom = 0.01\n om = numpy.atleast_2d(numpy.linspace(0.1, 1.0, (1.-0.1)/dom)).transpose()\n cosmo['omega_M_0'] = om\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\n cosmo['h'] = 0.701\n cosmo['omega_k_0'] = 0.0\n\n # Calculate the hubble distance.\n dh = cd.hubble_distance_z(0, **cosmo)\n # Calculate the angular diameter distance.\n da = cd.angular_diameter_distance(z, **cosmo)\n\n # Make plots.\n plot_dist(z, dz, om, dom, da, dh, 'angular diameter distance', r'D_A',\n filename)\n plot_dist_ony(z, dz, om, dom, da, dh, 'angular diameter distance', r'D_A',\n filename)","def plotLambdaDependency(folder='results/', analysis='good', sigma=3):\n matplotlib.rc('text', usetex=True)\n if 'ind' in analysis:\n print 'Individual Results'\n data800 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm*.pkl')]\n data600 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm54*.pkl')]\n data700 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm52*.pkl')]\n data890 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm50*.pkl')]\n data = (data600, data700, data800, data890)\n datacontainer = []\n for x in data:\n wx = np.median([d['wx'] for d in x])\n wxerr = np.median([d['wxerr'] for d in x])\n wy = np.median([d['wy'] for d in x])\n wyerr = np.median([d['wyerr'] for d in x])\n dat = dict(wx=wx, wy=wy, wxerr=wxerr, wyerr=wyerr)\n datacontainer.append(dat)\n data = datacontainer\n waves = [600, 700, 800, 890]\n elif 'join' in analysis:\n print 'Joint Results'\n data800nm = fileIO.cPicleRead(folder+'J800nm.pkl')\n data600nm = fileIO.cPicleRead(folder+'J600nm54k.pkl')\n data700nm = fileIO.cPicleRead(folder+'J700nm52k.pkl')\n data890nm = fileIO.cPicleRead(folder+'J890nm50k.pkl')\n data = (data600nm, data700nm, data800nm, data890nm)\n waves = [int(d['wavelength'].replace('nm', '')) for d in data]\n else:\n print 'Using subset of data'\n #data600nm = fileIO.cPicleRead(folder+'G600nm0.pkl')\n data600nm = fileIO.cPicleRead(folder+'J600nm54k.pkl')\n #data700nm = fileIO.cPicleRead(folder+'G700nm0.pkl')\n data700nm = fileIO.cPicleRead(folder+'J700nm52k.pkl')\n #data800nm = fileIO.cPicleRead(folder+'G800nm0.pkl')\n data800nm = fileIO.cPicleRead(folder+'J800nm.pkl')\n #data890nm = fileIO.cPicleRead(folder+'G890nm0.pkl')\n data890nm = fileIO.cPicleRead(folder+'J890nm50k.pkl')\n data = (data600nm, data700nm, data800nm, data890nm)\n waves = [600, 700, 800, 890]\n\n wx = np.asarray([_FWHMGauss(d['wx']) for d in data])\n wxerr = np.asarray([_FWHMGauss(d['wxerr']) for d in data])\n wypix = np.asarray([d['wy'] for d in data])\n wy = _FWHMGauss(wypix)\n wyerrpix = np.asarray([d['wyerr'] for d in data])\n wyerr = _FWHMGauss(wyerrpix)\n waves = np.asarray(waves)\n\n w = np.sqrt(wx*wy)\n werr = np.sqrt(wxerr*wyerr)\n\n print zip(waves, w)\n\n #plot FWHM\n fig = plt.figure()\n ax1 = fig.add_subplot(311)\n ax2 = fig.add_subplot(312)\n ax3 = fig.add_subplot(313)\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.95)\n ax1.set_title('CCD273 PSF Wavelength Dependency')\n\n ax1.errorbar(waves, wx, yerr=sigma*wxerr/3., fmt='o', label='Data')\n ax2.errorbar(waves, wy, yerr=sigma**wyerr/3., fmt='o', label='Data')\n ax3.errorbar(waves, w, yerr=sigma*werr, fmt='o', label='Data')\n\n #fit a power law\n fitfunc = lambda p, x: p[0] * x ** p[1]\n errfunc = lambda p, x, y: fitfunc(p, x) - y\n fit1, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, wx))\n fit2, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, wy))\n fit3, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, w))\n\n #requirement\n alpha=0.2\n x = np.arange(500, 950, 1)\n y = 37*x**-alpha\n # compute the best fit function from the best fit parameters\n corrfit1 = fitfunc(fit1, x)\n corrfit2 = fitfunc(fit2, x)\n corrfit3 = fitfunc(fit3, x)\n print 'Slope:', fit1[1]\n print 'Slope:', fit2[1]\n print 'Slope [requirement < -0.2]:', fit3[1]\n\n #ax1.plot(x, corrfit1, 'k-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (fit1[1]))\n #ax2.plot(x, corrfit2, 'k-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (fit2[1]))\n ax3.plot(x, y, 'r-', label=r'Requirement: $\\alpha \\leq - %.1f$' % alpha)\n #ax3.plot(x, corrfit3, 'k-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (fit3[1]))\n\n # Bayesian\n shift = 0.\n waves -= shift\n px, paramsx, errorsx, outliersx = powerlawFitWithOutliers(waves, wx, wxerr, outtriangle='WFWHMx.png')\n py, paramsy, errorsy, outliersy = powerlawFitWithOutliers(waves, wy, wyerr, outtriangle='WFWHMy.png')\n p, params, errors, outliers = powerlawFitWithOutliers(waves, w, werr, outtriangle='WFWHM.png')\n print paramsx[::-1], errorsx[::-1]\n print paramsy[::-1], errorsy[::-1]\n print params[::-1], errors[::-1]\n\n ax1.plot(x, paramsx[0]*(x-shift)**paramsx[1], 'g-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (paramsx[1]))\n ax2.plot(x, paramsy[0]*(x-shift)**paramsy[1], 'g-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (paramsy[1]))\n ax3.plot(x, params[0]*(x-shift)**params[1], 'g-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (params[1]))\n\n plt.sca(ax1)\n plt.xticks(visible=False)\n plt.sca(ax2)\n plt.xticks(visible=False)\n plt.sca(ax3)\n\n ax1.set_ylim(6.6, 13.5)\n ax2.set_ylim(6.6, 13.5)\n ax3.set_ylim(6.6, 13.5)\n ax1.set_xlim(550, 900)\n ax2.set_xlim(550, 900)\n ax3.set_xlim(550, 900)\n\n ax1.set_ylabel(r'FWHM$_{X} \\, [\\mu$m$]$')\n ax2.set_ylabel(r'FWHM$_{Y} \\, [\\mu$m$]$')\n ax3.set_ylabel(r'FWHM$\\, [\\mu$m$]$')\n ax3.set_xlabel('Wavelength [nm]')\n ax1.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\n ax2.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\n ax3.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\n plt.savefig('LambdaDependency.pdf')\n plt.close()\n\n print 'R2:'\n R2 = _R2FromGaussian(wxpix, wypix)*1e3\n print zip(waves, R2)\n errR2 = _R2err(wxpix, wypix, wxerrpix, wyerrpix)*1e3\n p, params, errors, outliers = powerlawFitWithOutliers(waves, R2, errR2, outtriangle='WR2.png')\n print params[::-1], errors[::-1]\n\n fig = plt.figure()\n ax1 = fig.add_subplot(211)\n ax2 = fig.add_subplot(212)\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\n ax1.set_title('CCD273 PSF Wavelength Dependency')\n ax1.errorbar(waves, R2, yerr=sigma*errR2, fmt='o', label='Data')\n ax1.plot(x, params[0] * (x - shift)**params[1], 'm-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (params[1]))\n #ax1.plot(waves[outliers], R2[outliers], 'ro', ms=20, mfc='none', mec='red')\n ax1.set_ylabel(r'R^{2} \\, [$mas$^{2}]$')\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n\n print 'Ellipticity:'\n ell = _ellipticityFromGaussian(wxpix, wypix) + 1\n print zip(waves, ell)\n ellerr = _ellipticityerr(wxpix, wypix, wxerrpix, wyerrpix)\n p, params, errors, outliers = powerlawFitWithOutliers(waves, ell, ellerr, outtriangle='Well.png')\n print params[::-1], errors[::-1]\n\n fitfunc = lambda p, x: p[0] * x ** p[1]\n errfunc = lambda p, x, y: fitfunc(p, x) - y\n fit1, success = optimize.leastsq(errfunc, [2., -0.1], args=(waves, ell), maxfev=100000)\n print fit1[::-1]\n\n ax2.errorbar(waves, ell, yerr=sigma*ellerr, fmt='o', label='Data')\n ax2.plot(x, params[0] * (x - shift)**params[1], 'm-', label=r'Power Law Fit: $\\alpha \\sim %.2f $' % (params[1]))\n #ax2.plot(waves[outliers], ell[outliers], 'ro', ms=20, mfc='none', mec='red')\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n ax2.legend(shadow=True, fancybox=True, numpoints=1)\n ax2.set_ylabel('Ellipticity')\n\n ax1.set_ylim(0.65, 2.5)\n ax2.set_ylim(1+-0.01, 1+0.16)\n\n plt.sca(ax1)\n plt.xticks(visible=False)\n\n plt.savefig('LambdaR2ell.pdf')\n plt.close()","def plotdFvsLambda2(nb=10):\n x = numpy.arange(len(df_allk))\n if len(x) < nb:\n return\n xs = numpy.array_split(x, len(x)/nb+1)\n mnb = max([len(i) for i in xs])\n fig = pl.figure(figsize = (8,6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\n ndx = 1\n for x in xs:\n lines = tuple()\n ax = pl.subplot(len(xs), 1, ndx)\n for name in P.methods:\n y = [df_allk[i][name]/P.beta_report for i in x]\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.05*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\n lines += (line[0],)\n for dir in ['left', 'right', 'top', 'bottom']:\n if dir == 'left':\n ax.yaxis.set_ticks_position(dir)\n else:\n ax.spines[dir].set_color('none')\n pl.yticks(fontsize=10)\n ax.xaxis.set_ticks([])\n for i in x+0.5*width*len(P.methods):\n ax.annotate('$\\mathrm{%d-%d}$' % (i, i+1), xy=(i, 0), xycoords=('data', 'axes fraction'), xytext=(0, -2), size=10, textcoords='offset points', va='top', ha='center')\n pl.xlim(x[0], x[-1]+len(lines)*width + (mnb - len(x)))\n ndx += 1\n leg = ax.legend(lines, tuple(P.methods), loc=0, ncol=2, prop=FP(size=8), title='$\\mathrm{\\Delta G\\/%s\\/}\\mathit{vs.}\\/\\mathrm{lambda\\/pair}$' % P.units, fancybox=True)\n leg.get_frame().set_alpha(0.5)\n pl.savefig(os.path.join(P.output_directory, 'dF_state.pdf'), bbox_inches='tight')\n pl.close(fig)\n return","def EDA(data):\n\t# mean value curve\n\n\tfig,axs = plt.subplots(5,1, sharey='all')\n\tfig.set_size_inches(10, 15)\n\tdata.groupby('weather').mean().plot(y='count', marker='o', ax=axs[0])\n\tdata.groupby('humidity').mean().plot(y='count', marker='o', ax=axs[1])\n\tdata.groupby('temp').mean().plot(y='count', marker='o', ax=axs[2])\n\tdata.groupby('windspeed').mean().plot(y='count', marker='o', ax=axs[3])\n\tprint('\\n')\n\tdata.groupby('hour').mean().plot(y='count', marker='o', ax=axs[4])\n\tplt.title('mean count per hour')\n\tplt.tight_layout()\n\tplt.show()\n\n\t# grouping scatter\n\tfig,axs = plt.subplots(2,3, sharey='all')\n\tfig.set_size_inches(12, 8)\n\tdata.plot(x='temp', y='count', kind='scatter', ax=axs[0,0], color='magenta')\n\tdata.plot(x='humidity', y='count', kind='scatter', ax=axs[0,1], color='bisque')\n\tdata.plot(x='windspeed', y='count', kind='scatter', ax=axs[0,2], color='coral')\n\tdata.plot(x='month', y='count', kind='scatter', ax=axs[1,0], color='darkblue')\n\tdata.plot(x='day', y='count', kind='scatter', ax=axs[1,1], color='cyan')\n\tdata.plot(x='hour', y='count', kind='scatter', ax=axs[1,2], color='deeppink')\n\tplt.tight_layout()\n\tplt.show()\n\n\t# correlation analysis\n\tcorrMatt = data[[\"temp\",\"atemp\",\"casual\",\"registered\",\"humidity\",\"windspeed\",\"count\"]].corr()\n\tmask = np.array(corrMatt)\n\tmask[np.tril_indices_from(mask)] = False\n\n\tfig,ax= plt.subplots()\n\tfig.set_size_inches(20,10)\n\tsn.heatmap(corrMatt, mask=mask, vmax=.8, square=True, annot=True, cmap=\"Greens\")\n\tplt.show()","def main(\n error_band_dir,\n output_dir,\n indep_var,\n ivar_start,\n ivar_stop,\n ivar_step,\n param_list,\n observable_list,\n Lambda_b,\n lambda_mult,\n p_decimal_list,\n orders,\n ignore_orders,\n interaction,\n X_ref_hash,\n prior_set,\n h,\n cbar_lower,\n cbar_upper,\n sigma,\n convention\n ):\n\n color_dict = {\n \"LOp\": plt.get_cmap(\"Greys\"),\n \"LO\": plt.get_cmap(\"Purples\"),\n \"NLO\": plt.get_cmap(\"Oranges\"),\n \"N2LO\": plt.get_cmap(\"Greens\"),\n \"N3LO\": plt.get_cmap(\"Blues\"),\n \"N4LO\": plt.get_cmap(\"Reds\")\n }\n\n fill_transparency = 1\n x = np.arange(ivar_start, ivar_stop, ivar_step)\n\n fig = plt.figure(figsize=(3.4, 3.4))\n ax = fig.add_subplot(1, 1, 1)\n ax.set_zorder(15)\n ax.set_axisbelow(False)\n\n if indep_var == \"theta\":\n param_var = \"energy\"\n indep_var_label = r\"$\\theta$ (deg)\"\n param_var_label = r\"$E_{\\mathrm{lab}}\"\n param_var_units = r\"$ MeV\"\n xmin = 0\n xmax = 180\n else:\n param_var = \"theta\"\n indep_var_label = r\"$E$ (MeV)\"\n param_var_label = r\"$\\theta\"\n param_var_units = r\"^\\circ$\"\n xmin = 0\n xmax = 350\n\n for observable in observable_list:\n for param in param_list:\n if observable == [\"t\", \"t\", \"t\", \"t\"] or \\\n (observable == [\"0\", \"0\", \"0\", \"0\"] and indep_var == \"energy\"):\n ax.set_yscale(\"log\", nonposy='clip')\n\n ax.set_xlabel(indep_var_label)\n # ax.set_ylabel('')\n\n # if indep_var == \"theta\":\n # major_tick_spacing = 60\n # minor_tick_spacing = 20\n # ax.xaxis.set_major_locator(\n # ticker.MultipleLocator(major_tick_spacing))\n # ax.xaxis.set_minor_locator(\n # ticker.MultipleLocator(minor_tick_spacing))\n\n if indep_var == \"energy\":\n major_ticks = np.arange(0, 351, 100)\n # minor_ticks = np.arange(50, 351, 100)\n x_minor_locator = AutoMinorLocator(n=2)\n elif indep_var == \"theta\":\n major_ticks = np.arange(0, 181, 60)\n # minor_ticks = np.arange(0, 181, 20)\n x_minor_locator = AutoMinorLocator(n=3)\n\n ax.xaxis.set_minor_locator(x_minor_locator)\n ax.set_xticks(major_ticks)\n\n # Create the description box\n # text_str = r\"$C_{\" + observable[0] + observable[1] + \\\n # observable[2] + observable[3] + r\"}$\" + \", \" # + \"\\n\"\n text_str = indices_to_observable_name(observable)\n if observable == ['t', 't', 't', 't']:\n text_str += \" (mb)\"\n elif observable == ['0', '0', '0', '0']:\n text_str += \" (mb/sr)\"\n\n # Probably don't include this extra info. Leave for caption.\n #\n # text_str += \", \"\n # if observable != ['t', 't', 't', 't']:\n # text_str += \", \" + param_var_label + r\" = \" + str(param) + param_var_units + \", \" # + \"\\n\"\n # text_str += r\"$\\Lambda_b = \" + str(lambda_mult*Lambda_b) + r\"$ MeV\"\n\n # Don't put in a text box\n #\n # ax.text(.5, .96, text_str,\n # horizontalalignment='center',\n # verticalalignment='top',\n # multialignment='center',\n # transform=ax.transAxes,\n # bbox=dict(facecolor='white', alpha=1, boxstyle='square', pad=.5),\n # zorder=20)\n\n # Don't put in the title\n # plt.title(text_str, fontsize=10)\n\n # Instead use y axis\n ax.set_ylabel(text_str, fontsize=10)\n legend_patches = []\n\n try:\n npwa_name = npwa_filename(observable, param_var, param)\n npwa_file = DataFile().read(os.path.join(\"../npwa_data/\", npwa_name))\n npwa_plot, = ax.plot(npwa_file[0], npwa_file[1],\n color=\"black\", linewidth=1,\n label=\"NPWA\", zorder=10,\n linestyle=\"--\")\n except FileNotFoundError:\n npwa_plot = None\n\n # First get global min/max of all orders\n for i, order in enumerate(orders):\n # obs_name = observable_filename(\n # observable, indep_var, ivar_start, ivar_stop,\n # ivar_step, param_var, param, order)\n # dob_name = dob_filename(p_decimal_list[0], Lambda_b, obs_name)\n dob_name = dob_filename(\n observable, indep_var, ivar_start, ivar_stop,\n ivar_step, param_var, param, order, ignore_orders,\n Lambda_b, lambda_mult, X_ref_hash,\n p_decimal_list[0], prior_set, h, convention, None,\n cbar_lower, cbar_upper, sigma,\n potential_info=None)\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\n if i == 0:\n obs = dob_file[1]\n obs_min = np.min(obs)\n obs_max = np.max(obs)\n else:\n old_obs = obs\n obs = dob_file[1]\n # Probably the worst way to do this.\n obs_min = min(np.min(np.minimum(old_obs, obs)), obs_min)\n obs_max = max(np.max(np.maximum(old_obs, obs)), obs_max)\n\n # Decide the padding above/below the lines\n # This weights values far from 0 more heavily.\n # ymin = obs_min - .25 * abs(obs_min)\n # ymax = obs_max + .25 * abs(obs_max)\n ymin = -1\n ymax = 20\n ax.set_ylim([ymin, ymax])\n # ax.set_xlim([ivar_start, ivar_stop-1])\n ax.set_xlim([xmin, xmax])\n\n # Start layering the plots\n for i, order in enumerate(orders):\n # obs_name = observable_filename(\n # observable, indep_var, ivar_start, ivar_stop,\n # ivar_step, param_var, param, order)\n # dob_name = dob_filename(p_decimal_list[0], Lambda_b, obs_name)\n dob_name = dob_filename(\n observable, indep_var, ivar_start, ivar_stop,\n ivar_step, param_var, param, order, ignore_orders,\n Lambda_b, lambda_mult, X_ref_hash,\n p_decimal_list[0], prior_set, h, convention, None,\n cbar_lower, cbar_upper, sigma,\n potential_info=None)\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\n\n # Plot the lines\n obs = dob_file[1]\n ax.plot(x, obs, color=color_dict[order](.99), zorder=i)\n\n # Plot the error bands\n for band_num, p in enumerate(sorted(p_decimal_list, reverse=True)):\n # dob_name = dob_filename(p, Lambda_b, obs_name)\n dob_name = dob_filename(\n observable, indep_var, ivar_start, ivar_stop,\n ivar_step, param_var, param, order, ignore_orders,\n Lambda_b, lambda_mult, X_ref_hash,\n p, prior_set, h, convention, None,\n cbar_lower, cbar_upper, sigma,\n potential_info=None)\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\n obs_lower = dob_file[2]\n obs_upper = dob_file[3]\n ax.fill_between(\n x, obs_lower, obs_upper,\n facecolor=color_dict[order](\n (band_num + 1) / (len(p_decimal_list) + 1)\n ),\n color=color_dict[order](\n (band_num + 1) / (len(p_decimal_list) + 1)\n ),\n alpha=fill_transparency, interpolate=True, zorder=i)\n\n # Use block patches instead of lines\n # Use innermost \"dark\" color of bands for legend\n # legend_patches.append(\n # mp.patches.Patch(\n # color=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\n # label=order,\n # ))\n legend_patches.append(\n mpatches.Rectangle(\n (1, 1), 0.25, 0.25,\n # color=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\n edgecolor=color_dict[order](.9),\n facecolor=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\n label=order,\n linewidth=1\n ))\n\n if npwa_plot is None:\n my_handles = legend_patches\n handler_dict = dict(zip(my_handles, [HandlerSquare() for i in legend_patches]))\n else:\n my_handles = [npwa_plot, *legend_patches]\n squares = [HandlerSquare() for i in legend_patches]\n line = HandlerLine2D(marker_pad=1, numpoints=None)\n handler_dict = dict(zip(my_handles, [line] + squares))\n\n ax.legend(loc=\"best\", handles=my_handles,\n handler_map=handler_dict,\n handletextpad=.8,\n handlelength=.6,\n fontsize=8)\n\n # Squeeze and save it\n plt.tight_layout()\n # plot_name = plot_obs_error_bands_filename(\n # observable, indep_var, ivar_start, ivar_stop,\n # ivar_step, param_var, param, orders[:i+1],\n # Lambda_b, p_decimal_list)\n plot_name = plot_obs_error_bands_filename(\n observable, indep_var, ivar_start, ivar_stop, ivar_step,\n param_var, param, orders[:i+1], ignore_orders, Lambda_b,\n lambda_mult, X_ref_hash, p_decimal_list,\n prior_set, h, convention, None, cbar_lower, cbar_upper,\n sigma, potential_info=None)\n fig.savefig(os.path.join(output_dir, plot_name), bbox_inches=\"tight\")\n\n call([\"epstopdf\", os.path.join(output_dir, plot_name)])\n call([\"rm\", os.path.join(output_dir, plot_name)])\n\n # Clear the axes for the next observable/parameter.\n plt.cla()","def test_plot_hid(self):\n # also produce a light curve with the same binning\n command = ('{0} -b 100 --e-interval {1} {2}').format(\n os.path.join(self.datadir, 'monol_testA_nustar_fpma_ev_calib' +\n HEN_FILE_EXTENSION), 3, 10)\n\n hen.lcurve.main(command.split())\n lname = os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_E3-10_lc') + \\\n HEN_FILE_EXTENSION\n os.path.exists(lname)\n cname = os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\n HEN_FILE_EXTENSION\n hen.plot.main([cname, lname, '--noplot', '--xlog', '--ylog', '--HID',\n '-o', 'dummy.qdp'])","def make_area_plots(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\"):\n\n df = df.copy()\n\n # Get the regularizer and reset coeff\n coeff = [float(i.split(\"evidence_new_reg_\")[1]) if \"evidence\" in i else i for i in df['method_name']]\n df[\"method_name\"] = coeff\n df[\"Data\"] = convert_dataset_names(df[\"dataset\"])\n df[\"Method\"] = df[\"method_name\"]\n\n trials = 'trial_number'\n methods = 'Method'\n\n # Make area plot\n uniq_methods = set(df[\"Method\"].values)\n method_order = sorted(uniq_methods,\n key=lambda x : x if isinstance(x, float) else -1)\n method_df = []\n datasets = set()\n for data, sub_df in df.groupby(\"Data\"):\n # Add datasets\n datasets.add(data)\n x_vals = sub_df[x_input]\n y_vals = sub_df[y_input]\n methods_sub = sub_df[\"Method\"]\n trials_sub= sub_df['trial_number']\n for method_idx, method in enumerate(method_order):\n # Now summarize these lines\n bool_select = (methods_sub == method)\n lines_y = y_vals[bool_select]\n lines_x = x_vals[bool_select]\n trials_temp = trials_sub[bool_select]\n areas = []\n # create area!\n for trial, line_x, line_y in zip(trials_sub, lines_x, lines_y):\n new_y = np.abs(np.array(line_y) - np.array(line_x))\n area = simps(new_y, line_x)\n to_append = {\"Area from parity\": area,\n \"Regularizer Coeff, $\\lambda$\": method,\n \"method_name\": method,\n \"Data\": data,\n \"Trial\" : trial}\n method_df.append(to_append)\n method_df = pd.DataFrame(method_df)\n method_df_evidence = method_df[[isinstance(i, float) for i in\n method_df['method_name']]].reset_index()\n method_df_ensemble = method_df[[\"ensemble\" in str(i) for i in\n method_df['method_name']]].reset_index()\n data_colors = {\n dataset : sns.color_palette()[index]\n for index, dataset in enumerate(datasets)\n }\n\n min_x = np.min(method_df_evidence[\"Regularizer Coeff, $\\lambda$\"])\n max_x= np.max(method_df_evidence[\"Regularizer Coeff, $\\lambda$\"])\n\n sns.lineplot(x=\"Regularizer Coeff, $\\lambda$\", y=\"Area from parity\",\n hue=\"Data\", alpha=0.8, data=method_df_evidence,\n palette = data_colors)\n\n for data, subdf in method_df_ensemble.groupby(\"Data\"):\n\n color = data_colors[data]\n area = subdf[\"Area from parity\"].mean()\n std = subdf[\"Area from parity\"].std()\n plt.hlines(area, min_x, max_x, linestyle=\"--\", color=color, alpha=0.8)\n\n ensemble_line = plt.plot([], [], color='black', linestyle=\"--\",\n label=\"Ensemble\")\n # Now make ensemble plots\n plt.legend(bbox_to_anchor=(1.1, 1.05))","def plot_hill_func(self,sim_run=None,trace=0,synapse=0,average=False):\n\n if sim_run is None:\n sim_run = self.default_runs[0]\n\n cav_hits = sim_run.data[\"Ca_t\"][:,trace,synapse]\n\n p_v_func = hill(np.arange(200)/100.,S=1,ec50=sim_run.params[\"ca_ec50\"],n=sim_run.params[\"ca_coop\"])\n plt.plot(np.arange(200)/100.,p_v_func)\n for i in range(len(cav_hits)):\n plt.plot((cav_hits[i],cav_hits[i]),(0,1))\n plt.ylabel('Probbility of Vesicle Release')\n plt.xlabel('Calcium Concentration (arb. units)')\n plt.title('Location of [Ca] response on Hill Function for sequential APs')\n plt.show()","def view_datashade(self):\n # Select only sufficient data\n if self.x in self.y:\n self.y.remove(self.x)\n if self.y == []:\n return self.gif\n\n df = self.dataframe[[self.x] + self.y].copy()\n plot_opts = {\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\n\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\n # Compute\n dataframe = df.copy()\n if x_range is not None:\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\n data_length = len(dataframe) * len(dataframe.columns)\n step = 1 if data_length < self.max_step else data_length // self.max_step\n \n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \n plot_opts = {\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n if len(self.y) != 1:\n plot_opts['Scatter']['color'] = self.color_key\n return plot_df.options(plot_opts)\n\n # Define a RangeXY stream linked to the image\n rangex = hv.streams.RangeX(source=lines_overlay)\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\n if len(self.y) == 1:\n data_shade_plot *= datashade(lines_overlay)\n else:\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\n return pn.panel(data_shade_plot)","def dline_tdepl_array(lines,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig, axs = plt.subplots(len(lines), sharex='col',\\\n figsize=(6,15),facecolor='w',\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\n\n for i,ax in enumerate(axs):\n\n dline_tdepl(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add=True,cb=True)\n dline_tdepl(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add=True,cb=False)\n\n plt.tight_layout()\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/dlines_tdepl_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)","def plot_lfads(x_txd, avg_lfads_dict, data_dict=None, dd_bidx=None,\n renorm_fun=None):\n print(\"bidx: \", dd_bidx)\n ld = avg_lfads_dict\n\n def remove_outliers(A, nstds=3):\n clip = nstds * onp.std(A)\n A_mean = onp.mean(A)\n A_show = onp.where(A < A_mean - clip, A_mean - clip, A)\n return onp.where(A_show > A_mean + clip, A_mean + clip, A_show)\n \n f = plt.figure(figsize=(12,12))\n plt.subplot(361)\n plt.imshow(x_txd.T)\n plt.title('x')\n\n plt.subplot(362)\n x_enc = remove_outliers(ld['xenc_t'])\n plt.imshow(x_enc.T)\n plt.title('x enc')\n\n plt.subplot(363)\n gen = remove_outliers(ld['gen_t'])\n plt.imshow(gen.T)\n plt.title('generator')\n\n plt.subplot(364)\n factors = remove_outliers(ld['factor_t'])\n plt.imshow(factors.T)\n plt.title('factors')\n\n if data_dict is not None:\n true_rates = renorm_fun(data_dict['hiddens'][dd_bidx])\n plt.subplot(366)\n plt.imshow(true_rates.T)\n plt.title('True rates')\n\n plt.subplot(365)\n rates = remove_outliers(onp.exp(ld['lograte_t']))\n plt.imshow(rates.T)\n plt.title('rates') \n\n plt.subplot(334)\n ic_mean = ld['ic_mean']\n ic_std = onp.exp(0.5*ld['ic_logvar'])\n plt.stem(ic_mean)\n plt.title('g0 mean')\n\n plt.subplot(335)\n con = remove_outliers(ld['c_t'])\n plt.imshow(con.T)\n plt.title('controller')\n\n plt.subplot(336)\n ii_mean = ld['ii_mean_t']\n plt.plot(ii_mean, 'b')\n if data_dict is not None:\n true_input = data_dict['inputs'][dd_bidx]\n slope, intercept, r_value, p_value, std_err = \\\n stats.linregress(true_input.T, ii_mean.T)\n plt.plot(slope*true_input + intercept, 'm', lw=2)\n #plt.plot(ld['ii_t'], 'k')\n plt.title('inferred input mean')\n plt.legend(('LFADS inferred input', 'rescaled true input to integrator RNN'))\n \n plt.subplot(313)\n ntoplot=8\n a = 0.25\n plt.plot(rates[:, 0:ntoplot] + a*onp.arange(0, ntoplot, 1), 'b')\n plt.plot(true_rates[:, 0:ntoplot] + a*onp.arange(0, ntoplot, 1), 'r')\n plt.title('LFADS rates (blue), True rates (red)')\n plt.xlabel('timesteps')\n \n return f","def add_plot(self, state, data, y_axis, function=lambda x: x, x_axis='freq', ax=None, title=None, log_axis='x', save=True, show=False):\n\n functions_dict = {'x': plt.semilogx, 'y': plt.semilogx, 'both': plt.loglog, 'none': plt.plot}\n #TODO: Unfinished\n\n if ax is None:\n fig = plt.figure()\n ax = plt.gca()\n\n if title is None:\n title = y_axis\n\n # import IPython\n sweep_kwrds = data['sweep_params'][y_axis]\n sweep_kwrds = [kwrd for kwrd in sweep_kwrds if kwrd != x_axis]\n # combos = itertools.product(*(list(range(len(data[swp_kwrd]))) for swp_kwrd in sweep_kwrds))\n\n # IPython.embed()\n # if combos:\n # for index in combos:\n # functions_dict[log_axis](data[x_axis], np.abs(data[y_axis][index, :]))\n # else:\n functions_dict[log_axis](data[x_axis], function(data[y_axis]))\n plt.ylabel(y_axis)\n plt.xlabel(x_axis)\n ax.grid()\n if save:\n fname = os.path.join(self.data_dir, title + \".png\")\n if os.path.isfile(fname):\n os.remove(fname)\n plt.savefig(fname, dpi=200)\n plt.close()\n if show:\n plt.show()","def dtw_plot_appendix(output = 'output/img/series/dtw'):\n # regions\n regs = _src.regions()\n regsL = [(v) for v in regs.values()]\n \n # iterate\n for r1 in range(len(regs)):\n for r2 in range(r1+1, len(regs)):\n dtw_plot(regsL[r1]['NUTS3'], regsL[r2]['NUTS3'],\n output = output, font_size = 12)","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def descriptive_plot(data_onlyDV):\n outcome = data_onlyDV.columns.values[0] # get the outcome column name\n\n fig = plt.figure()\n # TODO: subplots appear in same frame instead of 3 separate ones (!!!)\n ax1 = fig.add_subplot(121)\n ax1 = data_onlyDV.plot(kind='hist', title=\"Histogram: \"+outcome, by=outcome)\n ax1.locator_params(axis='x', nbins=4)\n ax1.set_xlabel(outcome+\" bins\")\n ax1.set_ylabel(\"Num Instances\")\n\n ax2 = fig.add_subplot(122)\n ax2 = data_onlyDV.plot(kind='kde', title=\"KDE Density Plot: \"+outcome)\n\n fig.tight_layout()\n plt.show()","def _2d_plot_samples(self, **kwargs):\n\n from pesummary.core.plots.bounded_2d_kde import Bounded_2d_kde\n\n # get bounds\n lows = []\n highs = []\n methods = []\n for param in self.parameters[0:2]:\n if param in DEFAULT_BOUNDS:\n lows.append(\n DEFAULT_BOUNDS[param][\"low\"]\n if \"low\" in DEFAULT_BOUNDS[param]\n else None\n )\n highs.append(\n DEFAULT_BOUNDS[param][\"high\"]\n if \"high\" in DEFAULT_BOUNDS[param]\n else None\n )\n methods.append(\n DEFAULT_BOUNDS[param][\"method\"]\n if \"method\" in DEFAULT_BOUNDS[param]\n else \"Reflection\"\n )\n\n if self.plottype == \"triangle\":\n from pesummary.core.plots.publication import triangle_plot as plotfunc\n elif self.plottype == \"reverse_triangle\":\n from pesummary.core.plots.publication import (\n reverse_triangle_plot as plotfunc,\n )\n else:\n # contour plot\n from pesummary.core.plots.publication import (\n comparison_twod_contour_plot as plotfunc,\n )\n\n # set KDE information\n kwargs.update(\n {\n \"kde\": Bounded_2d_kde,\n \"kde_kwargs\": {\n \"xlow\": lows[0],\n \"xhigh\": highs[0],\n \"ylow\": lows[1],\n \"yhigh\": highs[1],\n },\n }\n )\n\n # default to not showing data points\n if \"plot_datapoints\" not in kwargs:\n kwargs[\"plot_datapoints\"] = False\n\n if \"triangle\" in self.plottype:\n from pesummary.core.plots.bounded_1d_kde import bounded_1d_kde\n\n # set KDE informaiton\n kwargs.update(\n {\n \"kde_2d\": Bounded_2d_kde,\n \"kde_2d_kwargs\": {\n \"xlow\": lows[0],\n \"xhigh\": highs[0],\n \"ylow\": lows[1],\n \"yhigh\": highs[1],\n },\n \"kde\": bounded_1d_kde,\n }\n )\n\n kwargs[\"kde_kwargs\"] = {\n \"x_axis\": {\"xlow\": lows[0], \"xhigh\": highs[0], \"method\": methods[0]},\n \"y_axis\": {\"xlow\": lows[1], \"xhigh\": highs[1], \"method\": methods[1]},\n }\n\n args = [\n [samps[self.parameters[0]].values for samps in self._samples.values()],\n [samps[self.parameters[1]].values for samps in self._samples.values()],\n ]\n\n if \"xlabel\" not in kwargs:\n kwargs[\"xlabel\"] = self.latex_labels[self.parameters[0]]\n if \"ylabel\" not in kwargs:\n kwargs[\"ylabel\"] = self.latex_labels[self.parameters[1]]\n\n if \"labels\" not in kwargs and len(self.results) > 1:\n kwargs[\"labels\"] = list(self._samples.keys())\n\n # set injection parameter values\n if self.injection_parameters is not None:\n if (\n self.injection_parameters[self.parameters[0]] is not None\n and self.injection_parameters[self.parameters[1]] is not None\n ):\n kwargname = \"truths\" if self.plottype == \"corner\" else \"truth\"\n kwargs[kwargname] = [\n self.injection_parameters[self.parameters[0]]\n - self.parameter_offsets[self.parameters[0]],\n self.injection_parameters[self.parameters[1]]\n - self.parameter_offsets[self.parameters[1]],\n ]\n\n # create plot\n with DisableLogger():\n fig = plotfunc(*args, **kwargs)\n\n return fig","def plot_calibration(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\",\n x_name=\"Mean Predicted\",\n y_name=\"Empirical Probability\",\n method_order = METHOD_ORDER, \n avg_x = False):\n\n methods = df['method_name']\n uniq_methods = pd.unique(methods)\n method_order = [j for j in METHOD_ORDER if j in uniq_methods]\n method_df = []\n\n if avg_x: \n df_copy = df.copy()\n new_list = [0]\n new_x_map = {}\n for method in uniq_methods: \n temp_vals = df[df['method_name'] == method][x_input]\n new_ar = np.vstack(temp_vals)\n new_ar = np.nanmean(new_ar, 0) # avg columnwise\n new_x_map[method] = new_ar\n df_copy[x_input] = [new_x_map[method] for method in methods]\n df = df_copy\n\n x, y = df[x_input].values, df[y_input].values\n\n\n method_df = [{x_name : xx, y_name : yy, \"Method\" : method}\n for x_i, y_i, method in zip(x, y, methods)\n for xx,yy in zip(x_i,y_i)]\n method_df = pd.DataFrame(method_df)\n sns.lineplot(x=x_name, y=y_name, hue=\"Method\", alpha=0.8,\n hue_order=method_order,\n data=method_df,\n palette = METHOD_COLORS)\n x = np.linspace(0,1,100)\n plt.plot(x, x, linestyle='--', color=\"black\")","def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\n df_decomposed = df.loc[df['block'] == 'decomposed']\n df_joint = df.loc[df['block'] == 'joint']\n ticklabels = []\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\n for i in range(len(num_sweeps)):\n ticklabels.append('K=%d\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\n fig = plt.figure(figsize=(fs*2.5, fs))\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax1.set_xticks(num_sweeps)\n ax1.set_xticklabels(ticklabels)\n ax1.tick_params(labelsize=fontsize)\n ax1.grid(alpha=0.4)\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax2.set_xticks(num_sweeps)\n ax2.set_xticklabels(ticklabels)\n ax2.tick_params(labelsize=fontsize)\n ax2.grid(alpha=0.4)\n ax2.legend(fontsize=fontsize)\n ax1.legend(fontsize=fontsize)\n ax1.set_ylabel(r'$\\log \\: p_\\theta(x, \\: z)$', fontsize=35)\n ax2.set_ylabel('ESS / L', fontsize=35)","def view_datashade(self):\n # Select only sufficient data\n if self.x in self.y:\n self.y.remove(self.x)\n if self.y == []:\n return self.gif\n\n df = self.dataframe[[self.x] + self.y].copy()\n lines_overlay = df.hvplot(**self.plot_options).options({'Curve': {'color': self.color_key}})\n\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\n # Compute\n dataframe = df.copy()\n if x_range is not None:\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\n data_length = len(dataframe) * len(dataframe.columns)\n step = 1 if data_length < self.max_step else data_length // self.max_step\n plot_df = dataframe[::step].hvplot(**self.plot_options)\n if len(self.y) == 1:\n return plot_df.options({'Curve': {'color': '#377eb8'}})\n else:\n return plot_df.options({'Curve': {'color': self.color_key}})\n\n # Define a RangeXY stream linked to the image\n rangex = hv.streams.RangeX(source=lines_overlay)\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\n if len(self.y) == 1:\n data_shade_plot *= datashade(lines_overlay)\n else:\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\n return pn.panel(data_shade_plot)","def plot(self, noTLS, path_plots, interactive):\n fig = plt.figure(figsize=(10,12))\n ax1 = fig.add_subplot(4, 1, 1)\n ax2 = fig.add_subplot(4, 1, 2)\n ax3 = fig.add_subplot(4, 2, 5)\n ax4 = fig.add_subplot(4, 2, 6)\n ax5 = fig.add_subplot(4, 2, 7)\n ax6 = fig.add_subplot(4, 2, 8)\n\n # First panel: data from each sector\n colors = self._get_colors(self.nlc)\n for i, lci in enumerate(self.alllc):\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\n ax1.legend(fontsize='small', ncol=4)\n\n # Second panel: Detrended light curve\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\n color='black',\n label='Detrended')\n\n # Third panel: BLS\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\n mean_SR = np.mean(self.BLS.power)\n std_SR = np.std(self.BLS.power)\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\n SDE = (best_power - mean_SR)/std_SR\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\n for n in range(2, 10):\n if n*self.BLS.period_max <= max(self.BLS.period.value):\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n sx, ex = ax3.get_xlim()\n sy, ey = ax3.get_ylim()\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.2f\\nDepth = %.4f\\nDuration = %.2f d\\nSDE = %.3f' %\n (self.BLS.period_max, self.BLS.t0_max,\n self.BLS.depth_max, self.BLS.duration_max, SDE))\n\n\n # Fourth panel: lightcurve folded to the best period from the BLS\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\n marker='.', alpha=0.5)\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\n\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\n duration=self.BLS.duration_max,\n transit_time=self.BLS.t0_max)\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\n ax4.set_xlim(-l, l)\n h = max(lc_model.flux)\n l = min(lc_model.flux)\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\n del lc_model, lc_model_folded, r1, dt1\n\n\n if not noTLS:\n # Fifth panel: TLS periodogram\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\n for n in range(2, 10):\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.set_ylabel(r'SDE')\n ax5.set_xlabel('Period (days)')\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\n ax5.set_xlim(0, max(self.tls.periods))\n\n period_tls = self.tls.period\n T0_tls = self.tls.T0\n depth_tls = self.tls.depth\n duration_tls = self.tls.duration\n FAP_tls = self.tls.FAP\n\n sx, ex = ax5.get_xlim()\n sy, ey = ax5.get_ylim()\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.1f\\nDepth = %.4f\\nDuration = %.2f d\\nFAP = %.4f' %\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\n\n # Sixth panel: folded light curve to the best period from the TLS\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\n alpha=0.5, ls='None', markersize=0.7)\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\n x0=0.0, nbins=nbins, useBinCenter=True)\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\n ax6.set_xlim(0.5-l, 0.5+l)\n h = max(self.tls.model_folded_model)\n l = min(self.tls.model_folded_model)\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\n ax6.set_xlabel('Phase')\n ax6.set_ylabel('Relative flux')\n del r1, dt1\n\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\n if interactive:\n plt.show()\n plt.close('all')\n del fig","def plot(self, dtables, figs, **kwargs):\n self.safe_update(**kwargs)\n\n sumtable = dtables['biasoscorr_sum']\n runtable = dtables['runs']\n\n yvals_s = sumtable['s_correl_mean'].flatten().clip(0., 1.)\n yvals_p = sumtable['p_correl_mean'].flatten().clip(0., 1.)\n runs = runtable['runs']\n\n figs.plot_run_chart(\"mean-s\", runs, yvals_s,\n ylabel=\"Correlation between serial overscan and imaging\")\n figs.plot_run_chart(\"mean-p\", runs, yvals_p,\n ylabel=\"Correlation between parallel overscan and imaging\")","def diagrama_ph(h: [np.ndarray] or [list], P: [np.ndarray] or [list], title: str, hide_values: bool) -> (Figure, Axes):\n return diagram(h, P, title, \"Ph\", hide_values)","def logit_model_plots(ds,Population = 'Population_%',Event_rate ='Event_rate',decile ='Band',Cumulative_Non_Event = 'Cumulative_Non_Event_%',Cumulative_Event= 'Cumulative_Event_%',sample_type ='Development'):\n \n import matplotlib.pyplot as plt\n fig, (ax1, ax2) = plt.subplots(1, 2,figsize=(15, 4))\n _= ax1.plot(plot_df[Cumulative_Non_Event],plot_df[Cumulative_Event])\n _= ax1.set_ylabel(Cumulative_Non_Event)\n _= ax1.set_title('Gini Curve : '+str(sample_type) +' sample')\n _= ax1.set_xlabel(Cumulative_Event)\n\n _= plot_df[Population].plot(kind='bar', color='b', width = 0.35,legend=True , label = Population)\n _= plot_df[Event_rate].plot(kind='line',color ='r', secondary_y=True,legend=True, label = Event_rate)\n _= ax2.set_xticklabels(plot_df[decile])\n _= ax2.set_ylim(0,plot_df[Event_rate].max()*0.15)\n _= ax2.right_ax.set_ylim(0,plot_df[Event_rate].max()*1.5)\n _= ax2.right_ax.set_ylabel(Event_rate)\n _= ax2.set_ylabel(Population)\n _= ax2.set_title('Decile Wise Event Rate : ' +str(sample_type) +' sample')\n _= ax2.set_xlabel(decile)\n plt.show()","def show_dcr_results(dg):\n cycle = dg.fileDB['cycle'].values[0]\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\n # print(df_dsp.describe()) \n\n # compare DCR and A/E distributions\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\n \n elo, ehi, epb = 0, 25000, 100\n \n # aoe distribution\n # ylo, yhi, ypb = -1, 2, 0.1\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\n p0.set_ylabel('A/E', ha='right', y=1)\n\n # dcr distribution\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\n # ylo, yhi, ypb = -3, 2, 0.1\n ylo, yhi, ypb = 0.9, 1.08, 0.001\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\n nbx = int((ehi-elo)/epb)\n nby = int((yhi-ylo)/ypb)\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\n norm=LogNorm())\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\n p1.set_ylabel('DCR', ha='right', y=1)\n \n # plt.show()\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\n plt.cla()","def checkdyn():\n args = parse_args()\n config = ScatterConfig()\n paths = ScatterPath(args.infile)\n dyn = dyndat(paths)\n\n fig, axes = plt.subplots(1,1)\n nvib = list()\n for i in range(dyn.Nalgorithm):\n print(i)\n final_E_dist = dyn.final_Ek_dist + dyn.final_Ep_dist\n final_Ex_dist_filt = \\\n final_E_dist[i,:,0][np.where(np.logical_or(\n dyn.final_r_dist[i,:,1] < dyn.boundary_rmin[1],\n dyn.final_r_dist[i,:,1] > dyn.boundary_rmax[1])\n )]\n final_n_vib_dist = np.round((final_Ex_dist_filt / 0.008) - 0.5)\n nvib.append(final_n_vib_dist)\n\n ax = axes\n ax.hist(nvib, color=config.colors[:dyn.Nalgorithm],\n bins=tuple(range(0,21,1)),\n align='left', rwidth= 0.8,\n range=(0, 21), normed=True)\n ax.legend(dyn.algorithms)\n ax.set_xlim(0, 20)\n ax.set_xticks([i for i in range(0,21,1)])\n ax.set_xticklabels([str(int(i)) for i in range(0,21,1)])\n ax.set_ylim(0, 0.5)\n\n ## -- save fig -- ##\n saveto=args.savedir\n if not saveto and not HAVE_DISPLAY:\n saveto = './'\n\n if saveto:\n if not args.savedir.endswith('/'):\n args.savedir += '/'\n fig.savefig(args.savedir + savename + '.png', dpi=2 * fig.dpi)\n\n if HAVE_DISPLAY:\n plt.show()","def plot_example_psds(example,rate):\r\n plt.figure()\r\n \r\n ##YOUR CODE HERE \r\n \r\n return","def plot_msd(msd, h_exp):\n fig, ax = plt.subplots(1, 2, figsize = (10, 10))\n av_msd = np.mean(msd, axis = 0)\n\n for p in np.arange(0, msd.shape[0], step = 1):\n for t in np.arange(0, msd.shape[1], step = 1): \n ax[0].plot(t, msd[p, t], 'bx')\n ax[1].plot(t, av_msd[t], 'ro')\n ax[0].set_xlabel('Time lag (number of steps)')\n ax[0].set_ylabel('MSD (pix^2)')\n ax[0].set_title('Individual TAMSDs: H = ' + str(h_exp))\n ax[1].set_xlabel('Time lag (number of steps)')\n ax[1].set_ylabel('MSD (pix^2)')\n ax[1].set_title('Averaged TAMSDs: H = ' + str(h_exp)) \n ax[0].set_xlim([0, np.max(t)])\n ax[1].set_xlim([0, np.max(t)])\n ax[0].set_ylim([0, np.max(msd)]) \n ax[1].set_ylim([0, np.max(av_msd)])","def stabplot(lambd, orders, phi=None, model=None, freq_range=None, frequency_unit='rad/s', damped_freq=False, psd_freq=None, psd_y=None, psd_plot_scale='log', \n renderer=None, pole_settings=None, selected_pole_settings=None, to_clipboard='none', return_ix=False):\n\n \n\n\n # Treat input settings\n if pole_settings is None: pole_settings = {}\n if selected_pole_settings is None: selected_pole_settings = {}\n\n unsel_settings = {'color':'#a9a9a9', 'size':6, 'opacity':0.6}\n unsel_settings.update(**pole_settings)\n\n current_settings = listify_each_dict_entry(unsel_settings, len(lambd))\n\n sel_settings = {'color':'#cd5c5c', 'size':10, 'opacity':1.0, 'line': {'color': '#000000', 'width': 0}}\n sel_settings.update(**selected_pole_settings)\n\n select_status = np.zeros(len(lambd), dtype=bool)\n \n # Create suffix and frequency value depending on whether damped freq. is requested or not\n if damped_freq:\n dampedornot = 'd'\n omega = np.abs(np.imag(lambd))\n else:\n dampedornot = 'n'\n omega = np.abs(lambd)\n\n # Create frequency/period axis and corresponding labels\n if frequency_unit == 'rad/s':\n x = omega\n xlabel = f'$\\omega_{dampedornot} \\; [{frequency_unit}]$'\n tooltip_name = f'\\omega_{dampedornot}'\n frequency_unit = 'rad/s'\n elif frequency_unit.lower() == 'hz':\n x = omega/(2*np.pi)\n xlabel = f'$f_{dampedornot} \\; [{frequency_unit}]$'\n tooltip_name = f'f_{dampedornot}'\n frequency_unit = 'Hz'\n elif (frequency_unit.lower() == 's') or (frequency_unit.lower() == 'period'):\n x = (2*np.pi)/omega\n xlabel = f'Period, $T_{dampedornot} \\; [{frequency_unit}]$'\n tooltip_name = f'T_{dampedornot}'\n frequency_unit = 's'\n \n # Damping ratio and index to hover\n xi = -np.real(lambd)/np.abs(lambd)\n text = [f'xi = {xi_i*100:.2f}% <br> ix = {ix}' for ix, xi_i in enumerate(xi)] # rewrite xi as %, and make string\n htemplate = f'{tooltip_name}' + ' = %{x:.2f} ' + f'{frequency_unit}<br>n =' + ' %{y}' +'<br> %{text}'\n\n # Construct dataframe and create scatter trace \n poles = pd.DataFrame({'freq': x, 'order':orders})\n scatter_trace = go.Scattergl(\n x=poles['freq'], y=poles['order'], mode='markers', name='',\n hovertemplate = htemplate, text=text,\n marker=current_settings)\n \n scatter_trace['name'] = 'Poles'\n\n # PSD overlay trace\n overlay_trace = go.Scatter(x=psd_freq, y=psd_y, mode='lines', name='PSD', \n hoverinfo='skip', line={'color':'#ffdab9'})\n \n # Create figure object, add traces and adjust labels and axes\n # fig = go.FigureWidget(scatter_trace)\n fig = make_subplots(rows=2, cols=1, specs=[[{\"type\": \"xy\", \"secondary_y\": True}],\n [{\"type\": \"table\"}]])\n fig.layout.hovermode = 'closest'\n fig.add_trace(scatter_trace, secondary_y=False, row=1, col=1)\n \n if psd_freq is not None:\n fig.add_trace(overlay_trace, secondary_y=True, row=1, col=1)\n fig.update_yaxes(title_text=\"PSD\", secondary_y=True, type=psd_plot_scale)\n fig['layout']['yaxis2']['showgrid'] = False\n \n fig.layout['xaxis']['title'] = xlabel\n fig.layout['yaxis']['title'] = '$n$'\n\n if freq_range is not None:\n fig.layout['xaxis']['range'] = freq_range\n \n fig['layout']['yaxis']['range'] = [0.05, np.max(orders)*1.1]\n\n # Renderer (refer to plotly documentation for details)\n if renderer is 'default':\n import plotly.io as pio\n renderer = pio.renderers.default\n\n df = pd.DataFrame(columns=['ix','x','xi'])\n pd.options.display.float_format = '{:,.2f}'.format\n \n fig.add_trace(\n go.Table(header=\n dict(values=['Pole index', xlabel, r'$\\xi [\\%]$'],\n fill_color='paleturquoise',\n align='left'),\n cells=\n dict(values=[],fill_color='lavender',\n align='left')), row=2, col=1)\n \n fig.update_layout(\n height=1000,\n showlegend=False\n )\n \n\n fig = go.FigureWidget(fig) #convert to widget\n \n # Callback function for selection poles\n ix = np.arange(0, len(lambd))\n ix_sel = []\n \n def update_table():\n df = pd.DataFrame(data={'ix': ix[select_status], 'freq': x[select_status], 'xi':100*xi[select_status]})\n \n if len(fig.data)==2:\n sel_ix = 1\n else:\n sel_ix = 2\n \n fig.data[sel_ix].cells.values=[df.ix, df.freq, df.xi]\n \n \n def toggle_pole_selection(trace, clicked_point, selector):\n def export_df():\n df.to_clipboard(index=False)\n \n def export_ix_list():\n import pyperclip #requires pyperclip\n ix_str = '[' + ', '.join(str(i) for i in ix_sel) + ']'\n pyperclip.copy(ix_str)\n\n for i in clicked_point.point_inds:\n if select_status[i]:\n for key in current_settings:\n current_settings[key][i] = unsel_settings[key]\n else:\n for key in current_settings:\n current_settings[key][i] = sel_settings[key] \n \n select_status[i] = not select_status[i] #swap status\n\n with fig.batch_update():\n trace.marker = current_settings\n \n update_table()\n ix_sel = ix[select_status]\n\n if to_clipboard == 'ix':\n export_ix_list()\n elif to_clipboard == 'df':\n export_df()\n\n fig.data[0].on_click(toggle_pole_selection) \n\n if renderer == 'browser_legacy':\n from plotly.offline import plot\n plot(fig, include_mathjax='cdn')\n elif renderer is not None:\n fig.show(renderer=renderer, include_mathjax='cdn')\n \n \n if return_ix:\n return fig, ix_sel\n else:\n return fig","def plot_pade_figure(self):\n data_analysis = DatabaseData(dataframe=self.plot_data)\n print (data_analysis.dataframe.columns)\n data_analysis.run_pade_through_R(rscript='birch',get_inits_ev=True)\n data_analysis.create_precisions()\n data_analysis.extract_pade_curve()\n x_eos_kpts, y_eos, xs_err, ys_err, x_pade_kpts, y_pade = \\\n data_analysis.create_pade_bokeh_compat(properties=self.properties)\n print (type(self.properties), self.properties)\n if self.properties == 'B':\n ext = data_analysis.Bp\n print ('HERE AT PROPERTIES', ext, type(ext))\n elif self.properties == 'BP':\n ext = data_analysis.BPp\n elif self.properties == 'E0':\n ext = data_analysis.E0p\n elif self.properties == 'V0':\n ext = data_analysis.V0p\n p = figure(plot_height=400, plot_width=400,tools=\"pan,wheel_zoom,box_zoom,reset,previewsave\",\\\n x_axis_type=\"log\", x_axis_label='K-points per atom', title='Pade Extrapolate of {0} is {1}'.format(self.properties, str(ext)) )\n p.xaxis.axis_label = 'K-points per atom'\n p.line(x_pade_kpts, y_pade, color='red')\n p.circle(x_eos_kpts, y_eos,color='blue',size=5, line_alpha=0)\n p.multi_line(xs_err, ys_err, color='black')\n if self.properties == 'B':\n p.yaxis.axis_label = 'Bulk Modulus B (GPa)'\n elif self.properties == 'dB':\n p.yaxis.axis_label = 'Bulk Modulus Pressure Derivative'\n elif self.properties == 'E0':\n p.yaxis.axis_label = 'DFT Energy (eV/atom)'\n elif self.properties == 'V0':\n p.yaxis.axis_label = 'Volume (A^3/atom)'\n\n return p","def plot_trace(self):\n az.plot_trace(self.ifd_)","def show_derivative(self):\n for trace in self.plotWidget.plotDataItems:\n dt = float(trace.attrs['dt'])\n dtrace = np.diff(trace.data)\n x = pgplot.make_xvector(dtrace, dt)\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))","def plot_axial(data, vb, vc, vt):\n\n name = 'AxialBot'\n det = data.detectors[name]\n zb = [line[0] for line in det.grids['Z']]\n valb = det.tallies\n vd1 = vb/len(zb)\n valb /= vd1\n\n name = 'AxialFuel'\n det = data.detectors[name]\n zf = [line[0] for line in det.grids['Z']]\n valf = det.tallies\n vd2 = vc/len(zf)\n valf /= vd2\n\n name = 'AxialTop'\n det = data.detectors[name]\n zt = [line[0] for line in det.grids['Z']]\n valt = det.tallies\n vd3 = vt/len(zt)\n valt /= vd3\n\n ther = np.concatenate([valb[0], valf[0], valt[0]])\n fast = np.concatenate([valb[1], valf[1], valt[1]])\n ztot = np.concatenate([zb, zf, zt])\n\n plt.figure()\n plt.step(ztot, ther, where='post', label='thermal')\n plt.step(ztot, fast, where='post', label='fast')\n plt.xlabel('z [cm]')\n plt.ylabel(r'$\\phi$')\n plt.legend(loc=\"upper right\")\n plt.title('Axial flux.')\n plt.savefig('axial1', dpi=300, bbox_inches=\"tight\")","def plot_group(self, group_name, domains, get_time_data, fs, get_freq_data=None, get_const_data=None):\n plots = []\n \n def many(f, n=4):\n return np.concatenate([f() for _ in range(n)])\n \n for domain in domains:\n \n if domain=='frequency':\n \n # HW accelerated FFT\n if get_freq_data != None:\n f_plot = sdr_plots.HWFreqPlot(\n [get_freq_data() for _ in range(4)],\n fs, animation_period=100, w=700)\n f_dt = dma_timer.DmaTimer(f_plot.add_frame, get_freq_data, 0.3)\n # SW FFT\n else:\n f_plot = sdr_plots.IQFreqPlot(\n [many(get_time_data) for _ in range(4)],\n fs, x_range=(-2000,2000), animation_period=100, w=700)\n f_dt = dma_timer.DmaTimer(f_plot.add_frame, lambda:many(get_time_data), 0.3)\n plots.append(dict(title='Frequency domain', plot=f_plot, control=f_dt))\n \n elif domain=='time' or domain=='time-binary':\n if domain=='time-binary':\n iq_plot = sdr_plots.IQTimePlot(many(get_time_data), fs, w=700, scaling=1, ylabel='Symbol value')\n iq_plot.set_line_mode(lines=True, markers=True, shape='hvh')\n iq_plot.get_widget().layout.yaxis.dtick=1\n else:\n iq_plot = sdr_plots.IQTimePlot(many(get_time_data), fs, w=700)\n iq_plot.set_line_mode(markers=False)\n iq_dt = dma_timer.DmaTimer(iq_plot.add_data, get_time_data, 0.05)\n plots.append(dict(title='Time domain', plot=iq_plot, control=iq_dt))\n \n elif domain=='constellation':\n c_plot = sdr_plots.IQConstellationPlot(many(get_const_data or get_time_data, n=10), h=550, fade=True)\n c_dt = dma_timer.DmaTimer(c_plot.add_data, get_const_data or get_time_data, 0.05)\n plots.append(dict(title='Constellation', plot=c_plot, control=c_dt,\n layout=ipw.Layout(width='550px', margin='auto')))\n \n self.timers.register_timers(group_name, list(map(lambda tab: tab['control'], plots)))\n return QpskOverlay.tab_plots(plots)","def dline_dSFR_array(lines,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig, axs = plt.subplots(len(lines), sharex='col',\\\n figsize=(6,15),facecolor='w',\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\n\n for i,ax in enumerate(axs):\n\n dline_dSFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\n dline_dSFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=False,add=True,cb=False)\n\n plt.tight_layout()\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/dlines_dSFR_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)","def plot_derivatives_divided(self, show=False):\n\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\n plt.subplots_adjust(hspace=0.5)\n training_index = np.random.randint(self.n_train * self.n_p)\n \n if self.flatten:\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\n # TODO\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n # Cl has shape (1,10) since it is the data vector for the \n # upper training image for both params\n labels =[r'$θ_1$ ($\\Omega_M$)']\n\n # we loop over them in this plot to assign labels\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\n else:\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\n ax[0, 0].set_title('One upper training example, Cl 0,0')\n ax[0, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n ax[0, 0].legend(frameon=False)\n\n if self.flatten:\n # TODO\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n # temp has shape (num_params, ncombinations, len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 0].plot(ells, Cl[i])\n else:\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 0].set_title('One lower training example, Cl 0,0')\n ax[1, 0].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 0].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 0].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m\"][training_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p\"][training_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n\n for i in range(Cl_lower.shape[0]):\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\n ax[2, 0].set_title('Difference between upper and lower training examples');\n ax[2, 0].set_xlabel(r'$\\ell$')\n ax[2, 0].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 0].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n ax[2, 0].legend(frameon=False)\n\n test_index = np.random.randint(self.n_p)\n\n if self.flatten:\n # TODO\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n \n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[0, 1].plot(ells, Cl[i])\n else:\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[0, 1].set_title('One upper test example Cl 0,0')\n ax[0, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[0, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[0, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\n x, y = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\n\n for i in range(Cl.shape[0]):\n if self.rescaled:\n ax[1, 1].plot(ells, Cl[i])\n else:\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\n ax[1, 1].set_title('One lower test example Cl 0,0')\n ax[1, 1].set_xlabel(r'$\\ell$')\n if self.rescaled:\n ax[1, 1].set_ylabel(r'$C_\\ell$')\n else:\n ax[1, 1].set_ylabel(r'$\\ell(\\ell+1) C_\\ell$')\n\n if self.flatten:\n # TODO\n temp = self.data[\"x_m_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xm, ym = temp.T[:,0]\n\n temp = self.data[\"x_p_test\"][test_index].reshape(len(theta_fid),*input_shape)\n xp, yp = temp.T[:,0]\n else:\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_lower = temp[:,0,:]\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\n Cl_upper = temp[:,0,:]\n \n for i in range(Cl_lower.shape[0]):\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\n ax[2, 1].set_title('Difference between upper and lower test samples');\n ax[2, 1].set_xlabel(r'$\\ell$')\n ax[2, 1].set_ylabel(r'$\\Delta C_\\ell$ / $C_{\\ell,thr}$')\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\n , linestyle = 'dashed', color = 'black')\n ax[2, 1].set_xscale('log')\n\n # also plot sigma_cl / CL\n sigma_cl = np.sqrt(self.covariance)\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\sigma_{Cl} / C_{\\ell,thr}$')\n\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def plot_anomalies_data_specific(df, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False, adjusted = True):\n \n #result = test_stationarity(SpeciesName=Species, data = data)\n #result.plot()\n if syndrome:\n if adjusted:\n vo = df[df.prediction_adjusted == syndrome]\n else:\n vo = df[df.prediction == syndrome]\n else:\n vo = df\n \n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\n weekly_vo = pd.DataFrame(weekly_vo)\n weekly_vo.columns = ['ID']\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\n\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\n \n def identify_anomalies(c, sigma=sigma):\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\n return c.ID\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\n \n upper_bound = go.Scatter(\n name='upper Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\n mode='lines',\n marker=dict(color=\"#820101\"),\n line=dict(width=0),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n \n rolling_m = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['rolling mean'],\n name='rolling mean',\n mode='lines',\n line=dict(color='#1f77b4'),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n\n lower_bound = go.Scatter(\n name='lower Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\n marker=dict(color=\"#b7b7b7\"),\n line=dict(width=0),\n mode='lines',)\n\n addmissions = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['# admissions'],\n name='# admissions',)\n\n ano = go.Scatter(\n x = weekly_vo.index,\n y =weekly_vo['anomalies'] ,\n name='anomalies',\n mode='markers')\n\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\n \n T = \"Weekly admissions\"\n print (T)\n layout = go.Layout(\n title= 'Weekly admissions',\n yaxis=dict( title='number of admissions',), width=900, height=640\n )\n\n fig = go.Figure(data=plottingdata, layout=layout)\n plot_url = iplot(fig)\n if verbose:\n print('number of admissions triggering alert') \n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\n if save:\n name = 'special_syndrome_study'\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WRMD_paper/outputs/'+name+'.png')\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\n\n #from IPython.display import Image\n #Image('C:\\Users\\Falco\\Desktop\\directory\\WMRD\\data\\TimeSeries.png')\n \n return weekly_vo","def save_plot_interpolate(input_samples, samples, idx, identifier, num_epochs=None, distances=None, sigma=1):\n n_samples = samples.shape[0]\n sample_length = samples.shape[1]\n\n if not num_epochs is None:\n col = hsv_to_rgb((1, 1.0*(idx)/num_epochs, 0.8))\n else:\n col = 'grey'\n\n x_points = np.arange(sample_length)\n if distances is None:\n nrow = n_samples\n else:\n nrow = n_samples + 1\n ncol = 1\n fig, axarr = plt.subplots(nrow, ncol, figsize=(3, 9))\n if distances is None:\n startat = 0\n else:\n startat = 1\n axarr[0].plot(distances.dA, color='green', label='distance from A', linestyle='--', marker='o', markersize=4)\n axarr[0].plot(distances.dB, color='orange', label='distance from B', linestyle='dotted', marker='o', markersize=4)\n axarr[0].get_xaxis().set_visible(False)\n axarr[0].set_title('distance from endpoints')\n for m in range(startat, nrow):\n sample = samples[m-startat, :, 0]\n axarr[m].plot(x_points, sample, color=col)\n for m in range(startat, nrow):\n axarr[m].set_ylim(-1.1, 1.1)\n axarr[m].set_xlim(0, sample_length)\n axarr[m].spines[\"top\"].set_visible(False)\n axarr[m].spines[\"bottom\"].set_visible(False)\n axarr[m].spines[\"right\"].set_visible(False)\n axarr[m].spines[\"left\"].set_visible(False)\n axarr[m].tick_params(bottom='off', left='off')\n axarr[m].get_xaxis().set_visible(False)\n axarr[m].get_yaxis().set_visible(False)\n axarr[m].set_facecolor((0.96, 0.96, 0.96))\n if not input_samples is None:\n # now do the real samples\n axarr[startat].plot(x_points, input_samples[0], color='green', linestyle='--')\n axarr[-1].plot(x_points, input_samples[1], color='green', linestyle='--')\n\n axarr[-1].xaxis.set_ticks(range(0, sample_length, int(sample_length/4)))\n fig.suptitle(idx)\n fig.subplots_adjust(hspace = 0.2)\n fig.savefig(\"./experiments/plots/\" + identifier + \"_interpolate.png\")\n fig.savefig(\"./experiments/plots/\" + identifier + \"_interpolate.pdf\")\n plt.clf()\n plt.close()\n return","def view_datashade(self):\n # Select only sufficient data\n if self.x in self.y:\n self.y.remove(self.x)\n if self.y == []:\n return self.gif\n\n df = self.dataframe[[self.x] + self.y].copy()\n lines_overlay = df.hvplot.scatter(**self.plot_options).options({'Scatter': {'color': self.color_key}})\n\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\n # Compute\n dataframe = df.copy()\n if x_range is not None:\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\n data_length = len(dataframe) * len(dataframe.columns)\n step = 1 if data_length < self.max_step else data_length // self.max_step\n plot_df = dataframe[::step].hvplot.scatter(**self.plot_options)\n if len(self.y) == 1:\n return plot_df.options({'Scatter': {'color': '#377eb8'}})\n else:\n return plot_df.options({'Scatter': {'color': self.color_key}})\n\n # Define a RangeXY stream linked to the image\n rangex = hv.streams.RangeX(source=lines_overlay)\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\n if len(self.y) == 1:\n data_shade_plot *= datashade(lines_overlay)\n else:\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\n return pn.panel(data_shade_plot)","def anova_analysis(df):\n time_periods = df.groupby(['week_ending','Holiday'],as_index = False)[['seats_sold']].sum()\n TG = time_periods.loc[time_periods['Holiday'] == 'ThanksGiving','seats_sold']\n WB = time_periods.loc[time_periods['Holiday'] == 'WinterBreak','seats_sold']\n SB = time_periods.loc[time_periods['Holiday'] == 'SummerBreak','seats_sold']\n NH = time_periods.loc[time_periods['Holiday'] == 'Not Holiday','seats_sold']\n f,p = stats.f_oneway(TG,WB,SB,NH)\n print('The f and p of ANOVA analysis are:')\n print(f,p)\n\n ## plot the mean of each group\n time_periods.boxplot('seats_sold', by='Holiday', figsize=(12, 8))\n fileName = 'ANOVA.png'\n plt.savefig(fileName)\n\n print(\"The mean seats sold of each time periods:\")\n print(time_periods.groupby('Holiday')['seats_sold'].mean())\n\n pairwise = MultiComparison(time_periods['seats_sold'], time_periods['Holiday'])\n result = pairwise.tukeyhsd()\n print(pairwise)\n print(result)\n #print(pairwise.groupsunique)","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def make_plot_for_different_thresholds(\n lambda_2,\n lambda_1,\n mu,\n num_of_servers,\n num_of_trials,\n seed_num=None,\n measurement_type=None,\n runtime=1440,\n max_threshold=None,\n):\n all_ambulance_patients_mean_times = []\n all_other_patients_mean_times = []\n all_total_mean_times = []\n if max_threshold == None:\n max_threshold = num_of_servers\n for threshold in range(1, max_threshold + 1):\n current_ambulance_patients_mean_times = []\n current_other_patients_mean_times = []\n current_total_mean_times = []\n for _ in range(num_of_trials):\n times = get_times_for_patients(\n lambda_2,\n lambda_1,\n mu,\n num_of_servers,\n threshold,\n seed_num,\n measurement_type,\n runtime,\n )\n current_ambulance_patients_mean_times.append(np.nanmean(times[0]))\n current_other_patients_mean_times.append(np.nanmean(times[1]))\n current_total_mean_times.append(np.nanmean(times[0] + times[1]))\n all_ambulance_patients_mean_times.append(\n np.nanmean(current_ambulance_patients_mean_times)\n )\n all_other_patients_mean_times.append(\n np.nanmean(current_other_patients_mean_times)\n )\n all_total_mean_times.append(np.nanmean(current_total_mean_times))\n\n x_axis = [thres for thres in range(1, max_threshold + 1)]\n x_axis_label, y_axis_label, title = get_plot_for_different_thresholds_labels(\n measurement_type\n )\n plt.figure(figsize=(23, 10))\n diff_threshold_plot = plt.plot(\n x_axis,\n all_ambulance_patients_mean_times,\n \"solid\",\n x_axis,\n all_other_patients_mean_times,\n \"solid\",\n x_axis,\n all_total_mean_times,\n \"solid\",\n )\n plt.title(title, fontsize=13, fontweight=\"bold\")\n plt.xlabel(x_axis_label, fontsize=13, fontweight=\"bold\")\n plt.ylabel(y_axis_label, fontsize=13, fontweight=\"bold\")\n plt.legend(\n [\"Ambulance Patients\", \"Other Patients\", \"All times\"], fontsize=\"x-large\"\n )\n\n return diff_threshold_plot","def plot_time_advances(self, path: str = None, methods: list = None, title=None):\n df = self.get_results(methods)\n ax = plt.axes()\n sns.lineplot(x='epoch', y='value', data=df, hue='statistics', style='method', ax=ax)\n plt.ylim(-31, 11)\n plt.ylabel('test statistics of log-lkl')\n lgd = plt.legend(loc='upper left', bbox_to_anchor=[1.01, -0.1, 0.2, 0.8], ncol=1)\n ax.set_position([0.1, 0.1, 0.75, 0.8])\n if title is not None:\n ax.set_title(title)\n if path is not None:\n for extension in ['eps', 'png']:\n plt.savefig(f'{path}.{extension}', format=extension)","def all(folder, mt=False):\n handles = []\n experiments = get_experiment_series(folder, mT=mt)\n for ex in experiments:\n if mt:\n handles.append(\n plt.plot(\n ex.distance,\n ex.weight,\n label='{}mm {}mT'.format(ex.height, ex.magnet))[0])\n else:\n handles.append(\n plt.plot(\n ex.distance,\n ex.weight,\n label='{}mm'.format(ex.height))[0])\n plt.legend()\n plt.show()","def test4():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\t#Voigt\n\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def fdd_plot(result_file_list,default_fdds,ion_default):\n # Getting data from the file\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\n# print \" Parameters to plot for:\", fdd_param_keys\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\n for j,result_file_name in enumerate(result_file_list):\n with open(result_file_name,'r') as res_file:\n res_data = res_file.read().split('\\n')\n if res_data[-1] == \"\": # delete empty line if present\n del res_data[-1]\n else:\n pass\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\n for line in res_data:\n line_split = line.split()\n if line_split[1] == '0' or line_split[1] == '-1':\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n if line_split[1] == '0':\n n_iter_list.append(int(line_split[2])) # number of iterations list\n else:\n n_iter_list.append(-1) # 125, number of iterations\n H_list.append(float(line_split[3])) # H_list\n Hunc_list.append(float(line_split[4])) # Hunc_list\n D_list.append(float(line_split[5])) # D_list\n Dunc_list.append(float(line_split[6])) # Dunc_list\n elif line_split[1] == '1':\n print \" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n n_iter_list.append(0) # number of iterations list\n elif line_split[1] == '2':\n print \" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '3':\n print \" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '4':\n print \" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-3) # number of iterations list\n elif line_split[1] == '5':\n print \" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-2) # number of iterations list\n else:\n print \" Unknown error code was specified in {}\".format(result_file_name)\n\n # Data are ready to plot\n # First column of subplots (uncertainties)\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\"steps-mid\") # Plotting data\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\n axs[5*j+1].set_ylabel(r'$\\Delta$N(D I)',color='b')\n axs[5*j+1].tick_params('y',colors='b')\n axs[5*j+1].ticklabel_format(useOffset=False)\n axs[5*j+1].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\"steps-mid\")\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\n axs[5*j+2].set_ylabel(r'$\\Delta$N(H I)',color='r')\n axs[5*j+2].tick_params('y',colors='r')\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\n # Second column of subplots (middle values)\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\n plot_interal = False # Add 1-sigma interval\n if plot_interal == True:\n median = np.median(D_list)\n med_unc = np.median(Dunc_list)\n print \"median = {} +/- {} for {}\".format(median,med_unc,fdd_param_keys[j])\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\"steps-mid\",zorder=2) # Plotting data\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\n axs[5*j+3].ticklabel_format(useOffset=False)\n axs[5*j+3].tick_params('y',colors='b')\n axs[5*j+3].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\n axs[5*j+4] = axs[5*j+3].twinx()\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\"steps-mid\",zorder=1)\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\n axs[5*j+4].tick_params('y',colors='r')\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\n # Third column of subplots (number of iterations)\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\"steps-mid\") # Plotting n_iter_list\n# axs[5*j+5].yaxis.tick_right()\n# axs[5*j+5].yaxis.set_label_position(\"right\")\n axs[5*j+5].set_ylabel('N iterations')\n axs[5*j+5].ticklabel_format(useOffset=False)\n axs[5*j+5].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\":\") # indicate fdd from vp_setup.dat\n\n# plt.tight_layout()\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\n plt.savefig(\"fdd_plot.pdf\",bbox_inches='tight', pad_inches=0)\n plt.show()\n plt.close()\n print \" Plot is done!\"","def test3():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def Diagnostic_plot2(self):\n\n probs = pd.read_csv(self.probfile)\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\n\n fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'SNR')\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\n plt.legend(loc='lower right')\n #plt.ylim([0,1])\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')","def plot_analytic_curve_loop(ax, n_HArr, tempArr, pltkwarg, txList, xr, yr, delta, fs=8):\n\t\n\tfor icol in xrange(tempArr.shape[1]):\n\t\tax.plot(n_HArr, tempArr[:, icol], **pltkwarg)\n\n\t\tif len(txList) > 0:\n\t\t\ttxloc = get_text_loc_axis_coord(n_HArr, tempArr[:, icol], xr, yr, delta)\n\t\t\tax.text(txloc[0], txloc[1], txList[icol], fontsize=fs, horizontalalignment=\"center\", verticalalignment=\"center\", transform=ax.transAxes)","def plot_dynamics(\n df: pandas.DataFrame, prop: str, title: Optional[str] = None, scale: str = \"linear\"\n) -> alt.Chart:\n if title is None:\n title = prop\n axis_format = \"g\"\n if scale == \"log\":\n axis_format = \"e\"\n\n dyn_chart_base = (\n alt.Chart(df)\n .encode(\n x=alt.X(\n \"time\",\n title=\"Time\",\n scale=alt.Scale(type=\"log\"),\n axis=alt.Axis(format=\"e\"),\n ),\n color=alt.Color(\"temperature:N\", title=\"Temperature\"),\n y=alt.Y(\n prop + \"_mean:Q\",\n title=title,\n scale=alt.Scale(type=scale),\n axis=alt.Axis(format=axis_format),\n ),\n yError=alt.YError(prop + \"_sem:Q\"),\n )\n .transform_filter(alt.datum.msd_mean < 50)\n )\n\n return dyn_chart_base.mark_errorband() + dyn_chart_base.mark_line()","def plot_ave(pulse, trap, ToP):\n time_array = np.linspace(0, pulse.t * trap.N, trap.N + 1)\n # fig, ax = plt.subplots()\n all_trial_n, all_trial_n_ave = trap.sideband_cool_sch(pulse, ave = True)\n if ToP == 'a':\n plt.plot(time_array * 1e3, all_trial_n_ave, label = pulse.t)\n if ToP == 'b':\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'magenta', linewidth = 3, label = 'Monte Carlo')\n if ToP == 'c':\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'b')\n if ToP == 'd':\n if trap.no_decay == True and trap.off_resonant_excite == False:\n plt.plot(time_array * 1e3, all_trial_n_ave, label = 'Decay to carrier')\n if trap.no_decay == False and trap.off_resonant_excite == False:\n plt.plot(time_array * 1e3, all_trial_n_ave, \n label = 'Decay to %s sideband'%(trap.sideband))\n if trap.no_decay == False and trap.off_resonant_excite == True:\n plt.plot(time_array * 1e3, all_trial_n_ave, \n label = 'Decay to %s sideband, off-resonant excite'%(trap.sideband))\n # plt.xlabel('time / ms')\n # plt.ylabel('Phonon State')\n # plt.legend()","def plotsurvey(filename='obslist_all.fits', plot_type='f', program='m'): \n\n t = Table.read(filename, format='fits')\n\n if plot_type == 'f':\n fig, ax = plt.subplots()\n ra = t['RA']\n ra[ra>300.0] -= 360.0\n dec = t['DEC']\n mjd = t['MJD']\n mjd_start = np.min(mjd)\n mjd -= mjd_start\n\n if program=='a':\n i1 = np.where( mjd/365.0 < 1.0 )\n i2 = np.where( (mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0) )\n i3 = np.where( (mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0) )\n i4 = np.where( (mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0) )\n i5 = np.where( (mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0) )\n elif program=='m':\n i1 = np.where( (mjd/365.0 < 1.0) & (t['PROGRAM']!='BRIGHT') )\n i2 = np.where( ((mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0)) & (t['PROGRAM']!='BRIGHT') )\n i3 = np.where( ((mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0)) & (t['PROGRAM']!='BRIGHT') )\n i4 = np.where( ((mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0)) & (t['PROGRAM']!='BRIGHT') )\n i5 = np.where( ((mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0)) & (t['PROGRAM']!='BRIGHT') )\n elif program=='b':\n i1 = np.where( (mjd/365.0 < 1.0) & (t['PROGRAM']=='BRIGHT') )\n i2 = np.where( ((mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0)) & (t['PROGRAM']=='BRIGHT') )\n i3 = np.where( ((mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0)) & (t['PROGRAM']=='BRIGHT') )\n i4 = np.where( ((mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0)) & (t['PROGRAM']=='BRIGHT') )\n i5 = np.where( ((mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0)) & (t['PROGRAM']=='BRIGHT') )\n else:\n print(\"if set, program should be a, m or b; default is m.\\n\")\n return\n y1 = plt.scatter(ra[i1], dec[i1], c='r', marker='.')\n y2 = plt.scatter(ra[i2], dec[i2], c='b', marker='.')\n y3 = plt.scatter(ra[i3], dec[i3], c='g', marker='.')\n y4 = plt.scatter(ra[i4], dec[i4], c='y', marker='.')\n y5 = plt.scatter(ra[i5], dec[i5], c='m', marker='.')\n\n plt.xlabel('RA (deg)')\n plt.ylabel('DEC (deg)')\n plt.legend((y1, y2, y3, y4, y5), ('Year 1', 'Year 2', 'Year 3', 'Year 4', 'Year 5'), scatterpoints=1, loc=2)\n ticks = ax.get_xticks()\n ticks[ticks < 0] += 360\n ax.set_xticklabels([int(tick) for tick in ticks])\n\n elif plot_type == 'h':\n if (program=='m'):\n i = np.where( t['PROGRAM'] != 'BRIGHT')\n elif (program=='b'):\n i = np.where( t['PROGRAM'] == 'BRIGHT')\n elif (program=='a'):\n i = np.arange(len(t['PROGRAM']))\n else:\n print(\"if set, program should be a, m or b; default is m.\\n\")\n return\n\n plt.figure(1)\n plt.subplot(231)\n x = t['EXPTIME']\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Exposure time (seconds)')\n plt.ylabel('Count')\n\n plt.subplot(232)\n x = t['SEEING']\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Seeing (arcseconds)')\n plt.ylabel('Count')\n\n plt.subplot(233)\n x = t['LINTRANS']\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Linear transparency')\n plt.ylabel('Count')\n\n plt.subplot(234)\n x = t['AIRMASS']\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Airmass')\n plt.ylabel('Count')\n\n plt.subplot(235)\n y1 = t['MOONALT']\n y2 = y1[i]\n x1 = t['MOONFRAC']\n x2 = x1[i]\n x = x2.compress((y2>0.0).flat)\n n, bins, patches = plt.hist(x, 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Moon illumination fraction')\n plt.ylabel('Count')\n\n plt.subplot(236)\n y = t['MOONALT']\n y2 = y[i]\n x1 = t['MOONDIST']\n x2 = x1[i]\n x = x2.compress((y2>0.0).flat)\n n, bins, patches = plt.hist(x, 20, facecolor='0.5', alpha=0.75)\n plt.xlabel('Distance from the Moon (deg)')\n plt.ylabel('Count')\n\n elif plot_type == 't':\n if (program=='m'):\n i = np.where( t['PROGRAM'] != 'BRIGHT')\n elif (program=='b'):\n i = np.where( t['PROGRAM'] == 'BRIGHT')\n elif (program=='a'):\n i = np.arange(len(t['PROGRAM']))\n else:\n print(\"if set, program should be a, m or b; default is m.\\n\")\n return\n \n mjd = t['MJD']\n mjd_start = np.min(mjd)\n mjd -= mjd_start\n plt.figure(1)\n\n plt.subplot(221)\n y = t['MOONALT']\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\n plt.xlabel('Days')\n plt.ylabel('Moon elevation (degrees)')\n\n plt.subplot(222)\n y = t['SEEING']\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\n plt.xlabel('Days')\n plt.ylabel('Seeing (arcseconds)')\n\n plt.subplot(223)\n y = t['LINTRANS']\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\n plt.xlabel('Days')\n plt.ylabel('Linear transparency')\n\n plt.subplot(224)\n if (program=='b'):\n x = mjd[t['PROGRAM']=='BRIGHT']\n elif (program=='m'):\n x = mjd[t['PROGRAM']!='BRIGHT']\n elif (program=='a'):\n x = mjd\n y = np.arange(len(x)) + 1\n #y = np.arange(len(mjd)) + 1\n #plt.plot(mjd[i], y[i], linestyle='-', color='black')\n plt.plot(x, y, linestyle='-', color='black')\n plt.xlabel('Days')\n plt.ylabel('Number of tiles observed')\n\n\n elif plot_type == 'e':\n y = t['EXPTIME']\n if (program=='m'):\n i = np.where( t['PROGRAM'] != 'BRIGHT')\n elif (program=='b'):\n i = np.where( t['PROGRAM'] == 'BRIGHT')\n elif (program=='a'):\n i = np.arange(len(y))\n else:\n print(\"if set, program should be a, m or b; default is m.\\n\")\n return\n plt.figure(1)\n\n plt.subplot(221)\n x = t['LINTRANS']\n plt.scatter(x[i], y[i], marker='.', color='black')\n plt.xlabel('Linear transparency')\n plt.ylabel('Exposure time (seconds)')\n\n plt.subplot(222)\n x = t['SEEING']\n plt.scatter(x[i], y[i], marker='.', color='black')\n plt.xlabel('Seeing (arcseconds)')\n plt.ylabel('Exposure time (seconds)')\n\n plt.subplot(223)\n x = t['EBMV']\n plt.scatter(x[i], y[i], marker='.', color='black')\n plt.xlabel('E(B-V)')\n plt.ylabel('Exposure time (seconds)')\n\n plt.subplot(224)\n x = t['AIRMASS']\n plt.scatter(x[i], y[i], marker='.', color='black')\n plt.xlabel('Airmass')\n plt.ylabel('Exposure time (seconds)')\n\n plt.show()","def plot_anomalies(data, Species, family, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False):\n \n #result = test_stationarity(SpeciesName=Species, data = data)\n #result.plot()\n if Species == 'None':\n vo = data[(data.family == family) & (data.prediction_adjusted == syndrome)]\n else:\n vo = data[(data.ScientificName == Species) & (data.prediction_adjusted == syndrome)]\n \n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\n weekly_vo = pd.DataFrame(weekly_vo)\n weekly_vo.columns = ['ID']\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\n\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\n \n def identify_anomalies(c, sigma=sigma):\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\n return c.ID\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\n \n upper_bound = go.Scatter(\n name='upper Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\n mode='lines',\n marker=dict(color=\"#820101\"),\n line=dict(width=0),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n \n rolling_m = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['rolling mean'],\n name='rolling mean',\n mode='lines',\n line=dict(color='#1f77b4'),\n fillcolor='#b7b7b7',\n fill='tonexty' )\n\n lower_bound = go.Scatter(\n name='lower Bound',\n x=weekly_vo.index,\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\n marker=dict(color=\"#b7b7b7\"),\n line=dict(width=0),\n mode='lines',)\n\n addmissions = go.Scatter(\n x = weekly_vo.index,\n y = weekly_vo['# admissions'],\n name='# admissions',)\n\n ano = go.Scatter(\n x = weekly_vo.index,\n y =weekly_vo['anomalies'] ,\n name='anomalies',\n mode='markers')\n\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\n if Species == 'None':\n T = \"Weekly admissions of \"+ str(family)+' ('+syndrome+')',\n else:\n T = \"Weekly admissions of \"+ str(Species)+' ('+syndrome+')',\n print (T)\n layout = go.Layout(\n title= 'Weekly admissions',\n yaxis=dict( title='number of admissions',), width=900, height=640\n )\n\n fig = go.Figure(data=plottingdata, layout=layout)\n plot_url = iplot(fig)\n if verbose:\n print('number of admissions triggering alert') \n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\n if save:\n name = family+Species+syndrome\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'.png')\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\n\n #from IPython.display import Image\n #Image('C:\\Users\\Falco\\Desktop\\directory\\WMRD\\data\\TimeSeries.png')\n \n return weekly_vo","def _debugPlotExamplesOfAll():\n\tbpData(plot=True)\n\tcapBankData(plot=True)\n\tcos1RogowskiData(plot=True)\n\tquartzJumperData(plot=True)\n\tfbData(plot=True)\n\tipData(plot=True)\n\tloopVoltageData(plot=True)\n\tmModeData(plot=True)\n\tnModeData(plot=True)\n\tpaData(plot=True)\n\tplasmaRadiusData(plot=True)\n\tqStarData(plot=True)\n\tsolData(plot=True)\n\tspectrometerData(plot=True)\n\ttaData(plot=True)\n\ttfData(plot=True)\n\ttpData(plot=True)\n\tsxrData(plot=True)","def plot_proof_functions():\n\n def thm1_D(x):\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\n\n def thm2_D(x):\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 2, 1000)\n\n plt.plot(x, thm1_D(x))\n plt.xlim(0, 2)\n plt.ylim(0.15, 0.22)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\n plt.xticks(range(3), range(3))\n plt.close()\n\n print(f'Saved plot to: plots/thm1_D.pdf')\n\n plt.figure(figsize=(2, 1.5))\n x = np.linspace(0, 5, 1000)\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\n plt.plot(x, thm2_D(x))\n plt.xlim(0, 5)\n plt.ylim(0, 0.4)\n plt.xticks(range(6), range(6))\n\n plt.ylabel('$D(Z)$')\n plt.xlabel('$s_Z / t$')\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\n plt.close()\n\n print(f'Saved plot to: plots/thm2_D.pdf')","def plots(self, events=None, title=None):\n data = self.data\n P = PH.regular_grid(3 , 1, order='columnsfirst', figsize=(8., 6), showgrid=False,\n verticalspacing=0.08, horizontalspacing=0.08,\n margins={'leftmargin': 0.07, 'rightmargin': 0.20, 'topmargin': 0.03, 'bottommargin': 0.1},\n labelposition=(-0.12, 0.95))\n scf = 1e12\n ax = P.axarr\n ax = ax.ravel()\n PH.nice_plot(ax)\n for i in range(1,2):\n ax[i].get_shared_x_axes().join(ax[i], ax[0])\n # raw traces, marked with onsets and peaks\n tb = self.timebase[:len(data)]\n ax[0].plot(tb, scf*data, 'k-', linewidth=0.75, label='Data') # original data\n ax[0].plot(tb[self.onsets], scf*data[self.onsets], 'k^', \n markersize=6, markerfacecolor=(1, 1, 0, 0.8), label='Onsets')\n if len(self.onsets) is not None:\n# ax[0].plot(tb[events], data[events], 'go', markersize=5, label='Events')\n# ax[0].plot(tb[self.peaks], self.data[self.peaks], 'r^', label=)\n ax[0].plot(tb[self.smpkindex], scf*np.array(self.smoothed_peaks), 'r^', label='Smoothed Peaks')\n ax[0].set_ylabel('I (pA)')\n ax[0].set_xlabel('T (s)')\n ax[0].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n \n # deconvolution trace, peaks marked (using onsets), plus threshold)\n ax[1].plot(tb[:self.Crit.shape[0]], self.Crit, label='Deconvolution') \n ax[1].plot([tb[0],tb[-1]], [self.sdthr, self.sdthr], 'r--', linewidth=0.75, \n label='Threshold ({0:4.2f}) SD'.format(self.sdthr))\n ax[1].plot(tb[self.onsets]-self.idelay, self.Crit[self.onsets], 'y^', label='Deconv. Peaks')\n if events is not None: # original events\n ax[1].plot(tb[:self.Crit.shape[0]][events], self.Crit[events],\n 'ro', markersize=5.)\n ax[1].set_ylabel('Deconvolution')\n ax[1].set_xlabel('T (s)')\n ax[1].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n# print (self.dt, self.template_tmax, len(self.template))\n # averaged events, convolution template, and fit\n if self.averaged:\n ax[2].plot(self.avgeventtb[:len(self.avgevent)], scf*self.avgevent, 'k', label='Average Event')\n maxa = np.max(self.sign*self.avgevent)\n #tpkmax = np.argmax(self.sign*self.template)\n if self.template is not None:\n maxl = int(np.min([len(self.template), len(self.avgeventtb)]))\n temp_tb = np.arange(0, maxl*self.dt, self.dt)\n #print(len(self.avgeventtb[:len(self.template)]), len(self.template))\n ax[2].plot(self.avgeventtb[:maxl], scf*self.sign*self.template[:maxl]*maxa/self.template_amax, \n 'r-', label='Template')\n # compute double exp based on rise and decay alone\n # print('res rise: ', self.res_rise)\n # p = [self.res_rise.x[0], self.res_rise.x[1], self.res_decay.x[1], self.res_rise.x[2]]\n # x = self.avgeventtb[:len(self.avg_best_fit)]\n # y = self.doubleexp(p, x, np.zeros_like(x), risepower=4, fixed_delay=0, mode=0)\n # ax[2].plot(x, y, 'b--', linewidth=1.5)\n tau1 = np.power(10, (1./self.risepower)*np.log10(self.tau1*1e3)) # correct for rise power\n tau2 = self.tau2*1e3\n ax[2].plot(self.avgeventtb[:len(self.avg_best_fit)], scf*self.avg_best_fit, 'c--', linewidth=2.0,\n label='Best Fit:\\nRise Power={0:.2f}\\nTau1={1:.3f} ms\\nTau2={2:.3f} ms\\ndelay: {3:.3f} ms'.\n format(self.risepower, self.res_rise.x[1]*1e3, self.res_decay.x[1]*1e3, self.bfdelay*1e3))\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.rise_fit, 'g--', linewidth=1.0,\n # label='Rise tau {0:.2f} ms'.format(self.res_rise.x[1]*1e3))\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.decay_fit, 'm--', linewidth=1.0,\n # label='Decay tau {0:.2f} ms'.format(self.res_decay.x[1]*1e3))\n if title is not None:\n P.figure_handle.suptitle(title)\n ax[2].set_ylabel('Averaged I (pA)')\n ax[2].set_xlabel('T (s)')\n ax[2].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n if self.fitted:\n print('measures: ', self.risetenninety, self.decaythirtyseven)\n mpl.show()","def get_vshape(self, dmax, plot=True):\n '''\n\n '''\n dists_label = np.linspace(0.001, dmax, 200)\n dists = np.concatenate([[0], np.linspace(0.001, dmax, 200)])/np.sqrt(2)\n dists_xy = np.stack([dists, dists], 1)\n dist_mat = self.get_distance_matrix(dists_xy[None, :, :])\n v_vect = self.V_vect(dist_mat)[0, 0, 1:]\n\n if plot:\n _, ax = plt.subplots(dpi=150)\n plt.title(\"Lennard-Jones Potential\")\n plt.xlabel(\"interaction distance\")\n plt.ylabel(\"potential\")\n plt.plot(dists_label, v_vect, c=\"blue\")\n plt.axvline(x=self.d_coll, color=\"red\", linestyle=\"dashed\", linewidth=1)\n plt.annotate(r\"$d_{coll}$\", (self.d_coll, np.min(v_vect)), textcoords=\"offset points\", xytext=(15, -5), ha='center', color=\"red\")\n plt.axvline(x=self.d_attr, color=\"black\", linestyle=\"dashed\", linewidth=1)\n plt.annotate(r\"$d_{eq}$\", (self.d_attr, np.min(v_vect)), textcoords=\"offset points\", xytext=(15, -5), ha='center')\n plt.semilogy()\n\n axins = ax.inset_axes([0.67, 0.67, 0.3, 0.3])\n axins.set_xlim(0.15, 0.4)\n axins.set_ylim(-0.2, 2)\n\n axins.plot(dists_label, v_vect, c=\"blue\")\n axins.axvline(x=self.d_attr, color=\"black\", linestyle=\"dashed\", linewidth=1)\n axins.annotate(r\"$d_{eq}$\", (self.d_attr, np.min(v_vect)), textcoords=\"offset points\", xytext=(15, -5), ha='center')\n\n plt.show()\n\n return dists_label, v_vect","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plot(self, dtables, figs, **kwargs):\n self.safe_update(**kwargs)\n sumtable = dtables['biasoscorr_stats']\n figs.plot_stat_color('mean-s', sumtable['s_correl_mean'].reshape(9, 16))\n figs.plot_stat_color('mean-p', sumtable['p_correl_mean'].reshape(9, 16))","def bodePlot(H_s,w_range=(0,8),points=800):\n \n w = logspace(*w_range,points)\n h_s = lambdify(s,H_s,'numpy')\n H_jw = h_s(1j*w)\n \n # find mag and phase\n mag = 20*np.log10(np.abs(H_jw))\n phase = angle(H_jw,deg = True)\n \n eqn = Eq(H,simplify(H_s))\n display(eqn)\n \n fig,axes = plt.subplots(1,2,figsize=(18,6))\n ax1,ax2 = axes[0],axes[1]\n \n # mag plot\n ax1.set_xscale('log')\n ax1.set_ylabel('Magntiude in dB')\n ax1.set_xlabel('$\\omega$ in rad/s')\n ax1.plot(w,mag)\n ax1.grid()\n ax1.set_title(\"Magnitude of $H(j \\omega)$\")\n \n # phase plot\n ax2.set_ylabel('Phase in degrees')\n ax2.set_xlabel('$\\omega$ in rad/s')\n ax2.set_xscale('log')\n ax2.plot(w,phase)\n ax2.grid()\n ax2.set_title(\"Phase of $H(j \\omega)$\")\n \n plt.show()","def _plot(x, mph, mpd, threshold, edge, valley, ax, ind):\n try:\n import matplotlib.pyplot as plt\n except ImportError:\n print('matplotlib is not available.')\n else:\n if ax is None:\n _, ax = plt.subplots(1, 1, figsize=(8, 4))\n\n ax.plot(x, 'b', lw=1)\n if ind.size:\n label = 'valley' if valley else 'peak'\n label = label + 's' if ind.size > 1 else label\n ax.plot(ind, x[ind], '+', mfc=None, mec='r', mew=2, ms=8,\n label='%d %s' % (ind.size, label))\n ax.legend(loc='best', framealpha=.5, numpoints=1)\n ax.set_xlim(-.02*x.size, x.size*1.02-1)\n ymin, ymax = x[np.isfinite(x)].min(), x[np.isfinite(x)].max()\n yrange = ymax - ymin if ymax > ymin else 1\n ax.set_ylim(ymin - 0.1*yrange, ymax + 0.1*yrange)\n ax.set_xlabel('Data #', fontsize=14)\n ax.set_ylabel('Amplitude', fontsize=14)\n mode = 'Valley detection' if valley else 'Peak detection'\n #ax.set_title(\"Deuxième détection\")\n ax.set_title(\"%s (mph=%s, mpd=%d, threshold=%s, edge='%s')\"\n % (mode, str(mph), mpd, str(threshold), edge))\n # plt.grid()\n plt.show()","def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\n\n figure = plt.figure()\n figure.subplots_adjust(top=0.76)\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\n\n functionGraph = figure.add_subplot(311)\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\n functionGraph.set_xlabel('X-values')\n functionGraph.set_ylabel('Y-values')\n\n errorGraph = figure.add_subplot(313)\n errorGraph.set_title('Truncation errors', fontsize=15)\n errorGraph.set_xlabel('X-values')\n errorGraph.set_ylabel('Error-values')\n\n if EU == True:\n euler = EulerMethod(self._IVP)\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\n\n if IEM == True:\n improvedEuler = ImprovedEulerMethod(self._IVP)\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\n \n if RK == True:\n rungeKutta = RungeKutta(self._IVP)\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\n\n if ES == True:\n exactSolution = AnalyticalSolution(self._IVP)\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\n \n functionGraph.legend(loc='lower right')\n errorGraph.legend(loc='lower right')\n\n return figure","def plot():\n pass","def plot(self, ax=None, savefile=None, shells=None, color='b', title=None,\n xlabel=None, ylabel=None, withavg=False):\n import matplotlib.pyplot as plt\n if ax is None:\n plt.figure()\n axset=plt\n else:\n axset=ax\n\n cmax = float(max(self.counts))\n total = sum(self.counts)\n nalpha = 0.85 if cmax/total > 0.33 else 0.65\n maxy = 1.\n for di, df in enumerate(self.dfs):\n alpha=nalpha*self.counts[di]/cmax\n axset.plot(df.x, df.df, color=color, alpha=alpha)\n maxy_ = np.max(df.df)\n if maxy_ > maxy:\n maxy = maxy_\n\n if withavg and len(self) > 0:\n x = self.dfs[0].x\n axset.plot(x, self.average, 'r-')\n maxy_ = np.max(self.average)\n if maxy_ > maxy:# pragma: no cover\n maxy = maxy_\n\n if len(self) > 0:\n dtype = self.dfs[0].dtype\n unit = \"Ang.\" if dtype == \"R\" else \"Rad.\"\n tstr = \"Radial\" if dtype == \"R\" else \"Angular\"\n else:# pragma: no cover\n unit = \"unknown units\"\n tstr = \"\"\n \n if ax is None:\n if title is None:\n plt.title(\"{} Distribution Function of Collection\".format(tstr))\n else:\n plt.title(title)\n if xlabel is None:\n plt.xlabel(\"Distance ({})\".format(unit))\n else:\n plt.xlabel(xlabel)\n if ylabel is None:\n plt.ylabel(\"Accumulated Density\")\n else:\n plt.ylabel(ylabel)\n\n _plot_shells(axset, shells, maxy)\n \n if savefile is not None:\n plt.savefig(savefile)\n\n from gblearn.base import testmode\n if not testmode:# pragma: no cover\n plt.show()\n return axset","def vis_eICU_patients_downsampled(pat_arrs, time_step, time_steps_to_plot=None,\n variable_names=['sao2', 'heartrate', 'respiration', 'systemicmean'],\n identifier=None, idx=0):\n # set up the plot\n fig, axarr = plt.subplots(len(variable_names), 1, sharex=True, figsize=(6.5, 9))\n # fix the same colour for each patient for each axis\n n_patients = pat_arrs.shape[0]\n colours = [hsv_to_rgb((i/n_patients, 0.8, 0.8)) for i in range(n_patients)]\n for (i, pat_arr) in enumerate(pat_arrs):\n if not time_steps_to_plot is None:\n pat_arr = pat_arr[0:time_steps_to_plot]\n for col, ax in zip(range(pat_arr.shape[1]), axarr):\n ax.plot(range(0, len(pat_arr)*time_step, time_step), pat_arr[:,col], alpha=0.5, color=colours[i])\n # aesthetics\n xmin, xmax = axarr[0].get_xlim()\n for variable, ax in zip(variable_names, axarr):\n ax.set_ylabel(variable)\n ax.get_yaxis().set_label_coords(-0.15,0.5)\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"bottom\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"left\"].set_visible(False)\n ax.tick_params(bottom='off')\n #ax.set_facecolor((0.96, 0.96, 0.96))\n ymin, ymax = ax.get_ylim()\n # expand the ylim ever so slightly\n yrange = np.abs(ymax - ymin)\n ybuffer = yrange*0.08\n ymin_new = ymin - ybuffer\n ymax_new = ymax + ybuffer\n for x in np.linspace(xmin, xmax - (xmax - xmin)*0.005, num=10):\n ax.plot((x, x), (ymin_new, ymax_new), ls='dotted', lw=0.5, color='black', alpha=0.25, zorder=0)\n #ax.set_ylim(ymin_new, ymax_new)\n ax.set_ylim(-1.5, 1.5)\n axarr[-1].set_xlabel(\"time since admision (minutes)\")\n axarr[-1].get_xaxis().tick_bottom()\n if not identifier is None:\n plt.suptitle(idx)\n fig.savefig(\"./experiments/plots/\" + identifier + \"_epoch\" + str(idx).zfill(4) + \".png\", bbox_inches='tight')\n else:\n fig.savefig('./experiments/plots/eICU_patients.png', bbox_inches='tight')\n plt.clf()\n plt.close()\n return True","def plotLogs(d, rho, v, usingT=True):\n d = np.sort(d)\n\n dpth, rholog, vlog, zlog, rseries = getLogs(d, rho, v, usingT)\n nd = len(dpth)\n\n\n xlimrho = (1.95,5.05)\n xlimv = (0.25,4.05)\n xlimz = (xlimrho[0]*xlimv[0], xlimrho[1]*xlimv[1])\n\n # Plot Density\n plt.figure(1)\n\n plt.subplot(141)\n plotLogFormat(rholog*10**-3,dpth,xlimrho,'blue')\n plt.title('$\\\\rho$')\n plt.xlabel('Density \\n $\\\\times 10^3$ (kg /m$^3$)',fontsize=9)\n plt.ylabel('Depth (m)',fontsize=9)\n\n plt.subplot(142)\n plotLogFormat(vlog*10**-3,dpth,xlimv,'red')\n plt.title('$v$')\n plt.xlabel('Velocity \\n $\\\\times 10^3$ (m/s)',fontsize=9)\n plt.setp(plt.yticks()[1],visible=False)\n\n plt.subplot(143)\n plotLogFormat(zlog*10.**-6.,dpth,xlimz,'green')\n plt.gca().set_title('$Z = \\\\rho v$')\n plt.gca().set_xlabel('Impedance \\n $\\\\times 10^{6}$ (kg m$^{-2}$ s$^{-1}$)',fontsize=9)\n plt.setp(plt.yticks()[1],visible=False)\n\n plt.subplot(144)\n plt.hlines(d[1:],np.zeros(len(d)-1),rseries,linewidth=2)\n plt.plot(np.zeros(nd),dpth,linewidth=2,color='black')\n plt.title('Reflectivity');\n plt.xlim((-1.,1.))\n plt.gca().set_xlabel('Reflectivity')\n plt.grid()\n plt.gca().invert_yaxis()\n plt.setp(plt.xticks()[1],rotation='90',fontsize=9)\n plt.setp(plt.yticks()[1],visible=False)\n\n plt.tight_layout()\n plt.show()","def figure8():\n\n plot_settings = {'y_limits': [15, 60],\n 'x_limits': None,\n 'y_ticks': [20, 30, 40, 50, 60],\n 'locator_size': 5,\n 'y_label': 'ISI (ms)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_8',\n 'legend': ['First ISI', 'Second ISI'],\n 'legend_size': 8,\n 'y_on': True,\n 'legend_location': 4}\n\n g_t_bars = np.linspace(0.02, 0.2, 10)\n isi = np.zeros((len(g_t_bars), 2))\n\n for ix, g_t_bar in enumerate(g_t_bars):\n t, y = solver(200, t_start=15, duration=260, g_t_bar=g_t_bar)\n t_spike, f = spike_times(t, y[:, 0])\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_t_bars[3], 35, 0, 11, head_width=0, head_length=0, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[3], 46, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[3], 35, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Acceleration\", (0.1, 35), fontsize=8)\n plt.gca().annotate(\"Adaptation\", (0.01, 46), fontsize=8)\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n g_n_bars = np.linspace(0.02, 0.2, 10)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_n_bar in enumerate(g_n_bars):\n t, y = solver(200, g_n_bar=g_n_bar, duration=260, t_start=15, g_t_bar=0.02)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_n_bars[3], 30, 0, 10, head_width=0, head_length=0, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[3], 40, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[3], 30, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Acceleration\", (0.1, 30), fontsize=8)\n plt.gca().annotate(\"Adaptation\", (0.015, 40), fontsize=8)\n plot_settings['y_ticks'] = []\n plot_settings['y_label'] = \"\"\n plot_settings['y_on'] = False\n plot_settings['legend_location'] = 4\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n g_t_bars = np.linspace(0.02, 0.16, 8)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_t_bar in enumerate(g_t_bars):\n t, y = solver(200, g_t_bar=g_t_bar, duration=260, t_start=15, ca_type=1)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_t_bars[2], 25, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[4], 25, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Adaptation\", (0.06, 25), fontsize=8)\n\n plot_settings['y_limits'] = [0, 45]\n plot_settings['y_ticks'] = [0, 10, 20, 30, 40]\n plot_settings['locator_size'] = 5\n plot_settings['y_label'] = 'ISI (ms)'\n plot_settings['y_on'] = True\n plot_settings['legend_location'] = 3\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 4)\n g_n_bars = np.linspace(0.02, 0.16, 8)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_n_bar in enumerate(g_n_bars):\n t, y = solver(200, duration=260, t_start=15, g_n_bar=g_n_bar, g_t_bar=0.02, ca_type=2)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_n_bars[2], 20, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[4], 20, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Adaptation\", (0.06, 20), fontsize=8)\n\n plot_settings['y_ticks'] = []\n plot_settings['y_label'] = ''\n plot_settings['y_on'] = False\n plot_settings['legend_location'] = 2\n alter_figure(plot_settings, close=True)","def gaze_ethoplot(anglearrays,title,show = True,save = False):\n colors = ['red','blue']\n labels = ['fish1 gaze', 'fish2 gaze']\n fig,ax = plt.subplots(2,1,sharex = True)\n for i in range(2):\n anglearray = anglearrays[i]\n inds = np.arange(len(anglearray))\n color = colors[i]\n ax[0].plot(anglearray,color = color,linewidth = 1,alpha = 0.5,label = labels[i])\n boolean = anglearray.apply(lambda x: 1 if x > 140 else 0) \n [ax[1].axvline(x = j,alpha = 0.2,color = color) for j in inds if boolean[j] == 1]\n\n ax[0].set_ylabel('relative angle (degrees)')\n ax[1].set_ylabel('threshold crossing')\n ax[1].set_xlabel('time (frame)')\n ax[0].set_title(title)\n\n ax[0].legend(loc = 1)## in the upper right; faster than best. \n\n if save == True:\n plt.savefig(title + '.png')\n \n if show == True:\n plt.show()","def DETCurve(fps, fns):\n axis_min = min(fps[0], fns[-1])\n fig, ax = plt.subplots()\n plt.xlabel(\"FAR\")\n plt.ylabel(\"FRR\")\n plt.plot(fps, fns, '-|')\n plt.yscale('log')\n plt.xscale('log')\n ax.get_xaxis().set_major_formatter(\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\n ax.get_yaxis().set_major_formatter(\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\n ticks_to_use = [0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1]\n ax.set_xticks(ticks_to_use)\n ax.set_yticks(ticks_to_use)\n plt.axis([0.01, 1, 0.01, 1])\n # plt.show()","def plot_posteriors(chain, P, nplot='all'):\n\n if 'posterior_plots' in opt:\n temp = opt['posterior_plots'].split(',')\n pairs = []\n for pair in temp:\n pairs.append(pair.split())\n nplot = len(pairs)\n elif nplot == 'all':\n nplot = chain.shape[-1]\n\n\n nrows, ncols = get_nrows_ncols(nplot)\n fig,axes = get_fig_axes(nrows, ncols, nplot)\n\n for i,ax in enumerate(axes):\n if 'posterior_plots' in opt:\n i0 = P['names'].index(pairs[i][0])\n i1 = P['names'].index(pairs[i][1])\n else:\n i0 = i\n i1 = i + 1\n if i1 == npar:\n i1 = 0\n\n #ax.plot(chain[:,0,i], chain[:,0,j], '.r', ms=4, label='p$_{initial}$')\n dhist(chain[:, i0], chain[:, i1],\n xbins=P['bins'][i0], ybins=P['bins'][i1],\n fmt='.', ms=1.5, c='0.5', chist='b', ax=ax, loc='left, bottom')\n\n #if contours:\n # i1sig = get_levels(np.array([chain[:,i], chain[:,j]]).T,)\n # #cont = ax.contour(*par, colors='k',linewidths=0.5)\n # for ind in P.ijoint_sig:\n # x,y = chain[:,i][ind], chain[:,j][ind]\n # delaunay = Delaunay(np.array([x, y]).T)\n # for i0,i1 in delaunay.convex_hull:\n # ax.plot([x[i0], x[i1]], [y[i0], y[i1]], 'k', lw=0.5)\n x,y = chain[:,i0][P['ijoint_sig'][1]], chain[:,i1][P['ijoint_sig'][1]]\n ax.plot(x,y,'g.', ms=3, mew=0)\n x,y = chain[:,i0][P['ijoint_sig'][0]], chain[:,i1][P['ijoint_sig'][0]]\n ax.plot(x,y,'r.', ms=3, mew=0)\n\n ax.plot(P['ml'][i0], P['ml'][i1], 'xk', ms=12, mew=4)\n ax.plot(P['ml'][i0], P['ml'][i1], 'xr', ms=10, mew=2)\n\n c = 'crimson'\n ax.axvline(P['p1sig'][i0][0], ymax=0.2, color=c, lw=0.5)\n ax.axvline(P['p1sig'][i0][1], ymax=0.2, color=c, lw=0.5)\n ax.axhline(P['p1sig'][i1][0], xmax=0.2, color=c, lw=0.5)\n ax.axhline(P['p1sig'][i1][1], xmax=0.2, color=c, lw=0.5)\n ax.axvline(P['median'][i0], ymax=0.2, color=c, lw=1.5)\n ax.axhline(P['median'][i1], xmax=0.2, color=c, lw=1.5)\n\n puttext(0.95, 0.05, P['names'][i0], ax, fontsize=16, ha='right')\n puttext(0.05, 0.95, P['names'][i1], ax, fontsize=16, va='top')\n x0, x1 = np.percentile(chain[:,i0], [5, 95])\n dx = x1 - x0\n ax.set_xlim(x0 - dx, x1 + dx)\n y0, y1 = np.percentile(chain[:,i1], [5, 95])\n dy = y1 - y0\n ax.set_ylim(y0 - dy, y1 + dy)\n\n return fig, axes","def plot(self, dtables, figs, **kwargs):\n self.safe_update(**kwargs)\n\n figs.setup_amp_plots_grid(\"ratio-row\", title=\"sflat ratio by row\",\n xlabel=\"row\", ylabel=\"Ratio\")\n figs.plot_xy_amps_from_tabledict(dtables, 'row', 'ratio_row',\n x_name='row_i', y_name='r_med')\n\n figs.setup_amp_plots_grid(\"ratio-col\", title=\"sflat ratio by col\",\n xlabel=\"col\", ylabel=\"Ratio\")\n figs.plot_xy_amps_from_tabledict(dtables, 'col', 'ratio_col',\n x_name='col_i', y_name='r_med')\n\n figs.setup_amp_plots_grid(\"scatter\", title=\"sflat ratio v. sbias\",\n xlabel=\"Superbias [ADU]\", ylabel=\"Ratio\")\n\n figs.plot_amp_arrays(\"mask\", self.quality_masks, vmin=0, vmax=3)\n\n for i, (amp, sbias_image) in enumerate(sorted(self.superbias_images)):\n figs.plot_two_image_hist2d('scatter', i,\n sbias_image,\n self.ratio_images[amp],\n bins=(200, 200),\n range=((-50, 50.), (0.018, 0.022)))","def do_2dla_plots(cat, subdir):\n #Omega_DLA in variance vs bayesian mode\n cat.second_dla=False\n cat.plot_omega_dla(zmax=5, label=\"Confidence interval\")\n cat.second_dla=True\n cat.plot_omega_dla_var(zmax=5, label=\"Variance\")\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"omega_gp_diff\"))\n plt.clf()\n\n #dNdX\n #Check effect of the second DLA\n cat.plot_line_density(zmax=5,label=\"Two-DLA\")\n cat.second_dla = False\n cat.plot_line_density(zmax=5,label=\"One-DLA\")\n cat.second_dla = True\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"dndx_2dla\"))\n plt.clf()\n\n cat.plot_omega_dla(zmax=5,label=\"Two-DLA\")\n cat.second_dla = False\n cat.plot_omega_dla(zmax=5,label=\"One-DLA\")\n cat.second_dla = True\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"omega_2dla\"))\n plt.clf()","def vanderpol_dymos_plots(p):\n\n # check validity by using scipy.integrate.solve_ivp to integrate the solution\n sim_out = p.model.traj.simulate()\n\n # plots\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 9))\n\n # state variable x1\n axes[0, 0].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.states:x1'),\n 'ro', label='solution')\n\n axes[0, 0].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\n 'b-', label='simulation')\n\n axes[0, 0].set_xlabel('time (s)')\n axes[0, 0].set_ylabel('x1 (V)')\n axes[0, 0].legend()\n axes[0, 0].grid()\n\n # state variable x0\n axes[0, 1].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.states:x0'),\n 'ro', label='solution')\n\n axes[0, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.states:x0'),\n 'b-', label='simulation')\n\n axes[0, 1].set_xlabel('time (s)')\n axes[0, 1].set_ylabel('x0 (V/s)')\n axes[0, 1].legend()\n axes[0, 1].grid()\n\n # state variable x1 vs x0\n axes[1, 0].plot(p.get_val('traj.phase0.timeseries.states:x0'),\n p.get_val('traj.phase0.timeseries.states:x1'),\n 'ro', label='solution')\n\n axes[1, 0].plot(sim_out.get_val('traj.phase0.timeseries.states:x0'),\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\n 'b-', label='simulation')\n\n axes[1, 0].set_xlabel('x0 (V/s)')\n axes[1, 0].set_ylabel('x1 (V)')\n axes[1, 0].legend()\n axes[1, 0].grid()\n\n # control variable u\n axes[1, 1].plot(p.get_val('traj.phase0.timeseries.time'),\n p.get_val('traj.phase0.timeseries.controls:u'),\n 'ro', label='solution')\n\n axes[1, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\n sim_out.get_val('traj.phase0.timeseries.controls:u'),\n 'b-', label='simulation')\n\n axes[1, 1].set_xlabel('time (s)')\n axes[1, 1].set_ylabel('control u')\n axes[1, 1].legend()\n axes[1, 1].grid()\n\n plt.show()","def plot_alternate_t(noncentrality, df, alpha=0.05, ax=None):\n\n if ax is None:\n ax = plt.axes()\n\n x, y1, y2, crit = _summarize_t(noncentrality, df, alpha)\n color1, color2 = _get_colors()\n\n ax.plot(x, y1, color=color1)\n ax.plot(x, y2, color=color2)\n\n sn.despine(ax=ax, left=True, offset=10)\n\n return ax","def samsemPlots1thru4(samsem_data,path,dict):\n \n telleoevelse = dict['telleoevelse'] if 'telleoevelse' in dict else 0\n \n # Defining the subfolder for the results\n path_res = path\n if 'subfolder' in dict:\n subfolder = dict['subfolder']\n path_res = os.path.join(path,subfolder)\n if not os.path.exists(path_res): os.makedirs(path_res)\n \n # Retrieving data from data set\n coldef_type = dict['coldef_type'] # Color deficiency type of the simulation method\n dict.update({'investigated-item': 'simulation method'})\n filename_orig = dict['filename']\n \n if 'method_ids' in dict:\n method_ids = dict['method_ids']\n else:\n method_ids = sorted(set(samsem_data['sim_id'].values.astype(int)))\n method_ids = sorted(method_ids) # IDs of the methods that need to be plotted\n \n print(\"Starting SAMSEM_RES#01+04: Analyzing data for \" + str(settings.id2ColDefLong[dict['coldef_type']]) + \" simulation methods: \"+str(keys2values(method_ids,settings.id2Sim))+\".\")\n \n pandas_dict = {}; i = 0; order_dict = {}; sim_names = []\n # Retrieving data for each of the algorithms algorithm\n for sim_id in method_ids:\n \n sim_method = settings.id2Sim[sim_id]\n if (sim_id != 3) and (sim_id != 99):\n whatArr_tmp = [dict['obs_operator'],['sim_id',operator.eq,sim_id],['coldef_type',operator.eq,coldef_type]]\n else:\n whatArr_tmp = [dict['obs_operator'],['sim_id',operator.eq,sim_id]] # For the kotera and the dummy method, both protanopia and deuteranopia variants are identical. Thus, no distinction of coldef_type is necessary.\n relevant_data_tmp = organizeArray(samsem_data,whatArr_tmp) \n \n pandas_dict.update({sim_method: relevant_data_tmp})\n order_dict.update({i: sim_method}); i += 1\n sim_names.append(sim_method)\n \n # Plot response time data as boxplots\n if telleoevelse: print(\"Observations RT plots\")\n boxes, labels = preparePandas4RTPlots(pandas_dict, order_dict)\n plotRTGraphs(boxes,labels,path_res,dict,order_dict)\n \n # Plot accuracy data with confidence intervals\n c = 1.96; type = 'wilson-score';\n \n if telleoevelse: print(\"Observations ACC plots\")\n accuracies = preparePandas4AccuracyPlots(pandas_dict,order_dict,c,type)\n plotAccuracyGraphs(accuracies,path_res,dict,order_dict)\n \n # Make median test as csv file\n dict.update({'filename': filename_orig+\"-RT\"})\n makeMedianTest(numpy.array(boxes), path_res, sim_names,dict)\n \n # Make Chi2 contingency test as text file\n obs_array, obs_pandas = preparePandas4Chi2(pandas_dict, order_dict)\n \n start = 0; end = 4 # For the global Chi2 test, we are excluding the dummy method.\n res = [start,end]\n dict.update({'filename': filename_orig+'-ACC'})\n makePearsonChi2Contingency(obs_array, obs_pandas, labels, path_res, dict, res)\n \n # Make pairwise Chi2 contingency test matrix as csv file\n makePearsonChi2Contingency2x2Test(obs_array, path_res, labels, dict)\n \n # Make normality Q-Q and log-Q-Q plots\n for i in range(numpy.shape(boxes)[0]):\n distribution_tmp = boxes[i]\n label_tmp = labels[i]\n dict.update({'filename': filename_orig+'-RT-'+label_tmp})\n plotQQPlot(distribution_tmp, path_res, dict)\n \n distribution_log_tmp = numpy.log(distribution_tmp)\n distribution_log_tmp = distribution_log_tmp[~numpy.isnan(distribution_log_tmp)]\n dict.update({'filename': filename_orig+'-RT-'+label_tmp+'-log'})\n plotQQPlot(distribution_log_tmp, path_res, dict)","def etio_subplot(df, ax, title, graph_color='skyblue'):\n\n post_dx_histo = histo_dx_includes(df)\n hist_df = pd.DataFrame({\"Dx\": post_dx_histo.index, \"Count\": post_dx_histo.data})\n #hist_df = hist_df.drop(1)\n print(hist_df)\n\n graph_range = range(1,len(hist_df.index)+1)\n ax.hlines(y=graph_range, xmin=0, xmax=hist_df['Count'], color=graph_color)\n ax.plot(hist_df['Count'], graph_range, \"D\", color=graph_color)\n ax.set_yticks(range(1, len(hist_df['Dx'])+1))\n ax.set_yticklabels(hist_df['Dx'], fontsize='10')\n\n ax.set_title(title, fontsize='10')\n return ax","def plot_hypnogram(et,window=None,stage_map=None,mask_kwargs=None,*args,**kwargs):\n if stage_map==None:\n stage_map = {\"awake\":0, \"REM\":-1, \"Stage 1\":-2, \"Stage 2\":-3, \"Stage 3\":-4, \"Stage 4\":-5, \"mask\":0}\n if mask_kwargs==None:\n mask_kwargs = dict(fc=\"k\",alpha=1.0)\n #et = eegpy.EventTable(fn)\n evts = et.get_all_events_with_keys()\n \n if window==None:\n window = np.median(np.diff([x[1] for x in evts]))\n \n xs = np.zeros((len(evts)*2))\n ys = np.zeros((len(evts)*2))\n \n mask_segments = []\n for i,e in enumerate(evts):\n xs[2*i] = e[1]\n if len(evts)-i>1:\n xs[2*i+1] = evts[i+1][1]-1\n else:\n xs[2*i+1] = xs[2*i]+window\n if e[0] in stage_map.keys():\n ys[2*i] = stage_map[e[0]]\n ys[2*i+1] = stage_map[e[0]] \n else:\n ys[2*i] = stage_map[\"mask\"]\n ys[2*i+1] = stage_map[\"mask\"] \n mask_segments.append((xs[2*i],xs[2*i+1]))\n \n p.plot(xs,ys,*args,**kwargs)\n for ms in mask_segments:\n p.axvspan(ms[0],ms[1],**mask_kwargs)\n p.ylim((np.array(stage_map.values()).min()-1,np.array(stage_map.values()).max()+1))\n #print [x for x in stage_map.keys()],[stage_map[x] for x in stage_map.keys()]\n del stage_map[\"mask\"]\n p.yticks([stage_map[x] for x in stage_map.keys()],[x for x in stage_map.keys()])\n \n return xs,ys","def main():\n save = False\n show = True\n\n #hd_parameter_plots = HDparameterPlots(save=save)\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\n #ice5g_comparison_plots.plotLine()\n #ice5g_comparison_plots.plotFilled()\n #ice5g_comparison_plots.plotCombined()\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\n #flowmapplot = FlowMapPlots(save)\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\n #flowmapplot.Etopo1FlowMap()\n #flowmapplot.ICE5G_data_all_points_0k()\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\n #flowmapplot.Etopo1FlowMap_two_color()\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\n outflowplots = OutflowPlots(save)\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #hd_output_plots = HDOutputPlots()\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\n #lake_plots = LakePlots()\n #lake_plots.plotLakeDepths()\n #lake_plots.LakeAndRiverMap()\n #lake_plots.LakeAndRiverMaps()\n if show:\n plt.show()","def plot_deviation(\n true_values: np.ndarray, pred_values: np.ndarray, save=None, show=True, return_axs=False, title: str = \"\"\n) -> Optional[Axes]:\n true_values, pred_values = _input_checks(true_values, pred_values)\n\n plt.ioff()\n\n n_par = true_values.shape[0]\n summary_fit = pd.concat(\n [\n pd.DataFrame(\n {\n \"deviation\": pred_values[i, :] - true_values[i, :],\n \"coefficient\": pd.Series([\"coef_\" + str(i) for x in range(pred_values.shape[1])], dtype=\"category\"),\n }\n )\n for i in range(n_par)\n ]\n )\n summary_fit[\"coefficient\"] = summary_fit[\"coefficient\"].astype(\"category\")\n\n fig, ax = plt.subplots()\n sns.violinplot(x=summary_fit[\"coefficient\"], y=summary_fit[\"deviation\"], ax=ax)\n\n if title is not None:\n ax.set_title(title)\n\n # Save, show and return figure.\n if save is not None:\n plt.savefig(save + \"_deviation_violin.png\")\n\n if show:\n plt.show()\n\n plt.close(fig)\n plt.ion()\n\n if return_axs:\n return ax\n return None","def plot_fig1(dysbiosis, dataset_order, samplesizes, edd_color=False):\n disease_colors = fmt.get_disease_colors()\n # Make color palette dictionary that has all of the datasets\n # Note: need trailing underscore so that cd studies are not considered cdi\n diseases = set([i.split('_')[0] + '_' for i in dataset_order])\n colors = {}\n for d in diseases:\n dis_datasets = [i for i in dataset_order if i.startswith(d)]\n colors.update({i: j for i, j in zip(dis_datasets,\n len(dis_datasets)*[sns.light_palette(disease_colors[d[:-1]])[-1]])})\n if edd_color:\n colors['cdi_singh'] = disease_colors['edd']\n\n ### Plot\n sns.set_style('white', {'ytick.direction': 'in', 'ytick.major.size': 2.0,\n 'font.size': 'xx-small'})\n\n ## Set up the plot\n # For spacing between plots: hspace in the following calls to gridspec\n # set the space between the subplots.\n # To set the space between the two gridspecs (top and bottom), need to\n # change h_pad in call to tight_layout() at the very bottom!\n fig = plt.figure(figsize=(0.27*len(dataset_order),8))\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\n # Bottom gridspec has sample size and AUCs\n gs_bottom = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[1],\n hspace=0.25)\n ax_samplesize = plt.subplot(gs_bottom[1])\n ax_auc = plt.subplot(gs_bottom[0])\n\n # Top gridspec has n_sig and balance\n gs_top = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[0],\n hspace=0.25)\n ax_metrics = [plt.subplot(i) for i in gs_top]\n\n ### Plot stuff\n ## Sample size\n # Sample size is the one with the labels.\n # dataset_order = [i if i != 'cdi_singh' else 'edd_singh' for i in dataset_order]\n # samplesizes['dataset'] = [i if i != 'cdi_singh' else 'edd_singh' for i in samplesizes['dataset']]\n # colors = {(i if i != 'cdi_singh' else 'edd_singh'): colors[i] for i in colors}\n labeldict = fmt.get_labeldict(dataset_order)\n\n # Plot barplot.\n sns.barplot(x='dataset', y='total', data=samplesizes,\n order=dataset_order, ax=ax_samplesize, palette=colors,\n edgecolor='')\n\n [ax_samplesize.spines[i].set_visible(False) for i in ['left', 'top']]\n\n ax_samplesize.yaxis.tick_right()\n ax_samplesize.yaxis.set_label_position('right')\n ax_samplesize.set_yticks([100,300,500])\n ax_samplesize.set_yticklabels(['100', '300', '500'], rotation=90)\n\n ax_samplesize.set_xticklabels([labeldict[i] for i in dataset_order],\n rotation=90)\n\n ax_samplesize.set_xlabel('')\n ax_samplesize.set_ylabel('Total samples')\n\n # # Change all labels back to the original cdi_singh\n # dataset_order = [i if i != 'edd_singh' else 'cdi_singh' for i in dataset_order]\n # samplesizes['dataset'] = [i if i != 'edd_singh' else 'cdi_singh' for i in samplesizes['dataset']]\n # colors = {(i if i != 'edd_singh' else 'cdi_singh'): colors[i] for i in colors}\n\n ## AUCs\n ## Plot AUCs as barplots\n # Plot dashed line\n ax_auc.plot([-0.5, 29.5], [1, 1], color='0.75', linestyle='--')\n\n # No dashed lines\n # sns.stripplot(x='label', y='value',\n # data=dysbiosis.query('metric == \"auc\"'),\n # order=dataset_order, ax=ax_auc, palette=colors,\n # size=7, marker='D')\n # I liked it with the dashed lines better\n ax_auc = stemplot(x='label', y='value',\n data=dysbiosis.query('metric == \"auc\"'),\n order=dataset_order, ax=ax_auc,\n palette=colors, marker='D')\n\n ax_auc.set_xticklabels([])\n ax_auc.set_ylim([0.5, 1])\n ax_auc.set_yticks([0.5, 0.75, 1.0])\n ax_auc.set_yticklabels([0.5, 0.75, 1], rotation=90)\n ax_auc.yaxis.tick_right()\n ax_auc.yaxis.set_label_position('right')\n\n [ax_auc.spines[i].set_visible(False) for i in ['left', 'top']]\n\n ax_auc.set_ylabel('AUC')\n ax_auc.set_xlabel('')\n\n ## n_sig\n ax_metrics[1] = stemplot(x='label', y='value',\n data=dysbiosis.query('metric == \"n_sig\"').replace(0, np.nan),\n order=dataset_order, ax=ax_metrics[1],\n palette=colors)#, marker='o')\n\n ax_metrics[1].set_xticklabels([])\n ax_metrics[1].set_ylim([0, None])\n ax_metrics[1].set_yticks([0, 20, 40, 60])\n ax_metrics[1].set_yticklabels([0, 20, 40, 60], rotation=90)\n ax_metrics[1].yaxis.tick_right()\n ax_metrics[1].yaxis.set_label_position('right')\n\n [ax_metrics[1].spines[i].set_visible(False) for i in ['left', 'top']]\n\n ax_metrics[1].set_ylabel('Genera, q < 0.05')\n ax_metrics[1].set_xlabel('')\n\n ## balance\n # center the balance values around zero\n dysbiosis['centered_value'] = \\\n dysbiosis.query('metric == \"balance\"')['value'] - 0.5\n\n ax_metrics[0] = stemplot(x='label', y='centered_value',\n data=dysbiosis.query('metric == \"balance\"'),\n order=dataset_order, ax=ax_metrics[0],\n palette=colors)\n\n # Plot the gray, blue and red lines for 0% and 100% depleted/enriched\n ax_metrics[0].plot([-0.5, 29.5], [0, 0],\n color='0.75', linestyle='-')\n ax_metrics[0].plot([-0.5, 29.5], [-0.5, -0.5],\n color='b', linestyle='-', alpha=0.2)\n ax_metrics[0].plot([-0.5, 29.5], [0.5, 0.5],\n color='r', linestyle='-', alpha=0.2)\n\n ax_metrics[0].set_ylim([-0.6, 0.6])\n ax_metrics[0].yaxis.tick_right()\n ax_metrics[0].yaxis.set_label_position('right')\n # The -0.5 tick needs to be moved a bit to be less scrunched\n ax_metrics[0].set_yticks([-0.4, 0.5])\n ax_metrics[0].tick_params(axis='y', which=u'both', length=0)\n ax_metrics[0].set_yticklabels(['Beneficial-\\n depleted',\n 'Pathogen-\\n enriched'],\n rotation=90)\n ax_metrics[0].set_xticklabels([])\n ax_metrics[0].yaxis.set_label_position('right')\n\n [ax_metrics[0].spines[i].set_visible(False) for i in ['left', 'top', 'bottom']]\n\n ax_metrics[0].set_xlabel('')\n ax_metrics[0].set_ylabel('')\n\n # Tight layout and set spacing between A and B panels\n gs.tight_layout(fig, h_pad=3.5)\n\n return fig","def figure1():\n\n plot_settings = {'y_limits': [-80, -50],\n 'x_limits': None,\n 'y_ticks': [-80, -70, -60, -50],\n 'locator_size': 5,\n 'y_label': 'Voltage (mV)',\n 'x_ticks': [],\n 'scale_size': 20,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_1',\n 'legend_size': 8,\n 'legend': None,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n plt.figure(figsize=(5, 2)) # Create figure\n plt.plot(t, y[:, 0], 'k-') # Plot solution\n\n \"\"\"\n Annotate plot with figures\n \"\"\"\n plt.gca().annotate('fAHP', xy=(13.5, -65), xytext=(17, -60),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n plt.gca().annotate('ADP', xy=(15.5, -66), xytext=(25, -65),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n plt.gca().annotate('mAHP', xy=(38, -77), xytext=(43, -72),\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\n alter_figure(plot_settings, close=True) # Alter figure for publication","def add_boxplotlike_data(stats, y_bottom,y_mid,y_top, y_label,method_index,statistic=\"mean_SD\"):\n if statistic==\"median_IQR\":\n x1,x2,x3=tuple(np.quantile(stats, q=[.25, .50, .75]))\n elif statistic==\"mean_SD\":\n sd = np.std(stats)\n x2 = np.mean(stats)\n x1 = x2 - sd\n x3 = x2 + sd\n elif statistic==\"meanall_replicatesd\": # when joining different fitfuns\n\n x2=np.mean(np.array(stats))\n sds=[np.std(stats[i]) for i in range(len(stats))]\n sd=np.mean(sds)\n x1= x2 - sd\n x3 = x2 + sd\n # assumes fitfun is first dimension of stats\n\n else:\n raise Exception(\"statistic %s not known\"%(statistic))\n\n y_bottom[y_label][method_index].append(x1)\n y_mid[y_label][method_index].append(x2)\n y_top[y_label][method_index].append(x3)","def evals_by_evals(ax, pds, baseline1_ds=None, baseline1_label=\"\", baseline2_ds=None, baseline2_label=\"\", dim=None, funcId=None, groupby=None):\n if groupby is None: groupby = GroupByMedian()\n pfsize = len(pds.algds.keys())\n\n runlengths = 10**np.linspace(0, np.log10(pds.maxevals((dim, funcId))), num=500)\n target_values = pp.RunlengthBasedTargetValues(runlengths,\n reference_data=pds.bestalg(None), force_different_targets_factor=10**0.004)\n targets = target_values((funcId, dim))\n\n if baseline1_ds:\n baseline1_fevs = np.array(groupby(baseline1_ds.detEvals(targets), axis=1))\n if baseline2_ds:\n baseline2_fevs = np.array(groupby(baseline2_ds.detEvals(targets), axis=1))\n\n for (kind, name, ds, style) in _pds_plot_iterator(pds, dim, funcId):\n #print name, ds\n fevs1 = groupby(ds.detEvals(targets), axis=1)\n if baseline1_ds:\n fevs1 /= baseline1_fevs\n fevs2 = groupby(ds.detEvals(targets), axis=1)\n if baseline2_ds:\n fevs2 /= baseline2_fevs\n\n infsx = np.nonzero(fevs1 == inf)\n infs = infsx[0]\n if np.size(infs) > 0:\n #print infs\n fevs1 = fevs1[:infs[0]-1]\n fevs2 = fevs2[:infs[0]-1]\n\n #print name, fevs1, fevs2\n style['markevery'] = 64\n ax.loglog(fevs2, fevs1, label=name, basex=pfsize, basey=pfsize, **style)\n ax.grid()\n ax.set_xlim(0, runlengths[-1] * pfsize) # i.e. log(runlengths) + 1\n ax.set_ylabel('Per-target ' + _evals_label(baseline1_ds, baseline1_label, str(groupby)))\n ax.set_xlabel('Per-target ' + _evals_label(baseline2_ds, baseline2_label, str(groupby)))","def plot_alleles(folder):\n\n abs_alt,perc_alt = parse_geno_file(folder,False)\n\n strain_matcher = re.compile('(.*) \\(.*\\)') ## regex to get strain name from radio button click\n strain_matcher2 = re.compile('(.*)-(.*)')\n \n fig, ax = plt.subplots()\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\n ax.set_ylabel('Alternate Allele Percentage (MC)')\n ax.set_xlabel('Alternate Allele Percentage (MC)')\n \n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\n\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\n\n #for strain in perc_alt.keys():\n #print strain\n \n #ylabel = plt.axes([1,1,0.08,0.08])\n\n def update1(strain):\n if strain not in [\"Rock-MZ\",\"Sand-MC\",\"Rock-MC\",\"Sand-MZ\",\"Rock-Sand\"]:\n match = re.match(strain_matcher,strain)\n strain = match.group(1)\n global base\n base = 'MC'\n else:\n match = re.match(strain_matcher2,strain)\n strain = match.group(1)\n #global base \n base = match.group(2)\n\n #print D\n if(D == \"%\"):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[strain])\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n else:\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[strain])\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n\n ax.relim()\n ax.autoscale()\n fig.canvas.draw_idle()\n global S \n #print S\n S = strain\n\n\n def update2(data):\n if(data == '%'):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n fig.canvas.draw_idle()\n if(data == 'Abs'):\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n fig.canvas.draw_idle()\n \n global D\n D = data\n\n radio1.on_clicked(update1)\n radio2.on_clicked(update2)\n plt.show()","def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\n if axdelta is None:\n axdelta = plt.gca()\n delta = self.means - exact\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\n if blocked:\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\n if blockederr:\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\n axdelta.set_xlabel('Number of determinants in estimator')\n axdelta.set_ylabel(r'$E-E_\\mathrm{CCSD}$ / ha')\n axdelta.legend()\n return axdelta","def plot_energies(self, np = None, ax=None):\n if not ax:\n import matplotlib.pyplot as plt\n fig = plt.figure()\n ax = fig.add_subplot(111)\n else:\n fig = None\n if np:\n datas = self.results['energies'][np[0]:np[1]]\n else:\n datas = self.results['energies']\n ax.plot(range(len(datas)), datas, '-o')\n # ax.set_ylim([self.results['energies'][-1], self.results['energies'][0]])\n ax.set_xlabel('steps')\n ax.set_ylabel('energy [eV]')\n ax.set_title('Energy profile {0}'.format(self.prefix))\n plt.savefig('{0}.png'.format(self.prefix))","def plot_dynamic(D, **kwargs):\n\t\n\tif not 'legend_label' in kwargs:\n\t\tkwargs['legend_label'] = 'Map T'\n\treturn plot(lambda x: D.f(RIF(x)).center(), 0, 1, **kwargs)","def plotDihedralEnergy(self, phys, forces, step): \r\n self.plotQuantity(step, phys.app.energies.getTable(4), 'dihedralenergy')","def __plot_delaunay(self, ax=None) -> None:\n for simplex in self.hull.simplices:\n ax.plot(self.points[simplex, 0], self.points[simplex, 1], \"r-\")\n\n tri = Delaunay(self.points)\n ax.triplot(self.points[:, 0], self.points[:, 1], tri.simplices.copy(), lw=1)","def dline_dSFR(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\n \n marker = 'o'\n if p.sim_run == p.sim_runs[0]: marker = '^'\n\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\n\n SFR = SFR[L_line > 0]\n M_star = M_star[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n L_line = L_line[L_line > 0]\n print('%i data points ' % (len(L_line)))\n\n # Distance from MS\n dlSFR = aux.distance_from_salim18(GR.M_star,GR.SFR)\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n # Distance from observed relation\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\n\n labs = {'_M10':'Mach=10 power-law',\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\n '_arepoPDF':'SIGAME v3',\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\n '_arepoPDF_M51':'SIGAME v3'}\n lab = labs[p.table_ext]\n\n\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\n ax.set_xlabel('log SFR - log SFR$_{MS,Salim+18}$')\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\n if not p.xlim: p.xlim = np.array([-3,3])\n if not p.ylim: \n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\n # if p.line == '[OI]63': p.ylim = [np.median(ldL_line) - 5,np.median(ldL_line) + 4]\n # if 'CO' in p.line: p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 4]\n\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\n m = ax.scatter(dlSFR[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/pc$^2$]',size=15)","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def create_dashboard(h, t, k, p):\n plt.style.use('seaborn')\n # Initialize the dashboard\n fig = plt.figure(figsize=(20, 8))\n ax1 = fig.add_subplot(2, 2, 1)\n ax2 = fig.add_subplot(2, 2, 2)\n ax3 = fig.add_subplot(2, 2, 3)\n ax4 = fig.add_subplot(2, 2, 4)\n\n # Create individual graphs\n dt_line, = ax1.plot(h, lw=3, c='k')\n total_line, = ax2.plot(t, lw=3, c='#d62728')\n k_line, = ax3.plot(k, lw=3, c='#1f77b4')\n p_line = ax4.plot(p, lw=3, c='#2ca02c')\n\n ax1.set_title(r'Variation in $\\Delta t$')\n ax1.set_ylabel(r'$\\Delta t$')\n ax2.set_title(r'Total Energy over Time')\n ax2.set_ylabel('Total Energy')\n ax3.set_title('Kinetic Energy over Time')\n ax3.set_ylabel('Kinetic Energy')\n ax3.set_xlabel('Time Steps')\n ax4.set_title('Potential Energy over Time')\n ax4.set_ylabel('Potential Energy')\n ax4.set_xlabel('Time Steps')\n\n plt.show()\n\n \"\"\"im = ax[0, 0].imshow(model.lattice, cmap='Greys', vmin=-1, vmax=1)\n energy_line, = ax[0, 1].plot([], [], lw=3)\n mag_line, = ax[1, 0].plot([], [], lw=3)\n heat_line, = ax[1, 1].plot([], [], lw=3)\n susceptibility_line, = ax[2, 0].plot([], [], lw=3)\n acceptance_line, = ax[2, 1].plot([], [], lw=3)\"\"\""],"string":"[\n \"def plotdFvsLambda1():\\n x = numpy.arange(len(df_allk))\\n if x[-1]<8:\\n fig = pl.figure(figsize = (8,6))\\n else:\\n fig = pl.figure(figsize = (len(x),6))\\n width = 1./(len(P.methods)+1)\\n elw = 30*width\\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\\n lines = tuple()\\n for name in P.methods:\\n y = [df_allk[i][name]/P.beta_report for i in x]\\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\\n lines += (line[0],)\\n pl.xlabel('States', fontsize=12, color='#151B54')\\n pl.ylabel('$\\\\Delta G$ '+P.units, fontsize=12, color='#151B54')\\n pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)\\n pl.yticks(fontsize=8)\\n pl.xlim(x[0], x[-1]+len(lines)*width)\\n ax = pl.gca()\\n for dir in ['right', 'top', 'bottom']:\\n ax.spines[dir].set_color('none')\\n ax.yaxis.set_ticks_position('left')\\n for tick in ax.get_xticklines():\\n tick.set_visible(False)\\n\\n leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)\\n leg.get_frame().set_alpha(0.5)\\n pl.title('The free energy change breakdown', fontsize = 12)\\n pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')\\n pl.close(fig)\\n return\",\n \"def deap_plot_hyp(stats, colour=\\\"blue\\\"):\\n plt.ion()\\n # plot hypervolumes\\n hyp = []\\n for gen in stats:\\n hyp.append(gen['hypervolume'])\\n plt.figure()\\n plt.plot(hyp, color=colour)\\n plt.xlabel(\\\"Function Evaluations\\\")\\n plt.ylabel(\\\"Hypervolume\\\")\",\n \"def plot_el(df, el, D, widths, lmbdas, to_pdf, is_sparse):\\n df_cut = df[df.elect == el]\\n fig, ax = plt.subplots(figsize=(8, 6))\\n ymax = 0.0\\n\\n for d in widths:\\n lbl = \\\"%i nm\\\" % d\\n sel = np.array(df_cut[[\\\"lmbda\\\", D]][df_cut.d == d])\\n\\n if el == \\\"Carbon\\\":\\n Nl = len(lmbdas)\\n eb = [1.0/i for i in range(1, Nl+1)]\\n plt.errorbar(sel[:, 0], sel[:, 1] * 1e9, yerr=eb, \\\\\\n fmt=\\\"D-\\\", lw=4, ms=10, mew=0, label=lbl)\\n else:\\n plt.plot(sel[:, 0], sel[:, 1] * 1e9, \\\\\\n \\\"D-\\\", lw=4, ms=10, mew=0, label=lbl)\\n\\n ymax_temp = (max(sel[:, 1] * 1e9) // 10 + 1) * 10 # round to 10s\\n if ymax_temp > ymax: ymax = ymax_temp\\n plt.ylim([0.0, ymax])\\n\\n plt.xlim([lmbdas[0]-1, lmbdas[-1]+1])\\n plt.xticks([4, 8, 12, 16, 20, 24])\\n plt.yticks(np.arange(0.0, ymax+1, 5))\\n plt.xlabel(\\\"$\\\\lambda$\\\")\\n ylbl = \\\"Normal\\\" if len(D) == 2 else \\\"Parralel\\\"\\n plt.ylabel(\\\"$D_{\\\\mathrm{%s}} \\\\; (10^{-9} \\\\; \\\\mathrm{m^2/s}) $\\\" % ylbl)\\n\\n plt.legend(loc=\\\"best\\\", fontsize=22)\\n# if el == \\\"Carbon\\\" and D == \\\"Dx\\\":\\n# plt.legend(loc=2, fontsize=22)\\n# if el == \\\"Carbon\\\" and D == \\\"Dyz\\\":\\n# plt.legend(loc=(0.5, 0.5), fontsize=22)\\n\\n plt.grid()\\n plt.title(el)\\n fmt = \\\"pdf\\\" if to_pdf else \\\"png\\\"\\n sp = \\\"_sp\\\" if is_sparse else \\\"\\\"\\n plotname = \\\"%s/%s_%s%s.%s\\\" % \\\\\\n (default_path, D, el.lower(), sp, fmt)\\n# plotname = default_path + D + \\\"_\\\" + el.lower() + fmt\\n plt.savefig(plotname, bbox_inches='tight')\",\n \"def investigate4DRepeatability():\\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\\n avgs = [1,2,4,8,16,32]\\n\\n #Temporal with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptemptilt = d[-1]-d[-2]\\n figtemptilt = d[-1]\\n\\n #Dynamic with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\\n #Make progressive averaging plot\\n plt.figure('DynamicTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdyntilt = d[-1]-d[-2]\\n figdyntilt = d[-1]\\n \\n #Temporal with fringes nulled\\n fn = glob.glob(parentdir+'Nulled/17*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalNulledFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptempnull = d[-1]-d[-2]\\n figtempnull = d[-1]\\n \\n #Dynamic with fringes nulled\\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\\n 'SolarBFlat/Repeatability/'\\n 'Nulled/170103_Processed.fits')\\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\\n #Make progressive averaging plot\\n plt.figure('DynamicNulledFigure')\\n for i in [0,1,3,7,15,31]:\\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(i+1))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdynnull = d[-1][0]-d[-1][1]\\n figdynnull = d[-1][0]\\n\\n #Make comparative repeatability plots with 32 averages\\n plt.figure('CompareRepeatability')\\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Repeatability - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make comparative figure plots with 32 averages\\n plt.figure('CompareFigure')\\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Figure - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make parroting repeatability plots\\n fig = plt.figure('Parroting')\\n fig.add_subplot(2,2,1)\\n plt.imshow(repdyntilt)\\n plt.title('Dynamic Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,2)\\n plt.imshow(reptemptilt)\\n plt.title('Temporal Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,3)\\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\\n plt.imshow(repdyntilt-res)\\n plt.title('Dynamic Repeatability Filtered')\\n plt.colorbar()\\n fig.add_subplot(2,2,4)\\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\\n plt.imshow(reptemptilt-res)\\n plt.title('Temporal Repeatability Filtered')\\n plt.colorbar()\",\n \"def test_2d_plot(self):\\n db = pd.HDFStore('test.h5')\\n df_iv = db['iv']\\n dates = df_iv[df_iv['dte'] == 30]['date']\\n impl_vols = df_iv[df_iv['dte'] == 30]['impl_vol']\\n db.close()\\n\\n print df_iv.sort_values('impl_vol').head()\\n\\n plt.plot(dates, impl_vols)\\n plt.xlabel('date')\\n plt.ylabel('impl_vols')\\n plt.show()\",\n \"def plot_tild_integrands(self):\\n fig, ax = plt.subplots()\\n lambdas = self.get_lambdas()\\n thermal_average, standard_error = self.get_tild_integrands()\\n ax.plot(lambdas, thermal_average, marker=\\\"o\\\")\\n ax.fill_between(\\n lambdas,\\n thermal_average - standard_error,\\n thermal_average + standard_error,\\n alpha=0.3,\\n )\\n ax.set_xlabel(\\\"Lambda\\\")\\n ax.set_ylabel(\\\"dF/dLambda\\\")\\n return fig, ax\",\n \"def _plot_dists_figure_2a(self, indexes = None, domain=None, two_landes=None, yrange=None, long=None, vline=None, params=None, different_stat =None, nolegend =None):\\n\\n bstat_stat = 'mean'\\n bstat_er = 'se'\\n\\n\\n if two_landes is None:\\n two_landes = False\\n\\n if nolegend is None:\\n nolegend = False\\n\\n if different_stat is None:\\n different_stat = False\\n elif not isinstance(different_stat, str):\\n different_stat = 'var'\\n\\n if indexes == None:\\n indexes = self.indexes\\n\\n if int is None:\\n long = False\\n\\n if int:\\n manyb = True\\n bstats = ['dist','dist_guess']\\n else:\\n manyb = False\\n bstats = ['dist']\\n\\n if different_stat:\\n bstats = [different_stat]\\n\\n if vline is None:\\n vline = False\\n\\n if params is None:\\n params = False\\n\\n indexes = indexes[:2]\\n\\n\\n undertext_params = [['N', 'U'], ['shift_s0', 'sigma_0_del'], ['f1', 's1', 's2']]\\n if not params:\\n undertext_params = []\\n params = []\\n else:\\n params =undertext_params\\n\\n\\n fewticks = False\\n the_colors = ['darkgreen', 'blue','cyan','limegreen']\\n the_colors_different = ['blue', 'cyan', 'darkgreen','limegreen']\\n\\n data_classes = [self.data_classes[indi] for indi in indexes]\\n\\n if self.data_classes[0].units_s0:\\n myunits = self.name_class.units\\n delti = False\\n myunits = ' in trait SD'\\n else:\\n myunits = r' (units $\\\\delta =\\\\omega/\\\\sqrt{2N}$)'\\n # myunits = r' (units $\\\\delta$)'\\n delti = True\\n\\n\\n plot_dict = dict()\\n plot_dict['xlabel'] = 'Generations after shift'\\n plot_dict['savedir'] = os.path.join(self.base_dir)\\n plot_dict['domain'] = domain\\n plot_dict['yrange'] = yrange\\n\\n plotspecs = dict()\\n if int:\\n plotspecs['fsize'] = (22, 5)\\n else:\\n plotspecs['fsize'] = (26, 14)\\n plotspecs['fsize'] = (26, 14)\\n\\n if different_stat:\\n plotspecs['fsize'] = (26, 8)\\n\\n plotspecs['dpi'] = 200\\n plotspecs['linewidth'] = 3.5\\n\\n plotspecs['ticksize'] = 34\\n\\n # plotspecs['nxticks'] = 3\\n\\n if fewticks:\\n plotspecs['nxticks'] = 2\\n plotspecs['nyticks'] = 2\\n\\n plotspecs['linewidth'] = 8\\n\\n _mylabel = ''\\n\\n #if bstats[0] == 'dist':\\n plotspecs['legend_loc'] = (0.98, 0.98)\\n plotspecs['legend_anchor'] = 'upper right'\\n if not delti:\\n plot_dict['ylabel'] = 'Distance from optimum ' + myunits + ' \\\\n'\\n else:\\n plot_dict['ylabel'] = myunits\\n if different_stat:\\n if different_stat == 'var':\\n plot_dict['ylabel'] = 'Variance'\\n plotspecs['ylabelspace'] = 1\\n elif different_stat == 'skewness':\\n plot_dict['ylabel'] = 'Skewness ' + r'($\\\\mu_{3}(t)/\\\\sigma^3 (t)$)'\\n else:\\n plot_dict['ylabel'] = different_stat\\n\\n\\n plotspecs['axis_font'] = {'fontname': 'Arial', 'size': '46'}\\n plotspecs['legend_font'] = {'size': '42'}\\n\\n #\\n # plotspecs['text_loc'] = [0.62, 0.5]\\n # plotspecs['text_color'] = 'indianred'\\n # plotspecs['text_size'] = 40\\n\\n\\n if vline:\\n #vlines = [data_classes[0].phase_2_time, data_classes[0].phase_3_time]\\n vlines = [data_classes[0].get_phase_two_time()]\\n plot_dict['vlines'] = vlines\\n plotspecs['vlinecolor'] = 'black'\\n plotspecs['vlineswidth'] = 4\\n\\n\\n if fewticks:\\n plotspecs['nyticks'] = 2\\n\\n plot_dict['plotspecs'] = plotspecs\\n\\n x = []\\n y = []\\n yer = []\\n ynames = []\\n linestyles = []\\n colors = []\\n len_y = 0\\n\\n\\n col_num = 0\\n for bstati in bstats:\\n first_data_class = True\\n for data_class in data_classes:\\n if bstati not in data_class._bstats:\\n print(bstati + \\\"not in\\\" + str(data_class.index))\\n return\\n\\n _mylabel += bstati\\n\\n for data_class in data_classes:\\n data = data_class.read_bstats(bstati)\\n times = sorted(data[bstati].keys())\\n yi = [data[bstati][tim][bstat_stat] for tim in times]\\n\\n style = '-'\\n if different_stat:\\n coli = the_colors_different[col_num]\\n else:\\n coli = the_colors[col_num]\\n\\n name = ''\\n lib = ''\\n if manyb:\\n nametemp = self.name_class.yname(bstati).split(\\\"(units\\\")\\n name += nametemp[0]\\n if bstati in self._theory_stats:\\n name = 'Simulations'\\n if len(data_classes) == 2:\\n if first_data_class:\\n name = 'Simulations Lande'\\n else:\\n name = 'Simulations non-Lande'\\n if params is None:\\n\\n if len(data_classes) > 1:\\n name += ' I:' + str(data_class.index)\\n lib += str(data_class.index)\\n else:\\n for param in params:\\n try:\\n name += param + ' = ' + '{0:.2f}'.format(data_class.param_dict[param]) + ' '\\n lib += param + '{0:.0f}'.format(data_class.param_dict[param]) + '_'\\n except KeyError:\\n print('KeyError: ' + param)\\n\\n if bstati == 'dist_guess':\\n if int:\\n name = 'Closed form approximation'\\n name = 'Quasi static approximation: ' + r'$\\\\mu_3 (t)/(2\\\\sigma^2 (t))$'\\n style = '--'\\n\\n if not (bstati == 'dist_guess' and first_data_class and len(data_classes) == 2):\\n col_num += 1\\n linestyles.append(style)\\n colors.append(coli)\\n len_y+=1\\n x.append(times)\\n y.append(yi)\\n ynames.append(name)\\n _mylabel = _mylabel + lib\\n first_data_class = False\\n\\n for bstati in bstats:\\n first_data_class = True\\n for data_class in data_classes:\\n if different_stat:\\n coli = the_colors_different[-1]\\n else:\\n coli = the_colors[-1]\\n if first_data_class:\\n style = '--'\\n else:\\n style = '-'\\n if first_data_class or two_landes:\\n if bstati =='var' or bstati == 'skewness' or bstati == 'mu3' or bstati in self._theory_stats and bstati != 'dist_guess':\\n if bstati =='var':\\n times = x[0]\\n var_0 = data_class.param_dict['var_0']\\n var_0 = 1.0\\n yi = [var_0 for _ in times]\\n ynami = 'Equilibrium variance'\\n elif bstati == 'skewness' or bstati == 'mu3':\\n times = x[0]\\n mu0 = 0\\n yi = [mu0 for _ in times]\\n if bstati == 'skewness':\\n ynami = 'Equilibrium skewness'\\n else:\\n ynami = 'Equilibrium third moment'\\n\\n elif bstati in self._theory_stats:\\n times, yi = self.theory_stat(data_class, bstati)\\n ynami = self.name_class.theory_yname(bstati)\\n\\n x.append(times)\\n y.append(yi)\\n len_y += 1\\n ynames.append(ynami)\\n colors.append(coli)\\n linestyles.append(style)\\n\\n first_data_class = False\\n\\n plot_dict['x'] = x\\n plot_dict['y'] = y\\n plot_dict['colors'] = colors\\n\\n\\n\\n if len(_mylabel) < 30:\\n plot_dict['label'] = _mylabel + '_many_cl'\\n else:\\n plot_dict['label'] = \\\"_\\\".join(bstats)\\n\\n # List with [text_top, text_bottom] containing relevant parameters\\n undertext = []\\n for listi in undertext_params:\\n text_list = self._plot_text(index_list=indexes, params_list=listi)\\n if text_list:\\n text_string = ', '.join(text_list)\\n undertext.append(text_string)\\n if len(ynames) > 1 and not nolegend:\\n plot_dict['ynames'] = ynames\\n\\n plot_dict['undertext'] = undertext\\n plot_dict['linestyles'] = linestyles\\n\\n plot_many_y(**plot_dict)\",\n \"def evidence_tuning_plots(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\",\\n x_name=\\\"Mean Predicted\\\",\\n y_name=\\\"Empirical Probability\\\"):\\n\\n def lineplot(x, y, trials, methods, **kwargs):\\n \\\"\\\"\\\"method_lineplot.\\n\\n Args:\\n y:\\n methods:\\n kwargs:\\n \\\"\\\"\\\"\\n uniq_methods = set(methods.values)\\n method_order = sorted(uniq_methods)\\n\\n method_new_names = [f\\\"$\\\\lambda={i:0.4f}$\\\" for i in method_order]\\n method_df = []\\n for method_idx, (method, method_new_name) in enumerate(zip(method_order,\\n method_new_names)):\\n lines_y = y[methods == method]\\n lines_x = x[methods == method]\\n for index, (xx, yy,trial) in enumerate(zip(lines_x, lines_y, trials)):\\n\\n to_append = [{x_name : x,\\n y_name: y,\\n \\\"Method\\\": method_new_name,\\n \\\"Trial\\\" : trial}\\n for i, (x,y) in enumerate(zip(xx,yy))]\\n method_df.extend(to_append)\\n method_df = pd.DataFrame(method_df)\\n x = np.linspace(0,1,100)\\n plt.plot(x, x, linestyle='--', color=\\\"black\\\")\\n sns.lineplot(x=x_name, y=y_name, hue=\\\"Method\\\",\\n alpha=0.8,\\n hue_order=method_new_names, data=method_df,)\\n # estimator=None, units = \\\"Trial\\\")\\n\\n df = df.copy()\\n # Query methods that have evidence_new_reg_2.0\\n df = df[[\\\"evidence\\\" in i for i in\\n df['method_name']]].reset_index()\\n\\n # Get the regularizer and reset coeff\\n coeff = [float(i.split(\\\"evidence_new_reg_\\\")[1]) for i in df['method_name']]\\n df[\\\"method_name\\\"] = coeff\\n df[\\\"Data\\\"] = convert_dataset_names(df[\\\"dataset\\\"])\\n df[\\\"Method\\\"] = df[\\\"method_name\\\"]\\n\\n g = sns.FacetGrid(df, col=\\\"Data\\\", height=6, sharex = False, sharey = False)\\n g.map(lineplot, x_input, y_input, \\\"trial_number\\\",\\n methods=df[\\\"Method\\\"]).add_legend()\",\n \"def makeaplot(events,\\n sensitivities,\\n hrf_estimates,\\n roi_pair,\\n fn=True):\\n import matplotlib.pyplot as plt\\n\\n # take the mean and transpose the sensitivities\\n sensitivities_stacked = mv.vstack(sensitivities)\\n\\n if bilateral:\\n sensitivities_stacked.sa['bilat_ROIs_str'] = map(lambda p: '_'.join(p),\\n sensitivities_stacked.sa.bilat_ROIs)\\n mean_sens = mv.mean_group_sample(['bilat_ROIs_str'])(sensitivities_stacked)\\n else:\\n sensitivities_stacked.sa['all_ROIs_str'] = map(lambda p: '_'.join(p),\\n sensitivities_stacked.sa.all_ROIs)\\n mean_sens = mv.mean_group_sample(['all_ROIs_str'])(sensitivities_stacked)\\n\\n mean_sens_transposed = mean_sens.get_mapped(mv.TransposeMapper())\\n\\n # some parameters\\n # get the conditions\\n block_design = sorted(np.unique(events['trial_type']))\\n reorder = [0, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11]\\n block_design = [block_design[i] for i in reorder]\\n # end indices to chunk timeseries into runs\\n run_startidx = np.array([0, 157, 313, 469])\\n run_endidx = np.array([156, 312, 468, 624])\\n\\n runs = np.unique(mean_sens_transposed.sa.chunks)\\n\\n for j in range(len(hrf_estimates.fa.bilat_ROIs_str)):\\n comparison = hrf_estimates.fa.bilat_ROIs[j][0]\\n if (roi_pair[0] in comparison) and (roi_pair[1] in comparison):\\n roi_pair_idx = j\\n roi_betas_ds = hrf_estimates[:, roi_pair_idx]\\n roi_sens_ds = mean_sens_transposed[:, roi_pair_idx]\\n\\n for run in runs:\\n fig, ax = plt.subplots(1, 1, figsize=[18, 10])\\n colors = ['#7b241c', '#e74c3c', '#154360', '#3498db', '#145a32', '#27ae60',\\n '#9a7d0a', '#f4d03f', '#5b2c6f', '#a569bd', '#616a6b', '#ccd1d1']\\n plt.suptitle('Timecourse of sensitivities, {} versus {}, run {}'.format(roi_pair[0],\\n roi_pair[1],\\n run + 1),\\n fontsize='large')\\n plt.xlim([0, max(mean_sens_transposed.sa.time_coords)])\\n plt.ylim([-5, 7])\\n plt.xlabel('Time in sec')\\n plt.legend(loc=1)\\n plt.grid(True)\\n # for each stimulus, plot a color band on top of the plot\\n for stimulus in block_design:\\n onsets = events[events['trial_type'] == stimulus]['onset'].values\\n durations = events[events['trial_type'] == stimulus]['duration'].values\\n stimulation_end = np.sum([onsets, durations], axis=0)\\n r_height = 1\\n color = colors[0]\\n y = 6\\n\\n # get the beta corresponding to the stimulus to later use in label\\n beta = roi_betas_ds.samples[hrf_estimates.sa.condition == stimulus.replace(\\\" \\\", \\\"\\\"), 0]\\n\\n for i in range(len(onsets)):\\n r_width = durations[i]\\n x = stimulation_end[i]\\n rectangle = plt.Rectangle((x, y),\\n r_width,\\n r_height,\\n fc=color,\\n alpha=0.5,\\n label='_'*i + stimulus.replace(\\\" \\\", \\\"\\\") + '(' + str('%.2f' % beta) + ')')\\n plt.gca().add_patch(rectangle)\\n plt.legend(loc=1)\\n del colors[0]\\n\\n times = roi_sens_ds.sa.time_coords[run_startidx[run]:run_endidx[run]]\\n\\n ax.plot(times, roi_sens_ds.samples[run_startidx[run]:run_endidx[run]], '-', color='black', lw=1.0)\\n glm_model = hrf_estimates.a.model.results_[0.0].predicted[run_startidx[run]:run_endidx[run], roi_pair_idx]\\n ax.plot(times, glm_model, '-', color='#7b241c', lw=1.0)\\n model_fit = hrf_estimates.a.model.results_[0.0].R2[roi_pair_idx]\\n plt.title('R squared: %.2f' % model_fit)\\n if fn:\\n plt.savefig(results_dir + 'timecourse_localizer_glm_sens_{}_vs_{}_run-{}.svg'.format(roi_pair[0], roi_pair[1], run + 1))\",\n \"def plot_DA(filename):\\n\\n # Set up an array of redshift values.\\n dz = 0.1\\n z = numpy.arange(0., 10. + dz, dz)\\n\\n # Set up a cosmology dictionary, with an array of matter density values.\\n cosmo = {}\\n dom = 0.01\\n om = numpy.atleast_2d(numpy.linspace(0.1, 1.0, (1.-0.1)/dom)).transpose()\\n cosmo['omega_M_0'] = om\\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\\n cosmo['h'] = 0.701\\n cosmo['omega_k_0'] = 0.0\\n\\n # Calculate the hubble distance.\\n dh = cd.hubble_distance_z(0, **cosmo)\\n # Calculate the angular diameter distance.\\n da = cd.angular_diameter_distance(z, **cosmo)\\n\\n # Make plots.\\n plot_dist(z, dz, om, dom, da, dh, 'angular diameter distance', r'D_A',\\n filename)\\n plot_dist_ony(z, dz, om, dom, da, dh, 'angular diameter distance', r'D_A',\\n filename)\",\n \"def plotLambdaDependency(folder='results/', analysis='good', sigma=3):\\n matplotlib.rc('text', usetex=True)\\n if 'ind' in analysis:\\n print 'Individual Results'\\n data800 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm*.pkl')]\\n data600 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm54*.pkl')]\\n data700 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm52*.pkl')]\\n data890 = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm50*.pkl')]\\n data = (data600, data700, data800, data890)\\n datacontainer = []\\n for x in data:\\n wx = np.median([d['wx'] for d in x])\\n wxerr = np.median([d['wxerr'] for d in x])\\n wy = np.median([d['wy'] for d in x])\\n wyerr = np.median([d['wyerr'] for d in x])\\n dat = dict(wx=wx, wy=wy, wxerr=wxerr, wyerr=wyerr)\\n datacontainer.append(dat)\\n data = datacontainer\\n waves = [600, 700, 800, 890]\\n elif 'join' in analysis:\\n print 'Joint Results'\\n data800nm = fileIO.cPicleRead(folder+'J800nm.pkl')\\n data600nm = fileIO.cPicleRead(folder+'J600nm54k.pkl')\\n data700nm = fileIO.cPicleRead(folder+'J700nm52k.pkl')\\n data890nm = fileIO.cPicleRead(folder+'J890nm50k.pkl')\\n data = (data600nm, data700nm, data800nm, data890nm)\\n waves = [int(d['wavelength'].replace('nm', '')) for d in data]\\n else:\\n print 'Using subset of data'\\n #data600nm = fileIO.cPicleRead(folder+'G600nm0.pkl')\\n data600nm = fileIO.cPicleRead(folder+'J600nm54k.pkl')\\n #data700nm = fileIO.cPicleRead(folder+'G700nm0.pkl')\\n data700nm = fileIO.cPicleRead(folder+'J700nm52k.pkl')\\n #data800nm = fileIO.cPicleRead(folder+'G800nm0.pkl')\\n data800nm = fileIO.cPicleRead(folder+'J800nm.pkl')\\n #data890nm = fileIO.cPicleRead(folder+'G890nm0.pkl')\\n data890nm = fileIO.cPicleRead(folder+'J890nm50k.pkl')\\n data = (data600nm, data700nm, data800nm, data890nm)\\n waves = [600, 700, 800, 890]\\n\\n wx = np.asarray([_FWHMGauss(d['wx']) for d in data])\\n wxerr = np.asarray([_FWHMGauss(d['wxerr']) for d in data])\\n wypix = np.asarray([d['wy'] for d in data])\\n wy = _FWHMGauss(wypix)\\n wyerrpix = np.asarray([d['wyerr'] for d in data])\\n wyerr = _FWHMGauss(wyerrpix)\\n waves = np.asarray(waves)\\n\\n w = np.sqrt(wx*wy)\\n werr = np.sqrt(wxerr*wyerr)\\n\\n print zip(waves, w)\\n\\n #plot FWHM\\n fig = plt.figure()\\n ax1 = fig.add_subplot(311)\\n ax2 = fig.add_subplot(312)\\n ax3 = fig.add_subplot(313)\\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.95)\\n ax1.set_title('CCD273 PSF Wavelength Dependency')\\n\\n ax1.errorbar(waves, wx, yerr=sigma*wxerr/3., fmt='o', label='Data')\\n ax2.errorbar(waves, wy, yerr=sigma**wyerr/3., fmt='o', label='Data')\\n ax3.errorbar(waves, w, yerr=sigma*werr, fmt='o', label='Data')\\n\\n #fit a power law\\n fitfunc = lambda p, x: p[0] * x ** p[1]\\n errfunc = lambda p, x, y: fitfunc(p, x) - y\\n fit1, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, wx))\\n fit2, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, wy))\\n fit3, success = optimize.leastsq(errfunc, [1, -0.2], args=(waves, w))\\n\\n #requirement\\n alpha=0.2\\n x = np.arange(500, 950, 1)\\n y = 37*x**-alpha\\n # compute the best fit function from the best fit parameters\\n corrfit1 = fitfunc(fit1, x)\\n corrfit2 = fitfunc(fit2, x)\\n corrfit3 = fitfunc(fit3, x)\\n print 'Slope:', fit1[1]\\n print 'Slope:', fit2[1]\\n print 'Slope [requirement < -0.2]:', fit3[1]\\n\\n #ax1.plot(x, corrfit1, 'k-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (fit1[1]))\\n #ax2.plot(x, corrfit2, 'k-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (fit2[1]))\\n ax3.plot(x, y, 'r-', label=r'Requirement: $\\\\alpha \\\\leq - %.1f$' % alpha)\\n #ax3.plot(x, corrfit3, 'k-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (fit3[1]))\\n\\n # Bayesian\\n shift = 0.\\n waves -= shift\\n px, paramsx, errorsx, outliersx = powerlawFitWithOutliers(waves, wx, wxerr, outtriangle='WFWHMx.png')\\n py, paramsy, errorsy, outliersy = powerlawFitWithOutliers(waves, wy, wyerr, outtriangle='WFWHMy.png')\\n p, params, errors, outliers = powerlawFitWithOutliers(waves, w, werr, outtriangle='WFWHM.png')\\n print paramsx[::-1], errorsx[::-1]\\n print paramsy[::-1], errorsy[::-1]\\n print params[::-1], errors[::-1]\\n\\n ax1.plot(x, paramsx[0]*(x-shift)**paramsx[1], 'g-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (paramsx[1]))\\n ax2.plot(x, paramsy[0]*(x-shift)**paramsy[1], 'g-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (paramsy[1]))\\n ax3.plot(x, params[0]*(x-shift)**params[1], 'g-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (params[1]))\\n\\n plt.sca(ax1)\\n plt.xticks(visible=False)\\n plt.sca(ax2)\\n plt.xticks(visible=False)\\n plt.sca(ax3)\\n\\n ax1.set_ylim(6.6, 13.5)\\n ax2.set_ylim(6.6, 13.5)\\n ax3.set_ylim(6.6, 13.5)\\n ax1.set_xlim(550, 900)\\n ax2.set_xlim(550, 900)\\n ax3.set_xlim(550, 900)\\n\\n ax1.set_ylabel(r'FWHM$_{X} \\\\, [\\\\mu$m$]$')\\n ax2.set_ylabel(r'FWHM$_{Y} \\\\, [\\\\mu$m$]$')\\n ax3.set_ylabel(r'FWHM$\\\\, [\\\\mu$m$]$')\\n ax3.set_xlabel('Wavelength [nm]')\\n ax1.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\\n ax2.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\\n ax3.legend(shadow=True, fancybox=True, loc='best', numpoints=1)\\n plt.savefig('LambdaDependency.pdf')\\n plt.close()\\n\\n print 'R2:'\\n R2 = _R2FromGaussian(wxpix, wypix)*1e3\\n print zip(waves, R2)\\n errR2 = _R2err(wxpix, wypix, wxerrpix, wyerrpix)*1e3\\n p, params, errors, outliers = powerlawFitWithOutliers(waves, R2, errR2, outtriangle='WR2.png')\\n print params[::-1], errors[::-1]\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(211)\\n ax2 = fig.add_subplot(212)\\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\\n ax1.set_title('CCD273 PSF Wavelength Dependency')\\n ax1.errorbar(waves, R2, yerr=sigma*errR2, fmt='o', label='Data')\\n ax1.plot(x, params[0] * (x - shift)**params[1], 'm-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (params[1]))\\n #ax1.plot(waves[outliers], R2[outliers], 'ro', ms=20, mfc='none', mec='red')\\n ax1.set_ylabel(r'R^{2} \\\\, [$mas$^{2}]$')\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n\\n print 'Ellipticity:'\\n ell = _ellipticityFromGaussian(wxpix, wypix) + 1\\n print zip(waves, ell)\\n ellerr = _ellipticityerr(wxpix, wypix, wxerrpix, wyerrpix)\\n p, params, errors, outliers = powerlawFitWithOutliers(waves, ell, ellerr, outtriangle='Well.png')\\n print params[::-1], errors[::-1]\\n\\n fitfunc = lambda p, x: p[0] * x ** p[1]\\n errfunc = lambda p, x, y: fitfunc(p, x) - y\\n fit1, success = optimize.leastsq(errfunc, [2., -0.1], args=(waves, ell), maxfev=100000)\\n print fit1[::-1]\\n\\n ax2.errorbar(waves, ell, yerr=sigma*ellerr, fmt='o', label='Data')\\n ax2.plot(x, params[0] * (x - shift)**params[1], 'm-', label=r'Power Law Fit: $\\\\alpha \\\\sim %.2f $' % (params[1]))\\n #ax2.plot(waves[outliers], ell[outliers], 'ro', ms=20, mfc='none', mec='red')\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n ax2.legend(shadow=True, fancybox=True, numpoints=1)\\n ax2.set_ylabel('Ellipticity')\\n\\n ax1.set_ylim(0.65, 2.5)\\n ax2.set_ylim(1+-0.01, 1+0.16)\\n\\n plt.sca(ax1)\\n plt.xticks(visible=False)\\n\\n plt.savefig('LambdaR2ell.pdf')\\n plt.close()\",\n \"def plotdFvsLambda2(nb=10):\\n x = numpy.arange(len(df_allk))\\n if len(x) < nb:\\n return\\n xs = numpy.array_split(x, len(x)/nb+1)\\n mnb = max([len(i) for i in xs])\\n fig = pl.figure(figsize = (8,6))\\n width = 1./(len(P.methods)+1)\\n elw = 30*width\\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}\\n ndx = 1\\n for x in xs:\\n lines = tuple()\\n ax = pl.subplot(len(xs), 1, ndx)\\n for name in P.methods:\\n y = [df_allk[i][name]/P.beta_report for i in x]\\n ye = [ddf_allk[i][name]/P.beta_report for i in x]\\n line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.05*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))\\n lines += (line[0],)\\n for dir in ['left', 'right', 'top', 'bottom']:\\n if dir == 'left':\\n ax.yaxis.set_ticks_position(dir)\\n else:\\n ax.spines[dir].set_color('none')\\n pl.yticks(fontsize=10)\\n ax.xaxis.set_ticks([])\\n for i in x+0.5*width*len(P.methods):\\n ax.annotate('$\\\\mathrm{%d-%d}$' % (i, i+1), xy=(i, 0), xycoords=('data', 'axes fraction'), xytext=(0, -2), size=10, textcoords='offset points', va='top', ha='center')\\n pl.xlim(x[0], x[-1]+len(lines)*width + (mnb - len(x)))\\n ndx += 1\\n leg = ax.legend(lines, tuple(P.methods), loc=0, ncol=2, prop=FP(size=8), title='$\\\\mathrm{\\\\Delta G\\\\/%s\\\\/}\\\\mathit{vs.}\\\\/\\\\mathrm{lambda\\\\/pair}$' % P.units, fancybox=True)\\n leg.get_frame().set_alpha(0.5)\\n pl.savefig(os.path.join(P.output_directory, 'dF_state.pdf'), bbox_inches='tight')\\n pl.close(fig)\\n return\",\n \"def EDA(data):\\n\\t# mean value curve\\n\\n\\tfig,axs = plt.subplots(5,1, sharey='all')\\n\\tfig.set_size_inches(10, 15)\\n\\tdata.groupby('weather').mean().plot(y='count', marker='o', ax=axs[0])\\n\\tdata.groupby('humidity').mean().plot(y='count', marker='o', ax=axs[1])\\n\\tdata.groupby('temp').mean().plot(y='count', marker='o', ax=axs[2])\\n\\tdata.groupby('windspeed').mean().plot(y='count', marker='o', ax=axs[3])\\n\\tprint('\\\\n')\\n\\tdata.groupby('hour').mean().plot(y='count', marker='o', ax=axs[4])\\n\\tplt.title('mean count per hour')\\n\\tplt.tight_layout()\\n\\tplt.show()\\n\\n\\t# grouping scatter\\n\\tfig,axs = plt.subplots(2,3, sharey='all')\\n\\tfig.set_size_inches(12, 8)\\n\\tdata.plot(x='temp', y='count', kind='scatter', ax=axs[0,0], color='magenta')\\n\\tdata.plot(x='humidity', y='count', kind='scatter', ax=axs[0,1], color='bisque')\\n\\tdata.plot(x='windspeed', y='count', kind='scatter', ax=axs[0,2], color='coral')\\n\\tdata.plot(x='month', y='count', kind='scatter', ax=axs[1,0], color='darkblue')\\n\\tdata.plot(x='day', y='count', kind='scatter', ax=axs[1,1], color='cyan')\\n\\tdata.plot(x='hour', y='count', kind='scatter', ax=axs[1,2], color='deeppink')\\n\\tplt.tight_layout()\\n\\tplt.show()\\n\\n\\t# correlation analysis\\n\\tcorrMatt = data[[\\\"temp\\\",\\\"atemp\\\",\\\"casual\\\",\\\"registered\\\",\\\"humidity\\\",\\\"windspeed\\\",\\\"count\\\"]].corr()\\n\\tmask = np.array(corrMatt)\\n\\tmask[np.tril_indices_from(mask)] = False\\n\\n\\tfig,ax= plt.subplots()\\n\\tfig.set_size_inches(20,10)\\n\\tsn.heatmap(corrMatt, mask=mask, vmax=.8, square=True, annot=True, cmap=\\\"Greens\\\")\\n\\tplt.show()\",\n \"def main(\\n error_band_dir,\\n output_dir,\\n indep_var,\\n ivar_start,\\n ivar_stop,\\n ivar_step,\\n param_list,\\n observable_list,\\n Lambda_b,\\n lambda_mult,\\n p_decimal_list,\\n orders,\\n ignore_orders,\\n interaction,\\n X_ref_hash,\\n prior_set,\\n h,\\n cbar_lower,\\n cbar_upper,\\n sigma,\\n convention\\n ):\\n\\n color_dict = {\\n \\\"LOp\\\": plt.get_cmap(\\\"Greys\\\"),\\n \\\"LO\\\": plt.get_cmap(\\\"Purples\\\"),\\n \\\"NLO\\\": plt.get_cmap(\\\"Oranges\\\"),\\n \\\"N2LO\\\": plt.get_cmap(\\\"Greens\\\"),\\n \\\"N3LO\\\": plt.get_cmap(\\\"Blues\\\"),\\n \\\"N4LO\\\": plt.get_cmap(\\\"Reds\\\")\\n }\\n\\n fill_transparency = 1\\n x = np.arange(ivar_start, ivar_stop, ivar_step)\\n\\n fig = plt.figure(figsize=(3.4, 3.4))\\n ax = fig.add_subplot(1, 1, 1)\\n ax.set_zorder(15)\\n ax.set_axisbelow(False)\\n\\n if indep_var == \\\"theta\\\":\\n param_var = \\\"energy\\\"\\n indep_var_label = r\\\"$\\\\theta$ (deg)\\\"\\n param_var_label = r\\\"$E_{\\\\mathrm{lab}}\\\"\\n param_var_units = r\\\"$ MeV\\\"\\n xmin = 0\\n xmax = 180\\n else:\\n param_var = \\\"theta\\\"\\n indep_var_label = r\\\"$E$ (MeV)\\\"\\n param_var_label = r\\\"$\\\\theta\\\"\\n param_var_units = r\\\"^\\\\circ$\\\"\\n xmin = 0\\n xmax = 350\\n\\n for observable in observable_list:\\n for param in param_list:\\n if observable == [\\\"t\\\", \\\"t\\\", \\\"t\\\", \\\"t\\\"] or \\\\\\n (observable == [\\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\"] and indep_var == \\\"energy\\\"):\\n ax.set_yscale(\\\"log\\\", nonposy='clip')\\n\\n ax.set_xlabel(indep_var_label)\\n # ax.set_ylabel('')\\n\\n # if indep_var == \\\"theta\\\":\\n # major_tick_spacing = 60\\n # minor_tick_spacing = 20\\n # ax.xaxis.set_major_locator(\\n # ticker.MultipleLocator(major_tick_spacing))\\n # ax.xaxis.set_minor_locator(\\n # ticker.MultipleLocator(minor_tick_spacing))\\n\\n if indep_var == \\\"energy\\\":\\n major_ticks = np.arange(0, 351, 100)\\n # minor_ticks = np.arange(50, 351, 100)\\n x_minor_locator = AutoMinorLocator(n=2)\\n elif indep_var == \\\"theta\\\":\\n major_ticks = np.arange(0, 181, 60)\\n # minor_ticks = np.arange(0, 181, 20)\\n x_minor_locator = AutoMinorLocator(n=3)\\n\\n ax.xaxis.set_minor_locator(x_minor_locator)\\n ax.set_xticks(major_ticks)\\n\\n # Create the description box\\n # text_str = r\\\"$C_{\\\" + observable[0] + observable[1] + \\\\\\n # observable[2] + observable[3] + r\\\"}$\\\" + \\\", \\\" # + \\\"\\\\n\\\"\\n text_str = indices_to_observable_name(observable)\\n if observable == ['t', 't', 't', 't']:\\n text_str += \\\" (mb)\\\"\\n elif observable == ['0', '0', '0', '0']:\\n text_str += \\\" (mb/sr)\\\"\\n\\n # Probably don't include this extra info. Leave for caption.\\n #\\n # text_str += \\\", \\\"\\n # if observable != ['t', 't', 't', 't']:\\n # text_str += \\\", \\\" + param_var_label + r\\\" = \\\" + str(param) + param_var_units + \\\", \\\" # + \\\"\\\\n\\\"\\n # text_str += r\\\"$\\\\Lambda_b = \\\" + str(lambda_mult*Lambda_b) + r\\\"$ MeV\\\"\\n\\n # Don't put in a text box\\n #\\n # ax.text(.5, .96, text_str,\\n # horizontalalignment='center',\\n # verticalalignment='top',\\n # multialignment='center',\\n # transform=ax.transAxes,\\n # bbox=dict(facecolor='white', alpha=1, boxstyle='square', pad=.5),\\n # zorder=20)\\n\\n # Don't put in the title\\n # plt.title(text_str, fontsize=10)\\n\\n # Instead use y axis\\n ax.set_ylabel(text_str, fontsize=10)\\n legend_patches = []\\n\\n try:\\n npwa_name = npwa_filename(observable, param_var, param)\\n npwa_file = DataFile().read(os.path.join(\\\"../npwa_data/\\\", npwa_name))\\n npwa_plot, = ax.plot(npwa_file[0], npwa_file[1],\\n color=\\\"black\\\", linewidth=1,\\n label=\\\"NPWA\\\", zorder=10,\\n linestyle=\\\"--\\\")\\n except FileNotFoundError:\\n npwa_plot = None\\n\\n # First get global min/max of all orders\\n for i, order in enumerate(orders):\\n # obs_name = observable_filename(\\n # observable, indep_var, ivar_start, ivar_stop,\\n # ivar_step, param_var, param, order)\\n # dob_name = dob_filename(p_decimal_list[0], Lambda_b, obs_name)\\n dob_name = dob_filename(\\n observable, indep_var, ivar_start, ivar_stop,\\n ivar_step, param_var, param, order, ignore_orders,\\n Lambda_b, lambda_mult, X_ref_hash,\\n p_decimal_list[0], prior_set, h, convention, None,\\n cbar_lower, cbar_upper, sigma,\\n potential_info=None)\\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\\n if i == 0:\\n obs = dob_file[1]\\n obs_min = np.min(obs)\\n obs_max = np.max(obs)\\n else:\\n old_obs = obs\\n obs = dob_file[1]\\n # Probably the worst way to do this.\\n obs_min = min(np.min(np.minimum(old_obs, obs)), obs_min)\\n obs_max = max(np.max(np.maximum(old_obs, obs)), obs_max)\\n\\n # Decide the padding above/below the lines\\n # This weights values far from 0 more heavily.\\n # ymin = obs_min - .25 * abs(obs_min)\\n # ymax = obs_max + .25 * abs(obs_max)\\n ymin = -1\\n ymax = 20\\n ax.set_ylim([ymin, ymax])\\n # ax.set_xlim([ivar_start, ivar_stop-1])\\n ax.set_xlim([xmin, xmax])\\n\\n # Start layering the plots\\n for i, order in enumerate(orders):\\n # obs_name = observable_filename(\\n # observable, indep_var, ivar_start, ivar_stop,\\n # ivar_step, param_var, param, order)\\n # dob_name = dob_filename(p_decimal_list[0], Lambda_b, obs_name)\\n dob_name = dob_filename(\\n observable, indep_var, ivar_start, ivar_stop,\\n ivar_step, param_var, param, order, ignore_orders,\\n Lambda_b, lambda_mult, X_ref_hash,\\n p_decimal_list[0], prior_set, h, convention, None,\\n cbar_lower, cbar_upper, sigma,\\n potential_info=None)\\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\\n\\n # Plot the lines\\n obs = dob_file[1]\\n ax.plot(x, obs, color=color_dict[order](.99), zorder=i)\\n\\n # Plot the error bands\\n for band_num, p in enumerate(sorted(p_decimal_list, reverse=True)):\\n # dob_name = dob_filename(p, Lambda_b, obs_name)\\n dob_name = dob_filename(\\n observable, indep_var, ivar_start, ivar_stop,\\n ivar_step, param_var, param, order, ignore_orders,\\n Lambda_b, lambda_mult, X_ref_hash,\\n p, prior_set, h, convention, None,\\n cbar_lower, cbar_upper, sigma,\\n potential_info=None)\\n dob_file = DataFile().read(os.path.join(error_band_dir, dob_name))\\n obs_lower = dob_file[2]\\n obs_upper = dob_file[3]\\n ax.fill_between(\\n x, obs_lower, obs_upper,\\n facecolor=color_dict[order](\\n (band_num + 1) / (len(p_decimal_list) + 1)\\n ),\\n color=color_dict[order](\\n (band_num + 1) / (len(p_decimal_list) + 1)\\n ),\\n alpha=fill_transparency, interpolate=True, zorder=i)\\n\\n # Use block patches instead of lines\\n # Use innermost \\\"dark\\\" color of bands for legend\\n # legend_patches.append(\\n # mp.patches.Patch(\\n # color=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\\n # label=order,\\n # ))\\n legend_patches.append(\\n mpatches.Rectangle(\\n (1, 1), 0.25, 0.25,\\n # color=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\\n edgecolor=color_dict[order](.9),\\n facecolor=color_dict[order](len(p_decimal_list) / (len(p_decimal_list) + 1)),\\n label=order,\\n linewidth=1\\n ))\\n\\n if npwa_plot is None:\\n my_handles = legend_patches\\n handler_dict = dict(zip(my_handles, [HandlerSquare() for i in legend_patches]))\\n else:\\n my_handles = [npwa_plot, *legend_patches]\\n squares = [HandlerSquare() for i in legend_patches]\\n line = HandlerLine2D(marker_pad=1, numpoints=None)\\n handler_dict = dict(zip(my_handles, [line] + squares))\\n\\n ax.legend(loc=\\\"best\\\", handles=my_handles,\\n handler_map=handler_dict,\\n handletextpad=.8,\\n handlelength=.6,\\n fontsize=8)\\n\\n # Squeeze and save it\\n plt.tight_layout()\\n # plot_name = plot_obs_error_bands_filename(\\n # observable, indep_var, ivar_start, ivar_stop,\\n # ivar_step, param_var, param, orders[:i+1],\\n # Lambda_b, p_decimal_list)\\n plot_name = plot_obs_error_bands_filename(\\n observable, indep_var, ivar_start, ivar_stop, ivar_step,\\n param_var, param, orders[:i+1], ignore_orders, Lambda_b,\\n lambda_mult, X_ref_hash, p_decimal_list,\\n prior_set, h, convention, None, cbar_lower, cbar_upper,\\n sigma, potential_info=None)\\n fig.savefig(os.path.join(output_dir, plot_name), bbox_inches=\\\"tight\\\")\\n\\n call([\\\"epstopdf\\\", os.path.join(output_dir, plot_name)])\\n call([\\\"rm\\\", os.path.join(output_dir, plot_name)])\\n\\n # Clear the axes for the next observable/parameter.\\n plt.cla()\",\n \"def test_plot_hid(self):\\n # also produce a light curve with the same binning\\n command = ('{0} -b 100 --e-interval {1} {2}').format(\\n os.path.join(self.datadir, 'monol_testA_nustar_fpma_ev_calib' +\\n HEN_FILE_EXTENSION), 3, 10)\\n\\n hen.lcurve.main(command.split())\\n lname = os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_E3-10_lc') + \\\\\\n HEN_FILE_EXTENSION\\n os.path.exists(lname)\\n cname = os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\\\\n HEN_FILE_EXTENSION\\n hen.plot.main([cname, lname, '--noplot', '--xlog', '--ylog', '--HID',\\n '-o', 'dummy.qdp'])\",\n \"def make_area_plots(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\"):\\n\\n df = df.copy()\\n\\n # Get the regularizer and reset coeff\\n coeff = [float(i.split(\\\"evidence_new_reg_\\\")[1]) if \\\"evidence\\\" in i else i for i in df['method_name']]\\n df[\\\"method_name\\\"] = coeff\\n df[\\\"Data\\\"] = convert_dataset_names(df[\\\"dataset\\\"])\\n df[\\\"Method\\\"] = df[\\\"method_name\\\"]\\n\\n trials = 'trial_number'\\n methods = 'Method'\\n\\n # Make area plot\\n uniq_methods = set(df[\\\"Method\\\"].values)\\n method_order = sorted(uniq_methods,\\n key=lambda x : x if isinstance(x, float) else -1)\\n method_df = []\\n datasets = set()\\n for data, sub_df in df.groupby(\\\"Data\\\"):\\n # Add datasets\\n datasets.add(data)\\n x_vals = sub_df[x_input]\\n y_vals = sub_df[y_input]\\n methods_sub = sub_df[\\\"Method\\\"]\\n trials_sub= sub_df['trial_number']\\n for method_idx, method in enumerate(method_order):\\n # Now summarize these lines\\n bool_select = (methods_sub == method)\\n lines_y = y_vals[bool_select]\\n lines_x = x_vals[bool_select]\\n trials_temp = trials_sub[bool_select]\\n areas = []\\n # create area!\\n for trial, line_x, line_y in zip(trials_sub, lines_x, lines_y):\\n new_y = np.abs(np.array(line_y) - np.array(line_x))\\n area = simps(new_y, line_x)\\n to_append = {\\\"Area from parity\\\": area,\\n \\\"Regularizer Coeff, $\\\\lambda$\\\": method,\\n \\\"method_name\\\": method,\\n \\\"Data\\\": data,\\n \\\"Trial\\\" : trial}\\n method_df.append(to_append)\\n method_df = pd.DataFrame(method_df)\\n method_df_evidence = method_df[[isinstance(i, float) for i in\\n method_df['method_name']]].reset_index()\\n method_df_ensemble = method_df[[\\\"ensemble\\\" in str(i) for i in\\n method_df['method_name']]].reset_index()\\n data_colors = {\\n dataset : sns.color_palette()[index]\\n for index, dataset in enumerate(datasets)\\n }\\n\\n min_x = np.min(method_df_evidence[\\\"Regularizer Coeff, $\\\\lambda$\\\"])\\n max_x= np.max(method_df_evidence[\\\"Regularizer Coeff, $\\\\lambda$\\\"])\\n\\n sns.lineplot(x=\\\"Regularizer Coeff, $\\\\lambda$\\\", y=\\\"Area from parity\\\",\\n hue=\\\"Data\\\", alpha=0.8, data=method_df_evidence,\\n palette = data_colors)\\n\\n for data, subdf in method_df_ensemble.groupby(\\\"Data\\\"):\\n\\n color = data_colors[data]\\n area = subdf[\\\"Area from parity\\\"].mean()\\n std = subdf[\\\"Area from parity\\\"].std()\\n plt.hlines(area, min_x, max_x, linestyle=\\\"--\\\", color=color, alpha=0.8)\\n\\n ensemble_line = plt.plot([], [], color='black', linestyle=\\\"--\\\",\\n label=\\\"Ensemble\\\")\\n # Now make ensemble plots\\n plt.legend(bbox_to_anchor=(1.1, 1.05))\",\n \"def plot_hill_func(self,sim_run=None,trace=0,synapse=0,average=False):\\n\\n if sim_run is None:\\n sim_run = self.default_runs[0]\\n\\n cav_hits = sim_run.data[\\\"Ca_t\\\"][:,trace,synapse]\\n\\n p_v_func = hill(np.arange(200)/100.,S=1,ec50=sim_run.params[\\\"ca_ec50\\\"],n=sim_run.params[\\\"ca_coop\\\"])\\n plt.plot(np.arange(200)/100.,p_v_func)\\n for i in range(len(cav_hits)):\\n plt.plot((cav_hits[i],cav_hits[i]),(0,1))\\n plt.ylabel('Probbility of Vesicle Release')\\n plt.xlabel('Calcium Concentration (arb. units)')\\n plt.title('Location of [Ca] response on Hill Function for sequential APs')\\n plt.show()\",\n \"def view_datashade(self):\\n # Select only sufficient data\\n if self.x in self.y:\\n self.y.remove(self.x)\\n if self.y == []:\\n return self.gif\\n\\n df = self.dataframe[[self.x] + self.y].copy()\\n plot_opts = {\\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\\n\\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\\n # Compute\\n dataframe = df.copy()\\n if x_range is not None:\\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\\n data_length = len(dataframe) * len(dataframe.columns)\\n step = 1 if data_length < self.max_step else data_length // self.max_step\\n \\n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\\\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \\n plot_opts = {\\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n if len(self.y) != 1:\\n plot_opts['Scatter']['color'] = self.color_key\\n return plot_df.options(plot_opts)\\n\\n # Define a RangeXY stream linked to the image\\n rangex = hv.streams.RangeX(source=lines_overlay)\\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\\n if len(self.y) == 1:\\n data_shade_plot *= datashade(lines_overlay)\\n else:\\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\\n return pn.panel(data_shade_plot)\",\n \"def dline_tdepl_array(lines,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig, axs = plt.subplots(len(lines), sharex='col',\\\\\\n figsize=(6,15),facecolor='w',\\\\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\\n\\n for i,ax in enumerate(axs):\\n\\n dline_tdepl(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add=True,cb=True)\\n dline_tdepl(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add=True,cb=False)\\n\\n plt.tight_layout()\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/dlines_tdepl_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)\",\n \"def plot_lfads(x_txd, avg_lfads_dict, data_dict=None, dd_bidx=None,\\n renorm_fun=None):\\n print(\\\"bidx: \\\", dd_bidx)\\n ld = avg_lfads_dict\\n\\n def remove_outliers(A, nstds=3):\\n clip = nstds * onp.std(A)\\n A_mean = onp.mean(A)\\n A_show = onp.where(A < A_mean - clip, A_mean - clip, A)\\n return onp.where(A_show > A_mean + clip, A_mean + clip, A_show)\\n \\n f = plt.figure(figsize=(12,12))\\n plt.subplot(361)\\n plt.imshow(x_txd.T)\\n plt.title('x')\\n\\n plt.subplot(362)\\n x_enc = remove_outliers(ld['xenc_t'])\\n plt.imshow(x_enc.T)\\n plt.title('x enc')\\n\\n plt.subplot(363)\\n gen = remove_outliers(ld['gen_t'])\\n plt.imshow(gen.T)\\n plt.title('generator')\\n\\n plt.subplot(364)\\n factors = remove_outliers(ld['factor_t'])\\n plt.imshow(factors.T)\\n plt.title('factors')\\n\\n if data_dict is not None:\\n true_rates = renorm_fun(data_dict['hiddens'][dd_bidx])\\n plt.subplot(366)\\n plt.imshow(true_rates.T)\\n plt.title('True rates')\\n\\n plt.subplot(365)\\n rates = remove_outliers(onp.exp(ld['lograte_t']))\\n plt.imshow(rates.T)\\n plt.title('rates') \\n\\n plt.subplot(334)\\n ic_mean = ld['ic_mean']\\n ic_std = onp.exp(0.5*ld['ic_logvar'])\\n plt.stem(ic_mean)\\n plt.title('g0 mean')\\n\\n plt.subplot(335)\\n con = remove_outliers(ld['c_t'])\\n plt.imshow(con.T)\\n plt.title('controller')\\n\\n plt.subplot(336)\\n ii_mean = ld['ii_mean_t']\\n plt.plot(ii_mean, 'b')\\n if data_dict is not None:\\n true_input = data_dict['inputs'][dd_bidx]\\n slope, intercept, r_value, p_value, std_err = \\\\\\n stats.linregress(true_input.T, ii_mean.T)\\n plt.plot(slope*true_input + intercept, 'm', lw=2)\\n #plt.plot(ld['ii_t'], 'k')\\n plt.title('inferred input mean')\\n plt.legend(('LFADS inferred input', 'rescaled true input to integrator RNN'))\\n \\n plt.subplot(313)\\n ntoplot=8\\n a = 0.25\\n plt.plot(rates[:, 0:ntoplot] + a*onp.arange(0, ntoplot, 1), 'b')\\n plt.plot(true_rates[:, 0:ntoplot] + a*onp.arange(0, ntoplot, 1), 'r')\\n plt.title('LFADS rates (blue), True rates (red)')\\n plt.xlabel('timesteps')\\n \\n return f\",\n \"def add_plot(self, state, data, y_axis, function=lambda x: x, x_axis='freq', ax=None, title=None, log_axis='x', save=True, show=False):\\n\\n functions_dict = {'x': plt.semilogx, 'y': plt.semilogx, 'both': plt.loglog, 'none': plt.plot}\\n #TODO: Unfinished\\n\\n if ax is None:\\n fig = plt.figure()\\n ax = plt.gca()\\n\\n if title is None:\\n title = y_axis\\n\\n # import IPython\\n sweep_kwrds = data['sweep_params'][y_axis]\\n sweep_kwrds = [kwrd for kwrd in sweep_kwrds if kwrd != x_axis]\\n # combos = itertools.product(*(list(range(len(data[swp_kwrd]))) for swp_kwrd in sweep_kwrds))\\n\\n # IPython.embed()\\n # if combos:\\n # for index in combos:\\n # functions_dict[log_axis](data[x_axis], np.abs(data[y_axis][index, :]))\\n # else:\\n functions_dict[log_axis](data[x_axis], function(data[y_axis]))\\n plt.ylabel(y_axis)\\n plt.xlabel(x_axis)\\n ax.grid()\\n if save:\\n fname = os.path.join(self.data_dir, title + \\\".png\\\")\\n if os.path.isfile(fname):\\n os.remove(fname)\\n plt.savefig(fname, dpi=200)\\n plt.close()\\n if show:\\n plt.show()\",\n \"def dtw_plot_appendix(output = 'output/img/series/dtw'):\\n # regions\\n regs = _src.regions()\\n regsL = [(v) for v in regs.values()]\\n \\n # iterate\\n for r1 in range(len(regs)):\\n for r2 in range(r1+1, len(regs)):\\n dtw_plot(regsL[r1]['NUTS3'], regsL[r2]['NUTS3'],\\n output = output, font_size = 12)\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def descriptive_plot(data_onlyDV):\\n outcome = data_onlyDV.columns.values[0] # get the outcome column name\\n\\n fig = plt.figure()\\n # TODO: subplots appear in same frame instead of 3 separate ones (!!!)\\n ax1 = fig.add_subplot(121)\\n ax1 = data_onlyDV.plot(kind='hist', title=\\\"Histogram: \\\"+outcome, by=outcome)\\n ax1.locator_params(axis='x', nbins=4)\\n ax1.set_xlabel(outcome+\\\" bins\\\")\\n ax1.set_ylabel(\\\"Num Instances\\\")\\n\\n ax2 = fig.add_subplot(122)\\n ax2 = data_onlyDV.plot(kind='kde', title=\\\"KDE Density Plot: \\\"+outcome)\\n\\n fig.tight_layout()\\n plt.show()\",\n \"def _2d_plot_samples(self, **kwargs):\\n\\n from pesummary.core.plots.bounded_2d_kde import Bounded_2d_kde\\n\\n # get bounds\\n lows = []\\n highs = []\\n methods = []\\n for param in self.parameters[0:2]:\\n if param in DEFAULT_BOUNDS:\\n lows.append(\\n DEFAULT_BOUNDS[param][\\\"low\\\"]\\n if \\\"low\\\" in DEFAULT_BOUNDS[param]\\n else None\\n )\\n highs.append(\\n DEFAULT_BOUNDS[param][\\\"high\\\"]\\n if \\\"high\\\" in DEFAULT_BOUNDS[param]\\n else None\\n )\\n methods.append(\\n DEFAULT_BOUNDS[param][\\\"method\\\"]\\n if \\\"method\\\" in DEFAULT_BOUNDS[param]\\n else \\\"Reflection\\\"\\n )\\n\\n if self.plottype == \\\"triangle\\\":\\n from pesummary.core.plots.publication import triangle_plot as plotfunc\\n elif self.plottype == \\\"reverse_triangle\\\":\\n from pesummary.core.plots.publication import (\\n reverse_triangle_plot as plotfunc,\\n )\\n else:\\n # contour plot\\n from pesummary.core.plots.publication import (\\n comparison_twod_contour_plot as plotfunc,\\n )\\n\\n # set KDE information\\n kwargs.update(\\n {\\n \\\"kde\\\": Bounded_2d_kde,\\n \\\"kde_kwargs\\\": {\\n \\\"xlow\\\": lows[0],\\n \\\"xhigh\\\": highs[0],\\n \\\"ylow\\\": lows[1],\\n \\\"yhigh\\\": highs[1],\\n },\\n }\\n )\\n\\n # default to not showing data points\\n if \\\"plot_datapoints\\\" not in kwargs:\\n kwargs[\\\"plot_datapoints\\\"] = False\\n\\n if \\\"triangle\\\" in self.plottype:\\n from pesummary.core.plots.bounded_1d_kde import bounded_1d_kde\\n\\n # set KDE informaiton\\n kwargs.update(\\n {\\n \\\"kde_2d\\\": Bounded_2d_kde,\\n \\\"kde_2d_kwargs\\\": {\\n \\\"xlow\\\": lows[0],\\n \\\"xhigh\\\": highs[0],\\n \\\"ylow\\\": lows[1],\\n \\\"yhigh\\\": highs[1],\\n },\\n \\\"kde\\\": bounded_1d_kde,\\n }\\n )\\n\\n kwargs[\\\"kde_kwargs\\\"] = {\\n \\\"x_axis\\\": {\\\"xlow\\\": lows[0], \\\"xhigh\\\": highs[0], \\\"method\\\": methods[0]},\\n \\\"y_axis\\\": {\\\"xlow\\\": lows[1], \\\"xhigh\\\": highs[1], \\\"method\\\": methods[1]},\\n }\\n\\n args = [\\n [samps[self.parameters[0]].values for samps in self._samples.values()],\\n [samps[self.parameters[1]].values for samps in self._samples.values()],\\n ]\\n\\n if \\\"xlabel\\\" not in kwargs:\\n kwargs[\\\"xlabel\\\"] = self.latex_labels[self.parameters[0]]\\n if \\\"ylabel\\\" not in kwargs:\\n kwargs[\\\"ylabel\\\"] = self.latex_labels[self.parameters[1]]\\n\\n if \\\"labels\\\" not in kwargs and len(self.results) > 1:\\n kwargs[\\\"labels\\\"] = list(self._samples.keys())\\n\\n # set injection parameter values\\n if self.injection_parameters is not None:\\n if (\\n self.injection_parameters[self.parameters[0]] is not None\\n and self.injection_parameters[self.parameters[1]] is not None\\n ):\\n kwargname = \\\"truths\\\" if self.plottype == \\\"corner\\\" else \\\"truth\\\"\\n kwargs[kwargname] = [\\n self.injection_parameters[self.parameters[0]]\\n - self.parameter_offsets[self.parameters[0]],\\n self.injection_parameters[self.parameters[1]]\\n - self.parameter_offsets[self.parameters[1]],\\n ]\\n\\n # create plot\\n with DisableLogger():\\n fig = plotfunc(*args, **kwargs)\\n\\n return fig\",\n \"def plot_calibration(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\",\\n x_name=\\\"Mean Predicted\\\",\\n y_name=\\\"Empirical Probability\\\",\\n method_order = METHOD_ORDER, \\n avg_x = False):\\n\\n methods = df['method_name']\\n uniq_methods = pd.unique(methods)\\n method_order = [j for j in METHOD_ORDER if j in uniq_methods]\\n method_df = []\\n\\n if avg_x: \\n df_copy = df.copy()\\n new_list = [0]\\n new_x_map = {}\\n for method in uniq_methods: \\n temp_vals = df[df['method_name'] == method][x_input]\\n new_ar = np.vstack(temp_vals)\\n new_ar = np.nanmean(new_ar, 0) # avg columnwise\\n new_x_map[method] = new_ar\\n df_copy[x_input] = [new_x_map[method] for method in methods]\\n df = df_copy\\n\\n x, y = df[x_input].values, df[y_input].values\\n\\n\\n method_df = [{x_name : xx, y_name : yy, \\\"Method\\\" : method}\\n for x_i, y_i, method in zip(x, y, methods)\\n for xx,yy in zip(x_i,y_i)]\\n method_df = pd.DataFrame(method_df)\\n sns.lineplot(x=x_name, y=y_name, hue=\\\"Method\\\", alpha=0.8,\\n hue_order=method_order,\\n data=method_df,\\n palette = METHOD_COLORS)\\n x = np.linspace(0,1,100)\\n plt.plot(x, x, linestyle='--', color=\\\"black\\\")\",\n \"def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\\n df_decomposed = df.loc[df['block'] == 'decomposed']\\n df_joint = df.loc[df['block'] == 'joint']\\n ticklabels = []\\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\\n for i in range(len(num_sweeps)):\\n ticklabels.append('K=%d\\\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\\n fig = plt.figure(figsize=(fs*2.5, fs))\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax1.set_xticks(num_sweeps)\\n ax1.set_xticklabels(ticklabels)\\n ax1.tick_params(labelsize=fontsize)\\n ax1.grid(alpha=0.4)\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax2.set_xticks(num_sweeps)\\n ax2.set_xticklabels(ticklabels)\\n ax2.tick_params(labelsize=fontsize)\\n ax2.grid(alpha=0.4)\\n ax2.legend(fontsize=fontsize)\\n ax1.legend(fontsize=fontsize)\\n ax1.set_ylabel(r'$\\\\log \\\\: p_\\\\theta(x, \\\\: z)$', fontsize=35)\\n ax2.set_ylabel('ESS / L', fontsize=35)\",\n \"def view_datashade(self):\\n # Select only sufficient data\\n if self.x in self.y:\\n self.y.remove(self.x)\\n if self.y == []:\\n return self.gif\\n\\n df = self.dataframe[[self.x] + self.y].copy()\\n lines_overlay = df.hvplot(**self.plot_options).options({'Curve': {'color': self.color_key}})\\n\\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\\n # Compute\\n dataframe = df.copy()\\n if x_range is not None:\\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\\n data_length = len(dataframe) * len(dataframe.columns)\\n step = 1 if data_length < self.max_step else data_length // self.max_step\\n plot_df = dataframe[::step].hvplot(**self.plot_options)\\n if len(self.y) == 1:\\n return plot_df.options({'Curve': {'color': '#377eb8'}})\\n else:\\n return plot_df.options({'Curve': {'color': self.color_key}})\\n\\n # Define a RangeXY stream linked to the image\\n rangex = hv.streams.RangeX(source=lines_overlay)\\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\\n if len(self.y) == 1:\\n data_shade_plot *= datashade(lines_overlay)\\n else:\\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\\n return pn.panel(data_shade_plot)\",\n \"def plot(self, noTLS, path_plots, interactive):\\n fig = plt.figure(figsize=(10,12))\\n ax1 = fig.add_subplot(4, 1, 1)\\n ax2 = fig.add_subplot(4, 1, 2)\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax4 = fig.add_subplot(4, 2, 6)\\n ax5 = fig.add_subplot(4, 2, 7)\\n ax6 = fig.add_subplot(4, 2, 8)\\n\\n # First panel: data from each sector\\n colors = self._get_colors(self.nlc)\\n for i, lci in enumerate(self.alllc):\\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\\n ax1.legend(fontsize='small', ncol=4)\\n\\n # Second panel: Detrended light curve\\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\\n color='black',\\n label='Detrended')\\n\\n # Third panel: BLS\\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\\n mean_SR = np.mean(self.BLS.power)\\n std_SR = np.std(self.BLS.power)\\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\\n SDE = (best_power - mean_SR)/std_SR\\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\\n for n in range(2, 10):\\n if n*self.BLS.period_max <= max(self.BLS.period.value):\\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n sx, ex = ax3.get_xlim()\\n sy, ey = ax3.get_ylim()\\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.2f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nSDE = %.3f' %\\n (self.BLS.period_max, self.BLS.t0_max,\\n self.BLS.depth_max, self.BLS.duration_max, SDE))\\n\\n\\n # Fourth panel: lightcurve folded to the best period from the BLS\\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\\n marker='.', alpha=0.5)\\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n\\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\\n duration=self.BLS.duration_max,\\n transit_time=self.BLS.t0_max)\\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\\n ax4.set_xlim(-l, l)\\n h = max(lc_model.flux)\\n l = min(lc_model.flux)\\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n del lc_model, lc_model_folded, r1, dt1\\n\\n\\n if not noTLS:\\n # Fifth panel: TLS periodogram\\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\\n for n in range(2, 10):\\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.set_ylabel(r'SDE')\\n ax5.set_xlabel('Period (days)')\\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\\n ax5.set_xlim(0, max(self.tls.periods))\\n\\n period_tls = self.tls.period\\n T0_tls = self.tls.T0\\n depth_tls = self.tls.depth\\n duration_tls = self.tls.duration\\n FAP_tls = self.tls.FAP\\n\\n sx, ex = ax5.get_xlim()\\n sy, ey = ax5.get_ylim()\\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.1f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nFAP = %.4f' %\\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\\n\\n # Sixth panel: folded light curve to the best period from the TLS\\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\\n alpha=0.5, ls='None', markersize=0.7)\\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\\n x0=0.0, nbins=nbins, useBinCenter=True)\\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\\n ax6.set_xlim(0.5-l, 0.5+l)\\n h = max(self.tls.model_folded_model)\\n l = min(self.tls.model_folded_model)\\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n ax6.set_xlabel('Phase')\\n ax6.set_ylabel('Relative flux')\\n del r1, dt1\\n\\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\\n if interactive:\\n plt.show()\\n plt.close('all')\\n del fig\",\n \"def plot(self, dtables, figs, **kwargs):\\n self.safe_update(**kwargs)\\n\\n sumtable = dtables['biasoscorr_sum']\\n runtable = dtables['runs']\\n\\n yvals_s = sumtable['s_correl_mean'].flatten().clip(0., 1.)\\n yvals_p = sumtable['p_correl_mean'].flatten().clip(0., 1.)\\n runs = runtable['runs']\\n\\n figs.plot_run_chart(\\\"mean-s\\\", runs, yvals_s,\\n ylabel=\\\"Correlation between serial overscan and imaging\\\")\\n figs.plot_run_chart(\\\"mean-p\\\", runs, yvals_p,\\n ylabel=\\\"Correlation between parallel overscan and imaging\\\")\",\n \"def diagrama_ph(h: [np.ndarray] or [list], P: [np.ndarray] or [list], title: str, hide_values: bool) -> (Figure, Axes):\\n return diagram(h, P, title, \\\"Ph\\\", hide_values)\",\n \"def logit_model_plots(ds,Population = 'Population_%',Event_rate ='Event_rate',decile ='Band',Cumulative_Non_Event = 'Cumulative_Non_Event_%',Cumulative_Event= 'Cumulative_Event_%',sample_type ='Development'):\\n \\n import matplotlib.pyplot as plt\\n fig, (ax1, ax2) = plt.subplots(1, 2,figsize=(15, 4))\\n _= ax1.plot(plot_df[Cumulative_Non_Event],plot_df[Cumulative_Event])\\n _= ax1.set_ylabel(Cumulative_Non_Event)\\n _= ax1.set_title('Gini Curve : '+str(sample_type) +' sample')\\n _= ax1.set_xlabel(Cumulative_Event)\\n\\n _= plot_df[Population].plot(kind='bar', color='b', width = 0.35,legend=True , label = Population)\\n _= plot_df[Event_rate].plot(kind='line',color ='r', secondary_y=True,legend=True, label = Event_rate)\\n _= ax2.set_xticklabels(plot_df[decile])\\n _= ax2.set_ylim(0,plot_df[Event_rate].max()*0.15)\\n _= ax2.right_ax.set_ylim(0,plot_df[Event_rate].max()*1.5)\\n _= ax2.right_ax.set_ylabel(Event_rate)\\n _= ax2.set_ylabel(Population)\\n _= ax2.set_title('Decile Wise Event Rate : ' +str(sample_type) +' sample')\\n _= ax2.set_xlabel(decile)\\n plt.show()\",\n \"def show_dcr_results(dg):\\n cycle = dg.fileDB['cycle'].values[0]\\n df_dsp = pd.read_hdf(f'./temp_{cycle}.h5', 'opt_dcr')\\n # print(df_dsp.describe()) \\n\\n # compare DCR and A/E distributions\\n fig, (p0, p1) = plt.subplots(2, 1, figsize=(8, 8))\\n \\n elo, ehi, epb = 0, 25000, 100\\n \\n # aoe distribution\\n # ylo, yhi, ypb = -1, 2, 0.1\\n # ylo, yhi, ypb = -0.1, 0.3, 0.005\\n ylo, yhi, ypb = 0.05, 0.08, 0.0005\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p0.hist2d(df_dsp['trapEmax'], df_dsp['aoe'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n # p0.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p0.set_ylabel('A/E', ha='right', y=1)\\n\\n # dcr distribution\\n # ylo, yhi, ypb = -20, 20, 1 # dcr_raw\\n # ylo, yhi, ypb = -5, 2.5, 0.1 # dcr = dcr_raw / trapEmax\\n # ylo, yhi, ypb = -3, 2, 0.1\\n ylo, yhi, ypb = 0.9, 1.08, 0.001\\n ylo, yhi, ypb = 1.034, 1.0425, 0.00005 # best for 64.4 us pz\\n # ylo, yhi, ypb = 1.05, 1.056, 0.00005 # best for 50 us pz\\n # ylo, yhi, ypb = 1.016, 1.022, 0.00005 # best for 100 us pz\\n nbx = int((ehi-elo)/epb)\\n nby = int((yhi-ylo)/ypb)\\n h = p1.hist2d(df_dsp['trapEmax'], df_dsp['dcr'], bins=[nbx,nby],\\n range=[[elo, ehi], [ylo, yhi]], cmap='jet',\\n norm=LogNorm())\\n p1.set_xlabel('Energy (uncal)', ha='right', x=1)\\n p1.set_ylabel('DCR', ha='right', y=1)\\n \\n # plt.show()\\n plt.savefig(f'./plots/dcr_cyc{cycle}.png', dpi=300)\\n plt.cla()\",\n \"def checkdyn():\\n args = parse_args()\\n config = ScatterConfig()\\n paths = ScatterPath(args.infile)\\n dyn = dyndat(paths)\\n\\n fig, axes = plt.subplots(1,1)\\n nvib = list()\\n for i in range(dyn.Nalgorithm):\\n print(i)\\n final_E_dist = dyn.final_Ek_dist + dyn.final_Ep_dist\\n final_Ex_dist_filt = \\\\\\n final_E_dist[i,:,0][np.where(np.logical_or(\\n dyn.final_r_dist[i,:,1] < dyn.boundary_rmin[1],\\n dyn.final_r_dist[i,:,1] > dyn.boundary_rmax[1])\\n )]\\n final_n_vib_dist = np.round((final_Ex_dist_filt / 0.008) - 0.5)\\n nvib.append(final_n_vib_dist)\\n\\n ax = axes\\n ax.hist(nvib, color=config.colors[:dyn.Nalgorithm],\\n bins=tuple(range(0,21,1)),\\n align='left', rwidth= 0.8,\\n range=(0, 21), normed=True)\\n ax.legend(dyn.algorithms)\\n ax.set_xlim(0, 20)\\n ax.set_xticks([i for i in range(0,21,1)])\\n ax.set_xticklabels([str(int(i)) for i in range(0,21,1)])\\n ax.set_ylim(0, 0.5)\\n\\n ## -- save fig -- ##\\n saveto=args.savedir\\n if not saveto and not HAVE_DISPLAY:\\n saveto = './'\\n\\n if saveto:\\n if not args.savedir.endswith('/'):\\n args.savedir += '/'\\n fig.savefig(args.savedir + savename + '.png', dpi=2 * fig.dpi)\\n\\n if HAVE_DISPLAY:\\n plt.show()\",\n \"def plot_example_psds(example,rate):\\r\\n plt.figure()\\r\\n \\r\\n ##YOUR CODE HERE \\r\\n \\r\\n return\",\n \"def plot_msd(msd, h_exp):\\n fig, ax = plt.subplots(1, 2, figsize = (10, 10))\\n av_msd = np.mean(msd, axis = 0)\\n\\n for p in np.arange(0, msd.shape[0], step = 1):\\n for t in np.arange(0, msd.shape[1], step = 1): \\n ax[0].plot(t, msd[p, t], 'bx')\\n ax[1].plot(t, av_msd[t], 'ro')\\n ax[0].set_xlabel('Time lag (number of steps)')\\n ax[0].set_ylabel('MSD (pix^2)')\\n ax[0].set_title('Individual TAMSDs: H = ' + str(h_exp))\\n ax[1].set_xlabel('Time lag (number of steps)')\\n ax[1].set_ylabel('MSD (pix^2)')\\n ax[1].set_title('Averaged TAMSDs: H = ' + str(h_exp)) \\n ax[0].set_xlim([0, np.max(t)])\\n ax[1].set_xlim([0, np.max(t)])\\n ax[0].set_ylim([0, np.max(msd)]) \\n ax[1].set_ylim([0, np.max(av_msd)])\",\n \"def stabplot(lambd, orders, phi=None, model=None, freq_range=None, frequency_unit='rad/s', damped_freq=False, psd_freq=None, psd_y=None, psd_plot_scale='log', \\n renderer=None, pole_settings=None, selected_pole_settings=None, to_clipboard='none', return_ix=False):\\n\\n \\n\\n\\n # Treat input settings\\n if pole_settings is None: pole_settings = {}\\n if selected_pole_settings is None: selected_pole_settings = {}\\n\\n unsel_settings = {'color':'#a9a9a9', 'size':6, 'opacity':0.6}\\n unsel_settings.update(**pole_settings)\\n\\n current_settings = listify_each_dict_entry(unsel_settings, len(lambd))\\n\\n sel_settings = {'color':'#cd5c5c', 'size':10, 'opacity':1.0, 'line': {'color': '#000000', 'width': 0}}\\n sel_settings.update(**selected_pole_settings)\\n\\n select_status = np.zeros(len(lambd), dtype=bool)\\n \\n # Create suffix and frequency value depending on whether damped freq. is requested or not\\n if damped_freq:\\n dampedornot = 'd'\\n omega = np.abs(np.imag(lambd))\\n else:\\n dampedornot = 'n'\\n omega = np.abs(lambd)\\n\\n # Create frequency/period axis and corresponding labels\\n if frequency_unit == 'rad/s':\\n x = omega\\n xlabel = f'$\\\\omega_{dampedornot} \\\\; [{frequency_unit}]$'\\n tooltip_name = f'\\\\omega_{dampedornot}'\\n frequency_unit = 'rad/s'\\n elif frequency_unit.lower() == 'hz':\\n x = omega/(2*np.pi)\\n xlabel = f'$f_{dampedornot} \\\\; [{frequency_unit}]$'\\n tooltip_name = f'f_{dampedornot}'\\n frequency_unit = 'Hz'\\n elif (frequency_unit.lower() == 's') or (frequency_unit.lower() == 'period'):\\n x = (2*np.pi)/omega\\n xlabel = f'Period, $T_{dampedornot} \\\\; [{frequency_unit}]$'\\n tooltip_name = f'T_{dampedornot}'\\n frequency_unit = 's'\\n \\n # Damping ratio and index to hover\\n xi = -np.real(lambd)/np.abs(lambd)\\n text = [f'xi = {xi_i*100:.2f}% <br> ix = {ix}' for ix, xi_i in enumerate(xi)] # rewrite xi as %, and make string\\n htemplate = f'{tooltip_name}' + ' = %{x:.2f} ' + f'{frequency_unit}<br>n =' + ' %{y}' +'<br> %{text}'\\n\\n # Construct dataframe and create scatter trace \\n poles = pd.DataFrame({'freq': x, 'order':orders})\\n scatter_trace = go.Scattergl(\\n x=poles['freq'], y=poles['order'], mode='markers', name='',\\n hovertemplate = htemplate, text=text,\\n marker=current_settings)\\n \\n scatter_trace['name'] = 'Poles'\\n\\n # PSD overlay trace\\n overlay_trace = go.Scatter(x=psd_freq, y=psd_y, mode='lines', name='PSD', \\n hoverinfo='skip', line={'color':'#ffdab9'})\\n \\n # Create figure object, add traces and adjust labels and axes\\n # fig = go.FigureWidget(scatter_trace)\\n fig = make_subplots(rows=2, cols=1, specs=[[{\\\"type\\\": \\\"xy\\\", \\\"secondary_y\\\": True}],\\n [{\\\"type\\\": \\\"table\\\"}]])\\n fig.layout.hovermode = 'closest'\\n fig.add_trace(scatter_trace, secondary_y=False, row=1, col=1)\\n \\n if psd_freq is not None:\\n fig.add_trace(overlay_trace, secondary_y=True, row=1, col=1)\\n fig.update_yaxes(title_text=\\\"PSD\\\", secondary_y=True, type=psd_plot_scale)\\n fig['layout']['yaxis2']['showgrid'] = False\\n \\n fig.layout['xaxis']['title'] = xlabel\\n fig.layout['yaxis']['title'] = '$n$'\\n\\n if freq_range is not None:\\n fig.layout['xaxis']['range'] = freq_range\\n \\n fig['layout']['yaxis']['range'] = [0.05, np.max(orders)*1.1]\\n\\n # Renderer (refer to plotly documentation for details)\\n if renderer is 'default':\\n import plotly.io as pio\\n renderer = pio.renderers.default\\n\\n df = pd.DataFrame(columns=['ix','x','xi'])\\n pd.options.display.float_format = '{:,.2f}'.format\\n \\n fig.add_trace(\\n go.Table(header=\\n dict(values=['Pole index', xlabel, r'$\\\\xi [\\\\%]$'],\\n fill_color='paleturquoise',\\n align='left'),\\n cells=\\n dict(values=[],fill_color='lavender',\\n align='left')), row=2, col=1)\\n \\n fig.update_layout(\\n height=1000,\\n showlegend=False\\n )\\n \\n\\n fig = go.FigureWidget(fig) #convert to widget\\n \\n # Callback function for selection poles\\n ix = np.arange(0, len(lambd))\\n ix_sel = []\\n \\n def update_table():\\n df = pd.DataFrame(data={'ix': ix[select_status], 'freq': x[select_status], 'xi':100*xi[select_status]})\\n \\n if len(fig.data)==2:\\n sel_ix = 1\\n else:\\n sel_ix = 2\\n \\n fig.data[sel_ix].cells.values=[df.ix, df.freq, df.xi]\\n \\n \\n def toggle_pole_selection(trace, clicked_point, selector):\\n def export_df():\\n df.to_clipboard(index=False)\\n \\n def export_ix_list():\\n import pyperclip #requires pyperclip\\n ix_str = '[' + ', '.join(str(i) for i in ix_sel) + ']'\\n pyperclip.copy(ix_str)\\n\\n for i in clicked_point.point_inds:\\n if select_status[i]:\\n for key in current_settings:\\n current_settings[key][i] = unsel_settings[key]\\n else:\\n for key in current_settings:\\n current_settings[key][i] = sel_settings[key] \\n \\n select_status[i] = not select_status[i] #swap status\\n\\n with fig.batch_update():\\n trace.marker = current_settings\\n \\n update_table()\\n ix_sel = ix[select_status]\\n\\n if to_clipboard == 'ix':\\n export_ix_list()\\n elif to_clipboard == 'df':\\n export_df()\\n\\n fig.data[0].on_click(toggle_pole_selection) \\n\\n if renderer == 'browser_legacy':\\n from plotly.offline import plot\\n plot(fig, include_mathjax='cdn')\\n elif renderer is not None:\\n fig.show(renderer=renderer, include_mathjax='cdn')\\n \\n \\n if return_ix:\\n return fig, ix_sel\\n else:\\n return fig\",\n \"def plot_pade_figure(self):\\n data_analysis = DatabaseData(dataframe=self.plot_data)\\n print (data_analysis.dataframe.columns)\\n data_analysis.run_pade_through_R(rscript='birch',get_inits_ev=True)\\n data_analysis.create_precisions()\\n data_analysis.extract_pade_curve()\\n x_eos_kpts, y_eos, xs_err, ys_err, x_pade_kpts, y_pade = \\\\\\n data_analysis.create_pade_bokeh_compat(properties=self.properties)\\n print (type(self.properties), self.properties)\\n if self.properties == 'B':\\n ext = data_analysis.Bp\\n print ('HERE AT PROPERTIES', ext, type(ext))\\n elif self.properties == 'BP':\\n ext = data_analysis.BPp\\n elif self.properties == 'E0':\\n ext = data_analysis.E0p\\n elif self.properties == 'V0':\\n ext = data_analysis.V0p\\n p = figure(plot_height=400, plot_width=400,tools=\\\"pan,wheel_zoom,box_zoom,reset,previewsave\\\",\\\\\\n x_axis_type=\\\"log\\\", x_axis_label='K-points per atom', title='Pade Extrapolate of {0} is {1}'.format(self.properties, str(ext)) )\\n p.xaxis.axis_label = 'K-points per atom'\\n p.line(x_pade_kpts, y_pade, color='red')\\n p.circle(x_eos_kpts, y_eos,color='blue',size=5, line_alpha=0)\\n p.multi_line(xs_err, ys_err, color='black')\\n if self.properties == 'B':\\n p.yaxis.axis_label = 'Bulk Modulus B (GPa)'\\n elif self.properties == 'dB':\\n p.yaxis.axis_label = 'Bulk Modulus Pressure Derivative'\\n elif self.properties == 'E0':\\n p.yaxis.axis_label = 'DFT Energy (eV/atom)'\\n elif self.properties == 'V0':\\n p.yaxis.axis_label = 'Volume (A^3/atom)'\\n\\n return p\",\n \"def plot_trace(self):\\n az.plot_trace(self.ifd_)\",\n \"def show_derivative(self):\\n for trace in self.plotWidget.plotDataItems:\\n dt = float(trace.attrs['dt'])\\n dtrace = np.diff(trace.data)\\n x = pgplot.make_xvector(dtrace, dt)\\n self.plotWidget.plot(x, dtrace, pen=pg.mkPen('r'))\",\n \"def plot_axial(data, vb, vc, vt):\\n\\n name = 'AxialBot'\\n det = data.detectors[name]\\n zb = [line[0] for line in det.grids['Z']]\\n valb = det.tallies\\n vd1 = vb/len(zb)\\n valb /= vd1\\n\\n name = 'AxialFuel'\\n det = data.detectors[name]\\n zf = [line[0] for line in det.grids['Z']]\\n valf = det.tallies\\n vd2 = vc/len(zf)\\n valf /= vd2\\n\\n name = 'AxialTop'\\n det = data.detectors[name]\\n zt = [line[0] for line in det.grids['Z']]\\n valt = det.tallies\\n vd3 = vt/len(zt)\\n valt /= vd3\\n\\n ther = np.concatenate([valb[0], valf[0], valt[0]])\\n fast = np.concatenate([valb[1], valf[1], valt[1]])\\n ztot = np.concatenate([zb, zf, zt])\\n\\n plt.figure()\\n plt.step(ztot, ther, where='post', label='thermal')\\n plt.step(ztot, fast, where='post', label='fast')\\n plt.xlabel('z [cm]')\\n plt.ylabel(r'$\\\\phi$')\\n plt.legend(loc=\\\"upper right\\\")\\n plt.title('Axial flux.')\\n plt.savefig('axial1', dpi=300, bbox_inches=\\\"tight\\\")\",\n \"def plot_group(self, group_name, domains, get_time_data, fs, get_freq_data=None, get_const_data=None):\\n plots = []\\n \\n def many(f, n=4):\\n return np.concatenate([f() for _ in range(n)])\\n \\n for domain in domains:\\n \\n if domain=='frequency':\\n \\n # HW accelerated FFT\\n if get_freq_data != None:\\n f_plot = sdr_plots.HWFreqPlot(\\n [get_freq_data() for _ in range(4)],\\n fs, animation_period=100, w=700)\\n f_dt = dma_timer.DmaTimer(f_plot.add_frame, get_freq_data, 0.3)\\n # SW FFT\\n else:\\n f_plot = sdr_plots.IQFreqPlot(\\n [many(get_time_data) for _ in range(4)],\\n fs, x_range=(-2000,2000), animation_period=100, w=700)\\n f_dt = dma_timer.DmaTimer(f_plot.add_frame, lambda:many(get_time_data), 0.3)\\n plots.append(dict(title='Frequency domain', plot=f_plot, control=f_dt))\\n \\n elif domain=='time' or domain=='time-binary':\\n if domain=='time-binary':\\n iq_plot = sdr_plots.IQTimePlot(many(get_time_data), fs, w=700, scaling=1, ylabel='Symbol value')\\n iq_plot.set_line_mode(lines=True, markers=True, shape='hvh')\\n iq_plot.get_widget().layout.yaxis.dtick=1\\n else:\\n iq_plot = sdr_plots.IQTimePlot(many(get_time_data), fs, w=700)\\n iq_plot.set_line_mode(markers=False)\\n iq_dt = dma_timer.DmaTimer(iq_plot.add_data, get_time_data, 0.05)\\n plots.append(dict(title='Time domain', plot=iq_plot, control=iq_dt))\\n \\n elif domain=='constellation':\\n c_plot = sdr_plots.IQConstellationPlot(many(get_const_data or get_time_data, n=10), h=550, fade=True)\\n c_dt = dma_timer.DmaTimer(c_plot.add_data, get_const_data or get_time_data, 0.05)\\n plots.append(dict(title='Constellation', plot=c_plot, control=c_dt,\\n layout=ipw.Layout(width='550px', margin='auto')))\\n \\n self.timers.register_timers(group_name, list(map(lambda tab: tab['control'], plots)))\\n return QpskOverlay.tab_plots(plots)\",\n \"def dline_dSFR_array(lines,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig, axs = plt.subplots(len(lines), sharex='col',\\\\\\n figsize=(6,15),facecolor='w',\\\\\\n gridspec_kw={'hspace': 0, 'wspace': 0})\\n\\n for i,ax in enumerate(axs):\\n\\n dline_dSFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[1],nGal=p.nGals[1],add_obs=p.add_obs,MS=p.MS,add=True,cb=True)\\n dline_dSFR(line=lines[i],ax=ax,select=p.select,sim_run=p.sim_runs[0],nGal=p.nGals[0],add_obs=False,add=True,cb=False)\\n\\n plt.tight_layout()\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/dlines_dSFR_array_%s%s%s_%s%s_%s.png' % (p.ext,p.grid_ext,p.table_ext,p.sim_name,p.sim_run,p.select), format='png', dpi=300)\",\n \"def plot_derivatives_divided(self, show=False):\\n\\n fig, ax = plt.subplots(3, 2, figsize = (15, 10))\\n # plt.subplots_adjust(wspace = 0, hspace = 0.1)\\n plt.subplots_adjust(hspace=0.5)\\n training_index = np.random.randint(self.n_train * self.n_p)\\n \\n if self.flatten:\\n print ('Plotting derivatives... reshaping the flattened data to %s'%str(input_shape))\\n # TODO\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n print ('Plotting derivatives... reshaping the flattened data to power spectra')\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n # Cl has shape (1,10) since it is the data vector for the \\n # upper training image for both params\\n labels =[r'$θ_1$ ($\\\\Omega_M$)']\\n\\n # we loop over them in this plot to assign labels\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 0].plot(ells, Cl[i],label=labels[i])\\n else:\\n ax[0, 0].loglog(ells, ells*(ells+1)*Cl[i],label=labels[i])\\n ax[0, 0].set_title('One upper training example, Cl 0,0')\\n ax[0, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n ax[0, 0].legend(frameon=False)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n # temp has shape (num_params, ncombinations, len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 0].plot(ells, Cl[i])\\n else:\\n ax[1, 0].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 0].set_title('One lower training example, Cl 0,0')\\n ax[1, 0].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 0].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 0].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p\\\"][training_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p'][training_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n\\n for i in range(Cl_lower.shape[0]):\\n ax[2, 0].plot(ells, (Cl_upper[i]-Cl_lower[i])/self.Cl_noiseless)\\n ax[2, 0].set_title('Difference between upper and lower training examples');\\n ax[2, 0].set_xlabel(r'$\\\\ell$')\\n ax[2, 0].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 0].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 0].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 0].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n ax[2, 0].legend(frameon=False)\\n\\n test_index = np.random.randint(self.n_p)\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n \\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[0, 1].plot(ells, Cl[i])\\n else:\\n ax[0, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[0, 1].set_title('One upper test example Cl 0,0')\\n ax[0, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[0, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[0, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),*input_shape)\\n x, y = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl = temp[:,0,:] # plot the (0,0) autocorrelation bin\\n\\n for i in range(Cl.shape[0]):\\n if self.rescaled:\\n ax[1, 1].plot(ells, Cl[i])\\n else:\\n ax[1, 1].loglog(ells, ells*(ells+1)*Cl[i])\\n ax[1, 1].set_title('One lower test example Cl 0,0')\\n ax[1, 1].set_xlabel(r'$\\\\ell$')\\n if self.rescaled:\\n ax[1, 1].set_ylabel(r'$C_\\\\ell$')\\n else:\\n ax[1, 1].set_ylabel(r'$\\\\ell(\\\\ell+1) C_\\\\ell$')\\n\\n if self.flatten:\\n # TODO\\n temp = self.data[\\\"x_m_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xm, ym = temp.T[:,0]\\n\\n temp = self.data[\\\"x_p_test\\\"][test_index].reshape(len(theta_fid),*input_shape)\\n xp, yp = temp.T[:,0]\\n else:\\n temp = self.data['x_m_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_lower = temp[:,0,:]\\n temp = self.data['x_p_test'][test_index].reshape(len(theta_fid),ncombinations,len(ells))\\n Cl_upper = temp[:,0,:]\\n \\n for i in range(Cl_lower.shape[0]):\\n ax[2, 1].plot(ells, (Cl_upper[i]-Cl_lower[i]) / self.Cl_noiseless)\\n ax[2, 1].set_title('Difference between upper and lower test samples');\\n ax[2, 1].set_xlabel(r'$\\\\ell$')\\n ax[2, 1].set_ylabel(r'$\\\\Delta C_\\\\ell$ / $C_{\\\\ell,thr}$')\\n ax[2, 1].axhline(xmin = 0., xmax = 1., y = 0.\\n , linestyle = 'dashed', color = 'black')\\n ax[2, 1].set_xscale('log')\\n\\n # also plot sigma_cl / CL\\n sigma_cl = np.sqrt(self.covariance)\\n ax[2, 1].plot(ells, sigma_cl/self.Cl_noiseless, label=r'$\\\\sigma_{Cl} / C_{\\\\ell,thr}$')\\n\\n plt.savefig(f'{self.figuredir}derivatives_visualization_divided_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def plot_anomalies_data_specific(df, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False, adjusted = True):\\n \\n #result = test_stationarity(SpeciesName=Species, data = data)\\n #result.plot()\\n if syndrome:\\n if adjusted:\\n vo = df[df.prediction_adjusted == syndrome]\\n else:\\n vo = df[df.prediction == syndrome]\\n else:\\n vo = df\\n \\n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\\n weekly_vo = pd.DataFrame(weekly_vo)\\n weekly_vo.columns = ['ID']\\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\\n\\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\\n \\n def identify_anomalies(c, sigma=sigma):\\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\\n return c.ID\\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\\n \\n upper_bound = go.Scatter(\\n name='upper Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\\n mode='lines',\\n marker=dict(color=\\\"#820101\\\"),\\n line=dict(width=0),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n \\n rolling_m = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['rolling mean'],\\n name='rolling mean',\\n mode='lines',\\n line=dict(color='#1f77b4'),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n\\n lower_bound = go.Scatter(\\n name='lower Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\\n marker=dict(color=\\\"#b7b7b7\\\"),\\n line=dict(width=0),\\n mode='lines',)\\n\\n addmissions = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['# admissions'],\\n name='# admissions',)\\n\\n ano = go.Scatter(\\n x = weekly_vo.index,\\n y =weekly_vo['anomalies'] ,\\n name='anomalies',\\n mode='markers')\\n\\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\\n \\n T = \\\"Weekly admissions\\\"\\n print (T)\\n layout = go.Layout(\\n title= 'Weekly admissions',\\n yaxis=dict( title='number of admissions',), width=900, height=640\\n )\\n\\n fig = go.Figure(data=plottingdata, layout=layout)\\n plot_url = iplot(fig)\\n if verbose:\\n print('number of admissions triggering alert') \\n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\\n if save:\\n name = 'special_syndrome_study'\\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WRMD_paper/outputs/'+name+'.png')\\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\\n\\n #from IPython.display import Image\\n #Image('C:\\\\Users\\\\Falco\\\\Desktop\\\\directory\\\\WMRD\\\\data\\\\TimeSeries.png')\\n \\n return weekly_vo\",\n \"def save_plot_interpolate(input_samples, samples, idx, identifier, num_epochs=None, distances=None, sigma=1):\\n n_samples = samples.shape[0]\\n sample_length = samples.shape[1]\\n\\n if not num_epochs is None:\\n col = hsv_to_rgb((1, 1.0*(idx)/num_epochs, 0.8))\\n else:\\n col = 'grey'\\n\\n x_points = np.arange(sample_length)\\n if distances is None:\\n nrow = n_samples\\n else:\\n nrow = n_samples + 1\\n ncol = 1\\n fig, axarr = plt.subplots(nrow, ncol, figsize=(3, 9))\\n if distances is None:\\n startat = 0\\n else:\\n startat = 1\\n axarr[0].plot(distances.dA, color='green', label='distance from A', linestyle='--', marker='o', markersize=4)\\n axarr[0].plot(distances.dB, color='orange', label='distance from B', linestyle='dotted', marker='o', markersize=4)\\n axarr[0].get_xaxis().set_visible(False)\\n axarr[0].set_title('distance from endpoints')\\n for m in range(startat, nrow):\\n sample = samples[m-startat, :, 0]\\n axarr[m].plot(x_points, sample, color=col)\\n for m in range(startat, nrow):\\n axarr[m].set_ylim(-1.1, 1.1)\\n axarr[m].set_xlim(0, sample_length)\\n axarr[m].spines[\\\"top\\\"].set_visible(False)\\n axarr[m].spines[\\\"bottom\\\"].set_visible(False)\\n axarr[m].spines[\\\"right\\\"].set_visible(False)\\n axarr[m].spines[\\\"left\\\"].set_visible(False)\\n axarr[m].tick_params(bottom='off', left='off')\\n axarr[m].get_xaxis().set_visible(False)\\n axarr[m].get_yaxis().set_visible(False)\\n axarr[m].set_facecolor((0.96, 0.96, 0.96))\\n if not input_samples is None:\\n # now do the real samples\\n axarr[startat].plot(x_points, input_samples[0], color='green', linestyle='--')\\n axarr[-1].plot(x_points, input_samples[1], color='green', linestyle='--')\\n\\n axarr[-1].xaxis.set_ticks(range(0, sample_length, int(sample_length/4)))\\n fig.suptitle(idx)\\n fig.subplots_adjust(hspace = 0.2)\\n fig.savefig(\\\"./experiments/plots/\\\" + identifier + \\\"_interpolate.png\\\")\\n fig.savefig(\\\"./experiments/plots/\\\" + identifier + \\\"_interpolate.pdf\\\")\\n plt.clf()\\n plt.close()\\n return\",\n \"def view_datashade(self):\\n # Select only sufficient data\\n if self.x in self.y:\\n self.y.remove(self.x)\\n if self.y == []:\\n return self.gif\\n\\n df = self.dataframe[[self.x] + self.y].copy()\\n lines_overlay = df.hvplot.scatter(**self.plot_options).options({'Scatter': {'color': self.color_key}})\\n\\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\\n # Compute\\n dataframe = df.copy()\\n if x_range is not None:\\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\\n data_length = len(dataframe) * len(dataframe.columns)\\n step = 1 if data_length < self.max_step else data_length // self.max_step\\n plot_df = dataframe[::step].hvplot.scatter(**self.plot_options)\\n if len(self.y) == 1:\\n return plot_df.options({'Scatter': {'color': '#377eb8'}})\\n else:\\n return plot_df.options({'Scatter': {'color': self.color_key}})\\n\\n # Define a RangeXY stream linked to the image\\n rangex = hv.streams.RangeX(source=lines_overlay)\\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\\n if len(self.y) == 1:\\n data_shade_plot *= datashade(lines_overlay)\\n else:\\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\\n return pn.panel(data_shade_plot)\",\n \"def anova_analysis(df):\\n time_periods = df.groupby(['week_ending','Holiday'],as_index = False)[['seats_sold']].sum()\\n TG = time_periods.loc[time_periods['Holiday'] == 'ThanksGiving','seats_sold']\\n WB = time_periods.loc[time_periods['Holiday'] == 'WinterBreak','seats_sold']\\n SB = time_periods.loc[time_periods['Holiday'] == 'SummerBreak','seats_sold']\\n NH = time_periods.loc[time_periods['Holiday'] == 'Not Holiday','seats_sold']\\n f,p = stats.f_oneway(TG,WB,SB,NH)\\n print('The f and p of ANOVA analysis are:')\\n print(f,p)\\n\\n ## plot the mean of each group\\n time_periods.boxplot('seats_sold', by='Holiday', figsize=(12, 8))\\n fileName = 'ANOVA.png'\\n plt.savefig(fileName)\\n\\n print(\\\"The mean seats sold of each time periods:\\\")\\n print(time_periods.groupby('Holiday')['seats_sold'].mean())\\n\\n pairwise = MultiComparison(time_periods['seats_sold'], time_periods['Holiday'])\\n result = pairwise.tukeyhsd()\\n print(pairwise)\\n print(result)\\n #print(pairwise.groupsunique)\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def make_plot_for_different_thresholds(\\n lambda_2,\\n lambda_1,\\n mu,\\n num_of_servers,\\n num_of_trials,\\n seed_num=None,\\n measurement_type=None,\\n runtime=1440,\\n max_threshold=None,\\n):\\n all_ambulance_patients_mean_times = []\\n all_other_patients_mean_times = []\\n all_total_mean_times = []\\n if max_threshold == None:\\n max_threshold = num_of_servers\\n for threshold in range(1, max_threshold + 1):\\n current_ambulance_patients_mean_times = []\\n current_other_patients_mean_times = []\\n current_total_mean_times = []\\n for _ in range(num_of_trials):\\n times = get_times_for_patients(\\n lambda_2,\\n lambda_1,\\n mu,\\n num_of_servers,\\n threshold,\\n seed_num,\\n measurement_type,\\n runtime,\\n )\\n current_ambulance_patients_mean_times.append(np.nanmean(times[0]))\\n current_other_patients_mean_times.append(np.nanmean(times[1]))\\n current_total_mean_times.append(np.nanmean(times[0] + times[1]))\\n all_ambulance_patients_mean_times.append(\\n np.nanmean(current_ambulance_patients_mean_times)\\n )\\n all_other_patients_mean_times.append(\\n np.nanmean(current_other_patients_mean_times)\\n )\\n all_total_mean_times.append(np.nanmean(current_total_mean_times))\\n\\n x_axis = [thres for thres in range(1, max_threshold + 1)]\\n x_axis_label, y_axis_label, title = get_plot_for_different_thresholds_labels(\\n measurement_type\\n )\\n plt.figure(figsize=(23, 10))\\n diff_threshold_plot = plt.plot(\\n x_axis,\\n all_ambulance_patients_mean_times,\\n \\\"solid\\\",\\n x_axis,\\n all_other_patients_mean_times,\\n \\\"solid\\\",\\n x_axis,\\n all_total_mean_times,\\n \\\"solid\\\",\\n )\\n plt.title(title, fontsize=13, fontweight=\\\"bold\\\")\\n plt.xlabel(x_axis_label, fontsize=13, fontweight=\\\"bold\\\")\\n plt.ylabel(y_axis_label, fontsize=13, fontweight=\\\"bold\\\")\\n plt.legend(\\n [\\\"Ambulance Patients\\\", \\\"Other Patients\\\", \\\"All times\\\"], fontsize=\\\"x-large\\\"\\n )\\n\\n return diff_threshold_plot\",\n \"def plot_time_advances(self, path: str = None, methods: list = None, title=None):\\n df = self.get_results(methods)\\n ax = plt.axes()\\n sns.lineplot(x='epoch', y='value', data=df, hue='statistics', style='method', ax=ax)\\n plt.ylim(-31, 11)\\n plt.ylabel('test statistics of log-lkl')\\n lgd = plt.legend(loc='upper left', bbox_to_anchor=[1.01, -0.1, 0.2, 0.8], ncol=1)\\n ax.set_position([0.1, 0.1, 0.75, 0.8])\\n if title is not None:\\n ax.set_title(title)\\n if path is not None:\\n for extension in ['eps', 'png']:\\n plt.savefig(f'{path}.{extension}', format=extension)\",\n \"def all(folder, mt=False):\\n handles = []\\n experiments = get_experiment_series(folder, mT=mt)\\n for ex in experiments:\\n if mt:\\n handles.append(\\n plt.plot(\\n ex.distance,\\n ex.weight,\\n label='{}mm {}mT'.format(ex.height, ex.magnet))[0])\\n else:\\n handles.append(\\n plt.plot(\\n ex.distance,\\n ex.weight,\\n label='{}mm'.format(ex.height))[0])\\n plt.legend()\\n plt.show()\",\n \"def test4():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\t#Voigt\\n\\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def fdd_plot(result_file_list,default_fdds,ion_default):\\n # Getting data from the file\\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\\n# print \\\" Parameters to plot for:\\\", fdd_param_keys\\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\\n for j,result_file_name in enumerate(result_file_list):\\n with open(result_file_name,'r') as res_file:\\n res_data = res_file.read().split('\\\\n')\\n if res_data[-1] == \\\"\\\": # delete empty line if present\\n del res_data[-1]\\n else:\\n pass\\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\\n for line in res_data:\\n line_split = line.split()\\n if line_split[1] == '0' or line_split[1] == '-1':\\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n if line_split[1] == '0':\\n n_iter_list.append(int(line_split[2])) # number of iterations list\\n else:\\n n_iter_list.append(-1) # 125, number of iterations\\n H_list.append(float(line_split[3])) # H_list\\n Hunc_list.append(float(line_split[4])) # Hunc_list\\n D_list.append(float(line_split[5])) # D_list\\n Dunc_list.append(float(line_split[6])) # Dunc_list\\n elif line_split[1] == '1':\\n print \\\" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n n_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '2':\\n print \\\" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '3':\\n print \\\" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '4':\\n print \\\" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-3) # number of iterations list\\n elif line_split[1] == '5':\\n print \\\" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-2) # number of iterations list\\n else:\\n print \\\" Unknown error code was specified in {}\\\".format(result_file_name)\\n\\n # Data are ready to plot\\n # First column of subplots (uncertainties)\\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\\\"steps-mid\\\") # Plotting data\\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\\n axs[5*j+1].set_ylabel(r'$\\\\Delta$N(D I)',color='b')\\n axs[5*j+1].tick_params('y',colors='b')\\n axs[5*j+1].ticklabel_format(useOffset=False)\\n axs[5*j+1].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\\\"steps-mid\\\")\\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\\n axs[5*j+2].set_ylabel(r'$\\\\Delta$N(H I)',color='r')\\n axs[5*j+2].tick_params('y',colors='r')\\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\\n # Second column of subplots (middle values)\\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\\n plot_interal = False # Add 1-sigma interval\\n if plot_interal == True:\\n median = np.median(D_list)\\n med_unc = np.median(Dunc_list)\\n print \\\"median = {} +/- {} for {}\\\".format(median,med_unc,fdd_param_keys[j])\\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\\\"steps-mid\\\",zorder=2) # Plotting data\\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\\n axs[5*j+3].ticklabel_format(useOffset=False)\\n axs[5*j+3].tick_params('y',colors='b')\\n axs[5*j+3].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\\n axs[5*j+4] = axs[5*j+3].twinx()\\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\\\"steps-mid\\\",zorder=1)\\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\\n axs[5*j+4].tick_params('y',colors='r')\\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\\n # Third column of subplots (number of iterations)\\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\\\"steps-mid\\\") # Plotting n_iter_list\\n# axs[5*j+5].yaxis.tick_right()\\n# axs[5*j+5].yaxis.set_label_position(\\\"right\\\")\\n axs[5*j+5].set_ylabel('N iterations')\\n axs[5*j+5].ticklabel_format(useOffset=False)\\n axs[5*j+5].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\\\":\\\") # indicate fdd from vp_setup.dat\\n\\n# plt.tight_layout()\\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\\n plt.savefig(\\\"fdd_plot.pdf\\\",bbox_inches='tight', pad_inches=0)\\n plt.show()\\n plt.close()\\n print \\\" Plot is done!\\\"\",\n \"def test3():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def Diagnostic_plot2(self):\\n\\n probs = pd.read_csv(self.probfile)\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n plt.scatter(probs['f0'], probs['Pdet_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['Pdet_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['Pdet_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_Pdet' + self.ds.epic + '.pdf')\\n\\n fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'SNR')\\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs')\\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr')\\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days')\\n plt.legend(loc='lower right')\\n #plt.ylim([0,1])\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot2_SNR' + self.ds.epic + '.pdf')\",\n \"def plot_analytic_curve_loop(ax, n_HArr, tempArr, pltkwarg, txList, xr, yr, delta, fs=8):\\n\\t\\n\\tfor icol in xrange(tempArr.shape[1]):\\n\\t\\tax.plot(n_HArr, tempArr[:, icol], **pltkwarg)\\n\\n\\t\\tif len(txList) > 0:\\n\\t\\t\\ttxloc = get_text_loc_axis_coord(n_HArr, tempArr[:, icol], xr, yr, delta)\\n\\t\\t\\tax.text(txloc[0], txloc[1], txList[icol], fontsize=fs, horizontalalignment=\\\"center\\\", verticalalignment=\\\"center\\\", transform=ax.transAxes)\",\n \"def plot_dynamics(\\n df: pandas.DataFrame, prop: str, title: Optional[str] = None, scale: str = \\\"linear\\\"\\n) -> alt.Chart:\\n if title is None:\\n title = prop\\n axis_format = \\\"g\\\"\\n if scale == \\\"log\\\":\\n axis_format = \\\"e\\\"\\n\\n dyn_chart_base = (\\n alt.Chart(df)\\n .encode(\\n x=alt.X(\\n \\\"time\\\",\\n title=\\\"Time\\\",\\n scale=alt.Scale(type=\\\"log\\\"),\\n axis=alt.Axis(format=\\\"e\\\"),\\n ),\\n color=alt.Color(\\\"temperature:N\\\", title=\\\"Temperature\\\"),\\n y=alt.Y(\\n prop + \\\"_mean:Q\\\",\\n title=title,\\n scale=alt.Scale(type=scale),\\n axis=alt.Axis(format=axis_format),\\n ),\\n yError=alt.YError(prop + \\\"_sem:Q\\\"),\\n )\\n .transform_filter(alt.datum.msd_mean < 50)\\n )\\n\\n return dyn_chart_base.mark_errorband() + dyn_chart_base.mark_line()\",\n \"def plot_ave(pulse, trap, ToP):\\n time_array = np.linspace(0, pulse.t * trap.N, trap.N + 1)\\n # fig, ax = plt.subplots()\\n all_trial_n, all_trial_n_ave = trap.sideband_cool_sch(pulse, ave = True)\\n if ToP == 'a':\\n plt.plot(time_array * 1e3, all_trial_n_ave, label = pulse.t)\\n if ToP == 'b':\\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'magenta', linewidth = 3, label = 'Monte Carlo')\\n if ToP == 'c':\\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'b')\\n if ToP == 'd':\\n if trap.no_decay == True and trap.off_resonant_excite == False:\\n plt.plot(time_array * 1e3, all_trial_n_ave, label = 'Decay to carrier')\\n if trap.no_decay == False and trap.off_resonant_excite == False:\\n plt.plot(time_array * 1e3, all_trial_n_ave, \\n label = 'Decay to %s sideband'%(trap.sideband))\\n if trap.no_decay == False and trap.off_resonant_excite == True:\\n plt.plot(time_array * 1e3, all_trial_n_ave, \\n label = 'Decay to %s sideband, off-resonant excite'%(trap.sideband))\\n # plt.xlabel('time / ms')\\n # plt.ylabel('Phonon State')\\n # plt.legend()\",\n \"def plotsurvey(filename='obslist_all.fits', plot_type='f', program='m'): \\n\\n t = Table.read(filename, format='fits')\\n\\n if plot_type == 'f':\\n fig, ax = plt.subplots()\\n ra = t['RA']\\n ra[ra>300.0] -= 360.0\\n dec = t['DEC']\\n mjd = t['MJD']\\n mjd_start = np.min(mjd)\\n mjd -= mjd_start\\n\\n if program=='a':\\n i1 = np.where( mjd/365.0 < 1.0 )\\n i2 = np.where( (mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0) )\\n i3 = np.where( (mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0) )\\n i4 = np.where( (mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0) )\\n i5 = np.where( (mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0) )\\n elif program=='m':\\n i1 = np.where( (mjd/365.0 < 1.0) & (t['PROGRAM']!='BRIGHT') )\\n i2 = np.where( ((mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0)) & (t['PROGRAM']!='BRIGHT') )\\n i3 = np.where( ((mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0)) & (t['PROGRAM']!='BRIGHT') )\\n i4 = np.where( ((mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0)) & (t['PROGRAM']!='BRIGHT') )\\n i5 = np.where( ((mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0)) & (t['PROGRAM']!='BRIGHT') )\\n elif program=='b':\\n i1 = np.where( (mjd/365.0 < 1.0) & (t['PROGRAM']=='BRIGHT') )\\n i2 = np.where( ((mjd/365.0 >= 1.0) & (mjd/365.0 < 2.0)) & (t['PROGRAM']=='BRIGHT') )\\n i3 = np.where( ((mjd/365.0 >= 2.0) & (mjd/365.0 < 3.0)) & (t['PROGRAM']=='BRIGHT') )\\n i4 = np.where( ((mjd/365.0 >= 3.0) & (mjd/365.0 < 4.0)) & (t['PROGRAM']=='BRIGHT') )\\n i5 = np.where( ((mjd/365.0 >= 4.0) & (mjd/365.0 < 5.0)) & (t['PROGRAM']=='BRIGHT') )\\n else:\\n print(\\\"if set, program should be a, m or b; default is m.\\\\n\\\")\\n return\\n y1 = plt.scatter(ra[i1], dec[i1], c='r', marker='.')\\n y2 = plt.scatter(ra[i2], dec[i2], c='b', marker='.')\\n y3 = plt.scatter(ra[i3], dec[i3], c='g', marker='.')\\n y4 = plt.scatter(ra[i4], dec[i4], c='y', marker='.')\\n y5 = plt.scatter(ra[i5], dec[i5], c='m', marker='.')\\n\\n plt.xlabel('RA (deg)')\\n plt.ylabel('DEC (deg)')\\n plt.legend((y1, y2, y3, y4, y5), ('Year 1', 'Year 2', 'Year 3', 'Year 4', 'Year 5'), scatterpoints=1, loc=2)\\n ticks = ax.get_xticks()\\n ticks[ticks < 0] += 360\\n ax.set_xticklabels([int(tick) for tick in ticks])\\n\\n elif plot_type == 'h':\\n if (program=='m'):\\n i = np.where( t['PROGRAM'] != 'BRIGHT')\\n elif (program=='b'):\\n i = np.where( t['PROGRAM'] == 'BRIGHT')\\n elif (program=='a'):\\n i = np.arange(len(t['PROGRAM']))\\n else:\\n print(\\\"if set, program should be a, m or b; default is m.\\\\n\\\")\\n return\\n\\n plt.figure(1)\\n plt.subplot(231)\\n x = t['EXPTIME']\\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Exposure time (seconds)')\\n plt.ylabel('Count')\\n\\n plt.subplot(232)\\n x = t['SEEING']\\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Seeing (arcseconds)')\\n plt.ylabel('Count')\\n\\n plt.subplot(233)\\n x = t['LINTRANS']\\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Linear transparency')\\n plt.ylabel('Count')\\n\\n plt.subplot(234)\\n x = t['AIRMASS']\\n n, bins, patches = plt.hist(x[i], 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Airmass')\\n plt.ylabel('Count')\\n\\n plt.subplot(235)\\n y1 = t['MOONALT']\\n y2 = y1[i]\\n x1 = t['MOONFRAC']\\n x2 = x1[i]\\n x = x2.compress((y2>0.0).flat)\\n n, bins, patches = plt.hist(x, 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Moon illumination fraction')\\n plt.ylabel('Count')\\n\\n plt.subplot(236)\\n y = t['MOONALT']\\n y2 = y[i]\\n x1 = t['MOONDIST']\\n x2 = x1[i]\\n x = x2.compress((y2>0.0).flat)\\n n, bins, patches = plt.hist(x, 20, facecolor='0.5', alpha=0.75)\\n plt.xlabel('Distance from the Moon (deg)')\\n plt.ylabel('Count')\\n\\n elif plot_type == 't':\\n if (program=='m'):\\n i = np.where( t['PROGRAM'] != 'BRIGHT')\\n elif (program=='b'):\\n i = np.where( t['PROGRAM'] == 'BRIGHT')\\n elif (program=='a'):\\n i = np.arange(len(t['PROGRAM']))\\n else:\\n print(\\\"if set, program should be a, m or b; default is m.\\\\n\\\")\\n return\\n \\n mjd = t['MJD']\\n mjd_start = np.min(mjd)\\n mjd -= mjd_start\\n plt.figure(1)\\n\\n plt.subplot(221)\\n y = t['MOONALT']\\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\\n plt.xlabel('Days')\\n plt.ylabel('Moon elevation (degrees)')\\n\\n plt.subplot(222)\\n y = t['SEEING']\\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\\n plt.xlabel('Days')\\n plt.ylabel('Seeing (arcseconds)')\\n\\n plt.subplot(223)\\n y = t['LINTRANS']\\n plt.plot(mjd[i], y[i], linestyle='-', color='black')\\n plt.xlabel('Days')\\n plt.ylabel('Linear transparency')\\n\\n plt.subplot(224)\\n if (program=='b'):\\n x = mjd[t['PROGRAM']=='BRIGHT']\\n elif (program=='m'):\\n x = mjd[t['PROGRAM']!='BRIGHT']\\n elif (program=='a'):\\n x = mjd\\n y = np.arange(len(x)) + 1\\n #y = np.arange(len(mjd)) + 1\\n #plt.plot(mjd[i], y[i], linestyle='-', color='black')\\n plt.plot(x, y, linestyle='-', color='black')\\n plt.xlabel('Days')\\n plt.ylabel('Number of tiles observed')\\n\\n\\n elif plot_type == 'e':\\n y = t['EXPTIME']\\n if (program=='m'):\\n i = np.where( t['PROGRAM'] != 'BRIGHT')\\n elif (program=='b'):\\n i = np.where( t['PROGRAM'] == 'BRIGHT')\\n elif (program=='a'):\\n i = np.arange(len(y))\\n else:\\n print(\\\"if set, program should be a, m or b; default is m.\\\\n\\\")\\n return\\n plt.figure(1)\\n\\n plt.subplot(221)\\n x = t['LINTRANS']\\n plt.scatter(x[i], y[i], marker='.', color='black')\\n plt.xlabel('Linear transparency')\\n plt.ylabel('Exposure time (seconds)')\\n\\n plt.subplot(222)\\n x = t['SEEING']\\n plt.scatter(x[i], y[i], marker='.', color='black')\\n plt.xlabel('Seeing (arcseconds)')\\n plt.ylabel('Exposure time (seconds)')\\n\\n plt.subplot(223)\\n x = t['EBMV']\\n plt.scatter(x[i], y[i], marker='.', color='black')\\n plt.xlabel('E(B-V)')\\n plt.ylabel('Exposure time (seconds)')\\n\\n plt.subplot(224)\\n x = t['AIRMASS']\\n plt.scatter(x[i], y[i], marker='.', color='black')\\n plt.xlabel('Airmass')\\n plt.ylabel('Exposure time (seconds)')\\n\\n plt.show()\",\n \"def plot_anomalies(data, Species, family, syndrome, window_size, sigma, time_bin = 'W', save = False, verbose = False):\\n \\n #result = test_stationarity(SpeciesName=Species, data = data)\\n #result.plot()\\n if Species == 'None':\\n vo = data[(data.family == family) & (data.prediction_adjusted == syndrome)]\\n else:\\n vo = data[(data.ScientificName == Species) & (data.prediction_adjusted == syndrome)]\\n \\n weekly_vo = vo.resample(time_bin)['WRMD_ID'].count()\\n weekly_vo = pd.DataFrame(weekly_vo)\\n weekly_vo.columns = ['ID']\\n weekly_vo['rolling_mean'] = weekly_vo.ID.rolling(window = window_size, center = False).mean()\\n weekly_vo['residual'] = weekly_vo.ID - weekly_vo.rolling_mean\\n weekly_vo['std'] = weekly_vo.residual.std(axis=0)\\n\\n weekly_vo['testing_std'] = weekly_vo.residual.rolling(window= window_size, center= False).std()\\n weekly_vo.testing_std.fillna(weekly_vo.testing_std.mean(), inplace= True)\\n \\n def identify_anomalies(c, sigma=sigma):\\n if c.ID > c.rolling_mean + (sigma*c.testing_std):\\n return c.ID\\n weekly_vo['anomalies'] = weekly_vo.apply(identify_anomalies, axis=1)\\n weekly_vo.columns = ['# admissions', 'rolling mean', 'std', 'residual', 'rolling std', 'anomalies']\\n \\n upper_bound = go.Scatter(\\n name='upper Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] + (2*weekly_vo['rolling std']),\\n mode='lines',\\n marker=dict(color=\\\"#820101\\\"),\\n line=dict(width=0),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n \\n rolling_m = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['rolling mean'],\\n name='rolling mean',\\n mode='lines',\\n line=dict(color='#1f77b4'),\\n fillcolor='#b7b7b7',\\n fill='tonexty' )\\n\\n lower_bound = go.Scatter(\\n name='lower Bound',\\n x=weekly_vo.index,\\n y=weekly_vo['rolling mean'] - (2*weekly_vo['rolling std']),\\n marker=dict(color=\\\"#b7b7b7\\\"),\\n line=dict(width=0),\\n mode='lines',)\\n\\n addmissions = go.Scatter(\\n x = weekly_vo.index,\\n y = weekly_vo['# admissions'],\\n name='# admissions',)\\n\\n ano = go.Scatter(\\n x = weekly_vo.index,\\n y =weekly_vo['anomalies'] ,\\n name='anomalies',\\n mode='markers')\\n\\n plottingdata = [lower_bound, rolling_m,upper_bound, addmissions, ano]\\n if Species == 'None':\\n T = \\\"Weekly admissions of \\\"+ str(family)+' ('+syndrome+')',\\n else:\\n T = \\\"Weekly admissions of \\\"+ str(Species)+' ('+syndrome+')',\\n print (T)\\n layout = go.Layout(\\n title= 'Weekly admissions',\\n yaxis=dict( title='number of admissions',), width=900, height=640\\n )\\n\\n fig = go.Figure(data=plottingdata, layout=layout)\\n plot_url = iplot(fig)\\n if verbose:\\n print('number of admissions triggering alert') \\n print(weekly_vo[weekly_vo['anomalies'].notnull()]['anomalies'])\\n if save:\\n name = family+Species+syndrome\\n py.image.save_as(fig, filename='C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'.png')\\n #pio.write_image(fig, 'C:/Users/Falco/Desktop/directory/WMRD/data/'+name+'2.png')\\n\\n #from IPython.display import Image\\n #Image('C:\\\\Users\\\\Falco\\\\Desktop\\\\directory\\\\WMRD\\\\data\\\\TimeSeries.png')\\n \\n return weekly_vo\",\n \"def _debugPlotExamplesOfAll():\\n\\tbpData(plot=True)\\n\\tcapBankData(plot=True)\\n\\tcos1RogowskiData(plot=True)\\n\\tquartzJumperData(plot=True)\\n\\tfbData(plot=True)\\n\\tipData(plot=True)\\n\\tloopVoltageData(plot=True)\\n\\tmModeData(plot=True)\\n\\tnModeData(plot=True)\\n\\tpaData(plot=True)\\n\\tplasmaRadiusData(plot=True)\\n\\tqStarData(plot=True)\\n\\tsolData(plot=True)\\n\\tspectrometerData(plot=True)\\n\\ttaData(plot=True)\\n\\ttfData(plot=True)\\n\\ttpData(plot=True)\\n\\tsxrData(plot=True)\",\n \"def plot_proof_functions():\\n\\n def thm1_D(x):\\n return abs(1 / (2 + x) - 3 / (5 + x)) + abs(1 / (2 + x) - 2 / (5 + x))\\n\\n def thm2_D(x):\\n return abs(2 / (2 + x) - (1 / 2) / ((1 / 2) + x))\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 2, 1000)\\n\\n plt.plot(x, thm1_D(x))\\n plt.xlim(0, 2)\\n plt.ylim(0.15, 0.22)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 6, 0, 2, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm1_D.pdf', bbox_inches='tight')\\n plt.xticks(range(3), range(3))\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm1_D.pdf')\\n\\n plt.figure(figsize=(2, 1.5))\\n x = np.linspace(0, 5, 1000)\\n plt.vlines(1, 0, 1, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.hlines(1 / 3, 0, 5, linestyles='dashed', colors='grey', alpha=0.5)\\n plt.plot(x, thm2_D(x))\\n plt.xlim(0, 5)\\n plt.ylim(0, 0.4)\\n plt.xticks(range(6), range(6))\\n\\n plt.ylabel('$D(Z)$')\\n plt.xlabel('$s_Z / t$')\\n plt.savefig('plots/thm2_D.pdf', bbox_inches='tight')\\n plt.close()\\n\\n print(f'Saved plot to: plots/thm2_D.pdf')\",\n \"def plots(self, events=None, title=None):\\n data = self.data\\n P = PH.regular_grid(3 , 1, order='columnsfirst', figsize=(8., 6), showgrid=False,\\n verticalspacing=0.08, horizontalspacing=0.08,\\n margins={'leftmargin': 0.07, 'rightmargin': 0.20, 'topmargin': 0.03, 'bottommargin': 0.1},\\n labelposition=(-0.12, 0.95))\\n scf = 1e12\\n ax = P.axarr\\n ax = ax.ravel()\\n PH.nice_plot(ax)\\n for i in range(1,2):\\n ax[i].get_shared_x_axes().join(ax[i], ax[0])\\n # raw traces, marked with onsets and peaks\\n tb = self.timebase[:len(data)]\\n ax[0].plot(tb, scf*data, 'k-', linewidth=0.75, label='Data') # original data\\n ax[0].plot(tb[self.onsets], scf*data[self.onsets], 'k^', \\n markersize=6, markerfacecolor=(1, 1, 0, 0.8), label='Onsets')\\n if len(self.onsets) is not None:\\n# ax[0].plot(tb[events], data[events], 'go', markersize=5, label='Events')\\n# ax[0].plot(tb[self.peaks], self.data[self.peaks], 'r^', label=)\\n ax[0].plot(tb[self.smpkindex], scf*np.array(self.smoothed_peaks), 'r^', label='Smoothed Peaks')\\n ax[0].set_ylabel('I (pA)')\\n ax[0].set_xlabel('T (s)')\\n ax[0].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n \\n # deconvolution trace, peaks marked (using onsets), plus threshold)\\n ax[1].plot(tb[:self.Crit.shape[0]], self.Crit, label='Deconvolution') \\n ax[1].plot([tb[0],tb[-1]], [self.sdthr, self.sdthr], 'r--', linewidth=0.75, \\n label='Threshold ({0:4.2f}) SD'.format(self.sdthr))\\n ax[1].plot(tb[self.onsets]-self.idelay, self.Crit[self.onsets], 'y^', label='Deconv. Peaks')\\n if events is not None: # original events\\n ax[1].plot(tb[:self.Crit.shape[0]][events], self.Crit[events],\\n 'ro', markersize=5.)\\n ax[1].set_ylabel('Deconvolution')\\n ax[1].set_xlabel('T (s)')\\n ax[1].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n# print (self.dt, self.template_tmax, len(self.template))\\n # averaged events, convolution template, and fit\\n if self.averaged:\\n ax[2].plot(self.avgeventtb[:len(self.avgevent)], scf*self.avgevent, 'k', label='Average Event')\\n maxa = np.max(self.sign*self.avgevent)\\n #tpkmax = np.argmax(self.sign*self.template)\\n if self.template is not None:\\n maxl = int(np.min([len(self.template), len(self.avgeventtb)]))\\n temp_tb = np.arange(0, maxl*self.dt, self.dt)\\n #print(len(self.avgeventtb[:len(self.template)]), len(self.template))\\n ax[2].plot(self.avgeventtb[:maxl], scf*self.sign*self.template[:maxl]*maxa/self.template_amax, \\n 'r-', label='Template')\\n # compute double exp based on rise and decay alone\\n # print('res rise: ', self.res_rise)\\n # p = [self.res_rise.x[0], self.res_rise.x[1], self.res_decay.x[1], self.res_rise.x[2]]\\n # x = self.avgeventtb[:len(self.avg_best_fit)]\\n # y = self.doubleexp(p, x, np.zeros_like(x), risepower=4, fixed_delay=0, mode=0)\\n # ax[2].plot(x, y, 'b--', linewidth=1.5)\\n tau1 = np.power(10, (1./self.risepower)*np.log10(self.tau1*1e3)) # correct for rise power\\n tau2 = self.tau2*1e3\\n ax[2].plot(self.avgeventtb[:len(self.avg_best_fit)], scf*self.avg_best_fit, 'c--', linewidth=2.0,\\n label='Best Fit:\\\\nRise Power={0:.2f}\\\\nTau1={1:.3f} ms\\\\nTau2={2:.3f} ms\\\\ndelay: {3:.3f} ms'.\\n format(self.risepower, self.res_rise.x[1]*1e3, self.res_decay.x[1]*1e3, self.bfdelay*1e3))\\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.rise_fit, 'g--', linewidth=1.0,\\n # label='Rise tau {0:.2f} ms'.format(self.res_rise.x[1]*1e3))\\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.decay_fit, 'm--', linewidth=1.0,\\n # label='Decay tau {0:.2f} ms'.format(self.res_decay.x[1]*1e3))\\n if title is not None:\\n P.figure_handle.suptitle(title)\\n ax[2].set_ylabel('Averaged I (pA)')\\n ax[2].set_xlabel('T (s)')\\n ax[2].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n if self.fitted:\\n print('measures: ', self.risetenninety, self.decaythirtyseven)\\n mpl.show()\",\n \"def get_vshape(self, dmax, plot=True):\\n '''\\n\\n '''\\n dists_label = np.linspace(0.001, dmax, 200)\\n dists = np.concatenate([[0], np.linspace(0.001, dmax, 200)])/np.sqrt(2)\\n dists_xy = np.stack([dists, dists], 1)\\n dist_mat = self.get_distance_matrix(dists_xy[None, :, :])\\n v_vect = self.V_vect(dist_mat)[0, 0, 1:]\\n\\n if plot:\\n _, ax = plt.subplots(dpi=150)\\n plt.title(\\\"Lennard-Jones Potential\\\")\\n plt.xlabel(\\\"interaction distance\\\")\\n plt.ylabel(\\\"potential\\\")\\n plt.plot(dists_label, v_vect, c=\\\"blue\\\")\\n plt.axvline(x=self.d_coll, color=\\\"red\\\", linestyle=\\\"dashed\\\", linewidth=1)\\n plt.annotate(r\\\"$d_{coll}$\\\", (self.d_coll, np.min(v_vect)), textcoords=\\\"offset points\\\", xytext=(15, -5), ha='center', color=\\\"red\\\")\\n plt.axvline(x=self.d_attr, color=\\\"black\\\", linestyle=\\\"dashed\\\", linewidth=1)\\n plt.annotate(r\\\"$d_{eq}$\\\", (self.d_attr, np.min(v_vect)), textcoords=\\\"offset points\\\", xytext=(15, -5), ha='center')\\n plt.semilogy()\\n\\n axins = ax.inset_axes([0.67, 0.67, 0.3, 0.3])\\n axins.set_xlim(0.15, 0.4)\\n axins.set_ylim(-0.2, 2)\\n\\n axins.plot(dists_label, v_vect, c=\\\"blue\\\")\\n axins.axvline(x=self.d_attr, color=\\\"black\\\", linestyle=\\\"dashed\\\", linewidth=1)\\n axins.annotate(r\\\"$d_{eq}$\\\", (self.d_attr, np.min(v_vect)), textcoords=\\\"offset points\\\", xytext=(15, -5), ha='center')\\n\\n plt.show()\\n\\n return dists_label, v_vect\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plot(self, dtables, figs, **kwargs):\\n self.safe_update(**kwargs)\\n sumtable = dtables['biasoscorr_stats']\\n figs.plot_stat_color('mean-s', sumtable['s_correl_mean'].reshape(9, 16))\\n figs.plot_stat_color('mean-p', sumtable['p_correl_mean'].reshape(9, 16))\",\n \"def bodePlot(H_s,w_range=(0,8),points=800):\\n \\n w = logspace(*w_range,points)\\n h_s = lambdify(s,H_s,'numpy')\\n H_jw = h_s(1j*w)\\n \\n # find mag and phase\\n mag = 20*np.log10(np.abs(H_jw))\\n phase = angle(H_jw,deg = True)\\n \\n eqn = Eq(H,simplify(H_s))\\n display(eqn)\\n \\n fig,axes = plt.subplots(1,2,figsize=(18,6))\\n ax1,ax2 = axes[0],axes[1]\\n \\n # mag plot\\n ax1.set_xscale('log')\\n ax1.set_ylabel('Magntiude in dB')\\n ax1.set_xlabel('$\\\\omega$ in rad/s')\\n ax1.plot(w,mag)\\n ax1.grid()\\n ax1.set_title(\\\"Magnitude of $H(j \\\\omega)$\\\")\\n \\n # phase plot\\n ax2.set_ylabel('Phase in degrees')\\n ax2.set_xlabel('$\\\\omega$ in rad/s')\\n ax2.set_xscale('log')\\n ax2.plot(w,phase)\\n ax2.grid()\\n ax2.set_title(\\\"Phase of $H(j \\\\omega)$\\\")\\n \\n plt.show()\",\n \"def _plot(x, mph, mpd, threshold, edge, valley, ax, ind):\\n try:\\n import matplotlib.pyplot as plt\\n except ImportError:\\n print('matplotlib is not available.')\\n else:\\n if ax is None:\\n _, ax = plt.subplots(1, 1, figsize=(8, 4))\\n\\n ax.plot(x, 'b', lw=1)\\n if ind.size:\\n label = 'valley' if valley else 'peak'\\n label = label + 's' if ind.size > 1 else label\\n ax.plot(ind, x[ind], '+', mfc=None, mec='r', mew=2, ms=8,\\n label='%d %s' % (ind.size, label))\\n ax.legend(loc='best', framealpha=.5, numpoints=1)\\n ax.set_xlim(-.02*x.size, x.size*1.02-1)\\n ymin, ymax = x[np.isfinite(x)].min(), x[np.isfinite(x)].max()\\n yrange = ymax - ymin if ymax > ymin else 1\\n ax.set_ylim(ymin - 0.1*yrange, ymax + 0.1*yrange)\\n ax.set_xlabel('Data #', fontsize=14)\\n ax.set_ylabel('Amplitude', fontsize=14)\\n mode = 'Valley detection' if valley else 'Peak detection'\\n #ax.set_title(\\\"Deuxième détection\\\")\\n ax.set_title(\\\"%s (mph=%s, mpd=%d, threshold=%s, edge='%s')\\\"\\n % (mode, str(mph), mpd, str(threshold), edge))\\n # plt.grid()\\n plt.show()\",\n \"def plotPage1(self, EU=True, IEM=True, RK=True, ES=True):\\n\\n figure = plt.figure()\\n figure.subplots_adjust(top=0.76)\\n figure.suptitle('ODE: ' + self._IVP.getLatexODE() + '\\\\nGeneral Solution: ' + self._IVP.getLatexGeneralSolution(), fontsize=15, y=1)\\n\\n functionGraph = figure.add_subplot(311)\\n functionGraph.set_title('Exact Solution: ' + self._IVP.getLatexExact1() + f'{self._IVP.getC():G}' + self._IVP.getLatexExact2() + ' ', fontsize=15)\\n functionGraph.set_xlabel('X-values')\\n functionGraph.set_ylabel('Y-values')\\n\\n errorGraph = figure.add_subplot(313)\\n errorGraph.set_title('Truncation errors', fontsize=15)\\n errorGraph.set_xlabel('X-values')\\n errorGraph.set_ylabel('Error-values')\\n\\n if EU == True:\\n euler = EulerMethod(self._IVP)\\n functionGraph.plot(euler.getXArray(), euler.getYArray(), color='green', label='Euler')\\n errorGraph.plot(euler.getXArray(), euler.getTruncationErrors(), color='green', label='Euler')\\n\\n if IEM == True:\\n improvedEuler = ImprovedEulerMethod(self._IVP)\\n functionGraph.plot(improvedEuler.getXArray(), improvedEuler.getYArray(), color='red', label='Improved Euler')\\n errorGraph.plot(improvedEuler.getXArray(), improvedEuler.getTruncationErrors(), color='red', label='Improved Euler')\\n \\n if RK == True:\\n rungeKutta = RungeKutta(self._IVP)\\n functionGraph.plot(rungeKutta.getXArray(), rungeKutta.getYArray(), color='orange', label='Runge-Kutta')\\n errorGraph.plot(rungeKutta.getXArray(), rungeKutta.getTruncationErrors(), color='orange', label='Runge-Kutta')\\n\\n if ES == True:\\n exactSolution = AnalyticalSolution(self._IVP)\\n functionGraph.plot(exactSolution.getXArray(), exactSolution.getYArray(), color='blue', label='Exact')\\n \\n functionGraph.legend(loc='lower right')\\n errorGraph.legend(loc='lower right')\\n\\n return figure\",\n \"def plot():\\n pass\",\n \"def plot(self, ax=None, savefile=None, shells=None, color='b', title=None,\\n xlabel=None, ylabel=None, withavg=False):\\n import matplotlib.pyplot as plt\\n if ax is None:\\n plt.figure()\\n axset=plt\\n else:\\n axset=ax\\n\\n cmax = float(max(self.counts))\\n total = sum(self.counts)\\n nalpha = 0.85 if cmax/total > 0.33 else 0.65\\n maxy = 1.\\n for di, df in enumerate(self.dfs):\\n alpha=nalpha*self.counts[di]/cmax\\n axset.plot(df.x, df.df, color=color, alpha=alpha)\\n maxy_ = np.max(df.df)\\n if maxy_ > maxy:\\n maxy = maxy_\\n\\n if withavg and len(self) > 0:\\n x = self.dfs[0].x\\n axset.plot(x, self.average, 'r-')\\n maxy_ = np.max(self.average)\\n if maxy_ > maxy:# pragma: no cover\\n maxy = maxy_\\n\\n if len(self) > 0:\\n dtype = self.dfs[0].dtype\\n unit = \\\"Ang.\\\" if dtype == \\\"R\\\" else \\\"Rad.\\\"\\n tstr = \\\"Radial\\\" if dtype == \\\"R\\\" else \\\"Angular\\\"\\n else:# pragma: no cover\\n unit = \\\"unknown units\\\"\\n tstr = \\\"\\\"\\n \\n if ax is None:\\n if title is None:\\n plt.title(\\\"{} Distribution Function of Collection\\\".format(tstr))\\n else:\\n plt.title(title)\\n if xlabel is None:\\n plt.xlabel(\\\"Distance ({})\\\".format(unit))\\n else:\\n plt.xlabel(xlabel)\\n if ylabel is None:\\n plt.ylabel(\\\"Accumulated Density\\\")\\n else:\\n plt.ylabel(ylabel)\\n\\n _plot_shells(axset, shells, maxy)\\n \\n if savefile is not None:\\n plt.savefig(savefile)\\n\\n from gblearn.base import testmode\\n if not testmode:# pragma: no cover\\n plt.show()\\n return axset\",\n \"def vis_eICU_patients_downsampled(pat_arrs, time_step, time_steps_to_plot=None,\\n variable_names=['sao2', 'heartrate', 'respiration', 'systemicmean'],\\n identifier=None, idx=0):\\n # set up the plot\\n fig, axarr = plt.subplots(len(variable_names), 1, sharex=True, figsize=(6.5, 9))\\n # fix the same colour for each patient for each axis\\n n_patients = pat_arrs.shape[0]\\n colours = [hsv_to_rgb((i/n_patients, 0.8, 0.8)) for i in range(n_patients)]\\n for (i, pat_arr) in enumerate(pat_arrs):\\n if not time_steps_to_plot is None:\\n pat_arr = pat_arr[0:time_steps_to_plot]\\n for col, ax in zip(range(pat_arr.shape[1]), axarr):\\n ax.plot(range(0, len(pat_arr)*time_step, time_step), pat_arr[:,col], alpha=0.5, color=colours[i])\\n # aesthetics\\n xmin, xmax = axarr[0].get_xlim()\\n for variable, ax in zip(variable_names, axarr):\\n ax.set_ylabel(variable)\\n ax.get_yaxis().set_label_coords(-0.15,0.5)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"left\\\"].set_visible(False)\\n ax.tick_params(bottom='off')\\n #ax.set_facecolor((0.96, 0.96, 0.96))\\n ymin, ymax = ax.get_ylim()\\n # expand the ylim ever so slightly\\n yrange = np.abs(ymax - ymin)\\n ybuffer = yrange*0.08\\n ymin_new = ymin - ybuffer\\n ymax_new = ymax + ybuffer\\n for x in np.linspace(xmin, xmax - (xmax - xmin)*0.005, num=10):\\n ax.plot((x, x), (ymin_new, ymax_new), ls='dotted', lw=0.5, color='black', alpha=0.25, zorder=0)\\n #ax.set_ylim(ymin_new, ymax_new)\\n ax.set_ylim(-1.5, 1.5)\\n axarr[-1].set_xlabel(\\\"time since admision (minutes)\\\")\\n axarr[-1].get_xaxis().tick_bottom()\\n if not identifier is None:\\n plt.suptitle(idx)\\n fig.savefig(\\\"./experiments/plots/\\\" + identifier + \\\"_epoch\\\" + str(idx).zfill(4) + \\\".png\\\", bbox_inches='tight')\\n else:\\n fig.savefig('./experiments/plots/eICU_patients.png', bbox_inches='tight')\\n plt.clf()\\n plt.close()\\n return True\",\n \"def plotLogs(d, rho, v, usingT=True):\\n d = np.sort(d)\\n\\n dpth, rholog, vlog, zlog, rseries = getLogs(d, rho, v, usingT)\\n nd = len(dpth)\\n\\n\\n xlimrho = (1.95,5.05)\\n xlimv = (0.25,4.05)\\n xlimz = (xlimrho[0]*xlimv[0], xlimrho[1]*xlimv[1])\\n\\n # Plot Density\\n plt.figure(1)\\n\\n plt.subplot(141)\\n plotLogFormat(rholog*10**-3,dpth,xlimrho,'blue')\\n plt.title('$\\\\\\\\rho$')\\n plt.xlabel('Density \\\\n $\\\\\\\\times 10^3$ (kg /m$^3$)',fontsize=9)\\n plt.ylabel('Depth (m)',fontsize=9)\\n\\n plt.subplot(142)\\n plotLogFormat(vlog*10**-3,dpth,xlimv,'red')\\n plt.title('$v$')\\n plt.xlabel('Velocity \\\\n $\\\\\\\\times 10^3$ (m/s)',fontsize=9)\\n plt.setp(plt.yticks()[1],visible=False)\\n\\n plt.subplot(143)\\n plotLogFormat(zlog*10.**-6.,dpth,xlimz,'green')\\n plt.gca().set_title('$Z = \\\\\\\\rho v$')\\n plt.gca().set_xlabel('Impedance \\\\n $\\\\\\\\times 10^{6}$ (kg m$^{-2}$ s$^{-1}$)',fontsize=9)\\n plt.setp(plt.yticks()[1],visible=False)\\n\\n plt.subplot(144)\\n plt.hlines(d[1:],np.zeros(len(d)-1),rseries,linewidth=2)\\n plt.plot(np.zeros(nd),dpth,linewidth=2,color='black')\\n plt.title('Reflectivity');\\n plt.xlim((-1.,1.))\\n plt.gca().set_xlabel('Reflectivity')\\n plt.grid()\\n plt.gca().invert_yaxis()\\n plt.setp(plt.xticks()[1],rotation='90',fontsize=9)\\n plt.setp(plt.yticks()[1],visible=False)\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def figure8():\\n\\n plot_settings = {'y_limits': [15, 60],\\n 'x_limits': None,\\n 'y_ticks': [20, 30, 40, 50, 60],\\n 'locator_size': 5,\\n 'y_label': 'ISI (ms)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_8',\\n 'legend': ['First ISI', 'Second ISI'],\\n 'legend_size': 8,\\n 'y_on': True,\\n 'legend_location': 4}\\n\\n g_t_bars = np.linspace(0.02, 0.2, 10)\\n isi = np.zeros((len(g_t_bars), 2))\\n\\n for ix, g_t_bar in enumerate(g_t_bars):\\n t, y = solver(200, t_start=15, duration=260, g_t_bar=g_t_bar)\\n t_spike, f = spike_times(t, y[:, 0])\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_t_bars[3], 35, 0, 11, head_width=0, head_length=0, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[3], 46, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[3], 35, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Acceleration\\\", (0.1, 35), fontsize=8)\\n plt.gca().annotate(\\\"Adaptation\\\", (0.01, 46), fontsize=8)\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n g_n_bars = np.linspace(0.02, 0.2, 10)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_n_bar in enumerate(g_n_bars):\\n t, y = solver(200, g_n_bar=g_n_bar, duration=260, t_start=15, g_t_bar=0.02)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_n_bars[3], 30, 0, 10, head_width=0, head_length=0, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[3], 40, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[3], 30, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Acceleration\\\", (0.1, 30), fontsize=8)\\n plt.gca().annotate(\\\"Adaptation\\\", (0.015, 40), fontsize=8)\\n plot_settings['y_ticks'] = []\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['y_on'] = False\\n plot_settings['legend_location'] = 4\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n g_t_bars = np.linspace(0.02, 0.16, 8)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_t_bar in enumerate(g_t_bars):\\n t, y = solver(200, g_t_bar=g_t_bar, duration=260, t_start=15, ca_type=1)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_t_bars[2], 25, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[4], 25, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Adaptation\\\", (0.06, 25), fontsize=8)\\n\\n plot_settings['y_limits'] = [0, 45]\\n plot_settings['y_ticks'] = [0, 10, 20, 30, 40]\\n plot_settings['locator_size'] = 5\\n plot_settings['y_label'] = 'ISI (ms)'\\n plot_settings['y_on'] = True\\n plot_settings['legend_location'] = 3\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 4)\\n g_n_bars = np.linspace(0.02, 0.16, 8)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_n_bar in enumerate(g_n_bars):\\n t, y = solver(200, duration=260, t_start=15, g_n_bar=g_n_bar, g_t_bar=0.02, ca_type=2)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_n_bars[2], 20, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[4], 20, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Adaptation\\\", (0.06, 20), fontsize=8)\\n\\n plot_settings['y_ticks'] = []\\n plot_settings['y_label'] = ''\\n plot_settings['y_on'] = False\\n plot_settings['legend_location'] = 2\\n alter_figure(plot_settings, close=True)\",\n \"def gaze_ethoplot(anglearrays,title,show = True,save = False):\\n colors = ['red','blue']\\n labels = ['fish1 gaze', 'fish2 gaze']\\n fig,ax = plt.subplots(2,1,sharex = True)\\n for i in range(2):\\n anglearray = anglearrays[i]\\n inds = np.arange(len(anglearray))\\n color = colors[i]\\n ax[0].plot(anglearray,color = color,linewidth = 1,alpha = 0.5,label = labels[i])\\n boolean = anglearray.apply(lambda x: 1 if x > 140 else 0) \\n [ax[1].axvline(x = j,alpha = 0.2,color = color) for j in inds if boolean[j] == 1]\\n\\n ax[0].set_ylabel('relative angle (degrees)')\\n ax[1].set_ylabel('threshold crossing')\\n ax[1].set_xlabel('time (frame)')\\n ax[0].set_title(title)\\n\\n ax[0].legend(loc = 1)## in the upper right; faster than best. \\n\\n if save == True:\\n plt.savefig(title + '.png')\\n \\n if show == True:\\n plt.show()\",\n \"def DETCurve(fps, fns):\\n axis_min = min(fps[0], fns[-1])\\n fig, ax = plt.subplots()\\n plt.xlabel(\\\"FAR\\\")\\n plt.ylabel(\\\"FRR\\\")\\n plt.plot(fps, fns, '-|')\\n plt.yscale('log')\\n plt.xscale('log')\\n ax.get_xaxis().set_major_formatter(\\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\\n ax.get_yaxis().set_major_formatter(\\n FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\\n ticks_to_use = [0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.75, 1]\\n ax.set_xticks(ticks_to_use)\\n ax.set_yticks(ticks_to_use)\\n plt.axis([0.01, 1, 0.01, 1])\\n # plt.show()\",\n \"def plot_posteriors(chain, P, nplot='all'):\\n\\n if 'posterior_plots' in opt:\\n temp = opt['posterior_plots'].split(',')\\n pairs = []\\n for pair in temp:\\n pairs.append(pair.split())\\n nplot = len(pairs)\\n elif nplot == 'all':\\n nplot = chain.shape[-1]\\n\\n\\n nrows, ncols = get_nrows_ncols(nplot)\\n fig,axes = get_fig_axes(nrows, ncols, nplot)\\n\\n for i,ax in enumerate(axes):\\n if 'posterior_plots' in opt:\\n i0 = P['names'].index(pairs[i][0])\\n i1 = P['names'].index(pairs[i][1])\\n else:\\n i0 = i\\n i1 = i + 1\\n if i1 == npar:\\n i1 = 0\\n\\n #ax.plot(chain[:,0,i], chain[:,0,j], '.r', ms=4, label='p$_{initial}$')\\n dhist(chain[:, i0], chain[:, i1],\\n xbins=P['bins'][i0], ybins=P['bins'][i1],\\n fmt='.', ms=1.5, c='0.5', chist='b', ax=ax, loc='left, bottom')\\n\\n #if contours:\\n # i1sig = get_levels(np.array([chain[:,i], chain[:,j]]).T,)\\n # #cont = ax.contour(*par, colors='k',linewidths=0.5)\\n # for ind in P.ijoint_sig:\\n # x,y = chain[:,i][ind], chain[:,j][ind]\\n # delaunay = Delaunay(np.array([x, y]).T)\\n # for i0,i1 in delaunay.convex_hull:\\n # ax.plot([x[i0], x[i1]], [y[i0], y[i1]], 'k', lw=0.5)\\n x,y = chain[:,i0][P['ijoint_sig'][1]], chain[:,i1][P['ijoint_sig'][1]]\\n ax.plot(x,y,'g.', ms=3, mew=0)\\n x,y = chain[:,i0][P['ijoint_sig'][0]], chain[:,i1][P['ijoint_sig'][0]]\\n ax.plot(x,y,'r.', ms=3, mew=0)\\n\\n ax.plot(P['ml'][i0], P['ml'][i1], 'xk', ms=12, mew=4)\\n ax.plot(P['ml'][i0], P['ml'][i1], 'xr', ms=10, mew=2)\\n\\n c = 'crimson'\\n ax.axvline(P['p1sig'][i0][0], ymax=0.2, color=c, lw=0.5)\\n ax.axvline(P['p1sig'][i0][1], ymax=0.2, color=c, lw=0.5)\\n ax.axhline(P['p1sig'][i1][0], xmax=0.2, color=c, lw=0.5)\\n ax.axhline(P['p1sig'][i1][1], xmax=0.2, color=c, lw=0.5)\\n ax.axvline(P['median'][i0], ymax=0.2, color=c, lw=1.5)\\n ax.axhline(P['median'][i1], xmax=0.2, color=c, lw=1.5)\\n\\n puttext(0.95, 0.05, P['names'][i0], ax, fontsize=16, ha='right')\\n puttext(0.05, 0.95, P['names'][i1], ax, fontsize=16, va='top')\\n x0, x1 = np.percentile(chain[:,i0], [5, 95])\\n dx = x1 - x0\\n ax.set_xlim(x0 - dx, x1 + dx)\\n y0, y1 = np.percentile(chain[:,i1], [5, 95])\\n dy = y1 - y0\\n ax.set_ylim(y0 - dy, y1 + dy)\\n\\n return fig, axes\",\n \"def plot(self, dtables, figs, **kwargs):\\n self.safe_update(**kwargs)\\n\\n figs.setup_amp_plots_grid(\\\"ratio-row\\\", title=\\\"sflat ratio by row\\\",\\n xlabel=\\\"row\\\", ylabel=\\\"Ratio\\\")\\n figs.plot_xy_amps_from_tabledict(dtables, 'row', 'ratio_row',\\n x_name='row_i', y_name='r_med')\\n\\n figs.setup_amp_plots_grid(\\\"ratio-col\\\", title=\\\"sflat ratio by col\\\",\\n xlabel=\\\"col\\\", ylabel=\\\"Ratio\\\")\\n figs.plot_xy_amps_from_tabledict(dtables, 'col', 'ratio_col',\\n x_name='col_i', y_name='r_med')\\n\\n figs.setup_amp_plots_grid(\\\"scatter\\\", title=\\\"sflat ratio v. sbias\\\",\\n xlabel=\\\"Superbias [ADU]\\\", ylabel=\\\"Ratio\\\")\\n\\n figs.plot_amp_arrays(\\\"mask\\\", self.quality_masks, vmin=0, vmax=3)\\n\\n for i, (amp, sbias_image) in enumerate(sorted(self.superbias_images)):\\n figs.plot_two_image_hist2d('scatter', i,\\n sbias_image,\\n self.ratio_images[amp],\\n bins=(200, 200),\\n range=((-50, 50.), (0.018, 0.022)))\",\n \"def do_2dla_plots(cat, subdir):\\n #Omega_DLA in variance vs bayesian mode\\n cat.second_dla=False\\n cat.plot_omega_dla(zmax=5, label=\\\"Confidence interval\\\")\\n cat.second_dla=True\\n cat.plot_omega_dla_var(zmax=5, label=\\\"Variance\\\")\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"omega_gp_diff\\\"))\\n plt.clf()\\n\\n #dNdX\\n #Check effect of the second DLA\\n cat.plot_line_density(zmax=5,label=\\\"Two-DLA\\\")\\n cat.second_dla = False\\n cat.plot_line_density(zmax=5,label=\\\"One-DLA\\\")\\n cat.second_dla = True\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"dndx_2dla\\\"))\\n plt.clf()\\n\\n cat.plot_omega_dla(zmax=5,label=\\\"Two-DLA\\\")\\n cat.second_dla = False\\n cat.plot_omega_dla(zmax=5,label=\\\"One-DLA\\\")\\n cat.second_dla = True\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"omega_2dla\\\"))\\n plt.clf()\",\n \"def vanderpol_dymos_plots(p):\\n\\n # check validity by using scipy.integrate.solve_ivp to integrate the solution\\n sim_out = p.model.traj.simulate()\\n\\n # plots\\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 9))\\n\\n # state variable x1\\n axes[0, 0].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.states:x1'),\\n 'ro', label='solution')\\n\\n axes[0, 0].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\\n 'b-', label='simulation')\\n\\n axes[0, 0].set_xlabel('time (s)')\\n axes[0, 0].set_ylabel('x1 (V)')\\n axes[0, 0].legend()\\n axes[0, 0].grid()\\n\\n # state variable x0\\n axes[0, 1].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.states:x0'),\\n 'ro', label='solution')\\n\\n axes[0, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.states:x0'),\\n 'b-', label='simulation')\\n\\n axes[0, 1].set_xlabel('time (s)')\\n axes[0, 1].set_ylabel('x0 (V/s)')\\n axes[0, 1].legend()\\n axes[0, 1].grid()\\n\\n # state variable x1 vs x0\\n axes[1, 0].plot(p.get_val('traj.phase0.timeseries.states:x0'),\\n p.get_val('traj.phase0.timeseries.states:x1'),\\n 'ro', label='solution')\\n\\n axes[1, 0].plot(sim_out.get_val('traj.phase0.timeseries.states:x0'),\\n sim_out.get_val('traj.phase0.timeseries.states:x1'),\\n 'b-', label='simulation')\\n\\n axes[1, 0].set_xlabel('x0 (V/s)')\\n axes[1, 0].set_ylabel('x1 (V)')\\n axes[1, 0].legend()\\n axes[1, 0].grid()\\n\\n # control variable u\\n axes[1, 1].plot(p.get_val('traj.phase0.timeseries.time'),\\n p.get_val('traj.phase0.timeseries.controls:u'),\\n 'ro', label='solution')\\n\\n axes[1, 1].plot(sim_out.get_val('traj.phase0.timeseries.time'),\\n sim_out.get_val('traj.phase0.timeseries.controls:u'),\\n 'b-', label='simulation')\\n\\n axes[1, 1].set_xlabel('time (s)')\\n axes[1, 1].set_ylabel('control u')\\n axes[1, 1].legend()\\n axes[1, 1].grid()\\n\\n plt.show()\",\n \"def plot_alternate_t(noncentrality, df, alpha=0.05, ax=None):\\n\\n if ax is None:\\n ax = plt.axes()\\n\\n x, y1, y2, crit = _summarize_t(noncentrality, df, alpha)\\n color1, color2 = _get_colors()\\n\\n ax.plot(x, y1, color=color1)\\n ax.plot(x, y2, color=color2)\\n\\n sn.despine(ax=ax, left=True, offset=10)\\n\\n return ax\",\n \"def samsemPlots1thru4(samsem_data,path,dict):\\n \\n telleoevelse = dict['telleoevelse'] if 'telleoevelse' in dict else 0\\n \\n # Defining the subfolder for the results\\n path_res = path\\n if 'subfolder' in dict:\\n subfolder = dict['subfolder']\\n path_res = os.path.join(path,subfolder)\\n if not os.path.exists(path_res): os.makedirs(path_res)\\n \\n # Retrieving data from data set\\n coldef_type = dict['coldef_type'] # Color deficiency type of the simulation method\\n dict.update({'investigated-item': 'simulation method'})\\n filename_orig = dict['filename']\\n \\n if 'method_ids' in dict:\\n method_ids = dict['method_ids']\\n else:\\n method_ids = sorted(set(samsem_data['sim_id'].values.astype(int)))\\n method_ids = sorted(method_ids) # IDs of the methods that need to be plotted\\n \\n print(\\\"Starting SAMSEM_RES#01+04: Analyzing data for \\\" + str(settings.id2ColDefLong[dict['coldef_type']]) + \\\" simulation methods: \\\"+str(keys2values(method_ids,settings.id2Sim))+\\\".\\\")\\n \\n pandas_dict = {}; i = 0; order_dict = {}; sim_names = []\\n # Retrieving data for each of the algorithms algorithm\\n for sim_id in method_ids:\\n \\n sim_method = settings.id2Sim[sim_id]\\n if (sim_id != 3) and (sim_id != 99):\\n whatArr_tmp = [dict['obs_operator'],['sim_id',operator.eq,sim_id],['coldef_type',operator.eq,coldef_type]]\\n else:\\n whatArr_tmp = [dict['obs_operator'],['sim_id',operator.eq,sim_id]] # For the kotera and the dummy method, both protanopia and deuteranopia variants are identical. Thus, no distinction of coldef_type is necessary.\\n relevant_data_tmp = organizeArray(samsem_data,whatArr_tmp) \\n \\n pandas_dict.update({sim_method: relevant_data_tmp})\\n order_dict.update({i: sim_method}); i += 1\\n sim_names.append(sim_method)\\n \\n # Plot response time data as boxplots\\n if telleoevelse: print(\\\"Observations RT plots\\\")\\n boxes, labels = preparePandas4RTPlots(pandas_dict, order_dict)\\n plotRTGraphs(boxes,labels,path_res,dict,order_dict)\\n \\n # Plot accuracy data with confidence intervals\\n c = 1.96; type = 'wilson-score';\\n \\n if telleoevelse: print(\\\"Observations ACC plots\\\")\\n accuracies = preparePandas4AccuracyPlots(pandas_dict,order_dict,c,type)\\n plotAccuracyGraphs(accuracies,path_res,dict,order_dict)\\n \\n # Make median test as csv file\\n dict.update({'filename': filename_orig+\\\"-RT\\\"})\\n makeMedianTest(numpy.array(boxes), path_res, sim_names,dict)\\n \\n # Make Chi2 contingency test as text file\\n obs_array, obs_pandas = preparePandas4Chi2(pandas_dict, order_dict)\\n \\n start = 0; end = 4 # For the global Chi2 test, we are excluding the dummy method.\\n res = [start,end]\\n dict.update({'filename': filename_orig+'-ACC'})\\n makePearsonChi2Contingency(obs_array, obs_pandas, labels, path_res, dict, res)\\n \\n # Make pairwise Chi2 contingency test matrix as csv file\\n makePearsonChi2Contingency2x2Test(obs_array, path_res, labels, dict)\\n \\n # Make normality Q-Q and log-Q-Q plots\\n for i in range(numpy.shape(boxes)[0]):\\n distribution_tmp = boxes[i]\\n label_tmp = labels[i]\\n dict.update({'filename': filename_orig+'-RT-'+label_tmp})\\n plotQQPlot(distribution_tmp, path_res, dict)\\n \\n distribution_log_tmp = numpy.log(distribution_tmp)\\n distribution_log_tmp = distribution_log_tmp[~numpy.isnan(distribution_log_tmp)]\\n dict.update({'filename': filename_orig+'-RT-'+label_tmp+'-log'})\\n plotQQPlot(distribution_log_tmp, path_res, dict)\",\n \"def etio_subplot(df, ax, title, graph_color='skyblue'):\\n\\n post_dx_histo = histo_dx_includes(df)\\n hist_df = pd.DataFrame({\\\"Dx\\\": post_dx_histo.index, \\\"Count\\\": post_dx_histo.data})\\n #hist_df = hist_df.drop(1)\\n print(hist_df)\\n\\n graph_range = range(1,len(hist_df.index)+1)\\n ax.hlines(y=graph_range, xmin=0, xmax=hist_df['Count'], color=graph_color)\\n ax.plot(hist_df['Count'], graph_range, \\\"D\\\", color=graph_color)\\n ax.set_yticks(range(1, len(hist_df['Dx'])+1))\\n ax.set_yticklabels(hist_df['Dx'], fontsize='10')\\n\\n ax.set_title(title, fontsize='10')\\n return ax\",\n \"def plot_hypnogram(et,window=None,stage_map=None,mask_kwargs=None,*args,**kwargs):\\n if stage_map==None:\\n stage_map = {\\\"awake\\\":0, \\\"REM\\\":-1, \\\"Stage 1\\\":-2, \\\"Stage 2\\\":-3, \\\"Stage 3\\\":-4, \\\"Stage 4\\\":-5, \\\"mask\\\":0}\\n if mask_kwargs==None:\\n mask_kwargs = dict(fc=\\\"k\\\",alpha=1.0)\\n #et = eegpy.EventTable(fn)\\n evts = et.get_all_events_with_keys()\\n \\n if window==None:\\n window = np.median(np.diff([x[1] for x in evts]))\\n \\n xs = np.zeros((len(evts)*2))\\n ys = np.zeros((len(evts)*2))\\n \\n mask_segments = []\\n for i,e in enumerate(evts):\\n xs[2*i] = e[1]\\n if len(evts)-i>1:\\n xs[2*i+1] = evts[i+1][1]-1\\n else:\\n xs[2*i+1] = xs[2*i]+window\\n if e[0] in stage_map.keys():\\n ys[2*i] = stage_map[e[0]]\\n ys[2*i+1] = stage_map[e[0]] \\n else:\\n ys[2*i] = stage_map[\\\"mask\\\"]\\n ys[2*i+1] = stage_map[\\\"mask\\\"] \\n mask_segments.append((xs[2*i],xs[2*i+1]))\\n \\n p.plot(xs,ys,*args,**kwargs)\\n for ms in mask_segments:\\n p.axvspan(ms[0],ms[1],**mask_kwargs)\\n p.ylim((np.array(stage_map.values()).min()-1,np.array(stage_map.values()).max()+1))\\n #print [x for x in stage_map.keys()],[stage_map[x] for x in stage_map.keys()]\\n del stage_map[\\\"mask\\\"]\\n p.yticks([stage_map[x] for x in stage_map.keys()],[x for x in stage_map.keys()])\\n \\n return xs,ys\",\n \"def main():\\n save = False\\n show = True\\n\\n #hd_parameter_plots = HDparameterPlots(save=save)\\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\\n #ice5g_comparison_plots.plotLine()\\n #ice5g_comparison_plots.plotFilled()\\n #ice5g_comparison_plots.plotCombined()\\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\\n #flowmapplot = FlowMapPlots(save)\\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\\n #flowmapplot.Etopo1FlowMap()\\n #flowmapplot.ICE5G_data_all_points_0k()\\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\\n outflowplots = OutflowPlots(save)\\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #hd_output_plots = HDOutputPlots()\\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\\n #lake_plots = LakePlots()\\n #lake_plots.plotLakeDepths()\\n #lake_plots.LakeAndRiverMap()\\n #lake_plots.LakeAndRiverMaps()\\n if show:\\n plt.show()\",\n \"def plot_deviation(\\n true_values: np.ndarray, pred_values: np.ndarray, save=None, show=True, return_axs=False, title: str = \\\"\\\"\\n) -> Optional[Axes]:\\n true_values, pred_values = _input_checks(true_values, pred_values)\\n\\n plt.ioff()\\n\\n n_par = true_values.shape[0]\\n summary_fit = pd.concat(\\n [\\n pd.DataFrame(\\n {\\n \\\"deviation\\\": pred_values[i, :] - true_values[i, :],\\n \\\"coefficient\\\": pd.Series([\\\"coef_\\\" + str(i) for x in range(pred_values.shape[1])], dtype=\\\"category\\\"),\\n }\\n )\\n for i in range(n_par)\\n ]\\n )\\n summary_fit[\\\"coefficient\\\"] = summary_fit[\\\"coefficient\\\"].astype(\\\"category\\\")\\n\\n fig, ax = plt.subplots()\\n sns.violinplot(x=summary_fit[\\\"coefficient\\\"], y=summary_fit[\\\"deviation\\\"], ax=ax)\\n\\n if title is not None:\\n ax.set_title(title)\\n\\n # Save, show and return figure.\\n if save is not None:\\n plt.savefig(save + \\\"_deviation_violin.png\\\")\\n\\n if show:\\n plt.show()\\n\\n plt.close(fig)\\n plt.ion()\\n\\n if return_axs:\\n return ax\\n return None\",\n \"def plot_fig1(dysbiosis, dataset_order, samplesizes, edd_color=False):\\n disease_colors = fmt.get_disease_colors()\\n # Make color palette dictionary that has all of the datasets\\n # Note: need trailing underscore so that cd studies are not considered cdi\\n diseases = set([i.split('_')[0] + '_' for i in dataset_order])\\n colors = {}\\n for d in diseases:\\n dis_datasets = [i for i in dataset_order if i.startswith(d)]\\n colors.update({i: j for i, j in zip(dis_datasets,\\n len(dis_datasets)*[sns.light_palette(disease_colors[d[:-1]])[-1]])})\\n if edd_color:\\n colors['cdi_singh'] = disease_colors['edd']\\n\\n ### Plot\\n sns.set_style('white', {'ytick.direction': 'in', 'ytick.major.size': 2.0,\\n 'font.size': 'xx-small'})\\n\\n ## Set up the plot\\n # For spacing between plots: hspace in the following calls to gridspec\\n # set the space between the subplots.\\n # To set the space between the two gridspecs (top and bottom), need to\\n # change h_pad in call to tight_layout() at the very bottom!\\n fig = plt.figure(figsize=(0.27*len(dataset_order),8))\\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\\n # Bottom gridspec has sample size and AUCs\\n gs_bottom = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[1],\\n hspace=0.25)\\n ax_samplesize = plt.subplot(gs_bottom[1])\\n ax_auc = plt.subplot(gs_bottom[0])\\n\\n # Top gridspec has n_sig and balance\\n gs_top = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[0],\\n hspace=0.25)\\n ax_metrics = [plt.subplot(i) for i in gs_top]\\n\\n ### Plot stuff\\n ## Sample size\\n # Sample size is the one with the labels.\\n # dataset_order = [i if i != 'cdi_singh' else 'edd_singh' for i in dataset_order]\\n # samplesizes['dataset'] = [i if i != 'cdi_singh' else 'edd_singh' for i in samplesizes['dataset']]\\n # colors = {(i if i != 'cdi_singh' else 'edd_singh'): colors[i] for i in colors}\\n labeldict = fmt.get_labeldict(dataset_order)\\n\\n # Plot barplot.\\n sns.barplot(x='dataset', y='total', data=samplesizes,\\n order=dataset_order, ax=ax_samplesize, palette=colors,\\n edgecolor='')\\n\\n [ax_samplesize.spines[i].set_visible(False) for i in ['left', 'top']]\\n\\n ax_samplesize.yaxis.tick_right()\\n ax_samplesize.yaxis.set_label_position('right')\\n ax_samplesize.set_yticks([100,300,500])\\n ax_samplesize.set_yticklabels(['100', '300', '500'], rotation=90)\\n\\n ax_samplesize.set_xticklabels([labeldict[i] for i in dataset_order],\\n rotation=90)\\n\\n ax_samplesize.set_xlabel('')\\n ax_samplesize.set_ylabel('Total samples')\\n\\n # # Change all labels back to the original cdi_singh\\n # dataset_order = [i if i != 'edd_singh' else 'cdi_singh' for i in dataset_order]\\n # samplesizes['dataset'] = [i if i != 'edd_singh' else 'cdi_singh' for i in samplesizes['dataset']]\\n # colors = {(i if i != 'edd_singh' else 'cdi_singh'): colors[i] for i in colors}\\n\\n ## AUCs\\n ## Plot AUCs as barplots\\n # Plot dashed line\\n ax_auc.plot([-0.5, 29.5], [1, 1], color='0.75', linestyle='--')\\n\\n # No dashed lines\\n # sns.stripplot(x='label', y='value',\\n # data=dysbiosis.query('metric == \\\"auc\\\"'),\\n # order=dataset_order, ax=ax_auc, palette=colors,\\n # size=7, marker='D')\\n # I liked it with the dashed lines better\\n ax_auc = stemplot(x='label', y='value',\\n data=dysbiosis.query('metric == \\\"auc\\\"'),\\n order=dataset_order, ax=ax_auc,\\n palette=colors, marker='D')\\n\\n ax_auc.set_xticklabels([])\\n ax_auc.set_ylim([0.5, 1])\\n ax_auc.set_yticks([0.5, 0.75, 1.0])\\n ax_auc.set_yticklabels([0.5, 0.75, 1], rotation=90)\\n ax_auc.yaxis.tick_right()\\n ax_auc.yaxis.set_label_position('right')\\n\\n [ax_auc.spines[i].set_visible(False) for i in ['left', 'top']]\\n\\n ax_auc.set_ylabel('AUC')\\n ax_auc.set_xlabel('')\\n\\n ## n_sig\\n ax_metrics[1] = stemplot(x='label', y='value',\\n data=dysbiosis.query('metric == \\\"n_sig\\\"').replace(0, np.nan),\\n order=dataset_order, ax=ax_metrics[1],\\n palette=colors)#, marker='o')\\n\\n ax_metrics[1].set_xticklabels([])\\n ax_metrics[1].set_ylim([0, None])\\n ax_metrics[1].set_yticks([0, 20, 40, 60])\\n ax_metrics[1].set_yticklabels([0, 20, 40, 60], rotation=90)\\n ax_metrics[1].yaxis.tick_right()\\n ax_metrics[1].yaxis.set_label_position('right')\\n\\n [ax_metrics[1].spines[i].set_visible(False) for i in ['left', 'top']]\\n\\n ax_metrics[1].set_ylabel('Genera, q < 0.05')\\n ax_metrics[1].set_xlabel('')\\n\\n ## balance\\n # center the balance values around zero\\n dysbiosis['centered_value'] = \\\\\\n dysbiosis.query('metric == \\\"balance\\\"')['value'] - 0.5\\n\\n ax_metrics[0] = stemplot(x='label', y='centered_value',\\n data=dysbiosis.query('metric == \\\"balance\\\"'),\\n order=dataset_order, ax=ax_metrics[0],\\n palette=colors)\\n\\n # Plot the gray, blue and red lines for 0% and 100% depleted/enriched\\n ax_metrics[0].plot([-0.5, 29.5], [0, 0],\\n color='0.75', linestyle='-')\\n ax_metrics[0].plot([-0.5, 29.5], [-0.5, -0.5],\\n color='b', linestyle='-', alpha=0.2)\\n ax_metrics[0].plot([-0.5, 29.5], [0.5, 0.5],\\n color='r', linestyle='-', alpha=0.2)\\n\\n ax_metrics[0].set_ylim([-0.6, 0.6])\\n ax_metrics[0].yaxis.tick_right()\\n ax_metrics[0].yaxis.set_label_position('right')\\n # The -0.5 tick needs to be moved a bit to be less scrunched\\n ax_metrics[0].set_yticks([-0.4, 0.5])\\n ax_metrics[0].tick_params(axis='y', which=u'both', length=0)\\n ax_metrics[0].set_yticklabels(['Beneficial-\\\\n depleted',\\n 'Pathogen-\\\\n enriched'],\\n rotation=90)\\n ax_metrics[0].set_xticklabels([])\\n ax_metrics[0].yaxis.set_label_position('right')\\n\\n [ax_metrics[0].spines[i].set_visible(False) for i in ['left', 'top', 'bottom']]\\n\\n ax_metrics[0].set_xlabel('')\\n ax_metrics[0].set_ylabel('')\\n\\n # Tight layout and set spacing between A and B panels\\n gs.tight_layout(fig, h_pad=3.5)\\n\\n return fig\",\n \"def figure1():\\n\\n plot_settings = {'y_limits': [-80, -50],\\n 'x_limits': None,\\n 'y_ticks': [-80, -70, -60, -50],\\n 'locator_size': 5,\\n 'y_label': 'Voltage (mV)',\\n 'x_ticks': [],\\n 'scale_size': 20,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_1',\\n 'legend_size': 8,\\n 'legend': None,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n plt.figure(figsize=(5, 2)) # Create figure\\n plt.plot(t, y[:, 0], 'k-') # Plot solution\\n\\n \\\"\\\"\\\"\\n Annotate plot with figures\\n \\\"\\\"\\\"\\n plt.gca().annotate('fAHP', xy=(13.5, -65), xytext=(17, -60),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n plt.gca().annotate('ADP', xy=(15.5, -66), xytext=(25, -65),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n plt.gca().annotate('mAHP', xy=(38, -77), xytext=(43, -72),\\n arrowprops=dict(facecolor='black', shrink=0, headlength=10, headwidth=5, width=1), )\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def add_boxplotlike_data(stats, y_bottom,y_mid,y_top, y_label,method_index,statistic=\\\"mean_SD\\\"):\\n if statistic==\\\"median_IQR\\\":\\n x1,x2,x3=tuple(np.quantile(stats, q=[.25, .50, .75]))\\n elif statistic==\\\"mean_SD\\\":\\n sd = np.std(stats)\\n x2 = np.mean(stats)\\n x1 = x2 - sd\\n x3 = x2 + sd\\n elif statistic==\\\"meanall_replicatesd\\\": # when joining different fitfuns\\n\\n x2=np.mean(np.array(stats))\\n sds=[np.std(stats[i]) for i in range(len(stats))]\\n sd=np.mean(sds)\\n x1= x2 - sd\\n x3 = x2 + sd\\n # assumes fitfun is first dimension of stats\\n\\n else:\\n raise Exception(\\\"statistic %s not known\\\"%(statistic))\\n\\n y_bottom[y_label][method_index].append(x1)\\n y_mid[y_label][method_index].append(x2)\\n y_top[y_label][method_index].append(x3)\",\n \"def evals_by_evals(ax, pds, baseline1_ds=None, baseline1_label=\\\"\\\", baseline2_ds=None, baseline2_label=\\\"\\\", dim=None, funcId=None, groupby=None):\\n if groupby is None: groupby = GroupByMedian()\\n pfsize = len(pds.algds.keys())\\n\\n runlengths = 10**np.linspace(0, np.log10(pds.maxevals((dim, funcId))), num=500)\\n target_values = pp.RunlengthBasedTargetValues(runlengths,\\n reference_data=pds.bestalg(None), force_different_targets_factor=10**0.004)\\n targets = target_values((funcId, dim))\\n\\n if baseline1_ds:\\n baseline1_fevs = np.array(groupby(baseline1_ds.detEvals(targets), axis=1))\\n if baseline2_ds:\\n baseline2_fevs = np.array(groupby(baseline2_ds.detEvals(targets), axis=1))\\n\\n for (kind, name, ds, style) in _pds_plot_iterator(pds, dim, funcId):\\n #print name, ds\\n fevs1 = groupby(ds.detEvals(targets), axis=1)\\n if baseline1_ds:\\n fevs1 /= baseline1_fevs\\n fevs2 = groupby(ds.detEvals(targets), axis=1)\\n if baseline2_ds:\\n fevs2 /= baseline2_fevs\\n\\n infsx = np.nonzero(fevs1 == inf)\\n infs = infsx[0]\\n if np.size(infs) > 0:\\n #print infs\\n fevs1 = fevs1[:infs[0]-1]\\n fevs2 = fevs2[:infs[0]-1]\\n\\n #print name, fevs1, fevs2\\n style['markevery'] = 64\\n ax.loglog(fevs2, fevs1, label=name, basex=pfsize, basey=pfsize, **style)\\n ax.grid()\\n ax.set_xlim(0, runlengths[-1] * pfsize) # i.e. log(runlengths) + 1\\n ax.set_ylabel('Per-target ' + _evals_label(baseline1_ds, baseline1_label, str(groupby)))\\n ax.set_xlabel('Per-target ' + _evals_label(baseline2_ds, baseline2_label, str(groupby)))\",\n \"def plot_alleles(folder):\\n\\n abs_alt,perc_alt = parse_geno_file(folder,False)\\n\\n strain_matcher = re.compile('(.*) \\\\(.*\\\\)') ## regex to get strain name from radio button click\\n strain_matcher2 = re.compile('(.*)-(.*)')\\n \\n fig, ax = plt.subplots()\\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\\n ax.set_ylabel('Alternate Allele Percentage (MC)')\\n ax.set_xlabel('Alternate Allele Percentage (MC)')\\n \\n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\\n\\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\\n\\n #for strain in perc_alt.keys():\\n #print strain\\n \\n #ylabel = plt.axes([1,1,0.08,0.08])\\n\\n def update1(strain):\\n if strain not in [\\\"Rock-MZ\\\",\\\"Sand-MC\\\",\\\"Rock-MC\\\",\\\"Sand-MZ\\\",\\\"Rock-Sand\\\"]:\\n match = re.match(strain_matcher,strain)\\n strain = match.group(1)\\n global base\\n base = 'MC'\\n else:\\n match = re.match(strain_matcher2,strain)\\n strain = match.group(1)\\n #global base \\n base = match.group(2)\\n\\n #print D\\n if(D == \\\"%\\\"):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[strain])\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n else:\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[strain])\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n\\n ax.relim()\\n ax.autoscale()\\n fig.canvas.draw_idle()\\n global S \\n #print S\\n S = strain\\n\\n\\n def update2(data):\\n if(data == '%'):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n fig.canvas.draw_idle()\\n if(data == 'Abs'):\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n fig.canvas.draw_idle()\\n \\n global D\\n D = data\\n\\n radio1.on_clicked(update1)\\n radio2.on_clicked(update2)\\n plt.show()\",\n \"def plot_comparisons(self, exact, blocked, blockederr, axdelta=None):\\n if axdelta is None:\\n axdelta = plt.gca()\\n delta = self.means - exact\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[0], yerr=self.stderr[0], label='independent')\\n axdelta.errorbar(list(range(1, self.max_dets)), delta[1], yerr=self.stderr[1], label='correlated')\\n axdelta.axhline(delta[0, 0], linestyle=':', color='grey', label='reference')\\n axdelta.axhline(0, linestyle='-', linewidth=1, color='black')\\n if blocked:\\n axdelta.axhline(blocked-exact, linestyle='--', color='darkgreen', label='reblocked')\\n if blockederr:\\n axdelta.fill_between([0, self.max_dets], [blocked-exact-blockederr,blocked-exact-blockederr],\\n [blocked-exact+blockederr,blocked-exact+blockederr], color='green', alpha=0.2)\\n axdelta.set_xlabel('Number of determinants in estimator')\\n axdelta.set_ylabel(r'$E-E_\\\\mathrm{CCSD}$ / ha')\\n axdelta.legend()\\n return axdelta\",\n \"def plot_energies(self, np = None, ax=None):\\n if not ax:\\n import matplotlib.pyplot as plt\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n else:\\n fig = None\\n if np:\\n datas = self.results['energies'][np[0]:np[1]]\\n else:\\n datas = self.results['energies']\\n ax.plot(range(len(datas)), datas, '-o')\\n # ax.set_ylim([self.results['energies'][-1], self.results['energies'][0]])\\n ax.set_xlabel('steps')\\n ax.set_ylabel('energy [eV]')\\n ax.set_title('Energy profile {0}'.format(self.prefix))\\n plt.savefig('{0}.png'.format(self.prefix))\",\n \"def plot_dynamic(D, **kwargs):\\n\\t\\n\\tif not 'legend_label' in kwargs:\\n\\t\\tkwargs['legend_label'] = 'Map T'\\n\\treturn plot(lambda x: D.f(RIF(x)).center(), 0, 1, **kwargs)\",\n \"def plotDihedralEnergy(self, phys, forces, step): \\r\\n self.plotQuantity(step, phys.app.energies.getTable(4), 'dihedralenergy')\",\n \"def __plot_delaunay(self, ax=None) -> None:\\n for simplex in self.hull.simplices:\\n ax.plot(self.points[simplex, 0], self.points[simplex, 1], \\\"r-\\\")\\n\\n tri = Delaunay(self.points)\\n ax.triplot(self.points[:, 0], self.points[:, 1], tri.simplices.copy(), lw=1)\",\n \"def dline_dSFR(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\\n \\n marker = 'o'\\n if p.sim_run == p.sim_runs[0]: marker = '^'\\n\\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\\n\\n SFR = SFR[L_line > 0]\\n M_star = M_star[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n L_line = L_line[L_line > 0]\\n print('%i data points ' % (len(L_line)))\\n\\n # Distance from MS\\n dlSFR = aux.distance_from_salim18(GR.M_star,GR.SFR)\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n # Distance from observed relation\\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\\n\\n labs = {'_M10':'Mach=10 power-law',\\\\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\\\\n '_arepoPDF':'SIGAME v3',\\\\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\\\\n '_arepoPDF_M51':'SIGAME v3'}\\n lab = labs[p.table_ext]\\n\\n\\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\\n ax.set_xlabel('log SFR - log SFR$_{MS,Salim+18}$')\\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\\n if not p.xlim: p.xlim = np.array([-3,3])\\n if not p.ylim: \\n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\\n # if p.line == '[OI]63': p.ylim = [np.median(ldL_line) - 5,np.median(ldL_line) + 4]\\n # if 'CO' in p.line: p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 4]\\n\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\\n m = ax.scatter(dlSFR[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/pc$^2$]',size=15)\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def create_dashboard(h, t, k, p):\\n plt.style.use('seaborn')\\n # Initialize the dashboard\\n fig = plt.figure(figsize=(20, 8))\\n ax1 = fig.add_subplot(2, 2, 1)\\n ax2 = fig.add_subplot(2, 2, 2)\\n ax3 = fig.add_subplot(2, 2, 3)\\n ax4 = fig.add_subplot(2, 2, 4)\\n\\n # Create individual graphs\\n dt_line, = ax1.plot(h, lw=3, c='k')\\n total_line, = ax2.plot(t, lw=3, c='#d62728')\\n k_line, = ax3.plot(k, lw=3, c='#1f77b4')\\n p_line = ax4.plot(p, lw=3, c='#2ca02c')\\n\\n ax1.set_title(r'Variation in $\\\\Delta t$')\\n ax1.set_ylabel(r'$\\\\Delta t$')\\n ax2.set_title(r'Total Energy over Time')\\n ax2.set_ylabel('Total Energy')\\n ax3.set_title('Kinetic Energy over Time')\\n ax3.set_ylabel('Kinetic Energy')\\n ax3.set_xlabel('Time Steps')\\n ax4.set_title('Potential Energy over Time')\\n ax4.set_ylabel('Potential Energy')\\n ax4.set_xlabel('Time Steps')\\n\\n plt.show()\\n\\n \\\"\\\"\\\"im = ax[0, 0].imshow(model.lattice, cmap='Greys', vmin=-1, vmax=1)\\n energy_line, = ax[0, 1].plot([], [], lw=3)\\n mag_line, = ax[1, 0].plot([], [], lw=3)\\n heat_line, = ax[1, 1].plot([], [], lw=3)\\n susceptibility_line, = ax[2, 0].plot([], [], lw=3)\\n acceptance_line, = ax[2, 1].plot([], [], lw=3)\\\"\\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5631575","0.56224716","0.55810195","0.5569204","0.544854","0.54324406","0.5401097","0.5397317","0.53738916","0.53561234","0.5292456","0.52792794","0.52540356","0.52267444","0.5214065","0.52021885","0.5194347","0.5180309","0.5170628","0.51551074","0.5147858","0.5143375","0.5120442","0.5089592","0.5088283","0.5071791","0.5065929","0.5061781","0.50574464","0.50520223","0.5051976","0.5044257","0.50074446","0.5001882","0.4995954","0.49861255","0.49839786","0.49831992","0.49826506","0.49805072","0.4975266","0.49696478","0.49596292","0.49586248","0.49399096","0.49385706","0.49338442","0.493032","0.49156365","0.49126276","0.4896375","0.48865637","0.48819834","0.48774725","0.48547107","0.48524797","0.4848144","0.48442608","0.48423174","0.4837731","0.48367685","0.48361507","0.48316258","0.48308894","0.48172677","0.48155588","0.48155436","0.48151764","0.48146394","0.48138505","0.4813058","0.48088595","0.48064607","0.4799117","0.47974145","0.47954798","0.47878358","0.47864312","0.47784075","0.47729912","0.4772798","0.47706932","0.47703478","0.47703224","0.47699678","0.47685602","0.47649738","0.47603703","0.47563374","0.4751953","0.4747902","0.4739029","0.47389802","0.47387725","0.47344226","0.47312418","0.47261858","0.47246084","0.47241762","0.47240785"],"string":"[\n \"0.5631575\",\n \"0.56224716\",\n \"0.55810195\",\n \"0.5569204\",\n \"0.544854\",\n \"0.54324406\",\n \"0.5401097\",\n \"0.5397317\",\n \"0.53738916\",\n \"0.53561234\",\n \"0.5292456\",\n \"0.52792794\",\n \"0.52540356\",\n \"0.52267444\",\n \"0.5214065\",\n \"0.52021885\",\n \"0.5194347\",\n \"0.5180309\",\n \"0.5170628\",\n \"0.51551074\",\n \"0.5147858\",\n \"0.5143375\",\n \"0.5120442\",\n \"0.5089592\",\n \"0.5088283\",\n \"0.5071791\",\n \"0.5065929\",\n \"0.5061781\",\n \"0.50574464\",\n \"0.50520223\",\n \"0.5051976\",\n \"0.5044257\",\n \"0.50074446\",\n \"0.5001882\",\n \"0.4995954\",\n \"0.49861255\",\n \"0.49839786\",\n \"0.49831992\",\n \"0.49826506\",\n \"0.49805072\",\n \"0.4975266\",\n \"0.49696478\",\n \"0.49596292\",\n \"0.49586248\",\n \"0.49399096\",\n \"0.49385706\",\n \"0.49338442\",\n \"0.493032\",\n \"0.49156365\",\n \"0.49126276\",\n \"0.4896375\",\n \"0.48865637\",\n \"0.48819834\",\n \"0.48774725\",\n \"0.48547107\",\n \"0.48524797\",\n \"0.4848144\",\n \"0.48442608\",\n \"0.48423174\",\n \"0.4837731\",\n \"0.48367685\",\n \"0.48361507\",\n \"0.48316258\",\n \"0.48308894\",\n \"0.48172677\",\n \"0.48155588\",\n \"0.48155436\",\n \"0.48151764\",\n \"0.48146394\",\n \"0.48138505\",\n \"0.4813058\",\n \"0.48088595\",\n \"0.48064607\",\n \"0.4799117\",\n \"0.47974145\",\n \"0.47954798\",\n \"0.47878358\",\n \"0.47864312\",\n \"0.47784075\",\n \"0.47729912\",\n \"0.4772798\",\n \"0.47706932\",\n \"0.47703478\",\n \"0.47703224\",\n \"0.47699678\",\n \"0.47685602\",\n \"0.47649738\",\n \"0.47603703\",\n \"0.47563374\",\n \"0.4751953\",\n \"0.4747902\",\n \"0.4739029\",\n \"0.47389802\",\n \"0.47387725\",\n \"0.47344226\",\n \"0.47312418\",\n \"0.47261858\",\n \"0.47246084\",\n \"0.47241762\",\n \"0.47240785\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5738737"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9286,"cells":{"query":{"kind":"string","value":"A graphical representation of what Bennett calls 'CurveFitting Method'."},"document":{"kind":"string","value":"def plotCFM(u_kln, N_k, num_bins=100):\n\n print \"Plotting the CFM figure...\"\n def leaveTicksOnlyOnThe(xdir, ydir, axis):\n dirs = ['left', 'right', 'top', 'bottom']\n axis.xaxis.set_ticks_position(xdir)\n axis.yaxis.set_ticks_position(ydir)\n return\n\n def plotdg_vs_dU(yy, df_allk, ddf_allk):\n sq = (len(yy))**0.5\n h = int(sq)\n w = h + 1 + 1*(sq-h>0.5)\n scale = round(w/3., 1)+0.4 if len(yy)>13 else 1\n sf = numpy.ceil(scale*3) if scale>1 else 0\n fig = pl.figure(figsize = (8*scale,6*scale))\n matplotlib.rc('axes', facecolor = '#E3E4FA')\n matplotlib.rc('axes', edgecolor = 'white')\n if P.bSkipLambdaIndex:\n ks = [int(l) for l in P.bSkipLambdaIndex.split('-')]\n ks = numpy.delete(numpy.arange(K+len(ks)), ks)\n else:\n ks = range(K)\n for i, (xx_i, yy_i) in enumerate(yy):\n ax = pl.subplot(h, w, i+1)\n ax.plot(xx_i, yy_i, color='r', ls='-', lw=3, marker='o', mec='r')\n leaveTicksOnlyOnThe('bottom', 'left', ax)\n ax.locator_params(axis='x', nbins=5)\n ax.locator_params(axis='y', nbins=6)\n ax.fill_between(xx_i, df_allk[i]['BAR'] - ddf_allk[i]['BAR'], df_allk[i]['BAR'] + ddf_allk[i]['BAR'], color='#D2B9D3', zorder=-1)\n\n ax.annotate(r'$\\mathrm{%d-%d}$' % (ks[i], ks[i+1]), xy=(0.5, 0.9), xycoords=('axes fraction', 'axes fraction'), xytext=(0, -2), size=14, textcoords='offset points', va='top', ha='center', color='#151B54', bbox = dict(fc='w', ec='none', boxstyle='round', alpha=0.5))\n pl.xlim(xx_i.min(), xx_i.max())\n pl.annotate(r'$\\mathrm{\\Delta U_{i,i+1}\\/(reduced\\/units)}$', xy=(0.5, 0.03), xytext=(0.5, 0), xycoords=('figure fraction', 'figure fraction'), size=20+sf, textcoords='offset points', va='center', ha='center', color='#151B54')\n pl.annotate(r'$\\mathrm{\\Delta g_{i+1,i}\\/(reduced\\/units)}$', xy=(0.06, 0.5), xytext=(0, 0.5), rotation=90, xycoords=('figure fraction', 'figure fraction'), size=20+sf, textcoords='offset points', va='center', ha='center', color='#151B54')\n pl.savefig(os.path.join(P.output_directory, 'cfm.pdf'))\n pl.close(fig)\n return\n\n def findOptimalMinMax(ar):\n c = zip(*numpy.histogram(ar, bins=10))\n thr = int(ar.size/8.)\n mi, ma = ar.min(), ar.max()\n for (i,j) in c:\n if i>thr:\n mi = j\n break\n for (i,j) in c[::-1]:\n if i>thr:\n ma = j\n break\n return mi, ma\n\n def stripZeros(a, aa, b, bb):\n z = numpy.array([a, aa[:-1], b, bb[:-1]])\n til = 0\n for i,j in enumerate(a):\n if j>0:\n til = i\n break\n z = z[:, til:]\n til = 0\n for i,j in enumerate(b[::-1]):\n if j>0:\n til = i\n break\n z = z[:, :len(a)+1-til]\n a, aa, b, bb = z\n return a, numpy.append(aa, 100), b, numpy.append(bb, 100)\n\n K = len(u_kln)\n yy = []\n for k in range(0, K-1):\n upto = min(N_k[k], N_k[k+1])\n righ = -u_kln[k,k+1, : upto]\n left = u_kln[k+1,k, : upto]\n min1, max1 = findOptimalMinMax(righ)\n min2, max2 = findOptimalMinMax(left)\n\n mi = min(min1, min2)\n ma = max(max1, max2)\n\n (counts_l, xbins_l) = numpy.histogram(left, bins=num_bins, range=(mi, ma))\n (counts_r, xbins_r) = numpy.histogram(righ, bins=num_bins, range=(mi, ma))\n\n counts_l, xbins_l, counts_r, xbins_r = stripZeros(counts_l, xbins_l, counts_r, xbins_r)\n counts_r, xbins_r, counts_l, xbins_l = stripZeros(counts_r, xbins_r, counts_l, xbins_l)\n\n with numpy.errstate(divide='ignore', invalid='ignore'):\n log_left = numpy.log(counts_l) - 0.5*xbins_l[:-1]\n log_righ = numpy.log(counts_r) + 0.5*xbins_r[:-1]\n diff = log_left - log_righ\n yy.append((xbins_l[:-1], diff))\n\n plotdg_vs_dU(yy, df_allk, ddf_allk)\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_fitted_curve(self):\n\t\tcxpX, cxpY = self.curveCXP.cxp_X, self.curveCXP.cxp_Y\n\t\tfittedX, fittedY = self.fitted_X, self.fitted_Y\n\t\tself.curveFig.plot(cxpX, cxpY, 'o', fittedX, fittedY)\n\t\tpass","def plot_fitting_coefficients(self):\n from matplotlib import pyplot as plt\n coeff = self.linear_fit[\"coeff\"]\n order = self.linear_fit[\"order\"]\n\n data = {}\n annotations = {}\n for c, o in zip(coeff, order):\n if len(o) == 0:\n continue\n n = len(o)\n if n not in data.keys():\n data[n] = [c]\n annotations[n] = [WulffConstruction.order2string(o)]\n else:\n data[n].append(c)\n annotations[n].append(WulffConstruction.order2string(o))\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1)\n start = 0\n keys = list(data.keys())\n keys.sort()\n for k in keys:\n x = list(range(start, start+len(data[k])))\n ax.bar(x, data[k], label=str(k))\n start += len(data[k]) + 1\n for i in range(len(data[k])):\n ax.annotate(annotations[k][i], xy=(x[i], data[k][i]))\n ax.set_ylabel(\"Fitting coefficient\")\n ax.set_xticklabels([])\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend(frameon=False)\n return fig","def plotFittingResults(self):\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\n\n #_listExpStdDev = None\n #if self.getDataInput().getExperimentalDataStdDev():\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\n #if _listExpStdDev:\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\"Experimental Data\")\n # pylab.gca().set_yscale(\"log\", nonposy='clip')\n #else: \n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n pylab.semilogy(_listFitQ, _listFitValues, label=\"Fitting curve\")\n pylab.xlabel('q')\n pylab.ylabel('I(q)')\n pylab.suptitle(\"RMax : %3.2f. Fit quality : %1.3f\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\n pylab.legend()\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \"gnomFittingResults.png\"))\n pylab.clf()","def display_fit(x,y,p,func,fig=None):\n if fig is None:\n fig = plots.tac_figure('x','y','fitting')\n fig.plot(x,np.log(y),label='data')\n \n \n fig.plot(x,np.log(func(p,x)),'--x',label=func.__name__ + '('+\n ','.join(['%.1e'%k for k in p])+ ')')\n \n return fig","def plot_power_fitting(x,y,bias=True):\n\n def funcc(x, a, b, c):\n return a * x**b +c\n\n def func0(x,a,b):\n return a * x**b\n\n if bias:\n popt, pcov = curve_fit(funcc, x, y, p0=[1.0, -1.0, 0.0])\n yf = [funcc(i, popt[0],popt[1],popt[2]) for i in x]\n else:\n popt, pcov = curve_fit(func0, x, y, p0=[1.0, -1.0])\n yf = [func0(i, popt[0],popt[1]) for i in x]\n\n plt.plot(x,y,'o')\n plt.plot(x,yf,'--')\n\n return popt,pcov","def plot_power_fitting(x,y,bias=True):\n \n def funcc(x, a, b, c): \n return a * x**b +c\n \n def func0(x,a,b):\n return a * x**b\n \n if bias:\n popt, pcov = curve_fit(funcc, x, y, p0=[1.0, -1.0, 0.0]) \n yf = [funcc(i, popt[0],popt[1],popt[2]) for i in x]\n else:\n popt, pcov = curve_fit(func0, x, y, p0=[1.0, -1.0]) \n yf = [func0(i, popt[0],popt[1]) for i in x]\n \n plt.plot(x,y,'o')\n plt.plot(x,yf,'--')\n \n return popt,pcov","def plot():\n xvals = np.arange(-50, 250, step=0.1)\n\n fig = plt.figure()\n plt.suptitle(\"Gaussian with smooth transition to power law\")\n\n A0vals = [10, 11]\n avals = [5*10**-3, 10**-3, 5*10**-4]\n ttvals = [10., 50., 100.]\n cvals = [-0.1, -0.9, -5./3., -4.]\n offset = [-30, 0.0, 30]\n\n paramvals = [A0vals, avals, ttvals,cvals, offset]\n titles, labels = return_parameter_names()\n\n nplots = len(paramvals)\n\n for i in range(nplots):\n plt.subplot(nplots, 1, i+1)\n vals = paramvals[i]\n for j in range(len(vals)):\n pset = list(default())\n pset[i] = vals[j]\n yvals=[]\n ypower=[]\n ypeak=[]\n for x in xvals:\n yvals.append(fitfunc(x, pset))\n ypeak.append(logpeak(x,pset))\n if x > 0:\n ypower.append(logpowerlaw(x,pset))\n label = labels[i] + \"=\"+str(vals[j])\n plt.plot(xvals, yvals, label = label)\n\n plt.title(titles[i])\n plt.legend()\n\n fig.set_size_inches(15, 30)\n plt.savefig(\"graphs/misc/lightcurve_models.pdf\")\n plt.close()","def fit_curve(fitting_function, x, y, parameters_guess=None, to_plot=False):\n\n if parameters_guess is not None:\n parameters, p_covariance = curve_fit(fitting_function, x, y, parameters_guess)\n else:\n parameters, p_covariance = curve_fit(fitting_function, x, y)\n x2 = np.linspace(0, 1, 10)\n y_fit = fitting_function(x, *parameters)\n r2 = r2_score(y, y_fit)\n\n if to_plot:\n print(\"Fitting parameters:\", *parameters)\n plt.scatter(x, y)\n x2 = np.linspace(0, 1, 10)\n y2 = fitting_function(x2, *parameters)\n plt.plot(x2, y2, \"blue\", label=\"R^2= %0.5f\" % r2)\n plt.title(\"Least-squares fit\")\n plt.legend()\n return r2, parameters","def curve_number(self):","def plot_curve_fit(\n func: Callable,\n result: FitData,\n ax=None,\n num_fit_points: int = 100,\n labelsize: int = 14,\n grid: bool = True,\n fit_uncertainty: List[Tuple[float, float]] = None,\n **kwargs,\n):\n if ax is None:\n ax = get_non_gui_ax()\n\n if fit_uncertainty is None:\n fit_uncertainty = []\n elif isinstance(fit_uncertainty, tuple):\n fit_uncertainty = [fit_uncertainty]\n\n # Default plot options\n plot_opts = kwargs.copy()\n if \"color\" not in plot_opts:\n plot_opts[\"color\"] = \"blue\"\n if \"linestyle\" not in plot_opts:\n plot_opts[\"linestyle\"] = \"-\"\n if \"linewidth\" not in plot_opts:\n plot_opts[\"linewidth\"] = 2\n\n xmin, xmax = result.x_range\n\n # Plot fit data\n xs = np.linspace(xmin, xmax, num_fit_points)\n ys_fit_with_error = func(xs, **dict(zip(result.popt_keys, result.popt)))\n\n # Line\n ax.plot(xs, unp.nominal_values(ys_fit_with_error), **plot_opts)\n\n # Confidence interval of N sigma values\n stdev_arr = unp.std_devs(ys_fit_with_error)\n if np.isfinite(stdev_arr).all():\n for sigma, alpha in fit_uncertainty:\n ax.fill_between(\n xs,\n y1=unp.nominal_values(ys_fit_with_error) - sigma * stdev_arr,\n y2=unp.nominal_values(ys_fit_with_error) + sigma * stdev_arr,\n alpha=alpha,\n color=plot_opts[\"color\"],\n )\n\n # Formatting\n ax.tick_params(labelsize=labelsize)\n ax.grid(grid)\n return ax","def fit_and_plot(self):\n try:\n if not hasattr(self, \"file\"):\n self.ui.Result_textBrowser.setText(\"You need to load a data file.\")\n else:\n if self.opened_from_flim:\n x, y = self.hist_data_from_flim\n else:\n x,y = self.acquire_settings() #get data\n y_norm = y/np.max(y) #normalized y\n\n # find the max intensity in the array and start things from there\n find_max_int = np.nonzero(y_norm == 1)\n y = y[np.asscalar(find_max_int[0]):]\n x = x[np.asscalar(find_max_int[0]):]\n\n t = x\n time_fit = t\n TRPL_interp = np.interp(time_fit, t, y)\n \n fit_func = self.ui.FittingFunc_comboBox.currentText()\n self.ui.plot.plot(t, y, clear=self.ui.clear_plot_checkBox.isChecked(), pen=pg.mkPen(self.plot_color))\n \n if fit_func == \"Stretched Exponential\": #stretch exponential tab\n tc, beta, a, avg_tau, PL_fit, noise = stretch_exp_fit(TRPL_interp, t)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = PL_fit # PL fit\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Stretched Exponential\"\n \"\\nFit Method: \" + \"diff_ev\" + #TODO : change when diff_ev and fmin_tnc implemented for non-irf\n \"\\nAverage Lifetime = \" + str(avg_tau)+ \" ns\"\n \"\\nCharacteristic Tau = \" + str(tc)+\" ns\"\n \"\\nBeta = \"+str(beta)+\n \"\\nNoise = \"+ str(noise))\n self.ui.average_lifetime_spinBox.setValue(avg_tau)\n \n elif fit_func == \"Double Exponential\": #double exponential tab\n tau1, a1, tau2, a2, avg_tau, PL_fit, noise = double_exp_fit(TRPL_interp, t)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = PL_fit # PL fit\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Double Exponential\"\n \"\\nFit Method: \" + \"diff_ev\" +\n \"\\nAverage Lifetime = \" + str(avg_tau)+ \" ns\"\n \"\\nTau 1 = \" + str(tau1)+\" ns\"\n \"\\nA 1 = \" + str(a1)+\n \"\\nTau 2 = \" + str(tau2)+\" ns\"\n \"\\nA 2 = \" + str(a2)+\n \"\\nNoise = \"+ str(noise))\n #TODO - once tau_avg implemented, set average lifetime spinbox to tau_avg value\n \n elif fit_func == \"Single Exponential\": #single exponential tab\n tau, a, PL_fit, noise = single_exp_fit(TRPL_interp, t)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = PL_fit # PL fit\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Single Exponential\"\n \"\\nFit Method: \" + \"diff_ev\" +\n \"\\nLifetime = \" + str(tau)+ \" ns\"\n \"\\nA = \" + str(a)+\n \"\\nNoise = \"+ str(noise))\n self.ui.average_lifetime_spinBox.setValue(tau)\n \n #add fit params to data_list\n self.data_list.append(\"Data Channel: \" + str(self.ui.Data_channel_spinBox.value()) + \"\\n\" + self.ui.Result_textBrowser.toPlainText())\n self.fit_lifetime_called_wo_irf = True\n self.fit_lifetime_called_w_irf = False\n\n self.ui.plot.setLabel('left', 'Intensity', units='a.u.')\n self.ui.plot.setLabel('bottom', 'Time (ns)')\n return self.out\n \n except Exception as e:\n self.ui.Result_textBrowser.append(format(e))","def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \n plt.title(\"Polynomial function regression\")\n plt.grid()\n plt.plot(x_poly, y_poly, c='black', label='true function')\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\n plt.legend()\n plt.show()","def check_fit(data, data_fit, time_points):\n plt.figure()\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\"Cases\", \"Deaths\", \"Hospitalized\", \"ICU\"])):\n if data[ii] is not None:\n plt.plot(time_points, data[ii], c=f\"C{jj}\", label=lab)\n plt.plot(time_points, data_fit[ii], '--', c=f\"C{jj}\", label=f\"{lab} fit\")\n plt.yscale(\"log\")\n plt.legend()\n # plt.savefig(\"Test_fitting\", format=\"png\")\n plt.show()","def _repr_(self):\n return \"Jacobian of %s\"%self.__curve","def pr_curve(model, X_train, y_train, X_test, y_test, train=True):\n from sklearn.metrics import precision_recall_curve\n if train==True:\n ypredTrain = model.predict(X_train) \n precisions, recalls, thresholds = precision_recall_curve(y_train, ypredTrain)\n plt.plot(precisions, recalls, linewidth=3, color='r', linestyle='-')\n plt.rc('xtick', labelsize=10) \n plt.rc('ytick', labelsize=10) \n plt.xlabel(\"Precision\", size=12)\n plt.ylabel(\"Recall\", size=12)\n plt.grid()\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \n plt.rcParams['axes.facecolor'] = '#F2F3F4' \n plt.title(\"PR Curve: Precision/Recall Trade-off\\n\\n(Train)\\n\", size=14) \n plt.show()\n elif train==False:\n ypredTest = model.predict(X_test)\n precisions, recalls, thresholds = precision_recall_curve(y_test, ypredTest)\n plt.plot(precisions, recalls, linewidth=3, color='b', linestyle='-')\n plt.rc('xtick', labelsize=10) \n plt.rc('ytick', labelsize=10) \n plt.xlabel(\"Precision\", size=12)\n plt.ylabel(\"Recall\", size=12)\n plt.grid()\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \n plt.rcParams['axes.facecolor'] = '#F2F3F4'\n plt.title(\"PR Curve: Precision/Recall Trade-off\\n\\n(Test)\\n\", size=14)\n plt.show()","def evaluate(self, plot):","def EPI():\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\n\n area = [upper_left, center, upper_center, lower_right]\n colors = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\"]\n name = [\"Upper left area\", \"Center area\", \"Up center area\", \"Lower right area\"]\n x_new = np.linspace(4.22, 270.5, 10000)\n for i, j, k in zip(area, colors, name):\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\n M0, T2 = popt[0], popt[1]\n y_new = M_xy(x_new, M0, T2)\n plt.scatter(TE, i)\n plt.plot(x_new, y_new, \"--\", c=j, label=\"Fit: %s\" % k + f\", $T_2$={T2:.2f}\")\n plt.legend(loc=\"best\")\n plt.grid()\n plt.ylabel(\"Mean Signal Intensity\")\n plt.xlabel(\"TE [ms]\")\n plt.show()","def plot_calibration_curve(est, name, fig_index, data):\n\n X_train = data[0]\n X_test = data[1]\n y_train = data[2]\n y_test = data[3]\n\n y = np.concatenate([y_train, y_test], axis=0)\n\n # Calibrated with isotonic calibration\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\n\n # Calibrated with sigmoid calibration\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\n\n # Logistic regression with no calibration as baseline\n lr = LogisticRegression(C=1., solver='lbfgs')\n\n fig = plt.figure(1, figsize=(15, 10))\n ax1 = plt.subplot2grid((4, 6), (0, 0), colspan=2, rowspan=2)\n ax2 = plt.subplot2grid((4, 6), (0, 2), colspan=2, rowspan=2)\n ax3 = plt.subplot2grid((4, 6), (0, 4), colspan=2, rowspan=2)\n ax4 = plt.subplot2grid((4, 6), (2, 0), colspan=6, rowspan=2)\n\n ax1.plot([0, 1], [0, 1], \"k:\", label=\"Perfectly calibrated\")\n for clf, name in [(lr, 'Logistic'),\n (est, name),\n (isotonic, name + ' + Isotonic'),\n (sigmoid, name + ' + Sigmoid')]:\n clf.fit(X_train, y_train)\n y_pred = clf.predict(X_test)\n if hasattr(clf, \"predict_proba\"):\n prob_pos = clf.predict_proba(X_test)[:, 1]\n y_proba = prob_pos.copy()\n else: # use decision function\n prob_pos = clf.decision_function(X_test)\n y_proba = prob_pos.copy()\n prob_pos = \\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\n\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\n print(\"%s:\" % name)\n print(\"\\tBrier: %1.3f\" % (clf_score))\n print(\"\\tPrecision: %1.3f\" % precision_score(y_test, y_pred))\n print(\"\\tRecall: %1.3f\" % recall_score(y_test, y_pred))\n print(\"\\tF1: %1.3f\" % f1_score(y_test, y_pred))\n print(\"\\tAve. Precision Score: %1.3f\\n\" % \\\n average_precision_score(y_test, y_proba))\n\n fraction_of_positives, mean_predicted_value = \\\n calibration_curve(y_test, prob_pos, n_bins=10)\n\n ax1.plot(mean_predicted_value, fraction_of_positives, \"s-\",\n label=\"%s (%1.3f)\" % (name, clf_score))\n\n fpr, tpr, thresholds = roc_curve(y_test, y_proba, drop_intermediate=False)\n roc_auc = roc_auc_score(y_test, y_proba)\n ax2.plot(fpr, tpr, ls='-', label=\"%s (%1.3f)\" % (name, roc_auc))\n\n precision, recall, _ = precision_recall_curve(y_test, y_proba)\n ax3.plot(recall, precision)\n\n ax4.hist(prob_pos, range=(0, 1), bins=10,\n label='%s' % name, histtype=\"step\", lw=2)\n\n ax1.set_xlabel(\"Score\", fontsize=14)\n ax1.set_ylabel(\"Fraction of positives\", fontsize=14)\n ax1.set_ylim([-0.05, 1.05])\n ax1.legend(loc=\"lower right\")\n ax1.set_title('Calibration plots (reliability curve)', fontsize=16)\n\n ax2.set_xlabel(\"False Positive Rate\", fontsize=14)\n ax2.set_ylabel(\"True Positive Rate\", fontsize=14)\n ax2.set_ylim([-0.05, 1.05])\n ax2.legend(loc=\"lower right\")\n ax2.set_title('ROC Curve', fontsize=16)\n\n ax3.set_xlabel(\"Recall\", fontsize=14)\n ax3.set_ylabel(\"Precision\", fontsize=14)\n ax3.set_ylim([-0.05, 1.05])\n ax3.legend(loc=\"lower center\")\n ax3.set_title('Precision-Recall Curve', fontsize=16)\n\n ax4.set_xlabel(\"Mean predicted value\", fontsize=14)\n ax4.set_ylabel(\"Count\", fontsize=14)\n ax4.legend(loc=\"upper center\")\n ax4.set_title('Classification Result', fontsize=16)\n\n plt.tight_layout()\n\n plt.show()\n\n return","def plot_calibration_curve(est, name, fig_index):\n # Calibrated with isotonic calibration\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\n\n # Calibrated with sigmoid calibration\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\n\n # Logistic regression with no calibration as baseline\n lr = LogisticRegression(C=1.)\n\n fig = plt.figure(fig_index, figsize=(10, 10))\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\n ax2 = plt.subplot2grid((3, 1), (2, 0))\n\n ax1.plot([0, 1], [0, 1], \"k:\", label=\"Perfectly calibrated\")\n for clf, name in [(lr, 'Logistic'),(est, name),(isotonic, name + ' + Isotonic'),(sigmoid, name + ' + Sigmoid')]:\n #Para cada modelo, entrenamos y predecimos \n clf.fit(X_train, y_train)\n y_pred = clf.predict(X_test)\n if hasattr(clf, \"predict_proba\"):\n prob_pos = clf.predict_proba(X_test)[:, 1]\n else: # use decision function\n prob_pos = clf.decision_function(X_test)\n prob_pos = \\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\n\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\n print(\"%s:\" % name)\n print(\"\\tBrier: %1.3f\" % (clf_score))\n print(\"\\tPrecision: %1.3f\" % precision_score(y_test, y_pred))\n print(\"\\tRecall: %1.3f\" % recall_score(y_test, y_pred))\n print(\"\\tF1: %1.3f\\n\" % f1_score(y_test, y_pred))\n\n fraction_of_positives, mean_predicted_value = \\\n calibration_curve(y_test, prob_pos, n_bins=10)\n\n ax1.plot(mean_predicted_value, fraction_of_positives, \"s-\",\n label=\"%s (%1.3f)\" % (name, clf_score))\n\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\n histtype=\"step\", lw=2)\n\n ax1.set_ylabel(\"Fraction of positives\")\n ax1.set_ylim([-0.05, 1.05])\n ax1.legend(loc=\"lower right\")\n ax1.set_title('Calibration plots (reliability curve)')\n\n ax2.set_xlabel(\"Mean predicted value\")\n ax2.set_ylabel(\"Count\")\n ax2.legend(loc=\"upper center\", ncol=2)\n\n plt.tight_layout()","def curve(self):\n return self.__curve","def fit(self):\n # Initialize parameter estimates\n if self.estimator is not None:\n param_estimates = self.estimator(self.xf, self.yf)\n else: param_estimates = None\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \n p0=param_estimates)\n self.fit_history.append({\"popt\" : self.popt, \"pcov\" : self.pcov})","def fit():\n pass","def curve(self, index):\n if index >= len(self) or len(self) == 0:\n print('ERROR Class Graph method Curve: cannot find Curve (index',\n index, ', max possible', len(self), ')')\n return\n return self.data[index]","def curves(self):\n return self._curve_reg","def plot(\n self,\n curve: Optional[Tuple[Tensor, Tensor, Tensor]] = None,\n ax: Optional[_AX_TYPE] = None,\n ) -> _PLOT_OUT_TYPE:\n curve = curve or self.compute()\n return plot_curve(\n curve,\n ax=ax,\n label_names=(\"False positive rate\", \"True positive rate\"),\n name=self.__class__.__name__,\n )","def _curve_fitting(self, phase, info):\n start_date = info[self.START]\n end_date = info[self.END]\n population = info[self.N]\n trend = Trend(\n self.jhu_data, population, self.country, province=self.province,\n start_date=start_date, end_date=end_date\n )\n trend.analyse()\n df = trend.result()\n if trend.rmsle() > self.max_rmsle:\n df[f\"{self.S}{self.P}\"] = None\n # Get min value for vline\n r_value = int(df[self.R].min())\n # Rename the columns\n phase = self.INITIAL if phase == \"0th\" else phase\n df = df.rename({f\"{self.S}{self.P}\": f\"{phase}{self.P}\"}, axis=1)\n df = df.rename({f\"{self.S}{self.A}\": f\"{phase}{self.A}\"}, axis=1)\n df = df.rename({f\"{self.R}\": f\"{phase}_{self.R}\"}, axis=1)\n return (df, r_value)","def FitPlot(self, xFit=None, yFit=None, fitFunc='exp1',\n fitPars=None, fixedPars=None, fitPlot=None, plotInstance=None,\n color=None):\n if xFit is None or fitPars is None:\n return\n func = self.fitfuncmap[fitFunc]\n if color is None:\n fcolor = func[3]\n else:\n fcolor = color\n if yFit is None:\n yFit = numpy.array(xFit.shape)\n# print 'xfit shape: ', xFit.shape\n yFit = func[0](fitPars, xFit, C=fixedPars)\n # for k in range(0, len(fitPars)):\n # yFit[k] = func[0](fitPars[k], xFit[k], C=fixedPars)\n if plotInstance is None or fitPlot is None:\n return (yFit)\n for k in range(0, len(fitPars)):\n plotInstance.PlotLine(fitPlot, xFit[k], yFit[k], color=fcolor)\n return (yFit)","def curve_fit():\n x_west, z_west, x_east, z_east = roof_measurements()\n \n # find best curve fit for west roof section\n param_west, param_cov_west = optimize.curve_fit(test_func, x_west, z_west)\n print(param_west)\n \n # z = 7.29944696 + (1.27415518*x) + (-0.0680139854*x**2) + (0.00152035861*x**3)\n \n z_west_fitted = test_func(x_west,*param_west)\n \n # mirror curve for east roof section\n z_east_fitted = np.flip(z_west_fitted,axis=0)\n \n # create array for both west and east roof sections\n x_whole_roof = np.concatenate((x_west, x_east), axis=0)\n z_whole_roof = np.concatenate((z_west_fitted, z_east_fitted), axis=0)\n\n # plot roof\n plt.plot(x_whole_roof, z_whole_roof, '-', color ='blue', label=\"roof curve\") \n plt.axis('equal') # make axes square\n plt.show() \n\n return param_west","def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\n if len(target_value) != len(x_value):\n raise ValueError(\"Value length not match\")\n\n fig = plt.figure()\n\n parameters, _ = curve_fit(\n model_function, x_value, target_value, method=fitting_method)\n\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\n if len(parameters) == 1:\n fit_A = parameters[0]\n fit_curve = model_function(xspace, fit_A)\n elif len(parameters) == 2:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_curve = model_function(xspace, fit_A, fit_B)\n elif len(parameters) == 3:\n fit_A = parameters[0]\n fit_B = parameters[1]\n fit_C = parameters[2]\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\n else:\n raise ValueError(\"Function do not support that Model\")\n\n # making plot\n plt.plot(x_value, target_value, 'o', label='cpu')\n plt.plot(xspace, fit_curve, '-', label='fit')\n plt.xlabel(\"cores_per_node\")\n plt.ylabel(\"time/s\")\n plt.title(type_of_fit + \"_Fitting Plot\")\n plt.legend()\n plt.savefig(type_of_fit + \"_fit.jpg\")\n plt.close()\n\n return parameters","def makeFit(self):\n if not self.fitModel.params:\n return\n cs = self.spectrum\n self.worker.make_model_curve(cs, allData=csi.allLoadedItems)\n\n dfparams = cs.fitParams\n lcfRes = dfparams['lcf_result']\n self.fitR.setText('R={0:.5g}'.format(lcfRes['R']))\n self.updateFitResults()\n self.fitReady.emit()","def graph_sas_curve(filename, x, y, title_text, x_lab, y_lab,\n x_min, x_max, y_min, y_max, **kwargs):\n\n fit_coeffs = kwargs.get('fitcoeffs', None)\n outputs = kwargs.get('outputs', None)\n rq_range = kwargs.get('rqrange', None)\n mask = kwargs.get('mask', None)\n\n # Plot the input x, y values and if provided a fit line\n # output is used to display values calculated from fit (Rg, Rxs?, R?*q over\n # fit values) on the plot\n\n plt.figure(figsize=(8, 6), dpi=300)\n\n ax = plt.subplot(111, xlabel=x_lab, ylabel=y_lab, title=title_text,\n xlim=(x_min, x_max), ylim=(y_min, y_max))\n\n plt.scatter(x, y, s=5)\n\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label]):\n item.set_fontsize(15)\n\n ax.tick_params(axis='both', which='major', labelsize=12)\n\n # Plot linear fit and highlight points used in its construction\n if fit_coeffs is not None:\n\n # Plot the fit line along the whole x range shown in the plot\n fitLine = np.poly1d(fit_coeffs[0:2])\n x_points = np.linspace(x_min, x_max, 300)\n plt.plot(x_points, fitLine(x_points))\n\n # Highlight points used in the fit\n if mask is None:\n plt.scatter(x, y, s=30)\n else:\n plt.scatter(x[mask], y[mask], s=30)\n\n plt.annotate(outputs + '\\n' + rq_range, xy=(0.45, 0.9),\n xycoords='axes fraction')\n \n \n d = date.today()\n plt.annotate(d.strftime('%d %B %Y'), xy=(0.01, 0.02),\n xycoords='axes fraction')\n\n plt.savefig(filename)","def plot(self, fitted=True, fitted_pltargs={}, ax=None, **pltargs):\n if ax is None:\n ax = plt.gca()\n\n ax.plot(self.I, self.f, **pltargs)\n if fitted:\n if 'label' in pltargs.keys():\n # `label` doesn't apply to fitted line, even if it isn't\n # overridden by `fitted_pltargs`, so we must remove it.\n pltargs.pop('label')\n pltargs.update(fitted_pltargs) # Inherit/override `pltargs`.\n\n ax.plot(*self._get_fitted_curve(), **pltargs)","def plot_precision_recall_curve(estimator, X, y, *, sample_weight=..., response_method=..., name=..., ax=..., pos_label=..., **kwargs):\n ...","def fit_line_Vo(x, y, n):\n x1=x[0:n]\n y1=y[0:n]\n X = sm.add_constant(x1)\n model = sm.OLS(y1, X, missing='drop') # ignores entires where x or y is NaN\n fit = model.fit()\n m=fit.params[1] \n b=fit.params[0] \n# stderr=fit.bse # could also return stderr in each via fit.bse\n \n N = 100 # could be just 2 if you are only drawing a straight line...\n points = np.linspace(x.min(), x.max(), N)\n \n \n fig=plt.figure(1) #PLOTING TOGETHER\n \n ax = fig.add_subplot(111)\n ax.plot(x, y)\n ax.plot(points, m*points + b)\n \n plt.legend(['data','fitt Vo'],fontsize=16)\n \n ax.set_yscale('linear',fontsize=16)\n ax.tick_params(axis='x', labelsize=14)\n ax.tick_params(axis='y', labelsize=14)\n plt.ylabel('Abs',fontsize=16)\n plt.xlabel('Time(sec)',fontsize=16)\n ax.grid()\n plt.grid()\n plt.show()\n \n print(\"The Vo fitted model is: {0:2f}*x+{1:2f} \".format(m, b))\n return m,b","def Curve(self, *args):\n return _Adaptor3d.Adaptor3d_HCurve_Curve(self, *args)","def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\n\n # useful display and computational data\n y_fitted = poly_fit(x_data)\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\n x_fitted_display = np.linspace(min_x_display, max_x_display)\n y_fitted_display = poly_fit(x_fitted_display)\n\n # goodness of fit indicators\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\n R2 = 1.0 - SSE/SST # R squared\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\n\n fig = plt.figure()\n ax = fig.add_subplot(1, 2, 1)\n\n # plot of the fitted polynomial itself\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\n ax.scatter(x_data, y_data, color='C7')\n ax.set(title=\"Fitted polynomial (deg{}) for \\'{}\\'\".format(poly_fit.order, fit_name), xlabel=\"x\", ylabel=\"y\")\n\n # histogram of residuals\n ax2 = fig.add_subplot(1, 2, 2)\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\n ax2.set(title=\"Histogram of residuals\", xlabel=\"Residual value $y_k - \\\\widehat{y_k}$\", ylabel=\"Count\")\n\n # display of fit indicators\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\n\n fig.tight_layout()\n fig.subplots_adjust(bottom=0.2)\n\n figurefiles.save_in_perfs_fits_folder(fig, \"Polyfit_{}_order_{}.pdf\".format(fit_name, poly_fit.order))","def fit(self):\n raise NotImplementedError('')","def get_expression_for_cliques(path, save_fig_path=\"extracted_data/Cliques/curve_fit.png\"):\n with open(path, 'r') as f:\n x = []\n grp = []\n rand = []\n stat = []\n for l in f:\n if \"Clique size\" in l:\n ind = l.split(',')\n for k in ind[1:]:\n x.append(float(k))\n print(ind[0], end=\":\\t\")\n print(x)\n if \"GROUP_MOBILITY\" in l:\n ind = l.split(',')\n for k in ind[1:]:\n grp.append(float(k))\n print(ind[0], end=\":\\t\")\n print(grp)\n if \"RANDOM\" in l:\n ind = l.split(',')\n for k in ind[1:]:\n rand.append(float(k))\n print(ind[0], end=\":\\t\")\n print(rand)\n if \"Average Stationary\" in l:\n ind = l.split(',')\n for k in ind[1:]:\n stat.append(float(k))\n print(ind[0], end=\":\\t\")\n print(stat)\n round_off = 8\n z_grp = np.polyfit(x, grp, 8).round(decimals=round_off)\n print(\"Group\", end=\"\\n\\t\")\n print(z_grp)\n f_grp = np.poly1d(z_grp)\n\n z_rand = np.polyfit(x, rand, 8).round(decimals=round_off)\n print(\"Random\", end=\"\\n\\t\")\n print(z_rand)\n f_rand = np.poly1d(z_rand)\n\n z_stat = np.polyfit(x, stat, 8).round(decimals=round_off)\n print(\"Stationary\", end=\"\\n\\t\")\n print(z_stat)\n f_stat = np.poly1d(z_stat)\n\n x_new = np.linspace(2, 14, 50)\n\n y_new_grp = f_grp(x_new)\n y_new_rand = f_rand(x_new)\n y_new_stat = f_stat(x_new)\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.plot(x, grp, 'o', x_new, y_new_grp)\n ax.plot(x, rand, '+', x_new, y_new_rand)\n ax.plot(x, stat, '*', x_new, y_new_stat)\n ax.set_xlabel('Clique size')\n ax.set_ylabel('Average no. of cliques')\n ax.legend((\"Group\", \"Group curve fit\", \"Random\", \"Random curve fit\", \"Stationary\", \"Stationary curve fit\"))\n fig.savefig(save_fig_path)\n plt.show()","def show_fit(self):\n self.fft_fit_plotter.plot(self.ax)\n plt.draw()","def plot(self):\n pass","def getCurve(self, *args):\n return _libsbml.GeneralGlyph_getCurve(self, *args)","def fitgeneral(xdata, ydata, fitfunc, fitparams, domain=None, showfit=False, showstartfit=False, showdata=True,\n label=\"\", mark_data='bo', mark_fit='r-'):\n\n # sort data\n order = np.argsort(xdata)\n xdata = xdata[order]\n ydata = ydata[order]\n\n if domain is not None:\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\n else:\n fitdatax=xdata\n fitdatay=ydata\n# print 'minimum', np.min(fitdatay)\n# ymin=np.min(fitdatay)\n errfunc = lambda p, x, y: (fitfunc(p,x) - y) #there shouldn't be **2 # Distance to the target function\n startparams=fitparams # Initial guess for the parameters\n bestfitparams, success = optimize.leastsq(errfunc, startparams[:], args=(fitdatax,fitdatay))\n if showfit:\n if showdata:\n plt.plot(fitdatax,fitdatay,mark_data,label=label+\" data\")\n if showstartfit:\n plt.plot(fitdatax,fitfunc(startparams,fitdatax),label=label+\" startfit\")\n plt.plot(fitdatax,fitfunc(bestfitparams,fitdatax),mark_fit,label=label+\" fit\")\n if label!='': plt.legend()\n err=math.fsum(errfunc(bestfitparams,fitdatax,fitdatay))\n #print 'the best fit has an RMS of {0}'.format(err)\n# plt.t\n# plt.figtext() \n return bestfitparams","def print_fit(funct, fit, cov=False):\n params = funct.__code__.co_varnames\n idx = 1\n if params[0] == 'self':\n idx = 2\n diag_cov = _np.sqrt(_np.diag(abs(cov)))\n params = params[idx:len(fit)+1]\n print('%s fit parameters' % funct.__name__)\n if cov is not False:\n for i, param in enumerate(params):\n print('%s: %.02e, %.02e' %(param, fit[i], diag_cov[i]))\n else:\n for i, param in enumerate(params):\n print('%s: %.02e' %(param, fit[i]))","def __init__(self, parent=None, pltw=None, cpos=None, model=None):\n super (fitCurveDlg, self).__init__(parent)\n\n self.parent = parent\n self.cpos = cpos\n self.model = model\n self.pltw = pltw\n self.blkno = self.pltw.curvelist[cpos].yvinfo.blkpos\n self.xpos = self.pltw.curvelist[cpos].xvinfo.vidx\n self.ypos = self.pltw.curvelist[cpos].yvinfo.vidx\n self.data = np.vstack( (self.pltw.blklst[self.blkno][self.xpos],\n self.pltw.blklst[self.blkno][self.ypos],\n self.pltw.blklst[self.blkno][self.ypos],\n np.zeros(len(self.pltw.blklst[self.blkno][self.xpos]))) )\n\n self.diffshift = getSpan(self.data[1]) * 0.2\n if self.data[1].min() + self.diffshift < 0.0:\n self.diffshift *= -1.0\n\n self.initParms()\n\n # Create the layout\n self.createLayout()\n # Connect buttons to callback functions\n self.exeBtn.clicked.connect(self.compute)\n self.okBtn.clicked.connect(self.validate)\n self.cancelBtn.clicked.connect(self.reject)\n self.setWindowTitle('Curve Fitting tool')\n\n self.updateParms()\n self.compute()\n QTimer.singleShot(5000, self.istest)","def prob4():\n # Load the data.\n data = np.loadtxt(\"../heating.txt\")\n\n # Define the function to optimize.\n def f(x, gamma, c, K):\n return 290.0 + 59.43/gamma + K*np.exp(-gamma*x/c)\n\n # Use curve_fit and the data to get the parameters.\n popt, pcov = opt.curve_fit(f, data[:,0], data[:,1])\n curve = f(data[:,0], popt[0], popt[1], popt[2])\n\n # Plot the data and the curve.\n plt.plot(data[:,0], data[:,1], '.k', label='Data')\n plt.plot(data[:,0], curve, 'b', label='Curve', linewidth=2)\n plt.xlim(-50, 400)\n plt.ylim(260, 380)\n plt.legend(loc=\"lower right\")\n plt.show()\n \n # Return the parameter values.\n return popt","def print_curve(xlist, ylist, precision=3):\r\n print (\"----------------------\")\r\n print (\"Maturities\\tCurve\")\r\n print (\"----------------------\")\r\n for x,y in zip(xlist, ylist):\r\n print (x,\"\\t\\t\", round(y, precision))\r\n print (\"----------------------\")","def plot_inv_RV_lit(outpath, fit_slopes, fit_intercepts, fit_stds):\n waves = np.arange(0.8, 4.01, 0.001)\n fig, ax = plt.subplots(figsize=(10, 9))\n\n for i, RV in enumerate([2.5, 3.1, 5.5]):\n # plot the extinction curve from this work\n offset = 0.1 * i\n slopes = interpolate.splev(waves, fit_slopes)\n alav = fit_intercepts(waves) + slopes * (1 / RV - 1 / 3.1)\n (line,) = ax.plot(waves, alav + offset, lw=1.5, label=r\"$R(V) = $\" + str(RV))\n stddev = interpolate.splev(waves, fit_stds)\n color = line.get_color()\n ax.fill_between(\n waves,\n alav + offset - stddev,\n alav + offset + stddev,\n color=color,\n alpha=0.2,\n edgecolor=None,\n )\n\n # plot the literature curves\n styles = [\"--\", \":\"]\n for i, cmodel in enumerate([CCM89, F19]):\n ext_model = cmodel(Rv=RV)\n (indxs,) = np.where(\n np.logical_and(\n 1 / waves >= ext_model.x_range[0], 1 / waves <= ext_model.x_range[1]\n )\n )\n yvals = ext_model(waves[indxs] * u.micron)\n ax.plot(\n waves[indxs],\n yvals + offset,\n lw=1.5,\n color=color,\n ls=styles[i],\n alpha=0.8,\n )\n\n # add text\n ax.text(3.45, 0.03, r\"$R(V) = 2.5$\", fontsize=0.8 * fs, color=\"tab:blue\")\n ax.text(3.45, 0.15, r\"$R(V) = 3.1$\", fontsize=0.8 * fs, color=\"tab:orange\")\n ax.text(3.45, 0.305, r\"$R(V) = 5.5$\", fontsize=0.8 * fs, color=\"tab:green\")\n\n # finalize and save the plot\n ax.set_xlabel(r\"$\\lambda\\ [\\mu m$]\", fontsize=1.2 * fs)\n ax.set_ylabel(r\"$A(\\lambda)/A(V)$ + offset\", fontsize=1.2 * fs)\n ax.set_xlim(0.75, 4.05)\n ax.set_ylim(-0.03, 0.98)\n handles = [\n Line2D([0], [0], color=\"k\", lw=1.5),\n Line2D([0], [0], color=\"k\", lw=1.5, ls=\"--\"),\n Line2D([0], [0], color=\"k\", lw=1.5, ls=\":\"),\n ]\n labels = [\n \"this work\",\n \"Cardelli et al. (1989)\",\n \"Fitzpatrick et al. (2019)\",\n ]\n plt.legend(handles, labels, fontsize=fs)\n plt.savefig(outpath + \"inv_RV_lit.pdf\", bbox_inches=\"tight\")\n\n # also save the plot in log scale\n plt.ylim(0.01, 1)\n plt.yscale(\"log\")\n plt.tight_layout()\n plt.savefig(outpath + \"inv_RV_lit_log.pdf\")","def drawFitTF(s,ivar,title=None,logscale=False,modbins=True,lumifrac=1.0):\n import SuCanvas\n s.canvas = canvas = SuCanvas.SuCanvas()\n canvas.buildRatio()\n canvas._xaxisName = s.vnames[0] + ' [GeV]'\n # main plot area: draw {data,model,fixed,qcd}\n canvas.cd_plotPad()\n fit = s.fit\n stack,fixed,free = None,None,None\n assert s.status==0,'Fit failed or not performed yet'\n if s.status==0:\n # fixed (EWK) - must be scaled\n fixed = s.hfixed if modbins==True else s.fixed.Clone()\n fixed.SetLineColor(s.LineColor_ewk)\n fixed.SetFillColor(s.FillColor_ewk)\n fixed.SetFillStyle(s.FillStyle_ewk)\n fixed.Scale(s.Wscales[0])\n #fixed.Draw('A SAME H')\n # free (qcd) - must be scaled\n ift = 0\n free = s.hfree if modbins==True else s.free[0].Clone()\n free.SetLineColor(s.LineColor_qcd)\n free.SetFillColor(s.FillColor_qcd)\n free.SetFillStyle(s.FillStyle_qcd)\n free.Scale(s.scales[0])\n #free.Draw('A SAME H')\n # make a stack\n s.stack = stack = ROOT.THStack('qcd_stack','Final QCD stack')\n stack.Add(fixed)\n stack.Add(free)\n stack.Draw('HIST')\n # model - already scaled to expectation\n if s.PlotModel:\n model = s.hmodel\n model.SetLineColor(s.LineColor_model)\n model.SetFillStyle(0)\n model.Draw('A SAME')\n # data\n s.hdata = data = s.data.Clone()\n #data.SetMarkerStyle(8)\n data.SetMarkerStyle(20)\n data.SetMarkerSize(0.8)\n data.SetFillStyle(0)\n data.Draw('X0 A SAME')\n\n # y axis\n canvas.cd_plotPad()\n stack.SetMaximum(stack.GetMaximum()*s.StackMaximum)\n\n # prettify\n obj = stack\n if obj:\n obj.GetXaxis().SetRange(s.plotmin,s.plotmax)\n xname = s.w.var(s.vnames[ivar]).GetName()\n obj.GetXaxis().SetTitle( xname ) # over-ridden in ratio plot\n bin_width = data.GetXaxis().GetBinWidth(1)\n obj.GetYaxis().SetTitle( \"Entries / %.2f GeV\" % bin_width )\n\n # indicate fit range\n if True:\n canvas.update()\n fmax = s.w.var(s.vnames[ivar]).getMax()\n s.gr = gr = ROOT.TGraph(2)\n gr.SetPoint(0,fmax,canvas._plotPad.GetFrame().GetY1())\n gr.SetPoint(1,fmax,canvas._plotPad.GetFrame().GetY2())\n gr.SetLineColor(ROOT.kRed)\n gr.SetLineStyle(2)\n gr.Draw('L')\n \n s.leg = leg = ROOT.TLegend()\n leg.AddEntry( data ,\"data 2011 (#sqrt{s} = 7 TeV) \",\"pe\")\n if s.PlotModel:\n leg.AddEntry( model , \"fit range\" , \"l\" )\n leg.AddEntry( free , 'QCD (template)' , \"f\" )\n leg.AddEntry( fixed , 'EWK + tops' , \"f\" )\n canvas.ConfigureLegend(leg)\n leg.Draw(\"9\");\n canvas.update()\n\n s.fractext = fractext = ROOT.TPaveText()\n for ift,frac in enumerate(s.fractions):\n if title:\n if type(title)==type([]):\n [fractext.AddText(zz) for zz in title]\n else:\n fractext.AddText(title)\n fractext.AddText('')\n if s.fractions[ift]!=0 and s.scales[ift]!=0:\n fractext.AddText( '%s Frac. = %.2f #pm %.2f%%'%(s.free[ift].getLegendName(),s.fractions[ift],s.fractionsE[ift]/s.fractions[ift]*100.0 if abs(s.fractions[ift])>1e-6 else 0) )\n fractext.AddText( '%s SF = %.2f #pm %.2f%%'%(s.free[ift].getLegendName(),s.scales[ift],s.scalesE[ift]/s.scales[ift]*100.0 if abs(s.scales[ift])>1e-6 else 0) )\n if s.Wfractions[ift]!=0 and s.Wscales[ift]!=0 and SUFIT_PLOT_EWK_FRAC:\n fractext.AddText( '%s SF = %.2f #pm %.2f%%'%('EWK',s.Wscales[ift]/lumifrac,s.WscalesE[ift]/s.Wscales[ift]*100.0 if s.Wscales[ift]!=0 else 0) )\n if s.ndf[ift]!=0:\n fractext.AddText( '#chi^{2}=%.1f #chi^{2}/NDF=%.1f'%(s.chi2[ift],s.chi2[ift]/s.ndf[ift]) )\n canvas.ConfigureText(fractext,text_y2 = leg.GetY1NDC()-0.03)\n fractext.Draw(\"9\");\n canvas.update()\n \n if logscale:\n print 'Applying log scale'\n ROOT.gPad.SetLogy(ROOT.kTRUE)\n\n # ratio\n canvas.cd_ratioPad()\n if s.status==0:\n hmodel = None\n if False: # this hmodel only includes bins that were actually part of the TFractionFitter fit\n hmodel = s.hmodel.Clone()\n else: # this includes all bins in the original range of the histograms\n hmodel = fixed.Clone()\n hmodel.Add( free )\n #scalefactor = 1.0*data.Integral(s.fitmin,s.fitmax)/model.Integral(s.fitmin,s.fitmax)\n #hmodel.Scale( scalefactor ); # scale model to actual data integral (not needed!)\n s.hratio = data.Clone('hratio')\n s.hratio.Divide(hmodel)\n canvas.drawRatio(s.hratio,yrange=s.RatioRange)\n canvas.ConfigureAxis(stack, s.hratio)\n s.hratio.GetXaxis().SetRange(s.plotmin,s.plotmax)\n TMAP = {}\n TMAP['met'] = 'E_{T}^{Miss} [GeV]'\n TMAP['d3_eta_lpt_met'] = TMAP['met']\n TMAP['d3_abseta_lpt_met'] = TMAP['met']\n TMAP['wmt'] = 'm_{T}^{W} [GeV]'\n TMAP['w_mt'] = TMAP['wmt']\n TMAP['d3_eta_lpt_wmt'] = TMAP['wmt']\n TMAP['d3_abseta_lpt_wmt'] = TMAP['wmt']\n vname = s.w.var(s.vnames[ivar]).GetName()\n xtitle = TMAP[vname] if vname in TMAP else vname\n if vname[:14] in TMAP:\n xtitle = TMAP[vname[:14]]\n if vname[:17] in TMAP:\n xtitle = TMAP[vname[:17]]\n s.hratio.GetXaxis().SetTitle( xtitle )\n\n # finalize\n canvas.update()\n if False: # debugging:\n canvas.SaveAs('SYS.png')\n return canvas,None","def plot_tuning_curves(self, baseline_rate=10.):\n x = np.arange(0, 1 + 0.01, 0.01)\n l0 = self.data['L0']\n l1 = self.data['L1']\n y_on = np.exp(np.log(l0) + x * np.log(l1 / l0))\n y_off = np.exp(np.log(l0) + (1 - x) * np.log(l1 / l0))\n plt.plot(x, y_on, label='ON')\n plt.plot(x, y_off, label='OFF')\n plt.plot(x, baseline_rate + 0 * x, '--')\n # plt.xlabel('Stimulus intensity')\n # plt.ylabel('Firing Rate (Hz)')\n # plt.title('Firing rate as a function \\n of Stimulus Intensity')\n # plt.legend()","def plot_learning_curve(model, X_train, X_test, y_train, y_test):\n\n m, train_scores, valid_scores = learning_curve(estimator = model, \n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\n\n train_cv_err = np.mean(train_scores, axis=1)\n test_cv_err = np.mean(valid_scores, axis=1)\n tr, = plt.plot(m, train_cv_err)\n ts, = plt.plot(m, test_cv_err)\n plt.legend((tr, ts), ('training error', 'test error'), loc = 'best')\n plt.title('Learning Curve')\n plt.xlabel('Data Points')\n plt.ylabel('Accuracy')","def fit(ydata):\n xdata = np.linspace(0,len(ydata),num = len(ydata))\n popt, pcov = curve_fit(func, xdata, ydata)\n #returns the parameters of the fitting\n return popt","def report_edp(self):\n lmfit.report_fit(self.edp_par)\n print(\"chisqr = {0:.3f}\".format(self.edp.chisqr))","def curve(self, data):\n x, y, y_smoothed = data\n\n curve_keys = ['color', 'linestyle', 'alpha', 'label']\n curve_config = self.config.filter(curve_keys, prefix='curve_')\n\n curves = self.ax.plot(x, y, **curve_config)\n\n if y_smoothed is not None:\n smoothed_color = scale_lightness(curve_config['color'], scale=.5)\n smoothed_label = self.config.get('smoothed_label')\n _ = self.ax.plot(x, y_smoothed, label=smoothed_label, color=smoothed_color, linestyle='--')\n\n return curves","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def get_fit_x(self, ploty):\n # Generate x and y values for plotting\n try:\n fitx = self.best_fit[0]*ploty**2 + self.best_fit[1]*ploty + self.best_fit[2]\n except TypeError:\n # Avoids an error if best_fit is still none or incorrect\n print('The function failed to fit a line!')\n fitx = 1*ploty**2 + 1*ploty\n\n return fitx","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def plotFit(title, threadCounts, bestTimes, coeffs, independentVar, unit):\n values = {}\n for impl in sorted(list(bestTimes.keys()), key=cmp_to_key(compareFn)):\n values[impl] = bestTimes[impl]\n (tThread, tZero) = coeffs[impl]\n values[impl + \"(best fit)\"] = [\n tZero + thread * tThread for thread in threadCounts\n ]\n generatePlot(\n title, unit, threadCounts, values, xLabel=independentVar, logarithmic=False\n )","def graph_points():\n fig_name = 'lect2_num_solv'\n\n # given data\n x = np.array([0.0, 0.4, 0.6, 0.8])\n ra = np.array([0.01, 0.0080, 0.005, 0.002])\n design_eq = np.divide(2.0, ra)\n print(\"Generic example design equation points: {}\".format([\"{:0.1f}\".format(x) for x in design_eq]))\n\n # cubic spline\n x_new = np.linspace(0.0, 0.8, 101)\n # alternately, from interpolation\n y_interp = interpolate.interp1d(x, design_eq, kind='quadratic')\n make_fig(fig_name, x, design_eq, ls1='o', x2_array=x_new, y2_array=y_interp(x_new),\n x_label=r'conversion (X, unitless)', y_label=r'$\\displaystyle\\frac{F_{A0}}{-r_A} \\left(L\\right)$',\n x_lima=0.0, x_limb=0.8, y_lima=0.0, y_limb=1000,\n fig_width=4, color2='green',\n )","def _repr_(self):\n return \"Ring of coordinate functions on {}\".format(self._chart)","def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1, 10)):\n font = {'family': 'Droid Sans',\n 'weight': 'normal',\n 'size': 14}\n plt.rc('font', **font)\n plt.figure()\n plt.title(title)\n if ylim is not None:\n plt.ylim(*ylim)\n plt.xlabel(u\"Объем тренировочной выборки\")\n plt.ylabel(u\"Точность\")\n train_sizes, train_scores, test_scores = learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n plt.grid()\n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.1,\n color=\"r\")\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.1, color=\"g\")\n\n plt.plot(train_sizes, train_scores_mean, 'o-', color=\"r\",label=u\"Точность обучения\")\n plt.plot(train_sizes, test_scores_mean, 'o-', color=\"g\",label=u\"Точность тестирования\")\n\n plt.legend(loc=\"best\")\n print('train scores')\n print(train_scores)\n print('test scores')\n print(train_scores)\n return plt","def __str__(self):\n if not self.has_converged or self.parameters is None:\n log.warning(\"The fit has not converged. Try again!\")\n return ''\n\n result = []\n for parameter in self.parameters.keys():\n if parameter in self.fit_for:\n parameter_string = self.get_parameter_string(parameter)\n if parameter_string is not None:\n result.append(parameter_string)\n\n rms = self.get_parameter_format('kelvin') % self.rms\n result.append(f\"[{rms} K rms]\")\n return '\\n'.join(result)","def plot_metrics(couplings, cost_func, cost_func_name, epsilons, log = False, points=False, scale=1.0, label_font_size=18, tick_font_size=12):\n zero_offset = epsilons[0]/2\n all_ys = []\n if \"lineageOT\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['lineage entropic rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"LineageOT, true tree\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"lineageOT\"])/scale])\n all_ys.append(ys)\n if \"OT\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['entropic rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"Entropic OT\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"OT\"])/scale])\n all_ys.append(ys)\n if \"lineageOT, fitted\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['fitted lineage rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"LineageOT, fitted tree\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"lineageOT, fitted\"])/scale])\n all_ys.append(ys)\n\n plt.ylabel(cost_func_name, fontsize=label_font_size)\n plt.xlabel(\"Entropy parameter\", fontsize=label_font_size)\n plt.xscale(\"log\")\n\n plt.xticks(fontsize=tick_font_size)\n plt.yticks(fontsize=tick_font_size)\n\n if points:\n plt.xlim([0.9*zero_offset, epsilons[-1]])\n else:\n plt.xlim([epsilons[0], epsilons[-1]])\n\n ylims = plt.ylim([0, None])\n # upper limit should be at least 1\n plt.ylim([0, max(ylims[1], 1)])\n\n plt.legend(fontsize=tick_font_size)\n return all_ys","def equity_curve_draw(self, profit_avg, profit_std, actual_profit, perfect_profit=None,\n std_multiple=1, mode=1, title='', x_axis=None):\n if not isinstance(actual_profit, (list, np.ndarray, pd.Series)):\n raise TypeError('Actual profit should be one of list, numpy.ndarray, pandas.Series. Type=%s'\n % type(actual_profit))\n # add 0 to the beginning of the array\n actual_profit = np.append(np.array([0]), np.array(actual_profit))\n if perfect_profit is not None:\n perfect_profit = np.append(np.array([0]), np.array(perfect_profit))\n\n actual_profit_len = len(actual_profit)\n total_len = int(actual_profit_len * 1.5)\n\n x = np.linspace(0, total_len, total_len+1)\n if x_axis is None:\n x_axis = x\n zero_line = 0 * x\n\n mid_curve = x * profit_avg\n upper_curve = mid_curve + std_multiple * np.sqrt(x) * profit_std\n lower_curve = mid_curve - std_multiple * np.sqrt(x) * profit_std\n upper_curve2 = mid_curve + std_multiple * np.sqrt(x) * profit_std * 2\n lower_curve2 = mid_curve - std_multiple * np.sqrt(x) * profit_std * 2\n\n plt.figure()\n plt.rc('grid', linestyle='--', color='grey', linewidth=0.8)\n plt.grid(True)\n plt.plot(x, zero_line, color='grey', linestyle='--', linewidth=1)\n plt.plot(x, mid_curve, color='black', label='Expected P&L', linewidth=1)\n plt.plot(x, upper_curve, color='green', label='+' + str(std_multiple) + ' std', linewidth=1)\n plt.plot(x, lower_curve, color='red', label='-' + str(std_multiple) + ' std', linewidth=1)\n plt.plot(x, upper_curve2, color='green', label='+' + str(std_multiple*2) + ' std', linewidth=1, linestyle='--')\n plt.plot(x, lower_curve2, color='red', label='-' + str(std_multiple*2) + ' std', linewidth=1, linestyle='--')\n\n plt.plot(x[0:len(actual_profit)], actual_profit, '-o', linewidth=1,\n color='#00008b', label='Actual P&L', markersize=3)\n if perfect_profit is not None:\n plt.plot(x[0:len(actual_profit)], perfect_profit, '-o', linewidth=1,\n color='#008081', label='Perfect P&L', markersize=3)\n\n plt.legend(loc='upper left')\n x_label = 'days' if mode == 1 else 'trades'\n plt.xlabel('# of ' + x_label)\n plt.ylabel('$')\n by_day_trade = 'date' if mode == 1 else 'trade'\n plt.title(title + '_by' + by_day_trade)\n # plt.show()\n\n return plt","def content_fitting():\n\n all_functions = {\n \"sigmoid_function\": \"return sigmoid function for fitting or plotting\",\n \"fit_curve\": \"returns values r2 score and fitting parameters for a single sample\",\n \"fitting_column\": \"returns r2_scores, fitting_parameters\",\n \"compute_r2_score\": \"returns array of r2_scores\",\n \"compute_fitting_function\": \"returns df with columns \\\n [fitting_function+'_r2'] and fitting_function\",\n \"compare_fitting_functions\": \"returns df with columns better_fitting, \\\n displays df_best.loc[fitting_function, min, max, \\\n r2>0, r2>0.8, r2>0.9, r2>0.99\",\n }\n return all_functions","def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\"\"):\n if domain is not None:\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\n else:\n fitdatax=xdata\n fitdatay=ydata\n if fitparams is None: \n fitparams=[0.,0.,0.,0.]\n fitparams[0]=fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[1]=fitdatay[0]-fitdatay[-1]\n fitparams[2]=fitdatax[0]\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\n #print fitparams\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\n label=label)\n return p1","def fit(self, X):","def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\n n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\n \n \n\n \n font = {'family': 'serif',\n 'color': 'black',\n 'weight': 'bold',\n 'size': 10,\n }\n \n fig=plt.figure(figsize=(5,3))\n\n plt.title(title, fontdict= font)\n if ylim is not None:\n plt.ylim(*ylim)\n plt.xlabel(\"Training examples\", fontdict=font)\n plt.ylabel(\"Score\", fontdict=font)\n train_sizes, train_scores, test_scores = learning_curve(\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n train_scores_mean = np.mean(train_scores, axis=1)\n train_scores_std = np.std(train_scores, axis=1)\n test_scores_mean = np.mean(test_scores, axis=1)\n test_scores_std = np.std(test_scores, axis=1)\n \n plt.grid(b=True, which='both', color='w', linewidth=1.0) \n# \n\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n train_scores_mean + train_scores_std, alpha=0.1,\n color=\"blue\")\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n test_scores_mean + test_scores_std, alpha=0.1, color=\"orange\")\n plt.plot(train_sizes, train_scores_mean, 'o--', color=\"blue\",\n label=\"Training score\")\n plt.plot(train_sizes, test_scores_mean, '--o', color=\"orange\",\n label=\"Cross-validation score\")\n \n plt.legend(facecolor='white',loc=\"best\")\n\n fig.savefig(\"learning_Curve.pdf\", dpi=300,bbox_inches='tight')\n plt.close(fig)\n\n return plt","def fit(self):\n raise NotImplementedError","def fithanger_new_withQc(xdata, ydata, fitparams=None, domain=None, showfit=False, showstartfit=False,\n printresult=False, label=\"\", mark_data='bo', mark_fit='r-'):\n \n if domain is not None:\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\n else:\n fitdatax=xdata\n fitdatay=ydata\n if fitparams is None: \n peakloc=np.argmin(fitdatay)\n ymax=(fitdatay[0]+fitdatay[-1])/2.\n ymin=fitdatay[peakloc] \n f0=fitdatax[peakloc]\n Q0=abs(fitdatax[peakloc]/((max(fitdatax)-min(fitdatax))/5.))\n scale= ymax-ymin\n Qi=2*Q0\n Qc=Q0\n #slope = (fitdatay[-1]-fitdatay[0])/(fitdatax[-1]-fitdatax[0])\n #offset= ymin-slope*f0\n fitparams=[f0,abs(Qi),abs(Qc),0.,scale]\n #print '--------------Initial Parameter Set--------------\\nf0: {0}\\nQi: {1}\\nQc: {2}\\ndf: {3}\\nScale: {4}\\nSlope: {5}\\nOffset:{6}\\n'.format(f0,Qi,Qc,0.,scale,slope, offset)\n fitresult = fitgeneral(fitdatax, fitdatay, hangerfunc_new_withQc, fitparams, domain=None, showfit=showfit,\n showstartfit=showstartfit, label=label, mark_data=mark_data, mark_fit=mark_fit)\n fitresult[1]=abs(fitresult[1])\n fitresult[2]=abs(fitresult[2])\n if printresult: print('-- Fit Result --\\nf0: {0}\\nQi: {1}\\nQc: {2}\\ndf: {3}\\nscale: {4}'.format(fitresult[0],\n fitresult[1],\n fitresult[2],\n fitresult[3],\n fitresult[4]))\n return fitresult","def plot_learning_curve(X, y, maxdepth, estimator, plt):\n # create cv training and test scores for various training set sizes\n train_sizes, train_scores, test_scores = learning_curve(estimator,\n X, # feature matrix\n y, # target vector\n cv=10, # number of folds in cross-validation\n scoring='neg_mean_squared_error', # metric\n n_jobs=-1, # use all computer cores,\n train_sizes=np.linspace(0.01, 1.0, 30) # 30 different sizes of the training set\n )\n # create means and standart deviations of training set scores\n train_mean = np.mean(train_scores, axis=1)\n train_std = np.std(train_scores, axis=1)\n\n # create means and standart deviations of test set scores\n test_mean = np.mean(test_scores, axis=1)\n test_std = np.std(test_scores, axis=1)\n\n # draw lines\n plt.plot(train_sizes, train_mean, '--', color='#111111', label=\"Training score\")\n plt.plot(train_sizes, test_mean, color='#111111', label=\"Cross-validation score\")\n\n # draw bands\n plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"#DDDDDD\")\n plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\"#f4d0d7\")\n \n # create plot \n plt.title(\"Learning curve\")\n plt.xlabel(\"Training set size\", fontsize=18)\n plt.ylabel(\"mse\", fontsize=18)\n plt.legend(loc=\"best\")\n plt.tight_layout()","def __draw_curve(self, points):\n x_pts = []\n y_pts = []\n curvex = []\n curvey = []\n self.debug += 1\n for point in points:\n x_pts.append(point[0])\n y_pts.append(point[1])\n curve = scipy.interpolate.interp1d(x_pts, y_pts, 'cubic')\n if self.debug == 1 or self.debug == 2:\n for i in np.arange(x_pts[0], x_pts[len(x_pts) - 1] + 1, 1):\n curvex.append(i)\n curvey.append(int(curve(i)))\n else:\n for i in np.arange(x_pts[len(x_pts) - 1] + 1, x_pts[0], 1):\n curvex.append(i)\n curvey.append(int(curve(i)))\n return curvex, curvey","def test_curve_statistics():\n c = Curve(data=np.linspace(1, 20, 2))\n\n assert c.median()[0] == 10.5\n assert c.mean()[0] == 10.5\n assert c.min()[0] == 1\n assert c.max()[0] == 20\n assert c.describe()[0][0] == 2","def fit(self, x):\n pass","def get_plot_expression(self):\n pass","def getCurve(self, *args):\n return _libsbml.ReactionGlyph_getCurve(self, *args)","def fitPowerRegressionCurveComparisons(self, xVals0, yVals0):\r\n xValCount = 0\r\n yValCount = 0\r\n if len(xVals0) > 2:\r\n xValCount += int(len(xVals0) / 2) - 1\r\n yValCount += int(len(xVals0) / 2) - 1\r\n else:\r\n return \"regression error\", 0.0\r\n xVals = []\r\n yVals = []\r\n xValIndex = xValCount + 1\r\n yValIndex = yValCount + 1\r\n for i in range(xValIndex, len(xVals0)):\r\n xVals.append(xVals0[i])\r\n for i in range(yValIndex, len(xVals0)):\r\n yVals.append(yVals0[i])\r\n n = len(xVals)\r\n sumLnxLny = 0.0\r\n sumLnx = 0.0\r\n sumLny = 0.0\r\n sumLnx2 = 0.0\r\n sumLny2 = 0.0\r\n for i in range(0, n - 1):\r\n lnx = np.log(xVals[i])\r\n lny = np.log(yVals[i])\r\n sumLnxLny += (lnx * lny)\r\n for i in range(0, n - 1):\r\n lnx = np.log(xVals[i])\r\n sumLnx += lnx\r\n for i in range(0, n - 1):\r\n lny = np.log(yVals[i])\r\n sumLny += lny\r\n for i in range(0, n - 1):\r\n lny = np.log(yVals[i])\r\n sumLny2 += (lny * lny)\r\n for i in range(0, n - 1):\r\n lnx = np.log(xVals[i])\r\n sumLnx2 += (lnx * lnx)\r\n lnxBar = sumLnx / n\r\n lnyBar = sumLny / n\r\n sxx = sumLnx2 - (n * (lnxBar ** 2))\r\n syy = sumLny2 - (n * (lnyBar ** 2))\r\n sxy = sumLnxLny - (n * lnxBar * lnyBar)\r\n b = sxy / sxx\r\n a = pow(np.e, lnyBar - (b * lnxBar))\r\n r = sxy / (np.sqrt(sxx) * np.sqrt(syy))\r\n xx = np.array(xVals)\r\n yy = np.array(yVals)\r\n def power_law(xx, a, b):\r\n return a * np.power(xx, b)\r\n yHats = []\r\n for xPrime in xx:\r\n yHats.append(power_law(xPrime, a, b))\r\n eq = str(f' y = {str(round(a, 4))} (x) ^ {str(round(b, 4))} w/ correlation {str(round(100.0000 * r, 1))} %')\r\n if 'nan' in eq:\r\n eq_nan = 'could not calculate regression\\t\\t'\r\n self.eq = eq_nan\r\n return eq_nan\r\n else:\r\n self.ex_eq = eq\r\n return eq","def getAnimCurve(self, *args, **kwargs):\n ...","def fit_gp(self):\n raise NotImplementedError('Abstract Method')","def ice_plot(curves, **kwargs):\n \n n,m = curves.shape\n \n #grid of plots\n gridspec_kw = {'height_ratios':[3, 1], \n 'wspace':0.0, \n 'hspace':0.0}\n fig, (ax_curves, ax_feature) = plt.subplots(2,1, \n gridspec_kw=gridspec_kw, \n figsize=kwargs.get('figsize', (6,6)))\n \n # top graph - curves\n for curve in curves:\n ax_curves.plot(np.arange(m), curve)\n ax_curves.set_xticklabels([])\n ax_curves.set_xlim((0, m))\n ax_curves.set_ylabel(kwargs.get('ylabel', 'decision function $\\Delta$'))\n \n # bottom graph - feature values\n if 'feature_values' in kwargs:\n ax_feature.plot(np.arange(m), kwargs.get('feature_values'))\n ax_feature.set_xlim((0, m)) \n ax_feature.set_xlabel(kwargs.get('xlabel', '$X_S$ values'))\n \n return fig, (ax_curves, ax_feature)","def fit_and_plot_with_irf(self):\n try:\n self.ui.Result_textBrowser.clear()\n if not hasattr(self, \"file\"):\n self.ui.Result_textBrowser.append(\"You need to load a data file.\")\n if not hasattr(self, \"irf_file\") and self.ui.separate_irf_checkBox.isChecked():\n self.ui.Result_textBrowser.append(\"You need to load an IRF file.\")\n else:\n if self.opened_from_flim:\n x,y = self.hist_data_from_flim\n else:\n x,y = self.acquire_settings() #get data\n _, irf_counts = self.acquire_settings(mode=\"irf\") #get irf counts\n\n #make sure Irf and data have the same length\n if len(y) != len(irf_counts):\n y = y[0:min(len(y), len(irf_counts))]\n irf_counts = irf_counts[0:min(len(y), len(irf_counts))]\n x = x[0:min(len(y), len(irf_counts))]\n\n y_norm = y/np.max(y) #normalized y\n irf_norm = irf_counts/np.amax(irf_counts) #normalized irf\n \n t = x\n time_fit = t \n y = y_norm\n irf_counts = irf_norm\n \n TRPL_interp = np.interp(time_fit, t, y)\n\n fit_func = self.ui.FittingFunc_comboBox.currentText()\n self.ui.plot.plot(t, y, clear=self.ui.clear_plot_checkBox.isChecked(), pen=pg.mkPen(self.plot_color))\n if fit_func == \"Stretched Exponential\": #stretched exponential tab\n tc_bounds = (self.ui.str_tc_min_spinBox.value(), self.ui.str_tc_max_spinBox.value()) #(0, 10000)\n a_bounds = (self.ui.str_a_min_spinBox.value(), self.ui.str_a_max_spinBox.value())#(0.9, 1.1)\n beta_bounds = (self.ui.str_beta_min_spinBox.value(), self.ui.str_beta_max_spinBox.value())#(0,1)\n noise_bounds = (self.ui.str_noise_min_spinBox.value(), self.ui.str_noise_max_spinBox.value())#(0, 1e4)\n stretch_exp_bounds = [tc_bounds, beta_bounds, a_bounds, noise_bounds]\n stretch_exp_init_params = [self.ui.str_tc_init_spinBox.value(), self.ui.str_a_init_spinBox.value(), self.ui.str_beta_init_spinBox.value(), self.ui.str_noise_init_spinBox.value()]\n\n #tc, beta, a, avg_tau, PL_fit = stretch_exp_fit(TRPL_interp, t)\n # resolution = float(self.ui.Res_comboBox.currentText())\n if self.ui.FittingMethod_comboBox.currentText() == \"diff_ev\":\n bestfit_params, t_avg, bestfit_model, data_array, time_array, irf = fit_exp_stretch_diffev(t, self.resolution, TRPL_interp, irf_counts, stretch_exp_bounds)\n else: #if fmin_tnc fitting method selected\n bestfit_params, t_avg, bestfit_model, data_array, time_array, irf = fit_exp_stretch_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, stretch_exp_init_params, stretch_exp_bounds)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = bestfit_model # PL fit\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Stretched Exponential with IRF\"\n \"\\nFit Method: \"+ self.ui.FittingMethod_comboBox.currentText() +\n \"\\ntau_avg = %.5f ns\"\n \"\\nbeta = %.5f\"\n \"\\ntau_c = %.5f ns\"\n \"\\na = %.5f \\nnoise = %.5f counts\" %(t_avg, bestfit_params[1], bestfit_params[0], bestfit_params[2], bestfit_params[3]))\n #self.effective_lifetime = t_avg\n self.ui.average_lifetime_spinBox.setValue(t_avg)\n \n elif fit_func == \"Double Exponential\": #double exponential tab\n a1_bounds = (self.ui.de_a1_min_spinBox.value(), self.ui.de_a1_max_spinBox.value())\n tau1_bounds = (self.ui.de_tau1_min_spinBox.value(), self.ui.de_tau1_max_spinBox.value())\n a2_bounds = (self.ui.de_a2_min_spinBox.value(), self.ui.de_a2_max_spinBox.value())\n tau2_bounds = (self.ui.de_tau2_min_spinBox.value(), self.ui.de_tau2_max_spinBox.value())\n noise_bounds = (self.ui.de_noise_min_spinBox.value(), self.ui.de_noise_max_spinBox.value())\n double_exp_bounds = [a1_bounds, tau1_bounds, a2_bounds, tau2_bounds, noise_bounds]\n double_exp_init_params = [self.ui.de_a1_init_spinBox.value(), self.ui.de_tau1_init_spinBox.value(), self.ui.de_a2_init_spinBox.value(), \n self.ui.de_tau2_init_spinBox.value(), self.ui.de_noise_init_spinBox.value()]\n\n if self.ui.FittingMethod_comboBox.currentText() == \"diff_ev\":\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, self.resolution, TRPL_interp, irf_counts, double_exp_bounds, 2)\n #bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, resolution, TRPL_interp, irf_counts, double_exp_init_bounds, 2)\n else:\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, double_exp_init_params, double_exp_bounds, 2)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = bestfit_model # PL fit\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Double Exponential with IRF\"\n \"\\nFit Method: \"+ self.ui.FittingMethod_comboBox.currentText() +\n \"\\na1 = %.5f\"\n \"\\ntau1 = %.5f ns\"\n \"\\na2 = %.5f\"\n \"\\ntau2 = %.5f ns\"\n \"\\nnoise = %.5f counts\" %(bestfit_params[0], bestfit_params[1], bestfit_params[2], bestfit_params[3], bestfit_params[4]))\n #TODO - once tau_avg implemented, set average lifetime spinbox to tau_avg value\n if bestfit_params[3] > bestfit_params[1]:\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[3])\n elif bestfit_params[1] > bestfit_params[3]:\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[1])\n\n elif fit_func == \"Single Exponential\": #single exponential tab\n a_bounds = (self.ui.se_a_min_spinBox.value(), self.ui.se_a_max_spinBox.value())\n tau_bounds = (self.ui.se_tau_min_spinBox.value(), self.ui.se_tau_max_spinBox.value())\n noise_bounds = (self.ui.se_noise_min_spinBox.value(), self.ui.se_noise_max_spinBox.value())\n single_exp_bounds = [a_bounds, tau_bounds, noise_bounds]\n single_exp_init_params = [self.ui.se_a_init_spinBox.value(), self.ui.se_tau_init_spinBox.value(), self.ui.se_noise_init_spinBox.value()]\n\n if self.ui.FittingMethod_comboBox.currentText() == \"diff_ev\":\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, self.resolution, TRPL_interp, irf_counts, single_exp_bounds, 1)\n else:\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, single_exp_init_params, single_exp_bounds, 1)\n self.out = np.empty((len(t), 3))\n self.out[:,0] = t #time\n self.out[:,1] = TRPL_interp #Raw PL \n self.out[:,2] = bestfit_model # PL fit\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\n self.ui.Result_textBrowser.setText(\"Fit Results:\\n\\nFit Function: Single Exponential with IRF\"\n \"\\nFit Method: \"+ self.ui.FittingMethod_comboBox.currentText() +\n \"\\na = %.5f\"\n \"\\ntau = %.5f ns\"\n \"\\nnoise = %.5f counts\" %(bestfit_params[0], bestfit_params[1], bestfit_params[2]))\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[1]) #set spinbox to tau value\n\n #add fit params to data_list\n self.data_list.append(\"Data Channel: \" + str(self.ui.Data_channel_spinBox.value()) + \"\\n\" + self.ui.Result_textBrowser.toPlainText())\n self.fit_lifetime_called_w_irf = True\n self.fit_lifetime_called_wo_irf = False\n except Exception as e:\n self.ui.Result_textBrowser.append(format(e))","def plot(self):\n raise Exception(\"pure virtual function\")","def add_results_text(self, plotData, function_nick):\n\t\ttext = \"Fit results\"\n\t\tif len(plotData.plotdict[\"function_fit\"]) > 1: # only add the nickname if more than one fit\n\t\t\ttext += \" {}:\".format(function_nick)\n\n\t\t# expand paramter_names if necessary\n\t\tif len(plotData.plotdict[\"function_fit_parameter_names\"]) < plotData.plotdict[\"root_objects\"][function_nick].GetNpar():\n\t\t\tplotData.plotdict[\"function_fit_parameter_names\"] *= plotData.plotdict[\"root_objects\"][function_nick].GetNpar() / len(plotData.plotdict[\"function_fit_parameter_names\"])\n\t\t\tplotData.plotdict[\"function_fit_parameter_names_x\"] *= plotData.plotdict[\"root_objects\"][function_nick].GetNpar() / len(plotData.plotdict[\"function_fit_parameter_names\"])\n\t\t\tplotData.plotdict[\"function_fit_parameter_names_y\"] *= plotData.plotdict[\"root_objects\"][function_nick].GetNpar() / len(plotData.plotdict[\"function_fit_parameter_names\"])\n\t\tl = max([len(s) for s in plotData.plotdict[\"function_fit_parameter_names\"]])\n\n\t\tfor i_par in range(plotData.plotdict[\"root_objects\"][function_nick].GetNpar()):\n\t\t\t#TODO automatically adjust decimal precision\n\t\t\ttext = \"\\n${} = {:.3f} \\pm {:.3f}$\".format(plotData.plotdict[\"function_fit_parameter_names\"][i_par],\n\t\t\t plotData.plotdict[\"root_objects\"][function_nick].GetParameter(i_par),\n\t\t\t plotData.plotdict[\"root_objects\"][function_nick].GetParError(i_par))\n\t\t\tif plotData.plotdict[\"texts\"] == [None]:\n\t\t\t\tplotData.plotdict[\"texts\"] = [text]\n\t\t\t\tplotData.plotdict[\"texts_x\"] = [plotData.plotdict[\"function_fit_parameter_names_x\"][i_par]]\n\t\t\t\tplotData.plotdict[\"texts_y\"] = [plotData.plotdict[\"function_fit_parameter_names_y\"][i_par]]\n\t\t\telse:\n\t\t\t\tplotData.plotdict[\"texts\"] += [text]\n\t\t\t\tplotData.plotdict[\"texts_x\"] += [plotData.plotdict[\"function_fit_parameter_names_x\"][i_par]]\n\t\t\t\tplotData.plotdict[\"texts_y\"] += [plotData.plotdict[\"function_fit_parameter_names_y\"][i_par]]\n\t\tfor i, expr in enumerate(plotData.plotdict[\"functions_text\"]):\n\t\t\tfor i_par in range(plotData.plotdict[\"root_objects\"][function_nick].GetNpar()):\n\t\t\t\texpr = expr.replace('[' + str(i_par) + ']', str(plotData.plotdict[\"root_objects\"][function_nick].GetParameter(i_par)))\n\t\t\timport math\n\t\t\ttext = \"\\n{} = {:.3f}\".format(\n\t\t\t\tplotData.plotdict[\"functions_text_names\"][i],\n\t\t\t eval(expr),\n\t\t\t)\n\t\t\tif plotData.plotdict[\"texts\"] == [None]:\n\t\t\t\tplotData.plotdict[\"texts\"] = [text]\n\t\t\t\tplotData.plotdict[\"texts_x\"] = [plotData.plotdict[\"functions_text_names_x\"][i]]\n\t\t\t\tplotData.plotdict[\"texts_y\"] = [plotData.plotdict[\"functions_text_names_y\"][i]]\n\t\t\telse:\n\t\t\t\tplotData.plotdict[\"texts\"] += [text]\n\t\t\t\tplotData.plotdict[\"texts_x\"] += [plotData.plotdict[\"functions_text_names_x\"][i]]\n\t\t\t\tplotData.plotdict[\"texts_y\"] += [plotData.plotdict[\"functions_text_names_y\"][i]]\n\n\t\tif not plotData.plotdict[\"function_collect_result_no_chi2\"]:\n\t\t\ttext = \"\\n$\\chi^2 / \\mathit{{n.d.f}} = {:.2f} / {}$\".format(\n\t\t\t plotData.fit_results[function_nick].Chi2(),\n\t\t\t plotData.fit_results[function_nick].Ndf())\n\t\t\tif plotData.plotdict[\"texts\"] == [None]:\n\t\t\t\tplotData.plotdict[\"texts\"] = [text]\n\t\t\telse:\n\t\t\t\tplotData.plotdict[\"texts\"] += [text]\n\t\t\tplotData.plotdict[\"texts_x\"] += [plotData.plotdict[\"function_fit_parameter_chi2_x\"][0]]\n\t\t\tplotData.plotdict[\"texts_y\"] += [plotData.plotdict[\"function_fit_parameter_chi2_y\"][0]]","def recovery(self):\n\n def exponential(time, tau):\n\n time = list(map(lambda x: float(x), time))\n exponent = np.exp(-np.divide(time, tau))\n return (1 - exponent)\n \n \n initial_guess = [55]\n \n tau = []\n for i in range(self.n_cols):\n current = self.screened_data.iloc[:,i]\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\n tau.append(popt[0][0])\n\n print('Median: ', np.median(tau))\n print('Min: ', np.min(tau))\n print('Max: ', np.max(tau))\n return 0\n\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\n for i in range(len(popt)):\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\n plt.xlabel('Time (ms)')\n plt.ylabel('Normalized Current')\n plt.title('Recovery from Inactivation')\n plt.legend()\n plt.savefig('recovery_exponential_fit.png')\n return popt","def oncurve(self, P):\n\t\traise Exception(NotImplemented)","def fit_function(function,\n energy_fit,\n eqe_fit,\n p0=None,\n bounds=None,\n include_disorder=False,\n double=False\n ):\n\n if bounds is not None:\n best_vals, covar = curve_fit(function,\n energy_fit,\n eqe_fit,\n p0=p0,\n bounds=bounds\n )\n else:\n best_vals, covar = curve_fit(function,\n energy_fit,\n eqe_fit,\n p0=p0\n )\n if double:\n if include_disorder:\n y_fit = [function(\n x,\n best_vals[0],\n best_vals[1],\n best_vals[2],\n best_vals[3],\n best_vals[4],\n best_vals[5],\n best_vals[6]\n ) for x in energy_fit]\n else:\n y_fit = [function(\n x,\n best_vals[0],\n best_vals[1],\n best_vals[2],\n best_vals[3],\n best_vals[4],\n best_vals[5]\n ) for x in energy_fit]\n else:\n if include_disorder:\n y_fit = [function(\n x,\n best_vals[0],\n best_vals[1],\n best_vals[2],\n best_vals[3]\n ) for x in energy_fit]\n else:\n y_fit = [function(\n x,\n best_vals[0],\n best_vals[1],\n best_vals[2]\n ) for x in energy_fit]\n r_squared = R_squared(eqe_fit, y_fit)\n\n return best_vals, covar, y_fit, r_squared","def plotCaliCurve(constants, data, outName):\n x=np.linspace(min(data[:,0]),max(data[:,0]),1000)\n plt.figure()\n plt.rcParams.update({'font.size' : 16})\n plt.scatter(data[:,0],data[:,1])\n plt.plot(x,LangmuirCurve(x,constants[0],constants[1],constants[2],constants[3]))\n #plt.xlabel(\"MG Concentration (nM)\")\n #plt.ylabel(\"Relative SHS signal (Arb. Units)\")\n plt.savefig(outName + \"_cali_model_plot.png\")\n plt.show()","def printfunc(self):\n zero1=self.Newton(True)\n print \"Using initial porition %0.2f ,%0.2f\" %(self.x_init,self.y_0)\n print \"extremum calculated witn Newton-Rapson: %0.2f ,%0.2f.\"%(zero1[0],zero1[1])\n zero2=self.Newton(False)\n print \"extremum calculated witn Secant: %0.2f ,%0.2f.\" %(zero2[0],zero2[1])\n xlist=np.arange(self.x_0-10,self.x_0+10,0.01)\n ylist=np.arange(self.y_0-10,self.y_0+10,0.01)\n X,Y=np.meshgrid(xlist,ylist)\n Z=self.sfunc(X,Y)\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n \n ax.plot(xlist, ylist, self.sfunc(xlist,ylist), 'g-',label='function $e^{(-(x-%0.2f)^2-(y-%0.2f)^2)}$' %(self.x_0,self.y_0))\n ax.contour(X, Y, Z)# colors = 'k', linestyles = 'solid')\n ax.plot([zero1[0]], [zero1[0]], self.sfunc(zero1[0],zero1[1]),'bo',label='extrema using Newton-Rapson (%0.2f; %0.2f)'%(zero1[0],zero1[1]))\n ax.plot([zero2[0]], [zero2[0]], self.sfunc(zero2[0],zero2[1]),'ro',label='extrema using Seacent (%0.2f; %0.2f)'%(zero2[0],zero2[1]))\n ax.legend()\n plt.show()","def plot(self):\n\t\tself.plotOfTF().plot()","def fit_circle_func():\n pass","def fit(self):\n raise NotImplementedError # pragma: no cover"],"string":"[\n \"def plot_fitted_curve(self):\\n\\t\\tcxpX, cxpY = self.curveCXP.cxp_X, self.curveCXP.cxp_Y\\n\\t\\tfittedX, fittedY = self.fitted_X, self.fitted_Y\\n\\t\\tself.curveFig.plot(cxpX, cxpY, 'o', fittedX, fittedY)\\n\\t\\tpass\",\n \"def plot_fitting_coefficients(self):\\n from matplotlib import pyplot as plt\\n coeff = self.linear_fit[\\\"coeff\\\"]\\n order = self.linear_fit[\\\"order\\\"]\\n\\n data = {}\\n annotations = {}\\n for c, o in zip(coeff, order):\\n if len(o) == 0:\\n continue\\n n = len(o)\\n if n not in data.keys():\\n data[n] = [c]\\n annotations[n] = [WulffConstruction.order2string(o)]\\n else:\\n data[n].append(c)\\n annotations[n].append(WulffConstruction.order2string(o))\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 1, 1)\\n start = 0\\n keys = list(data.keys())\\n keys.sort()\\n for k in keys:\\n x = list(range(start, start+len(data[k])))\\n ax.bar(x, data[k], label=str(k))\\n start += len(data[k]) + 1\\n for i in range(len(data[k])):\\n ax.annotate(annotations[k][i], xy=(x[i], data[k][i]))\\n ax.set_ylabel(\\\"Fitting coefficient\\\")\\n ax.set_xticklabels([])\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend(frameon=False)\\n return fig\",\n \"def plotFittingResults(self):\\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\\n\\n #_listExpStdDev = None\\n #if self.getDataInput().getExperimentalDataStdDev():\\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\\n #if _listExpStdDev:\\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\\\"Experimental Data\\\")\\n # pylab.gca().set_yscale(\\\"log\\\", nonposy='clip')\\n #else: \\n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n\\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n pylab.semilogy(_listFitQ, _listFitValues, label=\\\"Fitting curve\\\")\\n pylab.xlabel('q')\\n pylab.ylabel('I(q)')\\n pylab.suptitle(\\\"RMax : %3.2f. Fit quality : %1.3f\\\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\\n pylab.legend()\\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \\\"gnomFittingResults.png\\\"))\\n pylab.clf()\",\n \"def display_fit(x,y,p,func,fig=None):\\n if fig is None:\\n fig = plots.tac_figure('x','y','fitting')\\n fig.plot(x,np.log(y),label='data')\\n \\n \\n fig.plot(x,np.log(func(p,x)),'--x',label=func.__name__ + '('+\\n ','.join(['%.1e'%k for k in p])+ ')')\\n \\n return fig\",\n \"def plot_power_fitting(x,y,bias=True):\\n\\n def funcc(x, a, b, c):\\n return a * x**b +c\\n\\n def func0(x,a,b):\\n return a * x**b\\n\\n if bias:\\n popt, pcov = curve_fit(funcc, x, y, p0=[1.0, -1.0, 0.0])\\n yf = [funcc(i, popt[0],popt[1],popt[2]) for i in x]\\n else:\\n popt, pcov = curve_fit(func0, x, y, p0=[1.0, -1.0])\\n yf = [func0(i, popt[0],popt[1]) for i in x]\\n\\n plt.plot(x,y,'o')\\n plt.plot(x,yf,'--')\\n\\n return popt,pcov\",\n \"def plot_power_fitting(x,y,bias=True):\\n \\n def funcc(x, a, b, c): \\n return a * x**b +c\\n \\n def func0(x,a,b):\\n return a * x**b\\n \\n if bias:\\n popt, pcov = curve_fit(funcc, x, y, p0=[1.0, -1.0, 0.0]) \\n yf = [funcc(i, popt[0],popt[1],popt[2]) for i in x]\\n else:\\n popt, pcov = curve_fit(func0, x, y, p0=[1.0, -1.0]) \\n yf = [func0(i, popt[0],popt[1]) for i in x]\\n \\n plt.plot(x,y,'o')\\n plt.plot(x,yf,'--')\\n \\n return popt,pcov\",\n \"def plot():\\n xvals = np.arange(-50, 250, step=0.1)\\n\\n fig = plt.figure()\\n plt.suptitle(\\\"Gaussian with smooth transition to power law\\\")\\n\\n A0vals = [10, 11]\\n avals = [5*10**-3, 10**-3, 5*10**-4]\\n ttvals = [10., 50., 100.]\\n cvals = [-0.1, -0.9, -5./3., -4.]\\n offset = [-30, 0.0, 30]\\n\\n paramvals = [A0vals, avals, ttvals,cvals, offset]\\n titles, labels = return_parameter_names()\\n\\n nplots = len(paramvals)\\n\\n for i in range(nplots):\\n plt.subplot(nplots, 1, i+1)\\n vals = paramvals[i]\\n for j in range(len(vals)):\\n pset = list(default())\\n pset[i] = vals[j]\\n yvals=[]\\n ypower=[]\\n ypeak=[]\\n for x in xvals:\\n yvals.append(fitfunc(x, pset))\\n ypeak.append(logpeak(x,pset))\\n if x > 0:\\n ypower.append(logpowerlaw(x,pset))\\n label = labels[i] + \\\"=\\\"+str(vals[j])\\n plt.plot(xvals, yvals, label = label)\\n\\n plt.title(titles[i])\\n plt.legend()\\n\\n fig.set_size_inches(15, 30)\\n plt.savefig(\\\"graphs/misc/lightcurve_models.pdf\\\")\\n plt.close()\",\n \"def fit_curve(fitting_function, x, y, parameters_guess=None, to_plot=False):\\n\\n if parameters_guess is not None:\\n parameters, p_covariance = curve_fit(fitting_function, x, y, parameters_guess)\\n else:\\n parameters, p_covariance = curve_fit(fitting_function, x, y)\\n x2 = np.linspace(0, 1, 10)\\n y_fit = fitting_function(x, *parameters)\\n r2 = r2_score(y, y_fit)\\n\\n if to_plot:\\n print(\\\"Fitting parameters:\\\", *parameters)\\n plt.scatter(x, y)\\n x2 = np.linspace(0, 1, 10)\\n y2 = fitting_function(x2, *parameters)\\n plt.plot(x2, y2, \\\"blue\\\", label=\\\"R^2= %0.5f\\\" % r2)\\n plt.title(\\\"Least-squares fit\\\")\\n plt.legend()\\n return r2, parameters\",\n \"def curve_number(self):\",\n \"def plot_curve_fit(\\n func: Callable,\\n result: FitData,\\n ax=None,\\n num_fit_points: int = 100,\\n labelsize: int = 14,\\n grid: bool = True,\\n fit_uncertainty: List[Tuple[float, float]] = None,\\n **kwargs,\\n):\\n if ax is None:\\n ax = get_non_gui_ax()\\n\\n if fit_uncertainty is None:\\n fit_uncertainty = []\\n elif isinstance(fit_uncertainty, tuple):\\n fit_uncertainty = [fit_uncertainty]\\n\\n # Default plot options\\n plot_opts = kwargs.copy()\\n if \\\"color\\\" not in plot_opts:\\n plot_opts[\\\"color\\\"] = \\\"blue\\\"\\n if \\\"linestyle\\\" not in plot_opts:\\n plot_opts[\\\"linestyle\\\"] = \\\"-\\\"\\n if \\\"linewidth\\\" not in plot_opts:\\n plot_opts[\\\"linewidth\\\"] = 2\\n\\n xmin, xmax = result.x_range\\n\\n # Plot fit data\\n xs = np.linspace(xmin, xmax, num_fit_points)\\n ys_fit_with_error = func(xs, **dict(zip(result.popt_keys, result.popt)))\\n\\n # Line\\n ax.plot(xs, unp.nominal_values(ys_fit_with_error), **plot_opts)\\n\\n # Confidence interval of N sigma values\\n stdev_arr = unp.std_devs(ys_fit_with_error)\\n if np.isfinite(stdev_arr).all():\\n for sigma, alpha in fit_uncertainty:\\n ax.fill_between(\\n xs,\\n y1=unp.nominal_values(ys_fit_with_error) - sigma * stdev_arr,\\n y2=unp.nominal_values(ys_fit_with_error) + sigma * stdev_arr,\\n alpha=alpha,\\n color=plot_opts[\\\"color\\\"],\\n )\\n\\n # Formatting\\n ax.tick_params(labelsize=labelsize)\\n ax.grid(grid)\\n return ax\",\n \"def fit_and_plot(self):\\n try:\\n if not hasattr(self, \\\"file\\\"):\\n self.ui.Result_textBrowser.setText(\\\"You need to load a data file.\\\")\\n else:\\n if self.opened_from_flim:\\n x, y = self.hist_data_from_flim\\n else:\\n x,y = self.acquire_settings() #get data\\n y_norm = y/np.max(y) #normalized y\\n\\n # find the max intensity in the array and start things from there\\n find_max_int = np.nonzero(y_norm == 1)\\n y = y[np.asscalar(find_max_int[0]):]\\n x = x[np.asscalar(find_max_int[0]):]\\n\\n t = x\\n time_fit = t\\n TRPL_interp = np.interp(time_fit, t, y)\\n \\n fit_func = self.ui.FittingFunc_comboBox.currentText()\\n self.ui.plot.plot(t, y, clear=self.ui.clear_plot_checkBox.isChecked(), pen=pg.mkPen(self.plot_color))\\n \\n if fit_func == \\\"Stretched Exponential\\\": #stretch exponential tab\\n tc, beta, a, avg_tau, PL_fit, noise = stretch_exp_fit(TRPL_interp, t)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = PL_fit # PL fit\\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Stretched Exponential\\\"\\n \\\"\\\\nFit Method: \\\" + \\\"diff_ev\\\" + #TODO : change when diff_ev and fmin_tnc implemented for non-irf\\n \\\"\\\\nAverage Lifetime = \\\" + str(avg_tau)+ \\\" ns\\\"\\n \\\"\\\\nCharacteristic Tau = \\\" + str(tc)+\\\" ns\\\"\\n \\\"\\\\nBeta = \\\"+str(beta)+\\n \\\"\\\\nNoise = \\\"+ str(noise))\\n self.ui.average_lifetime_spinBox.setValue(avg_tau)\\n \\n elif fit_func == \\\"Double Exponential\\\": #double exponential tab\\n tau1, a1, tau2, a2, avg_tau, PL_fit, noise = double_exp_fit(TRPL_interp, t)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = PL_fit # PL fit\\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Double Exponential\\\"\\n \\\"\\\\nFit Method: \\\" + \\\"diff_ev\\\" +\\n \\\"\\\\nAverage Lifetime = \\\" + str(avg_tau)+ \\\" ns\\\"\\n \\\"\\\\nTau 1 = \\\" + str(tau1)+\\\" ns\\\"\\n \\\"\\\\nA 1 = \\\" + str(a1)+\\n \\\"\\\\nTau 2 = \\\" + str(tau2)+\\\" ns\\\"\\n \\\"\\\\nA 2 = \\\" + str(a2)+\\n \\\"\\\\nNoise = \\\"+ str(noise))\\n #TODO - once tau_avg implemented, set average lifetime spinbox to tau_avg value\\n \\n elif fit_func == \\\"Single Exponential\\\": #single exponential tab\\n tau, a, PL_fit, noise = single_exp_fit(TRPL_interp, t)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = PL_fit # PL fit\\n self.ui.plot.plot(t, PL_fit, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Single Exponential\\\"\\n \\\"\\\\nFit Method: \\\" + \\\"diff_ev\\\" +\\n \\\"\\\\nLifetime = \\\" + str(tau)+ \\\" ns\\\"\\n \\\"\\\\nA = \\\" + str(a)+\\n \\\"\\\\nNoise = \\\"+ str(noise))\\n self.ui.average_lifetime_spinBox.setValue(tau)\\n \\n #add fit params to data_list\\n self.data_list.append(\\\"Data Channel: \\\" + str(self.ui.Data_channel_spinBox.value()) + \\\"\\\\n\\\" + self.ui.Result_textBrowser.toPlainText())\\n self.fit_lifetime_called_wo_irf = True\\n self.fit_lifetime_called_w_irf = False\\n\\n self.ui.plot.setLabel('left', 'Intensity', units='a.u.')\\n self.ui.plot.setLabel('bottom', 'Time (ns)')\\n return self.out\\n \\n except Exception as e:\\n self.ui.Result_textBrowser.append(format(e))\",\n \"def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \\n plt.title(\\\"Polynomial function regression\\\")\\n plt.grid()\\n plt.plot(x_poly, y_poly, c='black', label='true function')\\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\\n plt.legend()\\n plt.show()\",\n \"def check_fit(data, data_fit, time_points):\\n plt.figure()\\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\\\"Cases\\\", \\\"Deaths\\\", \\\"Hospitalized\\\", \\\"ICU\\\"])):\\n if data[ii] is not None:\\n plt.plot(time_points, data[ii], c=f\\\"C{jj}\\\", label=lab)\\n plt.plot(time_points, data_fit[ii], '--', c=f\\\"C{jj}\\\", label=f\\\"{lab} fit\\\")\\n plt.yscale(\\\"log\\\")\\n plt.legend()\\n # plt.savefig(\\\"Test_fitting\\\", format=\\\"png\\\")\\n plt.show()\",\n \"def _repr_(self):\\n return \\\"Jacobian of %s\\\"%self.__curve\",\n \"def pr_curve(model, X_train, y_train, X_test, y_test, train=True):\\n from sklearn.metrics import precision_recall_curve\\n if train==True:\\n ypredTrain = model.predict(X_train) \\n precisions, recalls, thresholds = precision_recall_curve(y_train, ypredTrain)\\n plt.plot(precisions, recalls, linewidth=3, color='r', linestyle='-')\\n plt.rc('xtick', labelsize=10) \\n plt.rc('ytick', labelsize=10) \\n plt.xlabel(\\\"Precision\\\", size=12)\\n plt.ylabel(\\\"Recall\\\", size=12)\\n plt.grid()\\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \\n plt.rcParams['axes.facecolor'] = '#F2F3F4' \\n plt.title(\\\"PR Curve: Precision/Recall Trade-off\\\\n\\\\n(Train)\\\\n\\\", size=14) \\n plt.show()\\n elif train==False:\\n ypredTest = model.predict(X_test)\\n precisions, recalls, thresholds = precision_recall_curve(y_test, ypredTest)\\n plt.plot(precisions, recalls, linewidth=3, color='b', linestyle='-')\\n plt.rc('xtick', labelsize=10) \\n plt.rc('ytick', labelsize=10) \\n plt.xlabel(\\\"Precision\\\", size=12)\\n plt.ylabel(\\\"Recall\\\", size=12)\\n plt.grid()\\n plt.rcParams['figure.facecolor'] = '#F2F3F4' \\n plt.rcParams['axes.facecolor'] = '#F2F3F4'\\n plt.title(\\\"PR Curve: Precision/Recall Trade-off\\\\n\\\\n(Test)\\\\n\\\", size=14)\\n plt.show()\",\n \"def evaluate(self, plot):\",\n \"def EPI():\\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\\n\\n area = [upper_left, center, upper_center, lower_right]\\n colors = [\\\"#1f77b4\\\", \\\"#ff7f0e\\\", \\\"#2ca02c\\\", \\\"#d62728\\\"]\\n name = [\\\"Upper left area\\\", \\\"Center area\\\", \\\"Up center area\\\", \\\"Lower right area\\\"]\\n x_new = np.linspace(4.22, 270.5, 10000)\\n for i, j, k in zip(area, colors, name):\\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\\n M0, T2 = popt[0], popt[1]\\n y_new = M_xy(x_new, M0, T2)\\n plt.scatter(TE, i)\\n plt.plot(x_new, y_new, \\\"--\\\", c=j, label=\\\"Fit: %s\\\" % k + f\\\", $T_2$={T2:.2f}\\\")\\n plt.legend(loc=\\\"best\\\")\\n plt.grid()\\n plt.ylabel(\\\"Mean Signal Intensity\\\")\\n plt.xlabel(\\\"TE [ms]\\\")\\n plt.show()\",\n \"def plot_calibration_curve(est, name, fig_index, data):\\n\\n X_train = data[0]\\n X_test = data[1]\\n y_train = data[2]\\n y_test = data[3]\\n\\n y = np.concatenate([y_train, y_test], axis=0)\\n\\n # Calibrated with isotonic calibration\\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\\n\\n # Calibrated with sigmoid calibration\\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\\n\\n # Logistic regression with no calibration as baseline\\n lr = LogisticRegression(C=1., solver='lbfgs')\\n\\n fig = plt.figure(1, figsize=(15, 10))\\n ax1 = plt.subplot2grid((4, 6), (0, 0), colspan=2, rowspan=2)\\n ax2 = plt.subplot2grid((4, 6), (0, 2), colspan=2, rowspan=2)\\n ax3 = plt.subplot2grid((4, 6), (0, 4), colspan=2, rowspan=2)\\n ax4 = plt.subplot2grid((4, 6), (2, 0), colspan=6, rowspan=2)\\n\\n ax1.plot([0, 1], [0, 1], \\\"k:\\\", label=\\\"Perfectly calibrated\\\")\\n for clf, name in [(lr, 'Logistic'),\\n (est, name),\\n (isotonic, name + ' + Isotonic'),\\n (sigmoid, name + ' + Sigmoid')]:\\n clf.fit(X_train, y_train)\\n y_pred = clf.predict(X_test)\\n if hasattr(clf, \\\"predict_proba\\\"):\\n prob_pos = clf.predict_proba(X_test)[:, 1]\\n y_proba = prob_pos.copy()\\n else: # use decision function\\n prob_pos = clf.decision_function(X_test)\\n y_proba = prob_pos.copy()\\n prob_pos = \\\\\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\\n\\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\\n print(\\\"%s:\\\" % name)\\n print(\\\"\\\\tBrier: %1.3f\\\" % (clf_score))\\n print(\\\"\\\\tPrecision: %1.3f\\\" % precision_score(y_test, y_pred))\\n print(\\\"\\\\tRecall: %1.3f\\\" % recall_score(y_test, y_pred))\\n print(\\\"\\\\tF1: %1.3f\\\" % f1_score(y_test, y_pred))\\n print(\\\"\\\\tAve. Precision Score: %1.3f\\\\n\\\" % \\\\\\n average_precision_score(y_test, y_proba))\\n\\n fraction_of_positives, mean_predicted_value = \\\\\\n calibration_curve(y_test, prob_pos, n_bins=10)\\n\\n ax1.plot(mean_predicted_value, fraction_of_positives, \\\"s-\\\",\\n label=\\\"%s (%1.3f)\\\" % (name, clf_score))\\n\\n fpr, tpr, thresholds = roc_curve(y_test, y_proba, drop_intermediate=False)\\n roc_auc = roc_auc_score(y_test, y_proba)\\n ax2.plot(fpr, tpr, ls='-', label=\\\"%s (%1.3f)\\\" % (name, roc_auc))\\n\\n precision, recall, _ = precision_recall_curve(y_test, y_proba)\\n ax3.plot(recall, precision)\\n\\n ax4.hist(prob_pos, range=(0, 1), bins=10,\\n label='%s' % name, histtype=\\\"step\\\", lw=2)\\n\\n ax1.set_xlabel(\\\"Score\\\", fontsize=14)\\n ax1.set_ylabel(\\\"Fraction of positives\\\", fontsize=14)\\n ax1.set_ylim([-0.05, 1.05])\\n ax1.legend(loc=\\\"lower right\\\")\\n ax1.set_title('Calibration plots (reliability curve)', fontsize=16)\\n\\n ax2.set_xlabel(\\\"False Positive Rate\\\", fontsize=14)\\n ax2.set_ylabel(\\\"True Positive Rate\\\", fontsize=14)\\n ax2.set_ylim([-0.05, 1.05])\\n ax2.legend(loc=\\\"lower right\\\")\\n ax2.set_title('ROC Curve', fontsize=16)\\n\\n ax3.set_xlabel(\\\"Recall\\\", fontsize=14)\\n ax3.set_ylabel(\\\"Precision\\\", fontsize=14)\\n ax3.set_ylim([-0.05, 1.05])\\n ax3.legend(loc=\\\"lower center\\\")\\n ax3.set_title('Precision-Recall Curve', fontsize=16)\\n\\n ax4.set_xlabel(\\\"Mean predicted value\\\", fontsize=14)\\n ax4.set_ylabel(\\\"Count\\\", fontsize=14)\\n ax4.legend(loc=\\\"upper center\\\")\\n ax4.set_title('Classification Result', fontsize=16)\\n\\n plt.tight_layout()\\n\\n plt.show()\\n\\n return\",\n \"def plot_calibration_curve(est, name, fig_index):\\n # Calibrated with isotonic calibration\\n isotonic = CalibratedClassifierCV(est, cv=2, method='isotonic')\\n\\n # Calibrated with sigmoid calibration\\n sigmoid = CalibratedClassifierCV(est, cv=2, method='sigmoid')\\n\\n # Logistic regression with no calibration as baseline\\n lr = LogisticRegression(C=1.)\\n\\n fig = plt.figure(fig_index, figsize=(10, 10))\\n ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)\\n ax2 = plt.subplot2grid((3, 1), (2, 0))\\n\\n ax1.plot([0, 1], [0, 1], \\\"k:\\\", label=\\\"Perfectly calibrated\\\")\\n for clf, name in [(lr, 'Logistic'),(est, name),(isotonic, name + ' + Isotonic'),(sigmoid, name + ' + Sigmoid')]:\\n #Para cada modelo, entrenamos y predecimos \\n clf.fit(X_train, y_train)\\n y_pred = clf.predict(X_test)\\n if hasattr(clf, \\\"predict_proba\\\"):\\n prob_pos = clf.predict_proba(X_test)[:, 1]\\n else: # use decision function\\n prob_pos = clf.decision_function(X_test)\\n prob_pos = \\\\\\n (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())\\n\\n clf_score = brier_score_loss(y_test, prob_pos, pos_label=y.max())\\n print(\\\"%s:\\\" % name)\\n print(\\\"\\\\tBrier: %1.3f\\\" % (clf_score))\\n print(\\\"\\\\tPrecision: %1.3f\\\" % precision_score(y_test, y_pred))\\n print(\\\"\\\\tRecall: %1.3f\\\" % recall_score(y_test, y_pred))\\n print(\\\"\\\\tF1: %1.3f\\\\n\\\" % f1_score(y_test, y_pred))\\n\\n fraction_of_positives, mean_predicted_value = \\\\\\n calibration_curve(y_test, prob_pos, n_bins=10)\\n\\n ax1.plot(mean_predicted_value, fraction_of_positives, \\\"s-\\\",\\n label=\\\"%s (%1.3f)\\\" % (name, clf_score))\\n\\n ax2.hist(prob_pos, range=(0, 1), bins=10, label=name,\\n histtype=\\\"step\\\", lw=2)\\n\\n ax1.set_ylabel(\\\"Fraction of positives\\\")\\n ax1.set_ylim([-0.05, 1.05])\\n ax1.legend(loc=\\\"lower right\\\")\\n ax1.set_title('Calibration plots (reliability curve)')\\n\\n ax2.set_xlabel(\\\"Mean predicted value\\\")\\n ax2.set_ylabel(\\\"Count\\\")\\n ax2.legend(loc=\\\"upper center\\\", ncol=2)\\n\\n plt.tight_layout()\",\n \"def curve(self):\\n return self.__curve\",\n \"def fit(self):\\n # Initialize parameter estimates\\n if self.estimator is not None:\\n param_estimates = self.estimator(self.xf, self.yf)\\n else: param_estimates = None\\n self.popt, self.pcov = curve_fit(self.model, self.xf, self.yf, \\n p0=param_estimates)\\n self.fit_history.append({\\\"popt\\\" : self.popt, \\\"pcov\\\" : self.pcov})\",\n \"def fit():\\n pass\",\n \"def curve(self, index):\\n if index >= len(self) or len(self) == 0:\\n print('ERROR Class Graph method Curve: cannot find Curve (index',\\n index, ', max possible', len(self), ')')\\n return\\n return self.data[index]\",\n \"def curves(self):\\n return self._curve_reg\",\n \"def plot(\\n self,\\n curve: Optional[Tuple[Tensor, Tensor, Tensor]] = None,\\n ax: Optional[_AX_TYPE] = None,\\n ) -> _PLOT_OUT_TYPE:\\n curve = curve or self.compute()\\n return plot_curve(\\n curve,\\n ax=ax,\\n label_names=(\\\"False positive rate\\\", \\\"True positive rate\\\"),\\n name=self.__class__.__name__,\\n )\",\n \"def _curve_fitting(self, phase, info):\\n start_date = info[self.START]\\n end_date = info[self.END]\\n population = info[self.N]\\n trend = Trend(\\n self.jhu_data, population, self.country, province=self.province,\\n start_date=start_date, end_date=end_date\\n )\\n trend.analyse()\\n df = trend.result()\\n if trend.rmsle() > self.max_rmsle:\\n df[f\\\"{self.S}{self.P}\\\"] = None\\n # Get min value for vline\\n r_value = int(df[self.R].min())\\n # Rename the columns\\n phase = self.INITIAL if phase == \\\"0th\\\" else phase\\n df = df.rename({f\\\"{self.S}{self.P}\\\": f\\\"{phase}{self.P}\\\"}, axis=1)\\n df = df.rename({f\\\"{self.S}{self.A}\\\": f\\\"{phase}{self.A}\\\"}, axis=1)\\n df = df.rename({f\\\"{self.R}\\\": f\\\"{phase}_{self.R}\\\"}, axis=1)\\n return (df, r_value)\",\n \"def FitPlot(self, xFit=None, yFit=None, fitFunc='exp1',\\n fitPars=None, fixedPars=None, fitPlot=None, plotInstance=None,\\n color=None):\\n if xFit is None or fitPars is None:\\n return\\n func = self.fitfuncmap[fitFunc]\\n if color is None:\\n fcolor = func[3]\\n else:\\n fcolor = color\\n if yFit is None:\\n yFit = numpy.array(xFit.shape)\\n# print 'xfit shape: ', xFit.shape\\n yFit = func[0](fitPars, xFit, C=fixedPars)\\n # for k in range(0, len(fitPars)):\\n # yFit[k] = func[0](fitPars[k], xFit[k], C=fixedPars)\\n if plotInstance is None or fitPlot is None:\\n return (yFit)\\n for k in range(0, len(fitPars)):\\n plotInstance.PlotLine(fitPlot, xFit[k], yFit[k], color=fcolor)\\n return (yFit)\",\n \"def curve_fit():\\n x_west, z_west, x_east, z_east = roof_measurements()\\n \\n # find best curve fit for west roof section\\n param_west, param_cov_west = optimize.curve_fit(test_func, x_west, z_west)\\n print(param_west)\\n \\n # z = 7.29944696 + (1.27415518*x) + (-0.0680139854*x**2) + (0.00152035861*x**3)\\n \\n z_west_fitted = test_func(x_west,*param_west)\\n \\n # mirror curve for east roof section\\n z_east_fitted = np.flip(z_west_fitted,axis=0)\\n \\n # create array for both west and east roof sections\\n x_whole_roof = np.concatenate((x_west, x_east), axis=0)\\n z_whole_roof = np.concatenate((z_west_fitted, z_east_fitted), axis=0)\\n\\n # plot roof\\n plt.plot(x_whole_roof, z_whole_roof, '-', color ='blue', label=\\\"roof curve\\\") \\n plt.axis('equal') # make axes square\\n plt.show() \\n\\n return param_west\",\n \"def fitting(x_value, target_value, model_function, fitting_method, type_of_fit):\\n if len(target_value) != len(x_value):\\n raise ValueError(\\\"Value length not match\\\")\\n\\n fig = plt.figure()\\n\\n parameters, _ = curve_fit(\\n model_function, x_value, target_value, method=fitting_method)\\n\\n xspace = np.linspace(x_value[0], x_value[len(x_value) - 1], 100)\\n if len(parameters) == 1:\\n fit_A = parameters[0]\\n fit_curve = model_function(xspace, fit_A)\\n elif len(parameters) == 2:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_curve = model_function(xspace, fit_A, fit_B)\\n elif len(parameters) == 3:\\n fit_A = parameters[0]\\n fit_B = parameters[1]\\n fit_C = parameters[2]\\n fit_curve = model_function(xspace, fit_A, fit_B, fit_C)\\n else:\\n raise ValueError(\\\"Function do not support that Model\\\")\\n\\n # making plot\\n plt.plot(x_value, target_value, 'o', label='cpu')\\n plt.plot(xspace, fit_curve, '-', label='fit')\\n plt.xlabel(\\\"cores_per_node\\\")\\n plt.ylabel(\\\"time/s\\\")\\n plt.title(type_of_fit + \\\"_Fitting Plot\\\")\\n plt.legend()\\n plt.savefig(type_of_fit + \\\"_fit.jpg\\\")\\n plt.close()\\n\\n return parameters\",\n \"def makeFit(self):\\n if not self.fitModel.params:\\n return\\n cs = self.spectrum\\n self.worker.make_model_curve(cs, allData=csi.allLoadedItems)\\n\\n dfparams = cs.fitParams\\n lcfRes = dfparams['lcf_result']\\n self.fitR.setText('R={0:.5g}'.format(lcfRes['R']))\\n self.updateFitResults()\\n self.fitReady.emit()\",\n \"def graph_sas_curve(filename, x, y, title_text, x_lab, y_lab,\\n x_min, x_max, y_min, y_max, **kwargs):\\n\\n fit_coeffs = kwargs.get('fitcoeffs', None)\\n outputs = kwargs.get('outputs', None)\\n rq_range = kwargs.get('rqrange', None)\\n mask = kwargs.get('mask', None)\\n\\n # Plot the input x, y values and if provided a fit line\\n # output is used to display values calculated from fit (Rg, Rxs?, R?*q over\\n # fit values) on the plot\\n\\n plt.figure(figsize=(8, 6), dpi=300)\\n\\n ax = plt.subplot(111, xlabel=x_lab, ylabel=y_lab, title=title_text,\\n xlim=(x_min, x_max), ylim=(y_min, y_max))\\n\\n plt.scatter(x, y, s=5)\\n\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label]):\\n item.set_fontsize(15)\\n\\n ax.tick_params(axis='both', which='major', labelsize=12)\\n\\n # Plot linear fit and highlight points used in its construction\\n if fit_coeffs is not None:\\n\\n # Plot the fit line along the whole x range shown in the plot\\n fitLine = np.poly1d(fit_coeffs[0:2])\\n x_points = np.linspace(x_min, x_max, 300)\\n plt.plot(x_points, fitLine(x_points))\\n\\n # Highlight points used in the fit\\n if mask is None:\\n plt.scatter(x, y, s=30)\\n else:\\n plt.scatter(x[mask], y[mask], s=30)\\n\\n plt.annotate(outputs + '\\\\n' + rq_range, xy=(0.45, 0.9),\\n xycoords='axes fraction')\\n \\n \\n d = date.today()\\n plt.annotate(d.strftime('%d %B %Y'), xy=(0.01, 0.02),\\n xycoords='axes fraction')\\n\\n plt.savefig(filename)\",\n \"def plot(self, fitted=True, fitted_pltargs={}, ax=None, **pltargs):\\n if ax is None:\\n ax = plt.gca()\\n\\n ax.plot(self.I, self.f, **pltargs)\\n if fitted:\\n if 'label' in pltargs.keys():\\n # `label` doesn't apply to fitted line, even if it isn't\\n # overridden by `fitted_pltargs`, so we must remove it.\\n pltargs.pop('label')\\n pltargs.update(fitted_pltargs) # Inherit/override `pltargs`.\\n\\n ax.plot(*self._get_fitted_curve(), **pltargs)\",\n \"def plot_precision_recall_curve(estimator, X, y, *, sample_weight=..., response_method=..., name=..., ax=..., pos_label=..., **kwargs):\\n ...\",\n \"def fit_line_Vo(x, y, n):\\n x1=x[0:n]\\n y1=y[0:n]\\n X = sm.add_constant(x1)\\n model = sm.OLS(y1, X, missing='drop') # ignores entires where x or y is NaN\\n fit = model.fit()\\n m=fit.params[1] \\n b=fit.params[0] \\n# stderr=fit.bse # could also return stderr in each via fit.bse\\n \\n N = 100 # could be just 2 if you are only drawing a straight line...\\n points = np.linspace(x.min(), x.max(), N)\\n \\n \\n fig=plt.figure(1) #PLOTING TOGETHER\\n \\n ax = fig.add_subplot(111)\\n ax.plot(x, y)\\n ax.plot(points, m*points + b)\\n \\n plt.legend(['data','fitt Vo'],fontsize=16)\\n \\n ax.set_yscale('linear',fontsize=16)\\n ax.tick_params(axis='x', labelsize=14)\\n ax.tick_params(axis='y', labelsize=14)\\n plt.ylabel('Abs',fontsize=16)\\n plt.xlabel('Time(sec)',fontsize=16)\\n ax.grid()\\n plt.grid()\\n plt.show()\\n \\n print(\\\"The Vo fitted model is: {0:2f}*x+{1:2f} \\\".format(m, b))\\n return m,b\",\n \"def Curve(self, *args):\\n return _Adaptor3d.Adaptor3d_HCurve_Curve(self, *args)\",\n \"def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\\n\\n # useful display and computational data\\n y_fitted = poly_fit(x_data)\\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\\n x_fitted_display = np.linspace(min_x_display, max_x_display)\\n y_fitted_display = poly_fit(x_fitted_display)\\n\\n # goodness of fit indicators\\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\\n R2 = 1.0 - SSE/SST # R squared\\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 2, 1)\\n\\n # plot of the fitted polynomial itself\\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\\n ax.scatter(x_data, y_data, color='C7')\\n ax.set(title=\\\"Fitted polynomial (deg{}) for \\\\'{}\\\\'\\\".format(poly_fit.order, fit_name), xlabel=\\\"x\\\", ylabel=\\\"y\\\")\\n\\n # histogram of residuals\\n ax2 = fig.add_subplot(1, 2, 2)\\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\\n ax2.set(title=\\\"Histogram of residuals\\\", xlabel=\\\"Residual value $y_k - \\\\\\\\widehat{y_k}$\\\", ylabel=\\\"Count\\\")\\n\\n # display of fit indicators\\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\\n\\n fig.tight_layout()\\n fig.subplots_adjust(bottom=0.2)\\n\\n figurefiles.save_in_perfs_fits_folder(fig, \\\"Polyfit_{}_order_{}.pdf\\\".format(fit_name, poly_fit.order))\",\n \"def fit(self):\\n raise NotImplementedError('')\",\n \"def get_expression_for_cliques(path, save_fig_path=\\\"extracted_data/Cliques/curve_fit.png\\\"):\\n with open(path, 'r') as f:\\n x = []\\n grp = []\\n rand = []\\n stat = []\\n for l in f:\\n if \\\"Clique size\\\" in l:\\n ind = l.split(',')\\n for k in ind[1:]:\\n x.append(float(k))\\n print(ind[0], end=\\\":\\\\t\\\")\\n print(x)\\n if \\\"GROUP_MOBILITY\\\" in l:\\n ind = l.split(',')\\n for k in ind[1:]:\\n grp.append(float(k))\\n print(ind[0], end=\\\":\\\\t\\\")\\n print(grp)\\n if \\\"RANDOM\\\" in l:\\n ind = l.split(',')\\n for k in ind[1:]:\\n rand.append(float(k))\\n print(ind[0], end=\\\":\\\\t\\\")\\n print(rand)\\n if \\\"Average Stationary\\\" in l:\\n ind = l.split(',')\\n for k in ind[1:]:\\n stat.append(float(k))\\n print(ind[0], end=\\\":\\\\t\\\")\\n print(stat)\\n round_off = 8\\n z_grp = np.polyfit(x, grp, 8).round(decimals=round_off)\\n print(\\\"Group\\\", end=\\\"\\\\n\\\\t\\\")\\n print(z_grp)\\n f_grp = np.poly1d(z_grp)\\n\\n z_rand = np.polyfit(x, rand, 8).round(decimals=round_off)\\n print(\\\"Random\\\", end=\\\"\\\\n\\\\t\\\")\\n print(z_rand)\\n f_rand = np.poly1d(z_rand)\\n\\n z_stat = np.polyfit(x, stat, 8).round(decimals=round_off)\\n print(\\\"Stationary\\\", end=\\\"\\\\n\\\\t\\\")\\n print(z_stat)\\n f_stat = np.poly1d(z_stat)\\n\\n x_new = np.linspace(2, 14, 50)\\n\\n y_new_grp = f_grp(x_new)\\n y_new_rand = f_rand(x_new)\\n y_new_stat = f_stat(x_new)\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.plot(x, grp, 'o', x_new, y_new_grp)\\n ax.plot(x, rand, '+', x_new, y_new_rand)\\n ax.plot(x, stat, '*', x_new, y_new_stat)\\n ax.set_xlabel('Clique size')\\n ax.set_ylabel('Average no. of cliques')\\n ax.legend((\\\"Group\\\", \\\"Group curve fit\\\", \\\"Random\\\", \\\"Random curve fit\\\", \\\"Stationary\\\", \\\"Stationary curve fit\\\"))\\n fig.savefig(save_fig_path)\\n plt.show()\",\n \"def show_fit(self):\\n self.fft_fit_plotter.plot(self.ax)\\n plt.draw()\",\n \"def plot(self):\\n pass\",\n \"def getCurve(self, *args):\\n return _libsbml.GeneralGlyph_getCurve(self, *args)\",\n \"def fitgeneral(xdata, ydata, fitfunc, fitparams, domain=None, showfit=False, showstartfit=False, showdata=True,\\n label=\\\"\\\", mark_data='bo', mark_fit='r-'):\\n\\n # sort data\\n order = np.argsort(xdata)\\n xdata = xdata[order]\\n ydata = ydata[order]\\n\\n if domain is not None:\\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\\n else:\\n fitdatax=xdata\\n fitdatay=ydata\\n# print 'minimum', np.min(fitdatay)\\n# ymin=np.min(fitdatay)\\n errfunc = lambda p, x, y: (fitfunc(p,x) - y) #there shouldn't be **2 # Distance to the target function\\n startparams=fitparams # Initial guess for the parameters\\n bestfitparams, success = optimize.leastsq(errfunc, startparams[:], args=(fitdatax,fitdatay))\\n if showfit:\\n if showdata:\\n plt.plot(fitdatax,fitdatay,mark_data,label=label+\\\" data\\\")\\n if showstartfit:\\n plt.plot(fitdatax,fitfunc(startparams,fitdatax),label=label+\\\" startfit\\\")\\n plt.plot(fitdatax,fitfunc(bestfitparams,fitdatax),mark_fit,label=label+\\\" fit\\\")\\n if label!='': plt.legend()\\n err=math.fsum(errfunc(bestfitparams,fitdatax,fitdatay))\\n #print 'the best fit has an RMS of {0}'.format(err)\\n# plt.t\\n# plt.figtext() \\n return bestfitparams\",\n \"def print_fit(funct, fit, cov=False):\\n params = funct.__code__.co_varnames\\n idx = 1\\n if params[0] == 'self':\\n idx = 2\\n diag_cov = _np.sqrt(_np.diag(abs(cov)))\\n params = params[idx:len(fit)+1]\\n print('%s fit parameters' % funct.__name__)\\n if cov is not False:\\n for i, param in enumerate(params):\\n print('%s: %.02e, %.02e' %(param, fit[i], diag_cov[i]))\\n else:\\n for i, param in enumerate(params):\\n print('%s: %.02e' %(param, fit[i]))\",\n \"def __init__(self, parent=None, pltw=None, cpos=None, model=None):\\n super (fitCurveDlg, self).__init__(parent)\\n\\n self.parent = parent\\n self.cpos = cpos\\n self.model = model\\n self.pltw = pltw\\n self.blkno = self.pltw.curvelist[cpos].yvinfo.blkpos\\n self.xpos = self.pltw.curvelist[cpos].xvinfo.vidx\\n self.ypos = self.pltw.curvelist[cpos].yvinfo.vidx\\n self.data = np.vstack( (self.pltw.blklst[self.blkno][self.xpos],\\n self.pltw.blklst[self.blkno][self.ypos],\\n self.pltw.blklst[self.blkno][self.ypos],\\n np.zeros(len(self.pltw.blklst[self.blkno][self.xpos]))) )\\n\\n self.diffshift = getSpan(self.data[1]) * 0.2\\n if self.data[1].min() + self.diffshift < 0.0:\\n self.diffshift *= -1.0\\n\\n self.initParms()\\n\\n # Create the layout\\n self.createLayout()\\n # Connect buttons to callback functions\\n self.exeBtn.clicked.connect(self.compute)\\n self.okBtn.clicked.connect(self.validate)\\n self.cancelBtn.clicked.connect(self.reject)\\n self.setWindowTitle('Curve Fitting tool')\\n\\n self.updateParms()\\n self.compute()\\n QTimer.singleShot(5000, self.istest)\",\n \"def prob4():\\n # Load the data.\\n data = np.loadtxt(\\\"../heating.txt\\\")\\n\\n # Define the function to optimize.\\n def f(x, gamma, c, K):\\n return 290.0 + 59.43/gamma + K*np.exp(-gamma*x/c)\\n\\n # Use curve_fit and the data to get the parameters.\\n popt, pcov = opt.curve_fit(f, data[:,0], data[:,1])\\n curve = f(data[:,0], popt[0], popt[1], popt[2])\\n\\n # Plot the data and the curve.\\n plt.plot(data[:,0], data[:,1], '.k', label='Data')\\n plt.plot(data[:,0], curve, 'b', label='Curve', linewidth=2)\\n plt.xlim(-50, 400)\\n plt.ylim(260, 380)\\n plt.legend(loc=\\\"lower right\\\")\\n plt.show()\\n \\n # Return the parameter values.\\n return popt\",\n \"def print_curve(xlist, ylist, precision=3):\\r\\n print (\\\"----------------------\\\")\\r\\n print (\\\"Maturities\\\\tCurve\\\")\\r\\n print (\\\"----------------------\\\")\\r\\n for x,y in zip(xlist, ylist):\\r\\n print (x,\\\"\\\\t\\\\t\\\", round(y, precision))\\r\\n print (\\\"----------------------\\\")\",\n \"def plot_inv_RV_lit(outpath, fit_slopes, fit_intercepts, fit_stds):\\n waves = np.arange(0.8, 4.01, 0.001)\\n fig, ax = plt.subplots(figsize=(10, 9))\\n\\n for i, RV in enumerate([2.5, 3.1, 5.5]):\\n # plot the extinction curve from this work\\n offset = 0.1 * i\\n slopes = interpolate.splev(waves, fit_slopes)\\n alav = fit_intercepts(waves) + slopes * (1 / RV - 1 / 3.1)\\n (line,) = ax.plot(waves, alav + offset, lw=1.5, label=r\\\"$R(V) = $\\\" + str(RV))\\n stddev = interpolate.splev(waves, fit_stds)\\n color = line.get_color()\\n ax.fill_between(\\n waves,\\n alav + offset - stddev,\\n alav + offset + stddev,\\n color=color,\\n alpha=0.2,\\n edgecolor=None,\\n )\\n\\n # plot the literature curves\\n styles = [\\\"--\\\", \\\":\\\"]\\n for i, cmodel in enumerate([CCM89, F19]):\\n ext_model = cmodel(Rv=RV)\\n (indxs,) = np.where(\\n np.logical_and(\\n 1 / waves >= ext_model.x_range[0], 1 / waves <= ext_model.x_range[1]\\n )\\n )\\n yvals = ext_model(waves[indxs] * u.micron)\\n ax.plot(\\n waves[indxs],\\n yvals + offset,\\n lw=1.5,\\n color=color,\\n ls=styles[i],\\n alpha=0.8,\\n )\\n\\n # add text\\n ax.text(3.45, 0.03, r\\\"$R(V) = 2.5$\\\", fontsize=0.8 * fs, color=\\\"tab:blue\\\")\\n ax.text(3.45, 0.15, r\\\"$R(V) = 3.1$\\\", fontsize=0.8 * fs, color=\\\"tab:orange\\\")\\n ax.text(3.45, 0.305, r\\\"$R(V) = 5.5$\\\", fontsize=0.8 * fs, color=\\\"tab:green\\\")\\n\\n # finalize and save the plot\\n ax.set_xlabel(r\\\"$\\\\lambda\\\\ [\\\\mu m$]\\\", fontsize=1.2 * fs)\\n ax.set_ylabel(r\\\"$A(\\\\lambda)/A(V)$ + offset\\\", fontsize=1.2 * fs)\\n ax.set_xlim(0.75, 4.05)\\n ax.set_ylim(-0.03, 0.98)\\n handles = [\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5),\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5, ls=\\\"--\\\"),\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5, ls=\\\":\\\"),\\n ]\\n labels = [\\n \\\"this work\\\",\\n \\\"Cardelli et al. (1989)\\\",\\n \\\"Fitzpatrick et al. (2019)\\\",\\n ]\\n plt.legend(handles, labels, fontsize=fs)\\n plt.savefig(outpath + \\\"inv_RV_lit.pdf\\\", bbox_inches=\\\"tight\\\")\\n\\n # also save the plot in log scale\\n plt.ylim(0.01, 1)\\n plt.yscale(\\\"log\\\")\\n plt.tight_layout()\\n plt.savefig(outpath + \\\"inv_RV_lit_log.pdf\\\")\",\n \"def drawFitTF(s,ivar,title=None,logscale=False,modbins=True,lumifrac=1.0):\\n import SuCanvas\\n s.canvas = canvas = SuCanvas.SuCanvas()\\n canvas.buildRatio()\\n canvas._xaxisName = s.vnames[0] + ' [GeV]'\\n # main plot area: draw {data,model,fixed,qcd}\\n canvas.cd_plotPad()\\n fit = s.fit\\n stack,fixed,free = None,None,None\\n assert s.status==0,'Fit failed or not performed yet'\\n if s.status==0:\\n # fixed (EWK) - must be scaled\\n fixed = s.hfixed if modbins==True else s.fixed.Clone()\\n fixed.SetLineColor(s.LineColor_ewk)\\n fixed.SetFillColor(s.FillColor_ewk)\\n fixed.SetFillStyle(s.FillStyle_ewk)\\n fixed.Scale(s.Wscales[0])\\n #fixed.Draw('A SAME H')\\n # free (qcd) - must be scaled\\n ift = 0\\n free = s.hfree if modbins==True else s.free[0].Clone()\\n free.SetLineColor(s.LineColor_qcd)\\n free.SetFillColor(s.FillColor_qcd)\\n free.SetFillStyle(s.FillStyle_qcd)\\n free.Scale(s.scales[0])\\n #free.Draw('A SAME H')\\n # make a stack\\n s.stack = stack = ROOT.THStack('qcd_stack','Final QCD stack')\\n stack.Add(fixed)\\n stack.Add(free)\\n stack.Draw('HIST')\\n # model - already scaled to expectation\\n if s.PlotModel:\\n model = s.hmodel\\n model.SetLineColor(s.LineColor_model)\\n model.SetFillStyle(0)\\n model.Draw('A SAME')\\n # data\\n s.hdata = data = s.data.Clone()\\n #data.SetMarkerStyle(8)\\n data.SetMarkerStyle(20)\\n data.SetMarkerSize(0.8)\\n data.SetFillStyle(0)\\n data.Draw('X0 A SAME')\\n\\n # y axis\\n canvas.cd_plotPad()\\n stack.SetMaximum(stack.GetMaximum()*s.StackMaximum)\\n\\n # prettify\\n obj = stack\\n if obj:\\n obj.GetXaxis().SetRange(s.plotmin,s.plotmax)\\n xname = s.w.var(s.vnames[ivar]).GetName()\\n obj.GetXaxis().SetTitle( xname ) # over-ridden in ratio plot\\n bin_width = data.GetXaxis().GetBinWidth(1)\\n obj.GetYaxis().SetTitle( \\\"Entries / %.2f GeV\\\" % bin_width )\\n\\n # indicate fit range\\n if True:\\n canvas.update()\\n fmax = s.w.var(s.vnames[ivar]).getMax()\\n s.gr = gr = ROOT.TGraph(2)\\n gr.SetPoint(0,fmax,canvas._plotPad.GetFrame().GetY1())\\n gr.SetPoint(1,fmax,canvas._plotPad.GetFrame().GetY2())\\n gr.SetLineColor(ROOT.kRed)\\n gr.SetLineStyle(2)\\n gr.Draw('L')\\n \\n s.leg = leg = ROOT.TLegend()\\n leg.AddEntry( data ,\\\"data 2011 (#sqrt{s} = 7 TeV) \\\",\\\"pe\\\")\\n if s.PlotModel:\\n leg.AddEntry( model , \\\"fit range\\\" , \\\"l\\\" )\\n leg.AddEntry( free , 'QCD (template)' , \\\"f\\\" )\\n leg.AddEntry( fixed , 'EWK + tops' , \\\"f\\\" )\\n canvas.ConfigureLegend(leg)\\n leg.Draw(\\\"9\\\");\\n canvas.update()\\n\\n s.fractext = fractext = ROOT.TPaveText()\\n for ift,frac in enumerate(s.fractions):\\n if title:\\n if type(title)==type([]):\\n [fractext.AddText(zz) for zz in title]\\n else:\\n fractext.AddText(title)\\n fractext.AddText('')\\n if s.fractions[ift]!=0 and s.scales[ift]!=0:\\n fractext.AddText( '%s Frac. = %.2f #pm %.2f%%'%(s.free[ift].getLegendName(),s.fractions[ift],s.fractionsE[ift]/s.fractions[ift]*100.0 if abs(s.fractions[ift])>1e-6 else 0) )\\n fractext.AddText( '%s SF = %.2f #pm %.2f%%'%(s.free[ift].getLegendName(),s.scales[ift],s.scalesE[ift]/s.scales[ift]*100.0 if abs(s.scales[ift])>1e-6 else 0) )\\n if s.Wfractions[ift]!=0 and s.Wscales[ift]!=0 and SUFIT_PLOT_EWK_FRAC:\\n fractext.AddText( '%s SF = %.2f #pm %.2f%%'%('EWK',s.Wscales[ift]/lumifrac,s.WscalesE[ift]/s.Wscales[ift]*100.0 if s.Wscales[ift]!=0 else 0) )\\n if s.ndf[ift]!=0:\\n fractext.AddText( '#chi^{2}=%.1f #chi^{2}/NDF=%.1f'%(s.chi2[ift],s.chi2[ift]/s.ndf[ift]) )\\n canvas.ConfigureText(fractext,text_y2 = leg.GetY1NDC()-0.03)\\n fractext.Draw(\\\"9\\\");\\n canvas.update()\\n \\n if logscale:\\n print 'Applying log scale'\\n ROOT.gPad.SetLogy(ROOT.kTRUE)\\n\\n # ratio\\n canvas.cd_ratioPad()\\n if s.status==0:\\n hmodel = None\\n if False: # this hmodel only includes bins that were actually part of the TFractionFitter fit\\n hmodel = s.hmodel.Clone()\\n else: # this includes all bins in the original range of the histograms\\n hmodel = fixed.Clone()\\n hmodel.Add( free )\\n #scalefactor = 1.0*data.Integral(s.fitmin,s.fitmax)/model.Integral(s.fitmin,s.fitmax)\\n #hmodel.Scale( scalefactor ); # scale model to actual data integral (not needed!)\\n s.hratio = data.Clone('hratio')\\n s.hratio.Divide(hmodel)\\n canvas.drawRatio(s.hratio,yrange=s.RatioRange)\\n canvas.ConfigureAxis(stack, s.hratio)\\n s.hratio.GetXaxis().SetRange(s.plotmin,s.plotmax)\\n TMAP = {}\\n TMAP['met'] = 'E_{T}^{Miss} [GeV]'\\n TMAP['d3_eta_lpt_met'] = TMAP['met']\\n TMAP['d3_abseta_lpt_met'] = TMAP['met']\\n TMAP['wmt'] = 'm_{T}^{W} [GeV]'\\n TMAP['w_mt'] = TMAP['wmt']\\n TMAP['d3_eta_lpt_wmt'] = TMAP['wmt']\\n TMAP['d3_abseta_lpt_wmt'] = TMAP['wmt']\\n vname = s.w.var(s.vnames[ivar]).GetName()\\n xtitle = TMAP[vname] if vname in TMAP else vname\\n if vname[:14] in TMAP:\\n xtitle = TMAP[vname[:14]]\\n if vname[:17] in TMAP:\\n xtitle = TMAP[vname[:17]]\\n s.hratio.GetXaxis().SetTitle( xtitle )\\n\\n # finalize\\n canvas.update()\\n if False: # debugging:\\n canvas.SaveAs('SYS.png')\\n return canvas,None\",\n \"def plot_tuning_curves(self, baseline_rate=10.):\\n x = np.arange(0, 1 + 0.01, 0.01)\\n l0 = self.data['L0']\\n l1 = self.data['L1']\\n y_on = np.exp(np.log(l0) + x * np.log(l1 / l0))\\n y_off = np.exp(np.log(l0) + (1 - x) * np.log(l1 / l0))\\n plt.plot(x, y_on, label='ON')\\n plt.plot(x, y_off, label='OFF')\\n plt.plot(x, baseline_rate + 0 * x, '--')\\n # plt.xlabel('Stimulus intensity')\\n # plt.ylabel('Firing Rate (Hz)')\\n # plt.title('Firing rate as a function \\\\n of Stimulus Intensity')\\n # plt.legend()\",\n \"def plot_learning_curve(model, X_train, X_test, y_train, y_test):\\n\\n m, train_scores, valid_scores = learning_curve(estimator = model, \\n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\\n\\n train_cv_err = np.mean(train_scores, axis=1)\\n test_cv_err = np.mean(valid_scores, axis=1)\\n tr, = plt.plot(m, train_cv_err)\\n ts, = plt.plot(m, test_cv_err)\\n plt.legend((tr, ts), ('training error', 'test error'), loc = 'best')\\n plt.title('Learning Curve')\\n plt.xlabel('Data Points')\\n plt.ylabel('Accuracy')\",\n \"def fit(ydata):\\n xdata = np.linspace(0,len(ydata),num = len(ydata))\\n popt, pcov = curve_fit(func, xdata, ydata)\\n #returns the parameters of the fitting\\n return popt\",\n \"def report_edp(self):\\n lmfit.report_fit(self.edp_par)\\n print(\\\"chisqr = {0:.3f}\\\".format(self.edp.chisqr))\",\n \"def curve(self, data):\\n x, y, y_smoothed = data\\n\\n curve_keys = ['color', 'linestyle', 'alpha', 'label']\\n curve_config = self.config.filter(curve_keys, prefix='curve_')\\n\\n curves = self.ax.plot(x, y, **curve_config)\\n\\n if y_smoothed is not None:\\n smoothed_color = scale_lightness(curve_config['color'], scale=.5)\\n smoothed_label = self.config.get('smoothed_label')\\n _ = self.ax.plot(x, y_smoothed, label=smoothed_label, color=smoothed_color, linestyle='--')\\n\\n return curves\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def get_fit_x(self, ploty):\\n # Generate x and y values for plotting\\n try:\\n fitx = self.best_fit[0]*ploty**2 + self.best_fit[1]*ploty + self.best_fit[2]\\n except TypeError:\\n # Avoids an error if best_fit is still none or incorrect\\n print('The function failed to fit a line!')\\n fitx = 1*ploty**2 + 1*ploty\\n\\n return fitx\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def plotFit(title, threadCounts, bestTimes, coeffs, independentVar, unit):\\n values = {}\\n for impl in sorted(list(bestTimes.keys()), key=cmp_to_key(compareFn)):\\n values[impl] = bestTimes[impl]\\n (tThread, tZero) = coeffs[impl]\\n values[impl + \\\"(best fit)\\\"] = [\\n tZero + thread * tThread for thread in threadCounts\\n ]\\n generatePlot(\\n title, unit, threadCounts, values, xLabel=independentVar, logarithmic=False\\n )\",\n \"def graph_points():\\n fig_name = 'lect2_num_solv'\\n\\n # given data\\n x = np.array([0.0, 0.4, 0.6, 0.8])\\n ra = np.array([0.01, 0.0080, 0.005, 0.002])\\n design_eq = np.divide(2.0, ra)\\n print(\\\"Generic example design equation points: {}\\\".format([\\\"{:0.1f}\\\".format(x) for x in design_eq]))\\n\\n # cubic spline\\n x_new = np.linspace(0.0, 0.8, 101)\\n # alternately, from interpolation\\n y_interp = interpolate.interp1d(x, design_eq, kind='quadratic')\\n make_fig(fig_name, x, design_eq, ls1='o', x2_array=x_new, y2_array=y_interp(x_new),\\n x_label=r'conversion (X, unitless)', y_label=r'$\\\\displaystyle\\\\frac{F_{A0}}{-r_A} \\\\left(L\\\\right)$',\\n x_lima=0.0, x_limb=0.8, y_lima=0.0, y_limb=1000,\\n fig_width=4, color2='green',\\n )\",\n \"def _repr_(self):\\n return \\\"Ring of coordinate functions on {}\\\".format(self._chart)\",\n \"def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None, n_jobs=1, train_sizes=np.linspace(.1, 1, 10)):\\n font = {'family': 'Droid Sans',\\n 'weight': 'normal',\\n 'size': 14}\\n plt.rc('font', **font)\\n plt.figure()\\n plt.title(title)\\n if ylim is not None:\\n plt.ylim(*ylim)\\n plt.xlabel(u\\\"Объем тренировочной выборки\\\")\\n plt.ylabel(u\\\"Точность\\\")\\n train_sizes, train_scores, test_scores = learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n plt.grid()\\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.1,\\n color=\\\"r\\\")\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.1, color=\\\"g\\\")\\n\\n plt.plot(train_sizes, train_scores_mean, 'o-', color=\\\"r\\\",label=u\\\"Точность обучения\\\")\\n plt.plot(train_sizes, test_scores_mean, 'o-', color=\\\"g\\\",label=u\\\"Точность тестирования\\\")\\n\\n plt.legend(loc=\\\"best\\\")\\n print('train scores')\\n print(train_scores)\\n print('test scores')\\n print(train_scores)\\n return plt\",\n \"def __str__(self):\\n if not self.has_converged or self.parameters is None:\\n log.warning(\\\"The fit has not converged. Try again!\\\")\\n return ''\\n\\n result = []\\n for parameter in self.parameters.keys():\\n if parameter in self.fit_for:\\n parameter_string = self.get_parameter_string(parameter)\\n if parameter_string is not None:\\n result.append(parameter_string)\\n\\n rms = self.get_parameter_format('kelvin') % self.rms\\n result.append(f\\\"[{rms} K rms]\\\")\\n return '\\\\n'.join(result)\",\n \"def plot_metrics(couplings, cost_func, cost_func_name, epsilons, log = False, points=False, scale=1.0, label_font_size=18, tick_font_size=12):\\n zero_offset = epsilons[0]/2\\n all_ys = []\\n if \\\"lineageOT\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['lineage entropic rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"LineageOT, true tree\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"lineageOT\\\"])/scale])\\n all_ys.append(ys)\\n if \\\"OT\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['entropic rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"Entropic OT\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"OT\\\"])/scale])\\n all_ys.append(ys)\\n if \\\"lineageOT, fitted\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['fitted lineage rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"LineageOT, fitted tree\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"lineageOT, fitted\\\"])/scale])\\n all_ys.append(ys)\\n\\n plt.ylabel(cost_func_name, fontsize=label_font_size)\\n plt.xlabel(\\\"Entropy parameter\\\", fontsize=label_font_size)\\n plt.xscale(\\\"log\\\")\\n\\n plt.xticks(fontsize=tick_font_size)\\n plt.yticks(fontsize=tick_font_size)\\n\\n if points:\\n plt.xlim([0.9*zero_offset, epsilons[-1]])\\n else:\\n plt.xlim([epsilons[0], epsilons[-1]])\\n\\n ylims = plt.ylim([0, None])\\n # upper limit should be at least 1\\n plt.ylim([0, max(ylims[1], 1)])\\n\\n plt.legend(fontsize=tick_font_size)\\n return all_ys\",\n \"def equity_curve_draw(self, profit_avg, profit_std, actual_profit, perfect_profit=None,\\n std_multiple=1, mode=1, title='', x_axis=None):\\n if not isinstance(actual_profit, (list, np.ndarray, pd.Series)):\\n raise TypeError('Actual profit should be one of list, numpy.ndarray, pandas.Series. Type=%s'\\n % type(actual_profit))\\n # add 0 to the beginning of the array\\n actual_profit = np.append(np.array([0]), np.array(actual_profit))\\n if perfect_profit is not None:\\n perfect_profit = np.append(np.array([0]), np.array(perfect_profit))\\n\\n actual_profit_len = len(actual_profit)\\n total_len = int(actual_profit_len * 1.5)\\n\\n x = np.linspace(0, total_len, total_len+1)\\n if x_axis is None:\\n x_axis = x\\n zero_line = 0 * x\\n\\n mid_curve = x * profit_avg\\n upper_curve = mid_curve + std_multiple * np.sqrt(x) * profit_std\\n lower_curve = mid_curve - std_multiple * np.sqrt(x) * profit_std\\n upper_curve2 = mid_curve + std_multiple * np.sqrt(x) * profit_std * 2\\n lower_curve2 = mid_curve - std_multiple * np.sqrt(x) * profit_std * 2\\n\\n plt.figure()\\n plt.rc('grid', linestyle='--', color='grey', linewidth=0.8)\\n plt.grid(True)\\n plt.plot(x, zero_line, color='grey', linestyle='--', linewidth=1)\\n plt.plot(x, mid_curve, color='black', label='Expected P&L', linewidth=1)\\n plt.plot(x, upper_curve, color='green', label='+' + str(std_multiple) + ' std', linewidth=1)\\n plt.plot(x, lower_curve, color='red', label='-' + str(std_multiple) + ' std', linewidth=1)\\n plt.plot(x, upper_curve2, color='green', label='+' + str(std_multiple*2) + ' std', linewidth=1, linestyle='--')\\n plt.plot(x, lower_curve2, color='red', label='-' + str(std_multiple*2) + ' std', linewidth=1, linestyle='--')\\n\\n plt.plot(x[0:len(actual_profit)], actual_profit, '-o', linewidth=1,\\n color='#00008b', label='Actual P&L', markersize=3)\\n if perfect_profit is not None:\\n plt.plot(x[0:len(actual_profit)], perfect_profit, '-o', linewidth=1,\\n color='#008081', label='Perfect P&L', markersize=3)\\n\\n plt.legend(loc='upper left')\\n x_label = 'days' if mode == 1 else 'trades'\\n plt.xlabel('# of ' + x_label)\\n plt.ylabel('$')\\n by_day_trade = 'date' if mode == 1 else 'trade'\\n plt.title(title + '_by' + by_day_trade)\\n # plt.show()\\n\\n return plt\",\n \"def content_fitting():\\n\\n all_functions = {\\n \\\"sigmoid_function\\\": \\\"return sigmoid function for fitting or plotting\\\",\\n \\\"fit_curve\\\": \\\"returns values r2 score and fitting parameters for a single sample\\\",\\n \\\"fitting_column\\\": \\\"returns r2_scores, fitting_parameters\\\",\\n \\\"compute_r2_score\\\": \\\"returns array of r2_scores\\\",\\n \\\"compute_fitting_function\\\": \\\"returns df with columns \\\\\\n [fitting_function+'_r2'] and fitting_function\\\",\\n \\\"compare_fitting_functions\\\": \\\"returns df with columns better_fitting, \\\\\\n displays df_best.loc[fitting_function, min, max, \\\\\\n r2>0, r2>0.8, r2>0.9, r2>0.99\\\",\\n }\\n return all_functions\",\n \"def fitexp(xdata,ydata,fitparams=None,domain=None,showfit=False,showstartfit=False,label=\\\"\\\"):\\n if domain is not None:\\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\\n else:\\n fitdatax=xdata\\n fitdatay=ydata\\n if fitparams is None: \\n fitparams=[0.,0.,0.,0.]\\n fitparams[0]=fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[1]=fitdatay[0]-fitdatay[-1]\\n fitparams[2]=fitdatax[0]\\n fitparams[3]=(fitdatax[-1]-fitdatax[0])/5.\\n #print fitparams\\n p1 = fitgeneral(fitdatax, fitdatay, expfunc, fitparams, domain=None, showfit=showfit, showstartfit=showstartfit,\\n label=label)\\n return p1\",\n \"def fit(self, X):\",\n \"def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\\n n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\\n \\n \\n\\n \\n font = {'family': 'serif',\\n 'color': 'black',\\n 'weight': 'bold',\\n 'size': 10,\\n }\\n \\n fig=plt.figure(figsize=(5,3))\\n\\n plt.title(title, fontdict= font)\\n if ylim is not None:\\n plt.ylim(*ylim)\\n plt.xlabel(\\\"Training examples\\\", fontdict=font)\\n plt.ylabel(\\\"Score\\\", fontdict=font)\\n train_sizes, train_scores, test_scores = learning_curve(\\n estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\\n train_scores_mean = np.mean(train_scores, axis=1)\\n train_scores_std = np.std(train_scores, axis=1)\\n test_scores_mean = np.mean(test_scores, axis=1)\\n test_scores_std = np.std(test_scores, axis=1)\\n \\n plt.grid(b=True, which='both', color='w', linewidth=1.0) \\n# \\n\\n plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\\n train_scores_mean + train_scores_std, alpha=0.1,\\n color=\\\"blue\\\")\\n plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\\n test_scores_mean + test_scores_std, alpha=0.1, color=\\\"orange\\\")\\n plt.plot(train_sizes, train_scores_mean, 'o--', color=\\\"blue\\\",\\n label=\\\"Training score\\\")\\n plt.plot(train_sizes, test_scores_mean, '--o', color=\\\"orange\\\",\\n label=\\\"Cross-validation score\\\")\\n \\n plt.legend(facecolor='white',loc=\\\"best\\\")\\n\\n fig.savefig(\\\"learning_Curve.pdf\\\", dpi=300,bbox_inches='tight')\\n plt.close(fig)\\n\\n return plt\",\n \"def fit(self):\\n raise NotImplementedError\",\n \"def fithanger_new_withQc(xdata, ydata, fitparams=None, domain=None, showfit=False, showstartfit=False,\\n printresult=False, label=\\\"\\\", mark_data='bo', mark_fit='r-'):\\n \\n if domain is not None:\\n fitdatax,fitdatay = selectdomain(xdata,ydata,domain)\\n else:\\n fitdatax=xdata\\n fitdatay=ydata\\n if fitparams is None: \\n peakloc=np.argmin(fitdatay)\\n ymax=(fitdatay[0]+fitdatay[-1])/2.\\n ymin=fitdatay[peakloc] \\n f0=fitdatax[peakloc]\\n Q0=abs(fitdatax[peakloc]/((max(fitdatax)-min(fitdatax))/5.))\\n scale= ymax-ymin\\n Qi=2*Q0\\n Qc=Q0\\n #slope = (fitdatay[-1]-fitdatay[0])/(fitdatax[-1]-fitdatax[0])\\n #offset= ymin-slope*f0\\n fitparams=[f0,abs(Qi),abs(Qc),0.,scale]\\n #print '--------------Initial Parameter Set--------------\\\\nf0: {0}\\\\nQi: {1}\\\\nQc: {2}\\\\ndf: {3}\\\\nScale: {4}\\\\nSlope: {5}\\\\nOffset:{6}\\\\n'.format(f0,Qi,Qc,0.,scale,slope, offset)\\n fitresult = fitgeneral(fitdatax, fitdatay, hangerfunc_new_withQc, fitparams, domain=None, showfit=showfit,\\n showstartfit=showstartfit, label=label, mark_data=mark_data, mark_fit=mark_fit)\\n fitresult[1]=abs(fitresult[1])\\n fitresult[2]=abs(fitresult[2])\\n if printresult: print('-- Fit Result --\\\\nf0: {0}\\\\nQi: {1}\\\\nQc: {2}\\\\ndf: {3}\\\\nscale: {4}'.format(fitresult[0],\\n fitresult[1],\\n fitresult[2],\\n fitresult[3],\\n fitresult[4]))\\n return fitresult\",\n \"def plot_learning_curve(X, y, maxdepth, estimator, plt):\\n # create cv training and test scores for various training set sizes\\n train_sizes, train_scores, test_scores = learning_curve(estimator,\\n X, # feature matrix\\n y, # target vector\\n cv=10, # number of folds in cross-validation\\n scoring='neg_mean_squared_error', # metric\\n n_jobs=-1, # use all computer cores,\\n train_sizes=np.linspace(0.01, 1.0, 30) # 30 different sizes of the training set\\n )\\n # create means and standart deviations of training set scores\\n train_mean = np.mean(train_scores, axis=1)\\n train_std = np.std(train_scores, axis=1)\\n\\n # create means and standart deviations of test set scores\\n test_mean = np.mean(test_scores, axis=1)\\n test_std = np.std(test_scores, axis=1)\\n\\n # draw lines\\n plt.plot(train_sizes, train_mean, '--', color='#111111', label=\\\"Training score\\\")\\n plt.plot(train_sizes, test_mean, color='#111111', label=\\\"Cross-validation score\\\")\\n\\n # draw bands\\n plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\\\"#DDDDDD\\\")\\n plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\\\"#f4d0d7\\\")\\n \\n # create plot \\n plt.title(\\\"Learning curve\\\")\\n plt.xlabel(\\\"Training set size\\\", fontsize=18)\\n plt.ylabel(\\\"mse\\\", fontsize=18)\\n plt.legend(loc=\\\"best\\\")\\n plt.tight_layout()\",\n \"def __draw_curve(self, points):\\n x_pts = []\\n y_pts = []\\n curvex = []\\n curvey = []\\n self.debug += 1\\n for point in points:\\n x_pts.append(point[0])\\n y_pts.append(point[1])\\n curve = scipy.interpolate.interp1d(x_pts, y_pts, 'cubic')\\n if self.debug == 1 or self.debug == 2:\\n for i in np.arange(x_pts[0], x_pts[len(x_pts) - 1] + 1, 1):\\n curvex.append(i)\\n curvey.append(int(curve(i)))\\n else:\\n for i in np.arange(x_pts[len(x_pts) - 1] + 1, x_pts[0], 1):\\n curvex.append(i)\\n curvey.append(int(curve(i)))\\n return curvex, curvey\",\n \"def test_curve_statistics():\\n c = Curve(data=np.linspace(1, 20, 2))\\n\\n assert c.median()[0] == 10.5\\n assert c.mean()[0] == 10.5\\n assert c.min()[0] == 1\\n assert c.max()[0] == 20\\n assert c.describe()[0][0] == 2\",\n \"def fit(self, x):\\n pass\",\n \"def get_plot_expression(self):\\n pass\",\n \"def getCurve(self, *args):\\n return _libsbml.ReactionGlyph_getCurve(self, *args)\",\n \"def fitPowerRegressionCurveComparisons(self, xVals0, yVals0):\\r\\n xValCount = 0\\r\\n yValCount = 0\\r\\n if len(xVals0) > 2:\\r\\n xValCount += int(len(xVals0) / 2) - 1\\r\\n yValCount += int(len(xVals0) / 2) - 1\\r\\n else:\\r\\n return \\\"regression error\\\", 0.0\\r\\n xVals = []\\r\\n yVals = []\\r\\n xValIndex = xValCount + 1\\r\\n yValIndex = yValCount + 1\\r\\n for i in range(xValIndex, len(xVals0)):\\r\\n xVals.append(xVals0[i])\\r\\n for i in range(yValIndex, len(xVals0)):\\r\\n yVals.append(yVals0[i])\\r\\n n = len(xVals)\\r\\n sumLnxLny = 0.0\\r\\n sumLnx = 0.0\\r\\n sumLny = 0.0\\r\\n sumLnx2 = 0.0\\r\\n sumLny2 = 0.0\\r\\n for i in range(0, n - 1):\\r\\n lnx = np.log(xVals[i])\\r\\n lny = np.log(yVals[i])\\r\\n sumLnxLny += (lnx * lny)\\r\\n for i in range(0, n - 1):\\r\\n lnx = np.log(xVals[i])\\r\\n sumLnx += lnx\\r\\n for i in range(0, n - 1):\\r\\n lny = np.log(yVals[i])\\r\\n sumLny += lny\\r\\n for i in range(0, n - 1):\\r\\n lny = np.log(yVals[i])\\r\\n sumLny2 += (lny * lny)\\r\\n for i in range(0, n - 1):\\r\\n lnx = np.log(xVals[i])\\r\\n sumLnx2 += (lnx * lnx)\\r\\n lnxBar = sumLnx / n\\r\\n lnyBar = sumLny / n\\r\\n sxx = sumLnx2 - (n * (lnxBar ** 2))\\r\\n syy = sumLny2 - (n * (lnyBar ** 2))\\r\\n sxy = sumLnxLny - (n * lnxBar * lnyBar)\\r\\n b = sxy / sxx\\r\\n a = pow(np.e, lnyBar - (b * lnxBar))\\r\\n r = sxy / (np.sqrt(sxx) * np.sqrt(syy))\\r\\n xx = np.array(xVals)\\r\\n yy = np.array(yVals)\\r\\n def power_law(xx, a, b):\\r\\n return a * np.power(xx, b)\\r\\n yHats = []\\r\\n for xPrime in xx:\\r\\n yHats.append(power_law(xPrime, a, b))\\r\\n eq = str(f' y = {str(round(a, 4))} (x) ^ {str(round(b, 4))} w/ correlation {str(round(100.0000 * r, 1))} %')\\r\\n if 'nan' in eq:\\r\\n eq_nan = 'could not calculate regression\\\\t\\\\t'\\r\\n self.eq = eq_nan\\r\\n return eq_nan\\r\\n else:\\r\\n self.ex_eq = eq\\r\\n return eq\",\n \"def getAnimCurve(self, *args, **kwargs):\\n ...\",\n \"def fit_gp(self):\\n raise NotImplementedError('Abstract Method')\",\n \"def ice_plot(curves, **kwargs):\\n \\n n,m = curves.shape\\n \\n #grid of plots\\n gridspec_kw = {'height_ratios':[3, 1], \\n 'wspace':0.0, \\n 'hspace':0.0}\\n fig, (ax_curves, ax_feature) = plt.subplots(2,1, \\n gridspec_kw=gridspec_kw, \\n figsize=kwargs.get('figsize', (6,6)))\\n \\n # top graph - curves\\n for curve in curves:\\n ax_curves.plot(np.arange(m), curve)\\n ax_curves.set_xticklabels([])\\n ax_curves.set_xlim((0, m))\\n ax_curves.set_ylabel(kwargs.get('ylabel', 'decision function $\\\\Delta$'))\\n \\n # bottom graph - feature values\\n if 'feature_values' in kwargs:\\n ax_feature.plot(np.arange(m), kwargs.get('feature_values'))\\n ax_feature.set_xlim((0, m)) \\n ax_feature.set_xlabel(kwargs.get('xlabel', '$X_S$ values'))\\n \\n return fig, (ax_curves, ax_feature)\",\n \"def fit_and_plot_with_irf(self):\\n try:\\n self.ui.Result_textBrowser.clear()\\n if not hasattr(self, \\\"file\\\"):\\n self.ui.Result_textBrowser.append(\\\"You need to load a data file.\\\")\\n if not hasattr(self, \\\"irf_file\\\") and self.ui.separate_irf_checkBox.isChecked():\\n self.ui.Result_textBrowser.append(\\\"You need to load an IRF file.\\\")\\n else:\\n if self.opened_from_flim:\\n x,y = self.hist_data_from_flim\\n else:\\n x,y = self.acquire_settings() #get data\\n _, irf_counts = self.acquire_settings(mode=\\\"irf\\\") #get irf counts\\n\\n #make sure Irf and data have the same length\\n if len(y) != len(irf_counts):\\n y = y[0:min(len(y), len(irf_counts))]\\n irf_counts = irf_counts[0:min(len(y), len(irf_counts))]\\n x = x[0:min(len(y), len(irf_counts))]\\n\\n y_norm = y/np.max(y) #normalized y\\n irf_norm = irf_counts/np.amax(irf_counts) #normalized irf\\n \\n t = x\\n time_fit = t \\n y = y_norm\\n irf_counts = irf_norm\\n \\n TRPL_interp = np.interp(time_fit, t, y)\\n\\n fit_func = self.ui.FittingFunc_comboBox.currentText()\\n self.ui.plot.plot(t, y, clear=self.ui.clear_plot_checkBox.isChecked(), pen=pg.mkPen(self.plot_color))\\n if fit_func == \\\"Stretched Exponential\\\": #stretched exponential tab\\n tc_bounds = (self.ui.str_tc_min_spinBox.value(), self.ui.str_tc_max_spinBox.value()) #(0, 10000)\\n a_bounds = (self.ui.str_a_min_spinBox.value(), self.ui.str_a_max_spinBox.value())#(0.9, 1.1)\\n beta_bounds = (self.ui.str_beta_min_spinBox.value(), self.ui.str_beta_max_spinBox.value())#(0,1)\\n noise_bounds = (self.ui.str_noise_min_spinBox.value(), self.ui.str_noise_max_spinBox.value())#(0, 1e4)\\n stretch_exp_bounds = [tc_bounds, beta_bounds, a_bounds, noise_bounds]\\n stretch_exp_init_params = [self.ui.str_tc_init_spinBox.value(), self.ui.str_a_init_spinBox.value(), self.ui.str_beta_init_spinBox.value(), self.ui.str_noise_init_spinBox.value()]\\n\\n #tc, beta, a, avg_tau, PL_fit = stretch_exp_fit(TRPL_interp, t)\\n # resolution = float(self.ui.Res_comboBox.currentText())\\n if self.ui.FittingMethod_comboBox.currentText() == \\\"diff_ev\\\":\\n bestfit_params, t_avg, bestfit_model, data_array, time_array, irf = fit_exp_stretch_diffev(t, self.resolution, TRPL_interp, irf_counts, stretch_exp_bounds)\\n else: #if fmin_tnc fitting method selected\\n bestfit_params, t_avg, bestfit_model, data_array, time_array, irf = fit_exp_stretch_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, stretch_exp_init_params, stretch_exp_bounds)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = bestfit_model # PL fit\\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Stretched Exponential with IRF\\\"\\n \\\"\\\\nFit Method: \\\"+ self.ui.FittingMethod_comboBox.currentText() +\\n \\\"\\\\ntau_avg = %.5f ns\\\"\\n \\\"\\\\nbeta = %.5f\\\"\\n \\\"\\\\ntau_c = %.5f ns\\\"\\n \\\"\\\\na = %.5f \\\\nnoise = %.5f counts\\\" %(t_avg, bestfit_params[1], bestfit_params[0], bestfit_params[2], bestfit_params[3]))\\n #self.effective_lifetime = t_avg\\n self.ui.average_lifetime_spinBox.setValue(t_avg)\\n \\n elif fit_func == \\\"Double Exponential\\\": #double exponential tab\\n a1_bounds = (self.ui.de_a1_min_spinBox.value(), self.ui.de_a1_max_spinBox.value())\\n tau1_bounds = (self.ui.de_tau1_min_spinBox.value(), self.ui.de_tau1_max_spinBox.value())\\n a2_bounds = (self.ui.de_a2_min_spinBox.value(), self.ui.de_a2_max_spinBox.value())\\n tau2_bounds = (self.ui.de_tau2_min_spinBox.value(), self.ui.de_tau2_max_spinBox.value())\\n noise_bounds = (self.ui.de_noise_min_spinBox.value(), self.ui.de_noise_max_spinBox.value())\\n double_exp_bounds = [a1_bounds, tau1_bounds, a2_bounds, tau2_bounds, noise_bounds]\\n double_exp_init_params = [self.ui.de_a1_init_spinBox.value(), self.ui.de_tau1_init_spinBox.value(), self.ui.de_a2_init_spinBox.value(), \\n self.ui.de_tau2_init_spinBox.value(), self.ui.de_noise_init_spinBox.value()]\\n\\n if self.ui.FittingMethod_comboBox.currentText() == \\\"diff_ev\\\":\\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, self.resolution, TRPL_interp, irf_counts, double_exp_bounds, 2)\\n #bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, resolution, TRPL_interp, irf_counts, double_exp_init_bounds, 2)\\n else:\\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, double_exp_init_params, double_exp_bounds, 2)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = bestfit_model # PL fit\\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Double Exponential with IRF\\\"\\n \\\"\\\\nFit Method: \\\"+ self.ui.FittingMethod_comboBox.currentText() +\\n \\\"\\\\na1 = %.5f\\\"\\n \\\"\\\\ntau1 = %.5f ns\\\"\\n \\\"\\\\na2 = %.5f\\\"\\n \\\"\\\\ntau2 = %.5f ns\\\"\\n \\\"\\\\nnoise = %.5f counts\\\" %(bestfit_params[0], bestfit_params[1], bestfit_params[2], bestfit_params[3], bestfit_params[4]))\\n #TODO - once tau_avg implemented, set average lifetime spinbox to tau_avg value\\n if bestfit_params[3] > bestfit_params[1]:\\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[3])\\n elif bestfit_params[1] > bestfit_params[3]:\\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[1])\\n\\n elif fit_func == \\\"Single Exponential\\\": #single exponential tab\\n a_bounds = (self.ui.se_a_min_spinBox.value(), self.ui.se_a_max_spinBox.value())\\n tau_bounds = (self.ui.se_tau_min_spinBox.value(), self.ui.se_tau_max_spinBox.value())\\n noise_bounds = (self.ui.se_noise_min_spinBox.value(), self.ui.se_noise_max_spinBox.value())\\n single_exp_bounds = [a_bounds, tau_bounds, noise_bounds]\\n single_exp_init_params = [self.ui.se_a_init_spinBox.value(), self.ui.se_tau_init_spinBox.value(), self.ui.se_noise_init_spinBox.value()]\\n\\n if self.ui.FittingMethod_comboBox.currentText() == \\\"diff_ev\\\":\\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_diffev(t, self.resolution, TRPL_interp, irf_counts, single_exp_bounds, 1)\\n else:\\n bestfit_params, bestfit_model, data_array, time_array, irf = fit_multi_exp_fmin_tnc(t, self.resolution, TRPL_interp, irf_counts, single_exp_init_params, single_exp_bounds, 1)\\n self.out = np.empty((len(t), 3))\\n self.out[:,0] = t #time\\n self.out[:,1] = TRPL_interp #Raw PL \\n self.out[:,2] = bestfit_model # PL fit\\n self.ui.plot.plot(t, bestfit_model, clear=self.ui.clear_plot_checkBox.isChecked(), pen='k')\\n self.ui.Result_textBrowser.setText(\\\"Fit Results:\\\\n\\\\nFit Function: Single Exponential with IRF\\\"\\n \\\"\\\\nFit Method: \\\"+ self.ui.FittingMethod_comboBox.currentText() +\\n \\\"\\\\na = %.5f\\\"\\n \\\"\\\\ntau = %.5f ns\\\"\\n \\\"\\\\nnoise = %.5f counts\\\" %(bestfit_params[0], bestfit_params[1], bestfit_params[2]))\\n self.ui.average_lifetime_spinBox.setValue(bestfit_params[1]) #set spinbox to tau value\\n\\n #add fit params to data_list\\n self.data_list.append(\\\"Data Channel: \\\" + str(self.ui.Data_channel_spinBox.value()) + \\\"\\\\n\\\" + self.ui.Result_textBrowser.toPlainText())\\n self.fit_lifetime_called_w_irf = True\\n self.fit_lifetime_called_wo_irf = False\\n except Exception as e:\\n self.ui.Result_textBrowser.append(format(e))\",\n \"def plot(self):\\n raise Exception(\\\"pure virtual function\\\")\",\n \"def add_results_text(self, plotData, function_nick):\\n\\t\\ttext = \\\"Fit results\\\"\\n\\t\\tif len(plotData.plotdict[\\\"function_fit\\\"]) > 1: # only add the nickname if more than one fit\\n\\t\\t\\ttext += \\\" {}:\\\".format(function_nick)\\n\\n\\t\\t# expand paramter_names if necessary\\n\\t\\tif len(plotData.plotdict[\\\"function_fit_parameter_names\\\"]) < plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar():\\n\\t\\t\\tplotData.plotdict[\\\"function_fit_parameter_names\\\"] *= plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar() / len(plotData.plotdict[\\\"function_fit_parameter_names\\\"])\\n\\t\\t\\tplotData.plotdict[\\\"function_fit_parameter_names_x\\\"] *= plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar() / len(plotData.plotdict[\\\"function_fit_parameter_names\\\"])\\n\\t\\t\\tplotData.plotdict[\\\"function_fit_parameter_names_y\\\"] *= plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar() / len(plotData.plotdict[\\\"function_fit_parameter_names\\\"])\\n\\t\\tl = max([len(s) for s in plotData.plotdict[\\\"function_fit_parameter_names\\\"]])\\n\\n\\t\\tfor i_par in range(plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar()):\\n\\t\\t\\t#TODO automatically adjust decimal precision\\n\\t\\t\\ttext = \\\"\\\\n${} = {:.3f} \\\\pm {:.3f}$\\\".format(plotData.plotdict[\\\"function_fit_parameter_names\\\"][i_par],\\n\\t\\t\\t plotData.plotdict[\\\"root_objects\\\"][function_nick].GetParameter(i_par),\\n\\t\\t\\t plotData.plotdict[\\\"root_objects\\\"][function_nick].GetParError(i_par))\\n\\t\\t\\tif plotData.plotdict[\\\"texts\\\"] == [None]:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] = [text]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_x\\\"] = [plotData.plotdict[\\\"function_fit_parameter_names_x\\\"][i_par]]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_y\\\"] = [plotData.plotdict[\\\"function_fit_parameter_names_y\\\"][i_par]]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] += [text]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_x\\\"] += [plotData.plotdict[\\\"function_fit_parameter_names_x\\\"][i_par]]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_y\\\"] += [plotData.plotdict[\\\"function_fit_parameter_names_y\\\"][i_par]]\\n\\t\\tfor i, expr in enumerate(plotData.plotdict[\\\"functions_text\\\"]):\\n\\t\\t\\tfor i_par in range(plotData.plotdict[\\\"root_objects\\\"][function_nick].GetNpar()):\\n\\t\\t\\t\\texpr = expr.replace('[' + str(i_par) + ']', str(plotData.plotdict[\\\"root_objects\\\"][function_nick].GetParameter(i_par)))\\n\\t\\t\\timport math\\n\\t\\t\\ttext = \\\"\\\\n{} = {:.3f}\\\".format(\\n\\t\\t\\t\\tplotData.plotdict[\\\"functions_text_names\\\"][i],\\n\\t\\t\\t eval(expr),\\n\\t\\t\\t)\\n\\t\\t\\tif plotData.plotdict[\\\"texts\\\"] == [None]:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] = [text]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_x\\\"] = [plotData.plotdict[\\\"functions_text_names_x\\\"][i]]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_y\\\"] = [plotData.plotdict[\\\"functions_text_names_y\\\"][i]]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] += [text]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_x\\\"] += [plotData.plotdict[\\\"functions_text_names_x\\\"][i]]\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts_y\\\"] += [plotData.plotdict[\\\"functions_text_names_y\\\"][i]]\\n\\n\\t\\tif not plotData.plotdict[\\\"function_collect_result_no_chi2\\\"]:\\n\\t\\t\\ttext = \\\"\\\\n$\\\\chi^2 / \\\\mathit{{n.d.f}} = {:.2f} / {}$\\\".format(\\n\\t\\t\\t plotData.fit_results[function_nick].Chi2(),\\n\\t\\t\\t plotData.fit_results[function_nick].Ndf())\\n\\t\\t\\tif plotData.plotdict[\\\"texts\\\"] == [None]:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] = [text]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tplotData.plotdict[\\\"texts\\\"] += [text]\\n\\t\\t\\tplotData.plotdict[\\\"texts_x\\\"] += [plotData.plotdict[\\\"function_fit_parameter_chi2_x\\\"][0]]\\n\\t\\t\\tplotData.plotdict[\\\"texts_y\\\"] += [plotData.plotdict[\\\"function_fit_parameter_chi2_y\\\"][0]]\",\n \"def recovery(self):\\n\\n def exponential(time, tau):\\n\\n time = list(map(lambda x: float(x), time))\\n exponent = np.exp(-np.divide(time, tau))\\n return (1 - exponent)\\n \\n \\n initial_guess = [55]\\n \\n tau = []\\n for i in range(self.n_cols):\\n current = self.screened_data.iloc[:,i]\\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\\n tau.append(popt[0][0])\\n\\n print('Median: ', np.median(tau))\\n print('Min: ', np.min(tau))\\n print('Max: ', np.max(tau))\\n return 0\\n\\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\\n for i in range(len(popt)):\\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\\n plt.xlabel('Time (ms)')\\n plt.ylabel('Normalized Current')\\n plt.title('Recovery from Inactivation')\\n plt.legend()\\n plt.savefig('recovery_exponential_fit.png')\\n return popt\",\n \"def oncurve(self, P):\\n\\t\\traise Exception(NotImplemented)\",\n \"def fit_function(function,\\n energy_fit,\\n eqe_fit,\\n p0=None,\\n bounds=None,\\n include_disorder=False,\\n double=False\\n ):\\n\\n if bounds is not None:\\n best_vals, covar = curve_fit(function,\\n energy_fit,\\n eqe_fit,\\n p0=p0,\\n bounds=bounds\\n )\\n else:\\n best_vals, covar = curve_fit(function,\\n energy_fit,\\n eqe_fit,\\n p0=p0\\n )\\n if double:\\n if include_disorder:\\n y_fit = [function(\\n x,\\n best_vals[0],\\n best_vals[1],\\n best_vals[2],\\n best_vals[3],\\n best_vals[4],\\n best_vals[5],\\n best_vals[6]\\n ) for x in energy_fit]\\n else:\\n y_fit = [function(\\n x,\\n best_vals[0],\\n best_vals[1],\\n best_vals[2],\\n best_vals[3],\\n best_vals[4],\\n best_vals[5]\\n ) for x in energy_fit]\\n else:\\n if include_disorder:\\n y_fit = [function(\\n x,\\n best_vals[0],\\n best_vals[1],\\n best_vals[2],\\n best_vals[3]\\n ) for x in energy_fit]\\n else:\\n y_fit = [function(\\n x,\\n best_vals[0],\\n best_vals[1],\\n best_vals[2]\\n ) for x in energy_fit]\\n r_squared = R_squared(eqe_fit, y_fit)\\n\\n return best_vals, covar, y_fit, r_squared\",\n \"def plotCaliCurve(constants, data, outName):\\n x=np.linspace(min(data[:,0]),max(data[:,0]),1000)\\n plt.figure()\\n plt.rcParams.update({'font.size' : 16})\\n plt.scatter(data[:,0],data[:,1])\\n plt.plot(x,LangmuirCurve(x,constants[0],constants[1],constants[2],constants[3]))\\n #plt.xlabel(\\\"MG Concentration (nM)\\\")\\n #plt.ylabel(\\\"Relative SHS signal (Arb. Units)\\\")\\n plt.savefig(outName + \\\"_cali_model_plot.png\\\")\\n plt.show()\",\n \"def printfunc(self):\\n zero1=self.Newton(True)\\n print \\\"Using initial porition %0.2f ,%0.2f\\\" %(self.x_init,self.y_0)\\n print \\\"extremum calculated witn Newton-Rapson: %0.2f ,%0.2f.\\\"%(zero1[0],zero1[1])\\n zero2=self.Newton(False)\\n print \\\"extremum calculated witn Secant: %0.2f ,%0.2f.\\\" %(zero2[0],zero2[1])\\n xlist=np.arange(self.x_0-10,self.x_0+10,0.01)\\n ylist=np.arange(self.y_0-10,self.y_0+10,0.01)\\n X,Y=np.meshgrid(xlist,ylist)\\n Z=self.sfunc(X,Y)\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n \\n ax.plot(xlist, ylist, self.sfunc(xlist,ylist), 'g-',label='function $e^{(-(x-%0.2f)^2-(y-%0.2f)^2)}$' %(self.x_0,self.y_0))\\n ax.contour(X, Y, Z)# colors = 'k', linestyles = 'solid')\\n ax.plot([zero1[0]], [zero1[0]], self.sfunc(zero1[0],zero1[1]),'bo',label='extrema using Newton-Rapson (%0.2f; %0.2f)'%(zero1[0],zero1[1]))\\n ax.plot([zero2[0]], [zero2[0]], self.sfunc(zero2[0],zero2[1]),'ro',label='extrema using Seacent (%0.2f; %0.2f)'%(zero2[0],zero2[1]))\\n ax.legend()\\n plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfTF().plot()\",\n \"def fit_circle_func():\\n pass\",\n \"def fit(self):\\n raise NotImplementedError # pragma: no cover\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7055758","0.66392714","0.65292656","0.6458982","0.62626904","0.62592036","0.61264443","0.6093298","0.6078136","0.6074372","0.60485107","0.60373193","0.6032992","0.6027297","0.5985532","0.59401494","0.59209955","0.5901951","0.5901479","0.58885133","0.5854944","0.5840931","0.5815281","0.58143324","0.58099115","0.58069015","0.5802704","0.5796377","0.5786247","0.5759399","0.57523274","0.5745403","0.57449746","0.57438236","0.5733402","0.5721854","0.57205296","0.5719136","0.57057714","0.5692918","0.56898725","0.56753737","0.5671186","0.5671136","0.5665626","0.56645393","0.5651502","0.56417185","0.5640134","0.5624477","0.561869","0.5607651","0.5603047","0.559681","0.559681","0.559681","0.559681","0.559681","0.559681","0.559681","0.559681","0.559681","0.559681","0.5594046","0.5583898","0.5583898","0.5583898","0.55769426","0.55753237","0.55635786","0.55576223","0.5553346","0.5552608","0.5548668","0.5538596","0.55342937","0.55297315","0.55250585","0.5518799","0.5517549","0.5516455","0.55130637","0.5502358","0.5501535","0.5492025","0.54823095","0.54741144","0.5466124","0.5445561","0.54331267","0.54330045","0.54285336","0.5417644","0.5414232","0.5413561","0.5403476","0.54030234","0.5402034","0.539906","0.5396831","0.53925776"],"string":"[\n \"0.7055758\",\n \"0.66392714\",\n \"0.65292656\",\n \"0.6458982\",\n \"0.62626904\",\n \"0.62592036\",\n \"0.61264443\",\n \"0.6093298\",\n \"0.6078136\",\n \"0.6074372\",\n \"0.60485107\",\n \"0.60373193\",\n \"0.6032992\",\n \"0.6027297\",\n \"0.5985532\",\n \"0.59401494\",\n \"0.59209955\",\n \"0.5901951\",\n \"0.5901479\",\n \"0.58885133\",\n \"0.5854944\",\n \"0.5840931\",\n \"0.5815281\",\n \"0.58143324\",\n \"0.58099115\",\n \"0.58069015\",\n \"0.5802704\",\n \"0.5796377\",\n \"0.5786247\",\n \"0.5759399\",\n \"0.57523274\",\n \"0.5745403\",\n \"0.57449746\",\n \"0.57438236\",\n \"0.5733402\",\n \"0.5721854\",\n \"0.57205296\",\n \"0.5719136\",\n \"0.57057714\",\n \"0.5692918\",\n \"0.56898725\",\n \"0.56753737\",\n \"0.5671186\",\n \"0.5671136\",\n \"0.5665626\",\n \"0.56645393\",\n \"0.5651502\",\n \"0.56417185\",\n \"0.5640134\",\n \"0.5624477\",\n \"0.561869\",\n \"0.5607651\",\n \"0.5603047\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.559681\",\n \"0.5594046\",\n \"0.5583898\",\n \"0.5583898\",\n \"0.5583898\",\n \"0.55769426\",\n \"0.55753237\",\n \"0.55635786\",\n \"0.55576223\",\n \"0.5553346\",\n \"0.5552608\",\n \"0.5548668\",\n \"0.5538596\",\n \"0.55342937\",\n \"0.55297315\",\n \"0.55250585\",\n \"0.5518799\",\n \"0.5517549\",\n \"0.5516455\",\n \"0.55130637\",\n \"0.5502358\",\n \"0.5501535\",\n \"0.5492025\",\n \"0.54823095\",\n \"0.54741144\",\n \"0.5466124\",\n \"0.5445561\",\n \"0.54331267\",\n \"0.54330045\",\n \"0.54285336\",\n \"0.5417644\",\n \"0.5414232\",\n \"0.5413561\",\n \"0.5403476\",\n \"0.54030234\",\n \"0.5402034\",\n \"0.539906\",\n \"0.5396831\",\n \"0.53925776\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9287,"cells":{"query":{"kind":"string","value":"Searches for winning sequence in columns."},"document":{"kind":"string","value":"def check_columns(self, win: list) -> bool:\r\n for row in range(self.size):\r\n column = [self.tags[x][row] for x in range(self.size)]\r\n for j in range(len(column) - len(win) + 1):\r\n if win == column[j:j+self.win_condition]:\r\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def col_win(board, player):\n for row in board.T:\n if check_row(row, player):\n return True\n return False","def check_columns():\n global game_still_going\n # Check if any of the rows have all the same value.\n column1 = board[0] == board[3] == board[6] != '_'\n column2 = board[1] == board[4] == board[7] != '_'\n column3 = board[2] == board[5] == board[8] != '_'\n # If any column does have a match, then game still going to False.\n if column1 or column2 or column3:\n game_still_going = False\n # Return winner 'X' or 'O'.\n if column1:\n return board[0]\n if column2:\n return board[1]\n if column3:\n return board[2]","def win_column(playerid):\n\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\n return (True, \"Column 1\")\n\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\n return (True, \"Column 2\")\n\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\n return (True, \"Column 3\")\n\n return False","def col_win(board):\n\tfor col in range(3):\n\t\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\n\t\t\treturn True\n\treturn False","def _check_column(self):\n for column in np.transpose(self._board):\n col_string = ''.join(column)\n match = re.search(WIN_REGEX, col_string)\n if match:\n return match.group()[0]\n return None","def search_next_win(self, player):\n for i, j, k in self.winning_cases:\n if self.game_board[i] == player and \\\n self.game_board[j] == player and \\\n self.game_board[k] == ' ':\n return k\n elif self.game_board[j] == player and \\\n self.game_board[k] == player and \\\n self.game_board[i] == ' ':\n return i\n elif self.game_board[i] == player and \\\n self.game_board[k] == player and \\\n self.game_board[j] == ' ':\n return j\n return None","def check_columns():\n global ongoing_game\n column_1 = board[0] == board[3] == board[6] != \"*\"\n column_2 = board[1] == board[4] == board[7] != \"*\"\n column_3 = board[2] == board[5] == board[8] != \"*\"\n if column_1 or column_2 or column_3:\n ongoing_game = False\n if column_1:\n return board[0]\n elif column_2:\n return board[1]\n elif column_3:\n return board[2]\n else:\n return None","def check_column(self, column, symbol):\r\n\r\n tally = 0\r\n for row in range(3):\r\n if self.board[row][column][1] == symbol:\r\n tally += 1\r\n if tally == 3:\r\n self.winner = symbol","def test_row_col(board, rows):\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0","def column_wise_checking(player_):\n if board[0] == board[3] == player_:\n return 6\n elif board[3] == board[6] == player_:\n return 0\n elif board[1] == board[4] == player_:\n return 7\n elif board[4] == board[7] == player_:\n return 1\n elif board[2] == board[5] == player_:\n return 8\n elif board[5] == board[8] == player_:\n return 2\n else:\n return -1","def column_similarity (self, row, col):\n my_number = self.board[row][col]\n \n for i in range (9):\n if (i,col) == (row,col):\n continue\n elif self.board[i][col] == my_number:\n return [i, col, False] \n else:\n continue","def find_column_index(self, columns):\n for i in range(len(columns)):\n if self.match(columns[i]):\n return i\n return None","def check_for_win(self, row, col, player): \n\n count = 0\n for i in range(0, len(self.board[0])):\n # Check vertical\n if self.board[row][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n\n count = 0\n for i in range(0, len(self.board)):\n # Check horisontal\n if self.board[:, col][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n \n count = 0\n totoffset = col - row\n for i in np.diagonal(self.board, offset=totoffset):\n # Check diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True\n\n count = 0\n mirrorboard = np.fliplr(self.board)\n col = self.colswitch[col]\n totoffset = col - row\n for i in np.diagonal(mirrorboard, offset=totoffset):\n # Check other diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True","def winner_found(self):\n\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\n winner_in_rows = first_row or second_row or third_row\n\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\n winner_in_columns = first_column or second_column or third_column\n\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\n winner_in_diagonals = first_diagonal or second_diagonal\n\n return winner_in_rows or winner_in_columns or winner_in_diagonals","def winner(board):\n columns = []\n for row in board:\n xcount = row.count(X)\n ocount = row.count(O)\n if xcount == 3:\n return X\n if ocount == 3:\n return O\n\n for j in range(len(board)):\n column = [row[j] for row in board]\n columns.append(column)\n \n for j in columns:\n xcounter = j.count(X)\n ocounter = j.count(O)\n if xcounter == 3:\n return X\n if ocounter == 3:\n return O\n \n if board[0][0] == O and board[1][1] == O and board[2][2] == O:\n return O\n if board[0][0] == X and board[1][1] == X and board[2][2] == X:\n return X\n if board[0][2] == O and board[1][1] == O and board[2][0] == O:\n return O\n if board[0][2] == X and board[1][1] == X and board[2][0] == X:\n return X\n\n return None","def check_cols(self):\r\n for i in range(3):\r\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+3][-1] and self.grid[i+3][-1] == self.grid[i+6][-1]:\r\n return (i, (self.grid[i], self.grid[i+6]))\r\n return (-1, None)","def columnWin( self ):\n\n for x in list(range(0,3)):\n firstVal = self.__grid[x]\n secondVal = self.__grid[x+3]\n thirdVal = self.__grid[x+6]\n\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\n\n if compiledVal.lower() == 'xxx':\n return 'X'\n\n elif compiledVal.lower() == 'ooo':\n return 'O'\n\n return None","def check_columns(self):\n\t\ti=0\n\t\tfor i in range(len(self.board[i])):\n\t\t\tpts = 0\n\t\t\tfor j in range(len(self.board)):\n\t\t\t\tif self.board[j][i] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('YOU WON')\n\t\t\t\treturn True","def find_best_move(board):\n new_board = board.get_board()\n\n # X | X | X <-- Check for win on this row\n # ---------\n # 3 | 4 | 5\n # ---------\n # 6 | 7 | 9\n if new_board[0] == new_board[1] and new_board[2] == \"2\":\n return 2\n elif new_board[0] == new_board[2] and new_board[1] == \"1\":\n return 1\n elif new_board[1] == new_board[2] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | 2\n # ---------\n # X | X | X <-- Check for win on this row\n # ---------\n # 6 | 7 | 9\n elif new_board[3] == new_board[4] and new_board[5] == \"5\":\n return 5\n elif new_board[3] == new_board[5] and new_board[4] == \"4\":\n return 4\n elif new_board[4] == new_board[5] and new_board[3] == \"3\":\n return 3\n\n # 0 | 1 | 2\n # ---------\n # 3 | 4 | 5\n # ---------\n # X | X | X <-- Check for win on this row\n elif new_board[6] == new_board[7] and new_board[8] == \"8\":\n return 8\n elif new_board[6] == new_board[8] and new_board[7] == \"7\":\n return 7\n elif new_board[7] == new_board[8] and new_board[6] == \"6\":\n return 6\n\n # X | 1 | 2 Check for win on column one\n # ---------\n # X | 4 | 5\n # ---------\n # X | 7 | 9\n elif new_board[0] == new_board[3] and new_board[6] == \"6\":\n return 6\n elif new_board[0] == new_board[6] and new_board[3] == \"3\":\n return 3\n elif new_board[6] == new_board[3] and new_board[0] == \"0\":\n return 0\n\n # 0 | X | 2 Checks for win on column two\n # ---------\n # 3 | X | 5\n # ---------\n # 6 | X | 9\n elif new_board[1] == new_board[4] and new_board[7] == \"7\":\n return 7\n elif new_board[1] == new_board[7] and new_board[4] == \"4\":\n return 4\n elif new_board[7] == new_board[4] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | X\n # ---------\n # 3 | 4 | X\n # ---------\n # 6 | 7 | X\n elif new_board[2] == new_board[5] and new_board[8] == \"8\":\n return 8\n elif new_board[2] == new_board[8] and new_board[5] == \"5\":\n return 5\n elif new_board[8] == new_board[5] and new_board[2] == \"2\":\n return 2\n\n # X | 1 | 2\n # ---------\n # 3 | X | 5\n # ---------\n # 6 | 7 | X\n elif new_board[0] == new_board[4] and new_board[8] == \"8\":\n return 8\n elif new_board[0] == new_board[8] and new_board[4] == \"4\":\n return 4\n elif new_board[8] == new_board[4] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | X\n # ---------\n # 3 | X | 5\n # ---------\n # X | 7 | 9\n elif new_board[2] == new_board[4] and new_board[6] == \"6\":\n return 6\n elif new_board[2] == new_board[6] and new_board[4] == \"4\":\n return 4\n elif new_board[6] == new_board[4] and new_board[2] == \"2\":\n return 2\n\n # If corners are empty, play there\n elif new_board[0] == \"0\" or new_board[2] == \"2\" or new_board[6] == \"6\" or new_board[8] == \"8\":\n try_spot = 0\n while True:\n if new_board[try_spot] != \"X\" and new_board[try_spot] != \"O\":\n return try_spot\n else:\n try_spot = try_spot + 2\n\n # If middle is empty, play there\n elif new_board[4] == \"4\":\n return 4\n\n # Finally if edges are empty try there\n elif new_board[1] == \"1\" or new_board[3] == \"3\" or new_board[5] == \"5\" or new_board[7] == \"7\":\n try_spot = 1\n while True:\n if new_board[try_spot] != \"X\" and new_board[try_spot] != \"O\":\n return try_spot\n else:\n try_spot = try_spot + 2","def check_for_win_lose(b):\r\n win_move = None\r\n block_win = None\r\n # check for wins based on row\r\n for ri in range(3):\r\n row = b[ri]\r\n if single_move(row):\r\n if row==[1,1,0]:\r\n win_move = (ri+1,3)\r\n elif row==[2,2,0]:\r\n block_win = (ri+1,3)\r\n elif row==[1,0,1]:\r\n win_move = (ri+1,2)\r\n elif row==[2,0,2]:\r\n block_win = (ri+1,2)\r\n elif row==[0,1,1]:\r\n win_move = (ri+1,1)\r\n elif row==[0,2,2]:\r\n block_win = (ri+1,1)\r\n else:\r\n print '144 ERROR!'\r\n print single_move(row)\r\n print row\r\n print ' '\r\n\r\n # check for win based on column\r\n for ci in range(3):\r\n col = get_col(b,ci)\r\n if single_move(col):\r\n if col==[1,1,0]:\r\n win_move = (3,ci+1)\r\n elif col==[2,2,0]:\r\n block_win = (3,ci+1)\r\n elif col==[1,0,1]:\r\n win_move = (2,ci+1)\r\n elif col==[2,0,2]:\r\n block_win = (2,ci+1)\r\n elif col==[0,1,1]:\r\n win_move = (1,ci+1)\r\n elif col==[0,2,2]:\r\n block_win = (1,ci+1)\r\n else:\r\n print '166 ERROR!'\r\n print single_move(col)\r\n print col\r\n print ' '\r\n\r\n # check for win on backward diagonal\r\n diag = get_bw_diag(b)\r\n if single_move(diag):\r\n if diag==[1,1,0]:\r\n win_move = (3,3)\r\n elif diag==[2,2,0]:\r\n block_win (3,3)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,1)\r\n elif diag==[0,2,2]:\r\n block_win = (1,1)\r\n \r\n # check for win on forward diagonal\r\n diag = get_fwd_diag(b)\r\n if single_move(diag):\r\n if diag == [1,1,0]:\r\n win_move = (3,1)\r\n elif diag==[2,2,0]:\r\n block_win = (3,1)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,3)\r\n elif diag==[0,2,2]:\r\n block_win = (1,3)\r\n\r\n if win_move is not None:\r\n return (win_move, True)\r\n elif block_win is not None:\r\n return (block_win, False)\r\n else:\r\n return (None, False)","def searchcols(self,fctn,cols,*args):\n goodkeys=[]\n for key in self.allrowkeys:\n temp=[]\n for c in cols:\n temp.append(self.getentry(key,c))\n for i in range(len(args)):\n temp.append(args[i])\n\n if fctn(*tuple(temp)):\n goodkeys.append(key)\n return(goodkeys)","def look_through_rows(board, column, player):\n if board.shape[1] > column:\n count = board.shape[0] - 1\n count2 = 1\n while count >= 0 and count2 == 1:\n if board[count,column] == 0:\n board[count,column] = player\n count2 = count2 - 1\n else:\n count = count - 1\n return board\n else:\n print('Improper Column Given')","def check_rows(self, win: list) -> bool:\r\n for row in self.tags:\r\n for j in range(len(row) - len(win) + 1):\r\n if win == row[j:j+self.win_condition]:\r\n return True","def check_col(sudoku):\r\n for col in range(9):\r\n for row in range(8):\r\n test = sudoku[row][col]\r\n for i in range(row+1,9):\r\n if sudoku[i][col] == test:\r\n return True #returns True is there is more than two of the same numbers in a column\r","def check_diag(self, row, column, symbol):\r\n\r\n # get the current state of buttons..\r\n # tl -> top left; mm -> middle middle; etc...\r\n tl = self.board[0][0][1]\r\n mm = self.board[1][1][1]\r\n br = self.board[2][2][1]\r\n bl = self.board[0][2][1]\r\n tr = self.board[0][2][1]\r\n\r\n # we know if mm isn't on then we can return early\r\n if mm == symbol:\r\n if tl == symbol and br == symbol:\r\n self.winner = symbol\r\n return\r\n if tr == symbol and bl == symbol:\r\n self.winner = symbol\r\n return\r\n else:\r\n return\r\n else:\r\n return","def check_winner(self):\n for row in self.board.values():\n if all([mark == \"x\" for mark in row]):\n return self.player_1\n elif all([mark == \"o\" for mark in row]):\n return self.player_2\n\n # checks every column\n for i in range(3):\n first_row, second_row, third_row = self.board.values()\n if first_row[i] == \"x\" and second_row[i] == \"x\" and third_row[i] == \"x\":\n return self.player_1\n elif first_row[i] == \"o\" and second_row[i] == \"o\" and third_row[i] == \"o\":\n return self.player_2\n\n # checks the diagonals\n if self.board[\"a\"][0] == \"x\" and self.board[\"b\"][1] == \"x\" and self.board[\"c\"][2] == \"x\":\n return self.player_1\n if self.board[\"a\"][2] == \"o\" and self.board[\"b\"][1] == \"o\" and self.board[\"c\"][0] == \"o\":\n return self.player_2\n\n return None","def winner(board):\n x_in_board = []\n o_in_board = []\n winning_positions = [\n [[0, 0], [0, 1], [0, 2]],\n [[1, 0], [1, 1], [1, 2]],\n [[2, 0], [2, 1], [2, 2]],\n [[0, 0], [1, 0], [2, 0]],\n [[0, 1], [1, 1], [2, 1]],\n [[0, 2], [1, 2], [2, 2]],\n [[0, 0], [1, 1], [2, 2]],\n [[0, 2], [1, 1], [2, 0]]\n ]\n\n for i in range(len(board)):\n for j in range(len(board)):\n if board[i][j] == X:\n x_in_board.append([i, j])\n elif board[i][j] == O:\n o_in_board.append([i, j])\n\n for i in winning_positions:\n if i[0] in x_in_board and i[1] in x_in_board and i[2] in x_in_board:\n return X\n elif i[0] in o_in_board and i[1] in o_in_board and i[2] in o_in_board:\n return O\n\n return None","def row_win(board):\n\tfor row in range(3):\n\t\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\n\t\t\treturn True\n\treturn False","def player(board):\n X_count = 0\n O_count = 0\n\n for row in board:\n X_count += row.count(X)\n O_count += row.count(O)\n\n if X_count <= O_count:\n return X\n else:\n return O","def winner(board):\n # Hard code winning moves\n # row0\n if board[0][0] == board[0][1] == board[0][2] == X:\n return X\n elif board[0][0] == board[0][1] == board[0][2] == O:\n return O\n # row1\n elif board[1][0] == board[1][1] == board[1][2] == X:\n return X\n elif board[1][0] == board[1][1] == board[1][2] == O:\n return O\n # row2\n elif board[2][0] == board[2][1] == board[2][2] == X:\n return X\n elif board[2][0] == board[2][1] == board[2][2] == O:\n return O\n # col0\n elif board[0][0] == board[1][0] == board[2][0] == X:\n return X\n elif board[0][0] == board[1][0] == board[2][0] == O:\n return O\n # col1\n elif board[0][1] == board[1][1] == board[2][1] == X:\n return X\n elif board[0][1] == board[1][1] == board[2][1] == O:\n return O\n # col2\n elif board[0][2] == board[1][2] == board[2][2] == X:\n return X\n elif board[0][2] == board[1][2] == board[2][2] == O:\n return O\n # diagonal\n elif board[0][0] == board[1][1] == board[2][2] == X:\n return X\n elif board[0][0] == board[1][1] == board[2][2] == O:\n return O\n # inverse diagonal\n elif board[0][2] == board[1][1] == board[2][0] == X:\n return X\n elif board[0][2] == board[1][1] == board[2][0] == O:\n return O\n\n return None","def isSolved(board):\n for player in [1, 2]:\n if [player]*3 in chain(\n board, # Rows\n zip(board), # Columns\n [ # Diagonals\n [board[i][i] for i in range(len(board))],\n [board[len(board) - i - 1][i] for i in range(len(board))]\n ]\n ):\n return player\n return -1 if 0 in chain(*board) else 0","def check_rows():\n global game_still_going\n # Check if any of the rows have all the same value.\n row1 = board[0] == board[1] == board[2] != '_'\n row2 = board[3] == board[4] == board[5] != '_'\n row3 = board[6] == board[7] == board[8] != '_'\n # If any row does have a match, then game still going to False.\n if row1 or row2 or row3:\n game_still_going = False\n # Return winner 'X' or 'O'.\n if row1:\n return board[0]\n if row2:\n return board[3]\n if row3:\n return board[6]","def search_possible_steps(self):\n if self.ended:\n return False\n possible_steps_turple = (self.board == 0)\n possible_steps = np.transpose(possible_steps_turple.nonzero())\n return possible_steps","def winner(board):\n \n possible_wins = []\n row1 = board[0]\n row2 = board[1]\n row3 = board[2]\n col1 = [board[0][0],board[1][0],board[2][0]]\n col2 = [board[0][1],board[1][1],board[2][1]]\n col3 = [board[0][2],board[1][2],board[2][2]]\n diag1 = [board[0][0],board[1][1],board[2][2]]\n diag2 = [board[2][0],board[1][1],board[0][2]]\n \n possible_wins.append(row1)\n possible_wins.append(row2)\n possible_wins.append(row3)\n possible_wins.append(col1)\n possible_wins.append(col2)\n possible_wins.append(col3)\n possible_wins.append(diag1)\n possible_wins.append(diag2)\n \n for trait in possible_wins:\n if trait.count(\"X\") == 3:\n return \"X\"\n elif trait.count(\"O\") == 3:\n return \"O\"\n \n return None","def checkwin(self):\n w = self.getWidth()\n h = self.getHeight()\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\n for r in range(h):\n for c in range(w):\n if self.cell[c][r] == EMPTY:\n continue # this cell can't be part of winning segment\n # if we reach this point, the cell is occupied by a player stone\n numOccupiedCell = numOccupiedCell+1\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\n for i in range(NWIN):\n # test if there exists a segment of NWIN uniformly coloured cells\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\n break # segment broken\n else:\n # Python remark: notice that the else is attached to the for loop \"for i...\"\n # This block is executed if and only if 'i' arrives at the end of its range \n return self.cell[c][r] , True # found a winning segment \n return EMPTY, numOccupiedCell==w*h","def evaluate(board):\n winner = 0\n for player in [1, 2]:\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n winner = player\n \n if np.all(board != 0) and winner == 0:\n winner = -1\n return winner","def check_winner(self, row, column, symbol):\r\n self.check_row(row, symbol)\r\n self.check_column(column, symbol)\r\n self.check_diag(row, column, symbol)","def find_column(self, columns):\n for column in columns:\n if self.match(column):\n return column\n return None","def row_wise_checking(player_):\n if board[0] == board[1] == player_:\n return 2\n elif board[1] == board[2] == player_:\n return 0\n elif board[3] == board[4] == player_:\n return 5\n elif board[4] == board[5] == player_:\n return 3\n elif board[6] == board[7] == player_:\n return 8\n elif board[7] == board[8] == player_:\n return 6\n else:\n return -1","def TestColumn(SudokuGrid):\r\n for i in range(9):\r\n for j in range(8):\r\n for k in range(j+1,9):\r\n if SudokuGrid[j][i]==SudokuGrid[k][i]:\r\n return False\r\n return True","def winner(board):\n \n for m in [\"XXX\", \"OOO\"]:\n # horizontal\n for row in range(3):\n if board[row][0] == board[row][1] == board[row][2]:\n return board[row][0]\n # vertical\n for col in range(3):\n if board[0][col] == board[1][col] == board[2][col]:\n return board[0][col]\n # diagonal\n if board[0][0] == board[1][1] == board[2][2]:\n return board[1][1]\n if board[0][2] == board[1][1] == board[2][0]:\n return board[1][1]\n return None","def check_rows(self):\r\n for i in range(0, len(self.grid),3):\r\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+1][-1] and self.grid[i+1][-1] == self.grid[i+2][-1]:\r\n return (i, (self.grid[i], self.grid[i+2]))\r\n return (-1, None)","def check_rows():\n global ongoing_game\n row_1 = board[0] == board[1] == board[2] != \"*\"\n row_2 = board[3] == board[4] == board[5] != \"*\"\n row_3 = board[6] == board[7] == board[8] != \"*\"\n if row_1 or row_2 or row_3:\n ongoing_game = False\n if row_1:\n return board[0]\n elif row_2:\n return board[3]\n elif row_3:\n return board[6]\n else:\n return None","def _col_match(sheet, row, value):\r\n for cell in sheet[row]:\r\n if cell.value == value:\r\n return cell.column","def won(self):\n for y in range(self.size):\n winning = []\n for x in range(self.size):\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n for x in range(self.size):\n winning = []\n for y in range(self.size):\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n winning = []\n for y in range(self.size):\n x = y\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n winning = []\n for y in range(self.size):\n x = self.size-1-y\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n return None","def winner(board):\n chances = [X, O]\n for chance in chances:\n for row in range(3):\n if list(chance)*3 == board[row]:\n return chance\n for column in range(3):\n if [[chance] for i in range(3)] == [[board[row][column]] for row in range(3)]:\n return chance\n if board[0][0] == chance and board[1][1] == chance and board[2][2] == chance:\n return chance\n if board[0][2] == chance and board[1][1] == chance and board[2][0] == chance:\n return chance\n return None","def winner(board):\n for i in (O, X):\n for j in range(3):\n if (board[j][0] == i and board[j][1] == i and board[j][2] == i):\n return i\n if (board[0][j] == i and board[1][j] == i and board[2][j] == i):\n return i\n if (board[0][0] == i and board[1][1] == i and board[2][2] == i):\n return i\n if (board[2][0] == i and board[1][1] == i and board[0][2] == i):\n return i\n return None","def check(self):\n winner = None\n count = 0\n\n for y in range(self.gridSize):\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for item in self.grid[y]:\n # Check row of the grid\n if item == \"P1\":\n P1 += 1\n elif item == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for x in range(self.gridSize):\n # Check column of the grid\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check right top to left bottom across the grid\n for x in range(self.gridSize):\n if x == y:\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check the left top to the right bottom across the grid\n for x in range(self.gridSize - 1, -1, -1):\n # Check how many filled spaces there are\n if \".\" not in self.grid[y][x]:\n count += 1\n if x + y == self.gridSize - 1:\n if self.grid[y][x] == \"P1\":\n P1 += 1\n elif self.grid[y][x] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n # Check if there is a winner if so return the winner\n if winner != None:\n return winner\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\n if count == self.gridSize**2:\n return \"Tie\"","def row_win(board, player):\n for row in board:\n if check_row(row, player):\n return True\n return False","def win(board):\n # COLUMNS\n if board[7] == board[4] == board[1] != ' ': # first column down\n return board[7]\n elif board[8] == board[5] == board[2] != ' ': # second column down\n return board[8]\n elif board[9] == board[6] == board[3] != ' ': # third column down\n return board[9]\n\n # ROWS\n if board[7] == board[8] == board[9] != ' ': # first row across\n return board[7]\n elif board[4] == board[5] == board[6] != ' ': # second row across\n return board[4]\n elif board[1] == board[2] == board[3] != ' ': # third row across\n return board[1]\n\n # DIAGONALS\n if board[7] == board[5] == board[3] != ' ': # diagonal staring on left\n return board[7]\n elif board[9] == board[5] == board[1] != ' ': # diagonal starting on right\n return board[9]\n\n # else no winner\n return \"No\"","def check_win(self):\n win = None\n for pos in self.winning_pos:\n win = self.is_match(set(self.get_cells(pos)))\n if win:\n return win\n if not self.open_tiles():\n return \"Draw\"\n return win","def win_check(table: list) -> (bool, str):\n # Combinations that would lead to a win\n win_list = [\n [0,1,2], [3,4,5],\n [6,7,8], [0,3,6],\n [1,4,7], [2,5,8],\n [0,4,8], [6,4,2],\n ]\n for line in win_list:\n # Check rows, columns, and diagonals\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\n\n if len(combination) == 1 and combination != {\"-\"}: # Which mean we have a straight line of either X or O\n #unpack comb (which is 1 item), which is either \"X\" or \"O\" to know who won\n return True, *combination\n else:\n return False, None","def _check_row(self):\n match = None\n for row in self._board:\n row_string = ''.join(row)\n match = re.search(WIN_REGEX, row_string)\n if match:\n return match.group()[0]\n return None","def win_check(board, mark):\n win_positions = [\"123\", \"456\", \"789\", \"147\", \"258\", \"369\", \"159\", \"357\"]\n is_winner = False\n for positions in win_positions:\n for idx in positions:\n idx = int(idx)\n if board[idx] != mark:\n break\n else:\n is_winner = True\n\n return is_winner","def any_possible_moves(grid):\n if get_empty_cells(grid):\n return True\n for row in grid:\n if any(row[i]==row[i+1] for i in range(len(row)-1)):\n return True\n for i,val in enumerate(grid[0]):\n column = get_column(grid, i)\n if any(column[i]==column[i+1] for i in range(len(column)-1)):\n return True\n return False","def winner(board):\r\n\r\n #rows:\r\n if (board[0][0] == board[0][1] == board[0][2]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[1][0] == board[1][1] == board[1][2]) and (board[1][0] == \"X\" or board[1][0] == \"O\"):\r\n return board[1][0]\r\n if (board[2][0] == board[2][1] == board[2][2]) and (board[2][0] == \"X\" or board[2][0] == \"O\"):\r\n return board[2][0]\r\n\r\n #columns\r\n if (board[0][0] == board[1][0] == board[2][0]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[0][1] == board[1][1] == board[2][1]) and (board[0][1] == \"X\" or board[0][1] == \"O\"):\r\n return board[0][1]\r\n if (board[0][2] == board[1][2] == board[2][2]) and (board[0][2] == \"X\" or board[0][2] == \"O\"):\r\n return board[0][2]\r\n\r\n #diagonals\r\n if (board[0][0] == board[1][1] == board[2][2]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[0][2] == board[1][1] == board[2][0]) and (board[0][2] == \"X\" or board[0][2] == \"O\"):\r\n return board[0][2]\r\n \r\n return None\r\n\r\n raise NotImplementedError","def winner(board) -> any:\n numeric_board = [[0, 0, 0],\n [0, 0, 0],\n [0, 0, 0]]\n\n total_horizon = [0, 0, 0]\n total_vertical = [0, 0, 0]\n total_diagonally = [0, 0]\n for i, row in enumerate(board):\n for j, column in enumerate(row):\n if column == X:\n numeric_board[i][j] = 1\n total_horizon[i] += 1\n total_vertical[j] += 1\n elif column == O:\n numeric_board[i][j] = -1\n total_horizon[i] += -1\n total_vertical[j] += -1\n\n n = len(numeric_board)\n total_diagonally[0] = sum(numeric_board[i][i] for i in range(n))\n total_diagonally[1] = sum(numeric_board[i][n - i - 1] for i in range(n))\n\n if 3 in total_horizon or 3 in total_vertical or 3 in total_diagonally:\n return X\n elif -3 in total_horizon or -3 in total_vertical or -3 in total_diagonally:\n return O\n else:\n return None","def check_for_win(self,board, player_id, action):\n\n row = 0\n\n # check which row was inserted last:\n for i in range(ROWS):\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\n row = ROWS - i\n break\n\n # check horizontal:\n vec = board[row, :] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check vertical:\n vec = board[:, action] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check diagonals:\n vec = np.diagonal(board, action - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n return False","def _check_won(field, col, delta_row):\n player = field[col][-1]\n coord = len(field[col]) - 1\n total = 1\n # negative dir\n cur_coord = coord - delta_row\n for c in range(col - 1, -1, -1):\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\n break\n if field[c][cur_coord] != player:\n break\n total += 1\n if total == COUNT_TO_WIN:\n return True\n cur_coord -= delta_row\n # positive dir\n cur_coord = coord + delta_row\n for c in range(col + 1, GAME_COLS):\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\n break\n if field[c][cur_coord] != player:\n break\n total += 1\n if total == COUNT_TO_WIN:\n return True\n cur_coord += delta_row\n return False","def winner(board):\n for i in range(3):\n if board[i][0] == board[i][1] == board[i][2] != None:\n return board[i][0]\n for i in range(3):\n if board[0][i] == board[1][i] == board[2][i] != None:\n return board[0][i]\n if board[0][0] == board[1][1] == board[2][2]:\n return board[0][0]\n if board[0][2] == board[1][1] == board[2][0]:\n return board[0][2]\n return None","def player(board):\n number_of_X = 0\n number_of_O = 0\n \n for row in board: \n number_of_X += row.count(\"X\")\n number_of_O += row.count(\"O\")\n \n \n if number_of_X <= number_of_O:\n return(\"X\") \n else: \n return(\"O\")","def getWinner(board):\n players = [X, O]\n num_symbols_in_line = 3\n for player in players:\n # check rows\n for row in board:\n line_count = row.count(player)\n if line_count == num_symbols_in_line:\n return player\n \n # check columns\n for col_i in range(len(board[0])):\n line_count = 0\n for row_i in range(len(board)):\n if board[row_i][col_i] == player:\n line_count += 1\n if line_count == num_symbols_in_line:\n return player\n \n # check vertical from top left to bottom right\n line_count = 0\n for vert_cell in range(len(board)):\n if board[vert_cell][vert_cell] == player:\n line_count += 1\n if line_count == num_symbols_in_line:\n return player\n \n # check vertical from top right to bottom left\n line_count = 0\n col_i = len(board) - 1\n for row_i in range(len(board)):\n if board[row_i][col_i] == player:\n line_count += 1\n col_i -= 1\n if line_count == num_symbols_in_line:\n return player\n\n return None","def get_winner(board):\n\n def who_won(in_a_row, board_size, cur_player):\n \"\"\" \n a function private to get_winner() (yes you can do this. Cool huh!?) \n that tells get_winner if it has a winner \n \"\"\"\n if in_a_row == board_size:\n return 1 if cur_player == 'X' else 2\n else:\n return 0\n\n def test_row_col(board, rows):\n \"\"\" private function to test the rows and columns \"\"\"\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n def test_diagonal(board, normal):\n \"\"\" private function to test the two diagonals \"\"\"\n cur_player = board[0][0] if normal else board[0][len(board)-1]\n in_a_row = 0\n for i in range(len(board)):\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1 \n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n\n # test rows\n winner = test_row_col(board, True)\n if not winner == 0:\n return winner\n\n # test cols\n winner = test_row_col(board, False)\n if not winner == 0:\n return winner\n\n # test diagonal from top left to bottom right\n winner = test_diagonal(board, True)\n if not winner == 0:\n return winner\n\n # test diagonal from top right to bottom left\n winner = test_diagonal(board, False)\n if not winner == 0:\n return winner\n\n return 0","def winner(board):\n for turn in [X,O]:\n for i in range(3):\n if board[i] == [turn, turn, turn]:\n return turn\n if board[0][i] == turn and board[1][i] == turn and board[2][i] == turn:\n return turn\n if board[0][0] == turn and board[1][1] == turn and board[2][2] == turn:\n return turn\n if board[0][2] == turn and board[1][1] == turn and board[2][0] == turn:\n return turn\n return None","def rowWin( self ):\n\n for x in [0,3,6]:\n firstVal = self.__grid[x]\n secondVal = self.__grid[x+1]\n thirdVal = self.__grid[x+2]\n\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\n\n if compiledVal.lower() == 'xxx':\n return 'X'\n\n elif compiledVal.lower() == 'ooo':\n return 'O' \n \n return None","def find_twice_in_row_cols(row,item):\n results = [item]\n for i in range(9):\n if item in row[i]:\n results.append(i)\n return results","def col_match(sent1, sent2):\n\n for i in range(len(sent1)):\n if sent1[i] != sent2[i]:\n return i","def winning_move(board, position, player):\n win = list(player*3)\n if get_row(board, position) == win:\n return True\n elif get_column(board, position) == win:\n return True\n elif position % 2 != 0:\n # odd positions are on the diagonals\n return get_diagonal(board, 1) == win or get_diagonal(board, 3) == win\n return False","def winner(b):\n # Row of three\n for row in b:\n if row[0] == \" \":\n # First row entry is blank; ignore!\n continue\n if row[0]==row[1] and row[1]==row[2]:\n return row[0]\n # Column of three\n for i in range(3):\n if b[0][i] == \" \":\n # First column entry is blank; ignore!\n continue\n if b[0][i]==b[1][i] and b[1][i]==b[2][i]:\n return b[0][i]\n # Diagonals\n if b[1][1] != \" \":\n # Middle entry not blank, so diagonal win \n # is a possibility.\n if b[0][0] == b[1][1] and b[1][1]==b[2][2]:\n return b[0][0]\n if b[0][2] == b[1][1] and b[1][1]==b[2][0]:\n return b[0][2]\n # implicit return None","def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None","def player(board):\n\n # Game is over\n if terminal(board):\n return None\n\n # Count number of occurences of X and O\n x_count = 0\n o_count = 0\n for row in board:\n for box in row:\n if box == X:\n x_count = x_count + 1\n elif box == O:\n o_count = o_count + 1\n # When move count is tied, X is next\n if x_count <= o_count:\n return X\n # When X has moved once more than O, next move is O\n else:\n return O","def check_row(self, row, symbol):\r\n\r\n tally = 0\r\n for column in range(3):\r\n if self.board[row][column][1] == symbol:\r\n tally += 1\r\n if tally == 3:\r\n self.winner = symbol","def check_winner(self):\n if self.history:\n last_move = self.history[-1]\n last_player = self.get_last_player()\n\n connected_token = last_player*self.n_in_row\n # check for row\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for column\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope 1\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope -1\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for draw game\n if len(np.argwhere(self.state==0)) == 0:\n self.winner = [True, 0]\n return self.winner\n return self.winner","def same_row_col(self, num, squ):\n found = [pos for pos in squ if num in self.possibles[pos[0]][pos[1]]]\n if found:\n row = found[0][0]\n col = found[0][1]\n all_same_row = all(pos[0] == row for pos in found)\n all_same_col = all(pos[1] == col for pos in found)\n if all_same_row ^ all_same_col:\n return all_same_row, all_same_col, found\n return [], [], []","def move(self, row, col, player):\n score = 1 if player == 1 else -1\n self.rows[row] += score\n self.cols[col] += score\n if row == col:\n self.diagonal1 += score\n if row + col == self.n - 1:\n self.diagonal2 += score\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\n if self.n in win or -self.n in win:\n return player\n return 0","def check_game_status(self):\n for player in (\"1\", \"2\"):\n row_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 1, self.board\n ).any()\n col_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 0, self.board\n ).any()\n d1_win = set(self.data[[0, 4, 8]]) == {player}\n d2_win = set(self.data[[2, 4, 6]]) == {player}\n if any([row_win, col_win, d1_win, d2_win]):\n return (\"win\", player)\n\n if self.counter[\"_\"] == 0:\n return (\"tie\", None)\n else:\n return (\"turn\", \"1\" if self.counter[\"1\"] == self.counter[\"2\"] else \"2\")","def check_bingo_board(board_num):\n winning_board = False\n for i in range(BINGO_SIZE):\n if bingoboards[board_num][i].count(\"X\") == 5:\n winning_board = board_num\n for j in range(BINGO_SIZE):\n col = list(map(lambda x: x[j], bingoboards[board_num]))\n if col.count(\"X\") == 5:\n winning_board = board_num\n return winning_board","def any_possible_moves(grid):\n\tif get_empty_cells(grid):\n\t\treturn True\n\tfor row in grid:\n\t\tif any(row[i]==row[i+1] for i in range(len(row)-1)):\n\t\t\treturn True\n\tfor i,val in enumerate(grid[0]):\n\t\tcolumn = get_column(grid, i)\n\t\tif any(column[i]==column[i+1] for i in range(len(column)-1)):\n\t\t\treturn True\n\treturn False","def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\n num_connected = 1 # Tally of how many game pieces were found matching thus far\n\n def increment_connected(step_row, step_col):\n \"\"\"\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\n :param step_row: The amount to move in the Y direction\n :param step_col: The amount to move in the X direction\n :return: The number of adjacent matching tiles found by the function\n \"\"\"\n connected = 0\n current_row = row + step_row\n current_col = col + step_col\n\n while self.board[current_row][current_col] == player_symbol:\n connected += 1\n current_row += step_row\n current_col += step_col\n\n return connected\n\n num_connected += increment_connected(step_row_1, step_col_1)\n num_connected += increment_connected(step_row_2, step_col_2)\n\n if num_connected >= 4:\n self.game_over = True","def findOverlap( columns, t, minOverlap ):\n for c in columns:\n c.setOverlap() # defaults to 0.0\n for s in c.getConnectedSynapses():\n c.setOverlap( c.getOverlap() + s.getSourcetInput( t ) )\n\n if c.getOverlap() < minOverlap:\n c.setOverlap()\n else:\n c.boostOverlap()","def winner(board):\n # Checking for 3 in a row\n for row in board:\n if row[0] is not EMPTY and row[0] == row[1] == row[2]:\n return row[0]\n\n # Checking for 3 in a col\n for col in range(len(board)):\n if board[0][col] is not EMPTY and board[0][col] == board[1][col] == board[2][col]:\n return board[0][col]\n\n # Checking for Diagonals\n if board[0][0] is not EMPTY and board[0][0] == board[1][1] == board[2][2]:\n return board[0][0]\n \n if board[0][2] is not EMPTY and board[0][2] == board[2][0] == board[1][1]:\n return board[0][2]\n\n return None","def human_go(self, board):\r\n coord_pattern = re.compile(\"[0-{}]$\".format(board.shape[1]))\r\n print(\"Enter Column and press enter.\")\r\n input_str = input(\"(from 0-6)\\n\")\r\n if not coord_pattern.match(input_str):\r\n print(\"That is not in the right format, please try again...\")\r\n return self.human_go(board)\r\n else:\r\n col = int(input_str)\r\n if board[0][col] != 0:\r\n print(\"That column is already full, please try again\")\r\n self.human_go()\r\n else:\r\n for row in board[::-1]:\r\n if row[col] == 0:\r\n row[col] = -1\r\n return board","def check_for_win(self, index):\n\n\t\tpossible_comb = self.cell_combinations[index]\n\n\t\tfor comb in possible_comb:\n\n\t\t\ttokens = []\n\t\t\ttokens.append(self.player_model.grid[comb[0]].token)\n\t\t\ttokens.append(self.player_model.grid[comb[1]].token)\n\t\t\ttokens.append(self.player_model.grid[comb[2]].token)\n\n\t\t\tif all([token == self.player_model.current_player.token for token in tokens]):\n\n\t\t\t\treturn True\n\n\t\treturn False","def winner(board):\n for row in range(len(board)):\n if board[row].count(X) == 3:\n return X\n elif board[row].count(O) == 3:\n return O\n for column in range(len(board[row])):\n if board[0][column] == X and board[1][column] == X and board[2][column] == X:\n return X\n elif board[0][column] == O and board[1][column] == O and board[2][column] == O:\n return O\n\n if (board[0][0] == X and board[1][1] ==X and board[2][2] ==X) or (board[0][2] == X and board[1][1]==X and board[2][0] ==X):\n return X\n\n elif (board[0][0] == O and board[1][1] == O and board[2][2] == O) or (board[0][2] == O and board[1][1]== O and board[2][0] ==O):\n return O\n\n else: return None\n\n\n\n # raise NotImplementedError","def winner(board):\n # Check Rows\n for row in board:\n if row[0] != EMPTY and row[0] == row[1] and row[0] == row[2]:\n return row[0]\n \n # Check Columns\n for j in range(3):\n if board[0][j] != EMPTY and board[0][j] == board[1][j]:\n if board[0][j] == board[2][j]:\n return board[0][j]\n \n # Check Diagonals\n if board[1][1] != EMPTY:\n if board[0][0] == board[1][1] and board[0][0] == board[2][2]:\n return board[0][0]\n if board[0][2] == board[1][1] and board[0][2] == board[2][0]:\n return board[0][2]\n\n return None","def win_game(self):\n\n def horizontal_win():\n \"\"\"Return whether there is horizontal win\"\"\"\n\n for i in range(0, board_size):\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\n print \"horizontal win\"\n return True\n\n def vertical_win():\n \"\"\"Return whether there is vertical win\"\"\"\n\n vert_set = set()\n for i in range(0, board_size):\n for j in range(0, board_size):\n vert_set.add(self.board[j][i])\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\n print \"vertical win\"\n return True \n vert_set = set()\n\n def diagonal_win():\n \"\"\"Return whether there is diagonal win\"\"\"\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True\n\n if horizontal_win() or vertical_win() or diagonal_win():\n print \"You have won.\"\n return True","def winner(board):\n for i in range(len(board)):\n\n # Check rows\n if board[i][0] == board[i][1] == board[i][2] and not board[i][1] == EMPTY:\n return board[i][1]\n\n # Check columns\n elif board[0][i] == board[1][i] == board[2][i] and not board[1][i] == EMPTY:\n return board[1][i]\n\n # Check diagonals\n if board[0][0] == board[1][1] == board[2][2] and not board[1][1] == EMPTY:\n return board[1][1]\n\n if board[2][0] == board[1][1] == board[0][2] and not board[1][1] == EMPTY:\n return board[1][1]\n\n # No winner if get to this point\n return None","def col_checker(board, size):\n for i in range(size):\n for j in range(1, size):\n if board[0][i] != board[j][i]:\n break\n else:\n yield f\"'{board[j][i]}' (Col index {i})\"","def winner(self):\n\n\t\tfor player in [1,2]:\n\t\t\twon = np.full((self.boardSize), player)\n\n\t\t\t# Check diagonals\n\t\t\tif(np.array_equal(np.diag(self.board), won)): return player\n\t\t\tif(np.array_equal(np.diag(np.fliplr(self.board)), won)): return player\n\n\t\t\t# Check lines and columns\n\t\t\tfor i in range(self.boardSize):\n\t\t\t\tif(np.array_equal(self.board[i], won)): return player\n\t\t\t\tif(np.array_equal(self.board[:,i], won)): return player\n\n\t\t# Draw\n\t\tif(not(0 in self.board)): return 3\n\n\t\t# No win or draw\n\t\treturn 0","def check_column(self, letter, given_letter):\n count = 0\n avalible_pos = []\n for number in self.numbers:\n if self.positions[letter + number] == given_letter:\n count += 1\n else:\n avalible_pos.append(letter + number)\n return count, avalible_pos","def winner(self):\n for c in 'xo':\n for comb in [(0,3,6), (1,4,7), (2,5,8), (0,1,2), (3,4,5), (6,7,8), (0,4,8), (2,4,6)]:\n if all(self.spots[p] == c for p in comb):\n return c\n return None","def check_win(board_list):\n\n for i in range(0, 3):\n\n # rows\n if board_list[i][0] == board_list[i][1] == board_list[i][2]:\n if board_list[i][0] != 0:\n return board_list[i][0]\n\n # columns\n elif board_list[0][i] == board_list[1][i] == board_list[2][i]:\n if board_list[0][i] != 0:\n return board_list[0][i]\n\n # diagonal (top left to bottom right)\n elif board_list[0][0] == board_list[1][1] == board_list[2][2]:\n if board_list[0][0] != 0:\n return board_list[0][0]\n\n # diagonal (bottom left to top right)\n elif board_list[0][2] == board_list[1][1] == board_list[2][0]:\n if board_list[0][2] != 0:\n return board_list[0][2]\n\n return None","def record_winner(cls):\n # Determine number of contiguous positions needed to win\n win_length = 3 if cls.size == 3 else 4\n\n # Store all sets of coordinates for contiguous positions\n sets = []\n\n # Loop through all 3x3 squares on the board\n for x in range(0, cls.size-(win_length-1)):\n for y in range(0, cls.size-(win_length-1)):\n # Add sets for rows\n for row in range(x, x+win_length):\n set = []\n for col in range(y, y+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for columns\n for col in range(y, y+win_length):\n set = []\n for row in range(x, x+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for diagonals\n if cls.size == 3:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\n else:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\n\n # Check all sets for winner\n for set in sets:\n d = {}\n for coords in set:\n token = cls.board[coords[0]][coords[1]]\n d[token] = token != cls.empty\n # If the dictionary only has one key and it's not empty, then we have a winner\n tokens = list(d.keys())\n if len(tokens) == 1 and d[tokens[0]]:\n cls.winner = tokens[0]","def win(s):\r\n\r\n # check across\r\n for i in range(3):\r\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\r\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\r\n return True\r\n\r\n # check down\r\n for i in range(3):\r\n if board[i] == board[i + 3] == board[i + 6] == s:\r\n board[i] = board[i + 3] = board[i + 6] = '#'\r\n return True\r\n\r\n # check diagonal right\r\n if board[0] == board[4] == board[8] == s:\r\n board[0] = board[4] = board[8] = '#'\r\n return True\r\n\r\n # check diagonal left\r\n if board[6] == board[4] == board[2] == s:\r\n board[6] = board[4] = board[2] = '#'\r\n return True\r\n\r\n return False","def who_won(self, board):\n winners = set()\n for x,y,z in self.wins:\n if board[x] == board[y] and board[y] == board[z]:\n winners.add(board[x])\n if 1 in winners and 2 in winners:\n return 3\n if 1 in winners:\n return 1\n if 2 in winners:\n return 2\n return 0","def legitimateMoves(table,floor,X2,Y2,goes,csvX):\n scores = []\n legitimateColumns = []\n try:\n i = 0\n while True:\n if floor[i] != -1:\n legitimateColumns.append(i)\n i=i+1\n \n except IndexError:\n pass\n #print(legitimateColumns)\n for x in legitimateColumns:\n \n table[floor[x]][x] = \"x\"\n gameArray = []\n for z in range(7):\n for i in range(5,-1,-1):\n gameArray.append(table[i][z])\n \n \n gameArray = np.asarray(gameArray)\n gameArray = np.reshape(gameArray, (1,42))\n #print(gameArray)\n np.append(X2, gameArray)\n\n \n \n if checkWin(table,x,True,floor,\"x\") == \"win\":\n goes = goes+1\n finished(table,csvX,goes,X2,floor)\n\n elif checkWin(table,x,True,floor,\"o\") == \"win\":\n table[floor[x]][x] = \"b\"\n return(x)\n else:\n #print(\"norm\")\n #print(a[0][0])\n table[floor[x]][x] = \"b\"\n #scores.append(a[0][0])\n #print(gameArray)\n\n a = trainer(True,X2,-1,Y2,goes,csvX)\n\n for x in a:\n scores.append(x)\n \n #print(scores)\n scores2 = []\n for x in legitimateColumns:\n scores2.append(scores[x])\n scores = scores2\n best = max(scores) \n best_index = scores.index(best)\n col = legitimateColumns[best_index]\n #print(col)\n return(col)\n #floor[humanInput]=floor[humanInput]-1 ","def move(self, row, col, player):\n if self.winning == True:\n return\n self.matrix[row][col] = player\n n = len(self.matrix)\n indicator = True\n for i in range(n):\n if self.matrix[row][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n indicator = True\n for i in range(n):\n if self.matrix[i][col] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n if row == col:\n indicator = True\n for i in range(n):\n if self.matrix[i][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n if row + col == n - 1:\n indicator = True\n for i in range(n):\n if self.matrix[i][n - 1 - i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n return 0","def check_tie(board):\n return 0 not in board[0]","def get_trial_idx_from_win_idx(spikes, col='win_idx'):\n return np.ceil(spikes[col].dropna() / 2).astype(np.int) - 1","def check_for_winner(self, board):\n\n potential_move = (-1, -1)\n\n # Find Potential Three in a Row for Rows\n first_row = [(0, 0), (0, 1), (0, 2)]\n first_row_index = self.can_complete_three_in_row(first_row, board)\n if first_row_index[0] >= 0:\n return first_row[first_row_index[0]]\n elif first_row_index[1] >= 0:\n potential_move = first_row[first_row_index[1]]\n\n second_row = [(1, 0), (1, 1), (1, 2)]\n second_row_index = self.can_complete_three_in_row(second_row, board)\n if second_row_index[0] >= 0:\n return second_row[second_row_index[0]]\n elif second_row_index[1] >= 0:\n potential_move = second_row[second_row_index[1]]\n\n third_row = [(2, 0), (2, 1), (2, 2)]\n third_row_index = self.can_complete_three_in_row(third_row, board)\n if third_row_index[0] >= 0:\n return third_row[third_row_index[0]]\n elif third_row_index[1] >= 0:\n potential_move = third_row[third_row_index[1]]\n\n\n # Find Potential Three in a Row for Columns\n first_column = [(0, 0), (1, 0), (2, 0)]\n first_column_index = self.can_complete_three_in_row(first_column, board)\n if first_column_index[0] >= 0:\n return first_column[first_column_index[0]]\n elif first_column_index[1] >= 0:\n potential_move = first_column[first_column_index[1]]\n\n second_column = [(0, 1), (1, 1), (2, 1)]\n second_column_index = self.can_complete_three_in_row(second_column, board)\n if second_column_index[0] >= 0:\n return second_column[second_column_index[0]]\n elif second_column_index[1] >= 0:\n potential_move = second_column[second_column_index[1]]\n\n third_column = [(0, 2), (1, 2), (2, 2)]\n third_column_index = self.can_complete_three_in_row(third_column, board)\n if third_column_index[0] >= 0:\n return third_column[third_column_index[0]]\n elif third_column_index[1] >= 0:\n potential_move = third_column[third_column_index[1]]\n\n\n # Find Potential Three in a Row for Diagonals\n first_diagonal = [(0, 0), (1, 1), (2, 2)]\n first_diagonal_index = self.can_complete_three_in_row(first_diagonal, board)\n if first_diagonal_index[0] >= 0:\n return first_diagonal[first_diagonal_index[0]]\n elif first_diagonal_index[1] >= 0:\n potential_move = first_diagonal[first_diagonal_index[1]]\n\n second_diagonal = [(2, 0), (1, 1), (0, 2)]\n second_diagonal_index = self.can_complete_three_in_row(second_diagonal, board)\n\n if second_diagonal_index[0] >= 0:\n return second_diagonal[second_diagonal_index[0]]\n elif second_diagonal_index[1] >= 0:\n potential_move = second_diagonal[second_diagonal_index[1]]\n\n return potential_move"],"string":"[\n \"def col_win(board, player):\\n for row in board.T:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def check_columns():\\n global game_still_going\\n # Check if any of the rows have all the same value.\\n column1 = board[0] == board[3] == board[6] != '_'\\n column2 = board[1] == board[4] == board[7] != '_'\\n column3 = board[2] == board[5] == board[8] != '_'\\n # If any column does have a match, then game still going to False.\\n if column1 or column2 or column3:\\n game_still_going = False\\n # Return winner 'X' or 'O'.\\n if column1:\\n return board[0]\\n if column2:\\n return board[1]\\n if column3:\\n return board[2]\",\n \"def win_column(playerid):\\n\\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\\n return (True, \\\"Column 1\\\")\\n\\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\\n return (True, \\\"Column 2\\\")\\n\\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\\n return (True, \\\"Column 3\\\")\\n\\n return False\",\n \"def col_win(board):\\n\\tfor col in range(3):\\n\\t\\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def _check_column(self):\\n for column in np.transpose(self._board):\\n col_string = ''.join(column)\\n match = re.search(WIN_REGEX, col_string)\\n if match:\\n return match.group()[0]\\n return None\",\n \"def search_next_win(self, player):\\n for i, j, k in self.winning_cases:\\n if self.game_board[i] == player and \\\\\\n self.game_board[j] == player and \\\\\\n self.game_board[k] == ' ':\\n return k\\n elif self.game_board[j] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[i] == ' ':\\n return i\\n elif self.game_board[i] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[j] == ' ':\\n return j\\n return None\",\n \"def check_columns():\\n global ongoing_game\\n column_1 = board[0] == board[3] == board[6] != \\\"*\\\"\\n column_2 = board[1] == board[4] == board[7] != \\\"*\\\"\\n column_3 = board[2] == board[5] == board[8] != \\\"*\\\"\\n if column_1 or column_2 or column_3:\\n ongoing_game = False\\n if column_1:\\n return board[0]\\n elif column_2:\\n return board[1]\\n elif column_3:\\n return board[2]\\n else:\\n return None\",\n \"def check_column(self, column, symbol):\\r\\n\\r\\n tally = 0\\r\\n for row in range(3):\\r\\n if self.board[row][column][1] == symbol:\\r\\n tally += 1\\r\\n if tally == 3:\\r\\n self.winner = symbol\",\n \"def test_row_col(board, rows):\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\",\n \"def column_wise_checking(player_):\\n if board[0] == board[3] == player_:\\n return 6\\n elif board[3] == board[6] == player_:\\n return 0\\n elif board[1] == board[4] == player_:\\n return 7\\n elif board[4] == board[7] == player_:\\n return 1\\n elif board[2] == board[5] == player_:\\n return 8\\n elif board[5] == board[8] == player_:\\n return 2\\n else:\\n return -1\",\n \"def column_similarity (self, row, col):\\n my_number = self.board[row][col]\\n \\n for i in range (9):\\n if (i,col) == (row,col):\\n continue\\n elif self.board[i][col] == my_number:\\n return [i, col, False] \\n else:\\n continue\",\n \"def find_column_index(self, columns):\\n for i in range(len(columns)):\\n if self.match(columns[i]):\\n return i\\n return None\",\n \"def check_for_win(self, row, col, player): \\n\\n count = 0\\n for i in range(0, len(self.board[0])):\\n # Check vertical\\n if self.board[row][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n\\n count = 0\\n for i in range(0, len(self.board)):\\n # Check horisontal\\n if self.board[:, col][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n \\n count = 0\\n totoffset = col - row\\n for i in np.diagonal(self.board, offset=totoffset):\\n # Check diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\\n\\n count = 0\\n mirrorboard = np.fliplr(self.board)\\n col = self.colswitch[col]\\n totoffset = col - row\\n for i in np.diagonal(mirrorboard, offset=totoffset):\\n # Check other diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\",\n \"def winner_found(self):\\n\\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\\n winner_in_rows = first_row or second_row or third_row\\n\\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\\n winner_in_columns = first_column or second_column or third_column\\n\\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\\n winner_in_diagonals = first_diagonal or second_diagonal\\n\\n return winner_in_rows or winner_in_columns or winner_in_diagonals\",\n \"def winner(board):\\n columns = []\\n for row in board:\\n xcount = row.count(X)\\n ocount = row.count(O)\\n if xcount == 3:\\n return X\\n if ocount == 3:\\n return O\\n\\n for j in range(len(board)):\\n column = [row[j] for row in board]\\n columns.append(column)\\n \\n for j in columns:\\n xcounter = j.count(X)\\n ocounter = j.count(O)\\n if xcounter == 3:\\n return X\\n if ocounter == 3:\\n return O\\n \\n if board[0][0] == O and board[1][1] == O and board[2][2] == O:\\n return O\\n if board[0][0] == X and board[1][1] == X and board[2][2] == X:\\n return X\\n if board[0][2] == O and board[1][1] == O and board[2][0] == O:\\n return O\\n if board[0][2] == X and board[1][1] == X and board[2][0] == X:\\n return X\\n\\n return None\",\n \"def check_cols(self):\\r\\n for i in range(3):\\r\\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+3][-1] and self.grid[i+3][-1] == self.grid[i+6][-1]:\\r\\n return (i, (self.grid[i], self.grid[i+6]))\\r\\n return (-1, None)\",\n \"def columnWin( self ):\\n\\n for x in list(range(0,3)):\\n firstVal = self.__grid[x]\\n secondVal = self.__grid[x+3]\\n thirdVal = self.__grid[x+6]\\n\\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\\n\\n if compiledVal.lower() == 'xxx':\\n return 'X'\\n\\n elif compiledVal.lower() == 'ooo':\\n return 'O'\\n\\n return None\",\n \"def check_columns(self):\\n\\t\\ti=0\\n\\t\\tfor i in range(len(self.board[i])):\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor j in range(len(self.board)):\\n\\t\\t\\t\\tif self.board[j][i] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('YOU WON')\\n\\t\\t\\t\\treturn True\",\n \"def find_best_move(board):\\n new_board = board.get_board()\\n\\n # X | X | X <-- Check for win on this row\\n # ---------\\n # 3 | 4 | 5\\n # ---------\\n # 6 | 7 | 9\\n if new_board[0] == new_board[1] and new_board[2] == \\\"2\\\":\\n return 2\\n elif new_board[0] == new_board[2] and new_board[1] == \\\"1\\\":\\n return 1\\n elif new_board[1] == new_board[2] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | 2\\n # ---------\\n # X | X | X <-- Check for win on this row\\n # ---------\\n # 6 | 7 | 9\\n elif new_board[3] == new_board[4] and new_board[5] == \\\"5\\\":\\n return 5\\n elif new_board[3] == new_board[5] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[4] == new_board[5] and new_board[3] == \\\"3\\\":\\n return 3\\n\\n # 0 | 1 | 2\\n # ---------\\n # 3 | 4 | 5\\n # ---------\\n # X | X | X <-- Check for win on this row\\n elif new_board[6] == new_board[7] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[6] == new_board[8] and new_board[7] == \\\"7\\\":\\n return 7\\n elif new_board[7] == new_board[8] and new_board[6] == \\\"6\\\":\\n return 6\\n\\n # X | 1 | 2 Check for win on column one\\n # ---------\\n # X | 4 | 5\\n # ---------\\n # X | 7 | 9\\n elif new_board[0] == new_board[3] and new_board[6] == \\\"6\\\":\\n return 6\\n elif new_board[0] == new_board[6] and new_board[3] == \\\"3\\\":\\n return 3\\n elif new_board[6] == new_board[3] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | X | 2 Checks for win on column two\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # 6 | X | 9\\n elif new_board[1] == new_board[4] and new_board[7] == \\\"7\\\":\\n return 7\\n elif new_board[1] == new_board[7] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[7] == new_board[4] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | X\\n # ---------\\n # 3 | 4 | X\\n # ---------\\n # 6 | 7 | X\\n elif new_board[2] == new_board[5] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[2] == new_board[8] and new_board[5] == \\\"5\\\":\\n return 5\\n elif new_board[8] == new_board[5] and new_board[2] == \\\"2\\\":\\n return 2\\n\\n # X | 1 | 2\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # 6 | 7 | X\\n elif new_board[0] == new_board[4] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[0] == new_board[8] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[8] == new_board[4] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | X\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # X | 7 | 9\\n elif new_board[2] == new_board[4] and new_board[6] == \\\"6\\\":\\n return 6\\n elif new_board[2] == new_board[6] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[6] == new_board[4] and new_board[2] == \\\"2\\\":\\n return 2\\n\\n # If corners are empty, play there\\n elif new_board[0] == \\\"0\\\" or new_board[2] == \\\"2\\\" or new_board[6] == \\\"6\\\" or new_board[8] == \\\"8\\\":\\n try_spot = 0\\n while True:\\n if new_board[try_spot] != \\\"X\\\" and new_board[try_spot] != \\\"O\\\":\\n return try_spot\\n else:\\n try_spot = try_spot + 2\\n\\n # If middle is empty, play there\\n elif new_board[4] == \\\"4\\\":\\n return 4\\n\\n # Finally if edges are empty try there\\n elif new_board[1] == \\\"1\\\" or new_board[3] == \\\"3\\\" or new_board[5] == \\\"5\\\" or new_board[7] == \\\"7\\\":\\n try_spot = 1\\n while True:\\n if new_board[try_spot] != \\\"X\\\" and new_board[try_spot] != \\\"O\\\":\\n return try_spot\\n else:\\n try_spot = try_spot + 2\",\n \"def check_for_win_lose(b):\\r\\n win_move = None\\r\\n block_win = None\\r\\n # check for wins based on row\\r\\n for ri in range(3):\\r\\n row = b[ri]\\r\\n if single_move(row):\\r\\n if row==[1,1,0]:\\r\\n win_move = (ri+1,3)\\r\\n elif row==[2,2,0]:\\r\\n block_win = (ri+1,3)\\r\\n elif row==[1,0,1]:\\r\\n win_move = (ri+1,2)\\r\\n elif row==[2,0,2]:\\r\\n block_win = (ri+1,2)\\r\\n elif row==[0,1,1]:\\r\\n win_move = (ri+1,1)\\r\\n elif row==[0,2,2]:\\r\\n block_win = (ri+1,1)\\r\\n else:\\r\\n print '144 ERROR!'\\r\\n print single_move(row)\\r\\n print row\\r\\n print ' '\\r\\n\\r\\n # check for win based on column\\r\\n for ci in range(3):\\r\\n col = get_col(b,ci)\\r\\n if single_move(col):\\r\\n if col==[1,1,0]:\\r\\n win_move = (3,ci+1)\\r\\n elif col==[2,2,0]:\\r\\n block_win = (3,ci+1)\\r\\n elif col==[1,0,1]:\\r\\n win_move = (2,ci+1)\\r\\n elif col==[2,0,2]:\\r\\n block_win = (2,ci+1)\\r\\n elif col==[0,1,1]:\\r\\n win_move = (1,ci+1)\\r\\n elif col==[0,2,2]:\\r\\n block_win = (1,ci+1)\\r\\n else:\\r\\n print '166 ERROR!'\\r\\n print single_move(col)\\r\\n print col\\r\\n print ' '\\r\\n\\r\\n # check for win on backward diagonal\\r\\n diag = get_bw_diag(b)\\r\\n if single_move(diag):\\r\\n if diag==[1,1,0]:\\r\\n win_move = (3,3)\\r\\n elif diag==[2,2,0]:\\r\\n block_win (3,3)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,1)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,1)\\r\\n \\r\\n # check for win on forward diagonal\\r\\n diag = get_fwd_diag(b)\\r\\n if single_move(diag):\\r\\n if diag == [1,1,0]:\\r\\n win_move = (3,1)\\r\\n elif diag==[2,2,0]:\\r\\n block_win = (3,1)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,3)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,3)\\r\\n\\r\\n if win_move is not None:\\r\\n return (win_move, True)\\r\\n elif block_win is not None:\\r\\n return (block_win, False)\\r\\n else:\\r\\n return (None, False)\",\n \"def searchcols(self,fctn,cols,*args):\\n goodkeys=[]\\n for key in self.allrowkeys:\\n temp=[]\\n for c in cols:\\n temp.append(self.getentry(key,c))\\n for i in range(len(args)):\\n temp.append(args[i])\\n\\n if fctn(*tuple(temp)):\\n goodkeys.append(key)\\n return(goodkeys)\",\n \"def look_through_rows(board, column, player):\\n if board.shape[1] > column:\\n count = board.shape[0] - 1\\n count2 = 1\\n while count >= 0 and count2 == 1:\\n if board[count,column] == 0:\\n board[count,column] = player\\n count2 = count2 - 1\\n else:\\n count = count - 1\\n return board\\n else:\\n print('Improper Column Given')\",\n \"def check_rows(self, win: list) -> bool:\\r\\n for row in self.tags:\\r\\n for j in range(len(row) - len(win) + 1):\\r\\n if win == row[j:j+self.win_condition]:\\r\\n return True\",\n \"def check_col(sudoku):\\r\\n for col in range(9):\\r\\n for row in range(8):\\r\\n test = sudoku[row][col]\\r\\n for i in range(row+1,9):\\r\\n if sudoku[i][col] == test:\\r\\n return True #returns True is there is more than two of the same numbers in a column\\r\",\n \"def check_diag(self, row, column, symbol):\\r\\n\\r\\n # get the current state of buttons..\\r\\n # tl -> top left; mm -> middle middle; etc...\\r\\n tl = self.board[0][0][1]\\r\\n mm = self.board[1][1][1]\\r\\n br = self.board[2][2][1]\\r\\n bl = self.board[0][2][1]\\r\\n tr = self.board[0][2][1]\\r\\n\\r\\n # we know if mm isn't on then we can return early\\r\\n if mm == symbol:\\r\\n if tl == symbol and br == symbol:\\r\\n self.winner = symbol\\r\\n return\\r\\n if tr == symbol and bl == symbol:\\r\\n self.winner = symbol\\r\\n return\\r\\n else:\\r\\n return\\r\\n else:\\r\\n return\",\n \"def check_winner(self):\\n for row in self.board.values():\\n if all([mark == \\\"x\\\" for mark in row]):\\n return self.player_1\\n elif all([mark == \\\"o\\\" for mark in row]):\\n return self.player_2\\n\\n # checks every column\\n for i in range(3):\\n first_row, second_row, third_row = self.board.values()\\n if first_row[i] == \\\"x\\\" and second_row[i] == \\\"x\\\" and third_row[i] == \\\"x\\\":\\n return self.player_1\\n elif first_row[i] == \\\"o\\\" and second_row[i] == \\\"o\\\" and third_row[i] == \\\"o\\\":\\n return self.player_2\\n\\n # checks the diagonals\\n if self.board[\\\"a\\\"][0] == \\\"x\\\" and self.board[\\\"b\\\"][1] == \\\"x\\\" and self.board[\\\"c\\\"][2] == \\\"x\\\":\\n return self.player_1\\n if self.board[\\\"a\\\"][2] == \\\"o\\\" and self.board[\\\"b\\\"][1] == \\\"o\\\" and self.board[\\\"c\\\"][0] == \\\"o\\\":\\n return self.player_2\\n\\n return None\",\n \"def winner(board):\\n x_in_board = []\\n o_in_board = []\\n winning_positions = [\\n [[0, 0], [0, 1], [0, 2]],\\n [[1, 0], [1, 1], [1, 2]],\\n [[2, 0], [2, 1], [2, 2]],\\n [[0, 0], [1, 0], [2, 0]],\\n [[0, 1], [1, 1], [2, 1]],\\n [[0, 2], [1, 2], [2, 2]],\\n [[0, 0], [1, 1], [2, 2]],\\n [[0, 2], [1, 1], [2, 0]]\\n ]\\n\\n for i in range(len(board)):\\n for j in range(len(board)):\\n if board[i][j] == X:\\n x_in_board.append([i, j])\\n elif board[i][j] == O:\\n o_in_board.append([i, j])\\n\\n for i in winning_positions:\\n if i[0] in x_in_board and i[1] in x_in_board and i[2] in x_in_board:\\n return X\\n elif i[0] in o_in_board and i[1] in o_in_board and i[2] in o_in_board:\\n return O\\n\\n return None\",\n \"def row_win(board):\\n\\tfor row in range(3):\\n\\t\\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def player(board):\\n X_count = 0\\n O_count = 0\\n\\n for row in board:\\n X_count += row.count(X)\\n O_count += row.count(O)\\n\\n if X_count <= O_count:\\n return X\\n else:\\n return O\",\n \"def winner(board):\\n # Hard code winning moves\\n # row0\\n if board[0][0] == board[0][1] == board[0][2] == X:\\n return X\\n elif board[0][0] == board[0][1] == board[0][2] == O:\\n return O\\n # row1\\n elif board[1][0] == board[1][1] == board[1][2] == X:\\n return X\\n elif board[1][0] == board[1][1] == board[1][2] == O:\\n return O\\n # row2\\n elif board[2][0] == board[2][1] == board[2][2] == X:\\n return X\\n elif board[2][0] == board[2][1] == board[2][2] == O:\\n return O\\n # col0\\n elif board[0][0] == board[1][0] == board[2][0] == X:\\n return X\\n elif board[0][0] == board[1][0] == board[2][0] == O:\\n return O\\n # col1\\n elif board[0][1] == board[1][1] == board[2][1] == X:\\n return X\\n elif board[0][1] == board[1][1] == board[2][1] == O:\\n return O\\n # col2\\n elif board[0][2] == board[1][2] == board[2][2] == X:\\n return X\\n elif board[0][2] == board[1][2] == board[2][2] == O:\\n return O\\n # diagonal\\n elif board[0][0] == board[1][1] == board[2][2] == X:\\n return X\\n elif board[0][0] == board[1][1] == board[2][2] == O:\\n return O\\n # inverse diagonal\\n elif board[0][2] == board[1][1] == board[2][0] == X:\\n return X\\n elif board[0][2] == board[1][1] == board[2][0] == O:\\n return O\\n\\n return None\",\n \"def isSolved(board):\\n for player in [1, 2]:\\n if [player]*3 in chain(\\n board, # Rows\\n zip(board), # Columns\\n [ # Diagonals\\n [board[i][i] for i in range(len(board))],\\n [board[len(board) - i - 1][i] for i in range(len(board))]\\n ]\\n ):\\n return player\\n return -1 if 0 in chain(*board) else 0\",\n \"def check_rows():\\n global game_still_going\\n # Check if any of the rows have all the same value.\\n row1 = board[0] == board[1] == board[2] != '_'\\n row2 = board[3] == board[4] == board[5] != '_'\\n row3 = board[6] == board[7] == board[8] != '_'\\n # If any row does have a match, then game still going to False.\\n if row1 or row2 or row3:\\n game_still_going = False\\n # Return winner 'X' or 'O'.\\n if row1:\\n return board[0]\\n if row2:\\n return board[3]\\n if row3:\\n return board[6]\",\n \"def search_possible_steps(self):\\n if self.ended:\\n return False\\n possible_steps_turple = (self.board == 0)\\n possible_steps = np.transpose(possible_steps_turple.nonzero())\\n return possible_steps\",\n \"def winner(board):\\n \\n possible_wins = []\\n row1 = board[0]\\n row2 = board[1]\\n row3 = board[2]\\n col1 = [board[0][0],board[1][0],board[2][0]]\\n col2 = [board[0][1],board[1][1],board[2][1]]\\n col3 = [board[0][2],board[1][2],board[2][2]]\\n diag1 = [board[0][0],board[1][1],board[2][2]]\\n diag2 = [board[2][0],board[1][1],board[0][2]]\\n \\n possible_wins.append(row1)\\n possible_wins.append(row2)\\n possible_wins.append(row3)\\n possible_wins.append(col1)\\n possible_wins.append(col2)\\n possible_wins.append(col3)\\n possible_wins.append(diag1)\\n possible_wins.append(diag2)\\n \\n for trait in possible_wins:\\n if trait.count(\\\"X\\\") == 3:\\n return \\\"X\\\"\\n elif trait.count(\\\"O\\\") == 3:\\n return \\\"O\\\"\\n \\n return None\",\n \"def checkwin(self):\\n w = self.getWidth()\\n h = self.getHeight()\\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\\n for r in range(h):\\n for c in range(w):\\n if self.cell[c][r] == EMPTY:\\n continue # this cell can't be part of winning segment\\n # if we reach this point, the cell is occupied by a player stone\\n numOccupiedCell = numOccupiedCell+1\\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\\n for i in range(NWIN):\\n # test if there exists a segment of NWIN uniformly coloured cells\\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\\n break # segment broken\\n else:\\n # Python remark: notice that the else is attached to the for loop \\\"for i...\\\"\\n # This block is executed if and only if 'i' arrives at the end of its range \\n return self.cell[c][r] , True # found a winning segment \\n return EMPTY, numOccupiedCell==w*h\",\n \"def evaluate(board):\\n winner = 0\\n for player in [1, 2]:\\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\\n winner = player\\n \\n if np.all(board != 0) and winner == 0:\\n winner = -1\\n return winner\",\n \"def check_winner(self, row, column, symbol):\\r\\n self.check_row(row, symbol)\\r\\n self.check_column(column, symbol)\\r\\n self.check_diag(row, column, symbol)\",\n \"def find_column(self, columns):\\n for column in columns:\\n if self.match(column):\\n return column\\n return None\",\n \"def row_wise_checking(player_):\\n if board[0] == board[1] == player_:\\n return 2\\n elif board[1] == board[2] == player_:\\n return 0\\n elif board[3] == board[4] == player_:\\n return 5\\n elif board[4] == board[5] == player_:\\n return 3\\n elif board[6] == board[7] == player_:\\n return 8\\n elif board[7] == board[8] == player_:\\n return 6\\n else:\\n return -1\",\n \"def TestColumn(SudokuGrid):\\r\\n for i in range(9):\\r\\n for j in range(8):\\r\\n for k in range(j+1,9):\\r\\n if SudokuGrid[j][i]==SudokuGrid[k][i]:\\r\\n return False\\r\\n return True\",\n \"def winner(board):\\n \\n for m in [\\\"XXX\\\", \\\"OOO\\\"]:\\n # horizontal\\n for row in range(3):\\n if board[row][0] == board[row][1] == board[row][2]:\\n return board[row][0]\\n # vertical\\n for col in range(3):\\n if board[0][col] == board[1][col] == board[2][col]:\\n return board[0][col]\\n # diagonal\\n if board[0][0] == board[1][1] == board[2][2]:\\n return board[1][1]\\n if board[0][2] == board[1][1] == board[2][0]:\\n return board[1][1]\\n return None\",\n \"def check_rows(self):\\r\\n for i in range(0, len(self.grid),3):\\r\\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+1][-1] and self.grid[i+1][-1] == self.grid[i+2][-1]:\\r\\n return (i, (self.grid[i], self.grid[i+2]))\\r\\n return (-1, None)\",\n \"def check_rows():\\n global ongoing_game\\n row_1 = board[0] == board[1] == board[2] != \\\"*\\\"\\n row_2 = board[3] == board[4] == board[5] != \\\"*\\\"\\n row_3 = board[6] == board[7] == board[8] != \\\"*\\\"\\n if row_1 or row_2 or row_3:\\n ongoing_game = False\\n if row_1:\\n return board[0]\\n elif row_2:\\n return board[3]\\n elif row_3:\\n return board[6]\\n else:\\n return None\",\n \"def _col_match(sheet, row, value):\\r\\n for cell in sheet[row]:\\r\\n if cell.value == value:\\r\\n return cell.column\",\n \"def won(self):\\n for y in range(self.size):\\n winning = []\\n for x in range(self.size):\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n for x in range(self.size):\\n winning = []\\n for y in range(self.size):\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n winning = []\\n for y in range(self.size):\\n x = y\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n winning = []\\n for y in range(self.size):\\n x = self.size-1-y\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n return None\",\n \"def winner(board):\\n chances = [X, O]\\n for chance in chances:\\n for row in range(3):\\n if list(chance)*3 == board[row]:\\n return chance\\n for column in range(3):\\n if [[chance] for i in range(3)] == [[board[row][column]] for row in range(3)]:\\n return chance\\n if board[0][0] == chance and board[1][1] == chance and board[2][2] == chance:\\n return chance\\n if board[0][2] == chance and board[1][1] == chance and board[2][0] == chance:\\n return chance\\n return None\",\n \"def winner(board):\\n for i in (O, X):\\n for j in range(3):\\n if (board[j][0] == i and board[j][1] == i and board[j][2] == i):\\n return i\\n if (board[0][j] == i and board[1][j] == i and board[2][j] == i):\\n return i\\n if (board[0][0] == i and board[1][1] == i and board[2][2] == i):\\n return i\\n if (board[2][0] == i and board[1][1] == i and board[0][2] == i):\\n return i\\n return None\",\n \"def check(self):\\n winner = None\\n count = 0\\n\\n for y in range(self.gridSize):\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for item in self.grid[y]:\\n # Check row of the grid\\n if item == \\\"P1\\\":\\n P1 += 1\\n elif item == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for x in range(self.gridSize):\\n # Check column of the grid\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check right top to left bottom across the grid\\n for x in range(self.gridSize):\\n if x == y:\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check the left top to the right bottom across the grid\\n for x in range(self.gridSize - 1, -1, -1):\\n # Check how many filled spaces there are\\n if \\\".\\\" not in self.grid[y][x]:\\n count += 1\\n if x + y == self.gridSize - 1:\\n if self.grid[y][x] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[y][x] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n # Check if there is a winner if so return the winner\\n if winner != None:\\n return winner\\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\\n if count == self.gridSize**2:\\n return \\\"Tie\\\"\",\n \"def row_win(board, player):\\n for row in board:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def win(board):\\n # COLUMNS\\n if board[7] == board[4] == board[1] != ' ': # first column down\\n return board[7]\\n elif board[8] == board[5] == board[2] != ' ': # second column down\\n return board[8]\\n elif board[9] == board[6] == board[3] != ' ': # third column down\\n return board[9]\\n\\n # ROWS\\n if board[7] == board[8] == board[9] != ' ': # first row across\\n return board[7]\\n elif board[4] == board[5] == board[6] != ' ': # second row across\\n return board[4]\\n elif board[1] == board[2] == board[3] != ' ': # third row across\\n return board[1]\\n\\n # DIAGONALS\\n if board[7] == board[5] == board[3] != ' ': # diagonal staring on left\\n return board[7]\\n elif board[9] == board[5] == board[1] != ' ': # diagonal starting on right\\n return board[9]\\n\\n # else no winner\\n return \\\"No\\\"\",\n \"def check_win(self):\\n win = None\\n for pos in self.winning_pos:\\n win = self.is_match(set(self.get_cells(pos)))\\n if win:\\n return win\\n if not self.open_tiles():\\n return \\\"Draw\\\"\\n return win\",\n \"def win_check(table: list) -> (bool, str):\\n # Combinations that would lead to a win\\n win_list = [\\n [0,1,2], [3,4,5],\\n [6,7,8], [0,3,6],\\n [1,4,7], [2,5,8],\\n [0,4,8], [6,4,2],\\n ]\\n for line in win_list:\\n # Check rows, columns, and diagonals\\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\\n\\n if len(combination) == 1 and combination != {\\\"-\\\"}: # Which mean we have a straight line of either X or O\\n #unpack comb (which is 1 item), which is either \\\"X\\\" or \\\"O\\\" to know who won\\n return True, *combination\\n else:\\n return False, None\",\n \"def _check_row(self):\\n match = None\\n for row in self._board:\\n row_string = ''.join(row)\\n match = re.search(WIN_REGEX, row_string)\\n if match:\\n return match.group()[0]\\n return None\",\n \"def win_check(board, mark):\\n win_positions = [\\\"123\\\", \\\"456\\\", \\\"789\\\", \\\"147\\\", \\\"258\\\", \\\"369\\\", \\\"159\\\", \\\"357\\\"]\\n is_winner = False\\n for positions in win_positions:\\n for idx in positions:\\n idx = int(idx)\\n if board[idx] != mark:\\n break\\n else:\\n is_winner = True\\n\\n return is_winner\",\n \"def any_possible_moves(grid):\\n if get_empty_cells(grid):\\n return True\\n for row in grid:\\n if any(row[i]==row[i+1] for i in range(len(row)-1)):\\n return True\\n for i,val in enumerate(grid[0]):\\n column = get_column(grid, i)\\n if any(column[i]==column[i+1] for i in range(len(column)-1)):\\n return True\\n return False\",\n \"def winner(board):\\r\\n\\r\\n #rows:\\r\\n if (board[0][0] == board[0][1] == board[0][2]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[1][0] == board[1][1] == board[1][2]) and (board[1][0] == \\\"X\\\" or board[1][0] == \\\"O\\\"):\\r\\n return board[1][0]\\r\\n if (board[2][0] == board[2][1] == board[2][2]) and (board[2][0] == \\\"X\\\" or board[2][0] == \\\"O\\\"):\\r\\n return board[2][0]\\r\\n\\r\\n #columns\\r\\n if (board[0][0] == board[1][0] == board[2][0]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[0][1] == board[1][1] == board[2][1]) and (board[0][1] == \\\"X\\\" or board[0][1] == \\\"O\\\"):\\r\\n return board[0][1]\\r\\n if (board[0][2] == board[1][2] == board[2][2]) and (board[0][2] == \\\"X\\\" or board[0][2] == \\\"O\\\"):\\r\\n return board[0][2]\\r\\n\\r\\n #diagonals\\r\\n if (board[0][0] == board[1][1] == board[2][2]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[0][2] == board[1][1] == board[2][0]) and (board[0][2] == \\\"X\\\" or board[0][2] == \\\"O\\\"):\\r\\n return board[0][2]\\r\\n \\r\\n return None\\r\\n\\r\\n raise NotImplementedError\",\n \"def winner(board) -> any:\\n numeric_board = [[0, 0, 0],\\n [0, 0, 0],\\n [0, 0, 0]]\\n\\n total_horizon = [0, 0, 0]\\n total_vertical = [0, 0, 0]\\n total_diagonally = [0, 0]\\n for i, row in enumerate(board):\\n for j, column in enumerate(row):\\n if column == X:\\n numeric_board[i][j] = 1\\n total_horizon[i] += 1\\n total_vertical[j] += 1\\n elif column == O:\\n numeric_board[i][j] = -1\\n total_horizon[i] += -1\\n total_vertical[j] += -1\\n\\n n = len(numeric_board)\\n total_diagonally[0] = sum(numeric_board[i][i] for i in range(n))\\n total_diagonally[1] = sum(numeric_board[i][n - i - 1] for i in range(n))\\n\\n if 3 in total_horizon or 3 in total_vertical or 3 in total_diagonally:\\n return X\\n elif -3 in total_horizon or -3 in total_vertical or -3 in total_diagonally:\\n return O\\n else:\\n return None\",\n \"def check_for_win(self,board, player_id, action):\\n\\n row = 0\\n\\n # check which row was inserted last:\\n for i in range(ROWS):\\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\\n row = ROWS - i\\n break\\n\\n # check horizontal:\\n vec = board[row, :] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check vertical:\\n vec = board[:, action] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check diagonals:\\n vec = np.diagonal(board, action - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n return False\",\n \"def _check_won(field, col, delta_row):\\n player = field[col][-1]\\n coord = len(field[col]) - 1\\n total = 1\\n # negative dir\\n cur_coord = coord - delta_row\\n for c in range(col - 1, -1, -1):\\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\\n break\\n if field[c][cur_coord] != player:\\n break\\n total += 1\\n if total == COUNT_TO_WIN:\\n return True\\n cur_coord -= delta_row\\n # positive dir\\n cur_coord = coord + delta_row\\n for c in range(col + 1, GAME_COLS):\\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\\n break\\n if field[c][cur_coord] != player:\\n break\\n total += 1\\n if total == COUNT_TO_WIN:\\n return True\\n cur_coord += delta_row\\n return False\",\n \"def winner(board):\\n for i in range(3):\\n if board[i][0] == board[i][1] == board[i][2] != None:\\n return board[i][0]\\n for i in range(3):\\n if board[0][i] == board[1][i] == board[2][i] != None:\\n return board[0][i]\\n if board[0][0] == board[1][1] == board[2][2]:\\n return board[0][0]\\n if board[0][2] == board[1][1] == board[2][0]:\\n return board[0][2]\\n return None\",\n \"def player(board):\\n number_of_X = 0\\n number_of_O = 0\\n \\n for row in board: \\n number_of_X += row.count(\\\"X\\\")\\n number_of_O += row.count(\\\"O\\\")\\n \\n \\n if number_of_X <= number_of_O:\\n return(\\\"X\\\") \\n else: \\n return(\\\"O\\\")\",\n \"def getWinner(board):\\n players = [X, O]\\n num_symbols_in_line = 3\\n for player in players:\\n # check rows\\n for row in board:\\n line_count = row.count(player)\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check columns\\n for col_i in range(len(board[0])):\\n line_count = 0\\n for row_i in range(len(board)):\\n if board[row_i][col_i] == player:\\n line_count += 1\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check vertical from top left to bottom right\\n line_count = 0\\n for vert_cell in range(len(board)):\\n if board[vert_cell][vert_cell] == player:\\n line_count += 1\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check vertical from top right to bottom left\\n line_count = 0\\n col_i = len(board) - 1\\n for row_i in range(len(board)):\\n if board[row_i][col_i] == player:\\n line_count += 1\\n col_i -= 1\\n if line_count == num_symbols_in_line:\\n return player\\n\\n return None\",\n \"def get_winner(board):\\n\\n def who_won(in_a_row, board_size, cur_player):\\n \\\"\\\"\\\" \\n a function private to get_winner() (yes you can do this. Cool huh!?) \\n that tells get_winner if it has a winner \\n \\\"\\\"\\\"\\n if in_a_row == board_size:\\n return 1 if cur_player == 'X' else 2\\n else:\\n return 0\\n\\n def test_row_col(board, rows):\\n \\\"\\\"\\\" private function to test the rows and columns \\\"\\\"\\\"\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n def test_diagonal(board, normal):\\n \\\"\\\"\\\" private function to test the two diagonals \\\"\\\"\\\"\\n cur_player = board[0][0] if normal else board[0][len(board)-1]\\n in_a_row = 0\\n for i in range(len(board)):\\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1 \\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n\\n # test rows\\n winner = test_row_col(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test cols\\n winner = test_row_col(board, False)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top left to bottom right\\n winner = test_diagonal(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top right to bottom left\\n winner = test_diagonal(board, False)\\n if not winner == 0:\\n return winner\\n\\n return 0\",\n \"def winner(board):\\n for turn in [X,O]:\\n for i in range(3):\\n if board[i] == [turn, turn, turn]:\\n return turn\\n if board[0][i] == turn and board[1][i] == turn and board[2][i] == turn:\\n return turn\\n if board[0][0] == turn and board[1][1] == turn and board[2][2] == turn:\\n return turn\\n if board[0][2] == turn and board[1][1] == turn and board[2][0] == turn:\\n return turn\\n return None\",\n \"def rowWin( self ):\\n\\n for x in [0,3,6]:\\n firstVal = self.__grid[x]\\n secondVal = self.__grid[x+1]\\n thirdVal = self.__grid[x+2]\\n\\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\\n\\n if compiledVal.lower() == 'xxx':\\n return 'X'\\n\\n elif compiledVal.lower() == 'ooo':\\n return 'O' \\n \\n return None\",\n \"def find_twice_in_row_cols(row,item):\\n results = [item]\\n for i in range(9):\\n if item in row[i]:\\n results.append(i)\\n return results\",\n \"def col_match(sent1, sent2):\\n\\n for i in range(len(sent1)):\\n if sent1[i] != sent2[i]:\\n return i\",\n \"def winning_move(board, position, player):\\n win = list(player*3)\\n if get_row(board, position) == win:\\n return True\\n elif get_column(board, position) == win:\\n return True\\n elif position % 2 != 0:\\n # odd positions are on the diagonals\\n return get_diagonal(board, 1) == win or get_diagonal(board, 3) == win\\n return False\",\n \"def winner(b):\\n # Row of three\\n for row in b:\\n if row[0] == \\\" \\\":\\n # First row entry is blank; ignore!\\n continue\\n if row[0]==row[1] and row[1]==row[2]:\\n return row[0]\\n # Column of three\\n for i in range(3):\\n if b[0][i] == \\\" \\\":\\n # First column entry is blank; ignore!\\n continue\\n if b[0][i]==b[1][i] and b[1][i]==b[2][i]:\\n return b[0][i]\\n # Diagonals\\n if b[1][1] != \\\" \\\":\\n # Middle entry not blank, so diagonal win \\n # is a possibility.\\n if b[0][0] == b[1][1] and b[1][1]==b[2][2]:\\n return b[0][0]\\n if b[0][2] == b[1][1] and b[1][1]==b[2][0]:\\n return b[0][2]\\n # implicit return None\",\n \"def check_win(self):\\n lines = []\\n\\n # rows\\n lines.extend(self._board)\\n\\n # cols\\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\\n for colidx in range(self._dim)]\\n lines.extend(cols)\\n\\n # diags\\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\\n diag2 = [self._board[idx][self._dim - idx -1]\\n for idx in range(self._dim)]\\n lines.append(diag1)\\n lines.append(diag2)\\n\\n # check all lines\\n for line in lines:\\n if len(set(line)) == 1 and line[0] != EMPTY:\\n if self._reverse:\\n return switch_player(line[0])\\n else:\\n return line[0]\\n\\n # no winner, check for draw\\n if len(self.get_empty_squares()) == 0:\\n return DRAW\\n\\n # game is still in progress\\n return None\",\n \"def player(board):\\n\\n # Game is over\\n if terminal(board):\\n return None\\n\\n # Count number of occurences of X and O\\n x_count = 0\\n o_count = 0\\n for row in board:\\n for box in row:\\n if box == X:\\n x_count = x_count + 1\\n elif box == O:\\n o_count = o_count + 1\\n # When move count is tied, X is next\\n if x_count <= o_count:\\n return X\\n # When X has moved once more than O, next move is O\\n else:\\n return O\",\n \"def check_row(self, row, symbol):\\r\\n\\r\\n tally = 0\\r\\n for column in range(3):\\r\\n if self.board[row][column][1] == symbol:\\r\\n tally += 1\\r\\n if tally == 3:\\r\\n self.winner = symbol\",\n \"def check_winner(self):\\n if self.history:\\n last_move = self.history[-1]\\n last_player = self.get_last_player()\\n\\n connected_token = last_player*self.n_in_row\\n # check for row\\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for column\\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope 1\\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope -1\\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for draw game\\n if len(np.argwhere(self.state==0)) == 0:\\n self.winner = [True, 0]\\n return self.winner\\n return self.winner\",\n \"def same_row_col(self, num, squ):\\n found = [pos for pos in squ if num in self.possibles[pos[0]][pos[1]]]\\n if found:\\n row = found[0][0]\\n col = found[0][1]\\n all_same_row = all(pos[0] == row for pos in found)\\n all_same_col = all(pos[1] == col for pos in found)\\n if all_same_row ^ all_same_col:\\n return all_same_row, all_same_col, found\\n return [], [], []\",\n \"def move(self, row, col, player):\\n score = 1 if player == 1 else -1\\n self.rows[row] += score\\n self.cols[col] += score\\n if row == col:\\n self.diagonal1 += score\\n if row + col == self.n - 1:\\n self.diagonal2 += score\\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\\n if self.n in win or -self.n in win:\\n return player\\n return 0\",\n \"def check_game_status(self):\\n for player in (\\\"1\\\", \\\"2\\\"):\\n row_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 1, self.board\\n ).any()\\n col_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 0, self.board\\n ).any()\\n d1_win = set(self.data[[0, 4, 8]]) == {player}\\n d2_win = set(self.data[[2, 4, 6]]) == {player}\\n if any([row_win, col_win, d1_win, d2_win]):\\n return (\\\"win\\\", player)\\n\\n if self.counter[\\\"_\\\"] == 0:\\n return (\\\"tie\\\", None)\\n else:\\n return (\\\"turn\\\", \\\"1\\\" if self.counter[\\\"1\\\"] == self.counter[\\\"2\\\"] else \\\"2\\\")\",\n \"def check_bingo_board(board_num):\\n winning_board = False\\n for i in range(BINGO_SIZE):\\n if bingoboards[board_num][i].count(\\\"X\\\") == 5:\\n winning_board = board_num\\n for j in range(BINGO_SIZE):\\n col = list(map(lambda x: x[j], bingoboards[board_num]))\\n if col.count(\\\"X\\\") == 5:\\n winning_board = board_num\\n return winning_board\",\n \"def any_possible_moves(grid):\\n\\tif get_empty_cells(grid):\\n\\t\\treturn True\\n\\tfor row in grid:\\n\\t\\tif any(row[i]==row[i+1] for i in range(len(row)-1)):\\n\\t\\t\\treturn True\\n\\tfor i,val in enumerate(grid[0]):\\n\\t\\tcolumn = get_column(grid, i)\\n\\t\\tif any(column[i]==column[i+1] for i in range(len(column)-1)):\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\\n num_connected = 1 # Tally of how many game pieces were found matching thus far\\n\\n def increment_connected(step_row, step_col):\\n \\\"\\\"\\\"\\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\\n :param step_row: The amount to move in the Y direction\\n :param step_col: The amount to move in the X direction\\n :return: The number of adjacent matching tiles found by the function\\n \\\"\\\"\\\"\\n connected = 0\\n current_row = row + step_row\\n current_col = col + step_col\\n\\n while self.board[current_row][current_col] == player_symbol:\\n connected += 1\\n current_row += step_row\\n current_col += step_col\\n\\n return connected\\n\\n num_connected += increment_connected(step_row_1, step_col_1)\\n num_connected += increment_connected(step_row_2, step_col_2)\\n\\n if num_connected >= 4:\\n self.game_over = True\",\n \"def findOverlap( columns, t, minOverlap ):\\n for c in columns:\\n c.setOverlap() # defaults to 0.0\\n for s in c.getConnectedSynapses():\\n c.setOverlap( c.getOverlap() + s.getSourcetInput( t ) )\\n\\n if c.getOverlap() < minOverlap:\\n c.setOverlap()\\n else:\\n c.boostOverlap()\",\n \"def winner(board):\\n # Checking for 3 in a row\\n for row in board:\\n if row[0] is not EMPTY and row[0] == row[1] == row[2]:\\n return row[0]\\n\\n # Checking for 3 in a col\\n for col in range(len(board)):\\n if board[0][col] is not EMPTY and board[0][col] == board[1][col] == board[2][col]:\\n return board[0][col]\\n\\n # Checking for Diagonals\\n if board[0][0] is not EMPTY and board[0][0] == board[1][1] == board[2][2]:\\n return board[0][0]\\n \\n if board[0][2] is not EMPTY and board[0][2] == board[2][0] == board[1][1]:\\n return board[0][2]\\n\\n return None\",\n \"def human_go(self, board):\\r\\n coord_pattern = re.compile(\\\"[0-{}]$\\\".format(board.shape[1]))\\r\\n print(\\\"Enter Column and press enter.\\\")\\r\\n input_str = input(\\\"(from 0-6)\\\\n\\\")\\r\\n if not coord_pattern.match(input_str):\\r\\n print(\\\"That is not in the right format, please try again...\\\")\\r\\n return self.human_go(board)\\r\\n else:\\r\\n col = int(input_str)\\r\\n if board[0][col] != 0:\\r\\n print(\\\"That column is already full, please try again\\\")\\r\\n self.human_go()\\r\\n else:\\r\\n for row in board[::-1]:\\r\\n if row[col] == 0:\\r\\n row[col] = -1\\r\\n return board\",\n \"def check_for_win(self, index):\\n\\n\\t\\tpossible_comb = self.cell_combinations[index]\\n\\n\\t\\tfor comb in possible_comb:\\n\\n\\t\\t\\ttokens = []\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[0]].token)\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[1]].token)\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[2]].token)\\n\\n\\t\\t\\tif all([token == self.player_model.current_player.token for token in tokens]):\\n\\n\\t\\t\\t\\treturn True\\n\\n\\t\\treturn False\",\n \"def winner(board):\\n for row in range(len(board)):\\n if board[row].count(X) == 3:\\n return X\\n elif board[row].count(O) == 3:\\n return O\\n for column in range(len(board[row])):\\n if board[0][column] == X and board[1][column] == X and board[2][column] == X:\\n return X\\n elif board[0][column] == O and board[1][column] == O and board[2][column] == O:\\n return O\\n\\n if (board[0][0] == X and board[1][1] ==X and board[2][2] ==X) or (board[0][2] == X and board[1][1]==X and board[2][0] ==X):\\n return X\\n\\n elif (board[0][0] == O and board[1][1] == O and board[2][2] == O) or (board[0][2] == O and board[1][1]== O and board[2][0] ==O):\\n return O\\n\\n else: return None\\n\\n\\n\\n # raise NotImplementedError\",\n \"def winner(board):\\n # Check Rows\\n for row in board:\\n if row[0] != EMPTY and row[0] == row[1] and row[0] == row[2]:\\n return row[0]\\n \\n # Check Columns\\n for j in range(3):\\n if board[0][j] != EMPTY and board[0][j] == board[1][j]:\\n if board[0][j] == board[2][j]:\\n return board[0][j]\\n \\n # Check Diagonals\\n if board[1][1] != EMPTY:\\n if board[0][0] == board[1][1] and board[0][0] == board[2][2]:\\n return board[0][0]\\n if board[0][2] == board[1][1] and board[0][2] == board[2][0]:\\n return board[0][2]\\n\\n return None\",\n \"def win_game(self):\\n\\n def horizontal_win():\\n \\\"\\\"\\\"Return whether there is horizontal win\\\"\\\"\\\"\\n\\n for i in range(0, board_size):\\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\\n print \\\"horizontal win\\\"\\n return True\\n\\n def vertical_win():\\n \\\"\\\"\\\"Return whether there is vertical win\\\"\\\"\\\"\\n\\n vert_set = set()\\n for i in range(0, board_size):\\n for j in range(0, board_size):\\n vert_set.add(self.board[j][i])\\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\\n print \\\"vertical win\\\"\\n return True \\n vert_set = set()\\n\\n def diagonal_win():\\n \\\"\\\"\\\"Return whether there is diagonal win\\\"\\\"\\\"\\n\\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][i]) \\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 1\\\"\\n return True\\n \\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][board_size - 1 - i])\\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 2\\\"\\n return True\\n\\n if horizontal_win() or vertical_win() or diagonal_win():\\n print \\\"You have won.\\\"\\n return True\",\n \"def winner(board):\\n for i in range(len(board)):\\n\\n # Check rows\\n if board[i][0] == board[i][1] == board[i][2] and not board[i][1] == EMPTY:\\n return board[i][1]\\n\\n # Check columns\\n elif board[0][i] == board[1][i] == board[2][i] and not board[1][i] == EMPTY:\\n return board[1][i]\\n\\n # Check diagonals\\n if board[0][0] == board[1][1] == board[2][2] and not board[1][1] == EMPTY:\\n return board[1][1]\\n\\n if board[2][0] == board[1][1] == board[0][2] and not board[1][1] == EMPTY:\\n return board[1][1]\\n\\n # No winner if get to this point\\n return None\",\n \"def col_checker(board, size):\\n for i in range(size):\\n for j in range(1, size):\\n if board[0][i] != board[j][i]:\\n break\\n else:\\n yield f\\\"'{board[j][i]}' (Col index {i})\\\"\",\n \"def winner(self):\\n\\n\\t\\tfor player in [1,2]:\\n\\t\\t\\twon = np.full((self.boardSize), player)\\n\\n\\t\\t\\t# Check diagonals\\n\\t\\t\\tif(np.array_equal(np.diag(self.board), won)): return player\\n\\t\\t\\tif(np.array_equal(np.diag(np.fliplr(self.board)), won)): return player\\n\\n\\t\\t\\t# Check lines and columns\\n\\t\\t\\tfor i in range(self.boardSize):\\n\\t\\t\\t\\tif(np.array_equal(self.board[i], won)): return player\\n\\t\\t\\t\\tif(np.array_equal(self.board[:,i], won)): return player\\n\\n\\t\\t# Draw\\n\\t\\tif(not(0 in self.board)): return 3\\n\\n\\t\\t# No win or draw\\n\\t\\treturn 0\",\n \"def check_column(self, letter, given_letter):\\n count = 0\\n avalible_pos = []\\n for number in self.numbers:\\n if self.positions[letter + number] == given_letter:\\n count += 1\\n else:\\n avalible_pos.append(letter + number)\\n return count, avalible_pos\",\n \"def winner(self):\\n for c in 'xo':\\n for comb in [(0,3,6), (1,4,7), (2,5,8), (0,1,2), (3,4,5), (6,7,8), (0,4,8), (2,4,6)]:\\n if all(self.spots[p] == c for p in comb):\\n return c\\n return None\",\n \"def check_win(board_list):\\n\\n for i in range(0, 3):\\n\\n # rows\\n if board_list[i][0] == board_list[i][1] == board_list[i][2]:\\n if board_list[i][0] != 0:\\n return board_list[i][0]\\n\\n # columns\\n elif board_list[0][i] == board_list[1][i] == board_list[2][i]:\\n if board_list[0][i] != 0:\\n return board_list[0][i]\\n\\n # diagonal (top left to bottom right)\\n elif board_list[0][0] == board_list[1][1] == board_list[2][2]:\\n if board_list[0][0] != 0:\\n return board_list[0][0]\\n\\n # diagonal (bottom left to top right)\\n elif board_list[0][2] == board_list[1][1] == board_list[2][0]:\\n if board_list[0][2] != 0:\\n return board_list[0][2]\\n\\n return None\",\n \"def record_winner(cls):\\n # Determine number of contiguous positions needed to win\\n win_length = 3 if cls.size == 3 else 4\\n\\n # Store all sets of coordinates for contiguous positions\\n sets = []\\n\\n # Loop through all 3x3 squares on the board\\n for x in range(0, cls.size-(win_length-1)):\\n for y in range(0, cls.size-(win_length-1)):\\n # Add sets for rows\\n for row in range(x, x+win_length):\\n set = []\\n for col in range(y, y+win_length):\\n set.append([row, col])\\n sets.append(set)\\n # Add sets for columns\\n for col in range(y, y+win_length):\\n set = []\\n for row in range(x, x+win_length):\\n set.append([row, col])\\n sets.append(set)\\n # Add sets for diagonals\\n if cls.size == 3:\\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\\n else:\\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\\n\\n # Check all sets for winner\\n for set in sets:\\n d = {}\\n for coords in set:\\n token = cls.board[coords[0]][coords[1]]\\n d[token] = token != cls.empty\\n # If the dictionary only has one key and it's not empty, then we have a winner\\n tokens = list(d.keys())\\n if len(tokens) == 1 and d[tokens[0]]:\\n cls.winner = tokens[0]\",\n \"def win(s):\\r\\n\\r\\n # check across\\r\\n for i in range(3):\\r\\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\\r\\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\\r\\n return True\\r\\n\\r\\n # check down\\r\\n for i in range(3):\\r\\n if board[i] == board[i + 3] == board[i + 6] == s:\\r\\n board[i] = board[i + 3] = board[i + 6] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal right\\r\\n if board[0] == board[4] == board[8] == s:\\r\\n board[0] = board[4] = board[8] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal left\\r\\n if board[6] == board[4] == board[2] == s:\\r\\n board[6] = board[4] = board[2] = '#'\\r\\n return True\\r\\n\\r\\n return False\",\n \"def who_won(self, board):\\n winners = set()\\n for x,y,z in self.wins:\\n if board[x] == board[y] and board[y] == board[z]:\\n winners.add(board[x])\\n if 1 in winners and 2 in winners:\\n return 3\\n if 1 in winners:\\n return 1\\n if 2 in winners:\\n return 2\\n return 0\",\n \"def legitimateMoves(table,floor,X2,Y2,goes,csvX):\\n scores = []\\n legitimateColumns = []\\n try:\\n i = 0\\n while True:\\n if floor[i] != -1:\\n legitimateColumns.append(i)\\n i=i+1\\n \\n except IndexError:\\n pass\\n #print(legitimateColumns)\\n for x in legitimateColumns:\\n \\n table[floor[x]][x] = \\\"x\\\"\\n gameArray = []\\n for z in range(7):\\n for i in range(5,-1,-1):\\n gameArray.append(table[i][z])\\n \\n \\n gameArray = np.asarray(gameArray)\\n gameArray = np.reshape(gameArray, (1,42))\\n #print(gameArray)\\n np.append(X2, gameArray)\\n\\n \\n \\n if checkWin(table,x,True,floor,\\\"x\\\") == \\\"win\\\":\\n goes = goes+1\\n finished(table,csvX,goes,X2,floor)\\n\\n elif checkWin(table,x,True,floor,\\\"o\\\") == \\\"win\\\":\\n table[floor[x]][x] = \\\"b\\\"\\n return(x)\\n else:\\n #print(\\\"norm\\\")\\n #print(a[0][0])\\n table[floor[x]][x] = \\\"b\\\"\\n #scores.append(a[0][0])\\n #print(gameArray)\\n\\n a = trainer(True,X2,-1,Y2,goes,csvX)\\n\\n for x in a:\\n scores.append(x)\\n \\n #print(scores)\\n scores2 = []\\n for x in legitimateColumns:\\n scores2.append(scores[x])\\n scores = scores2\\n best = max(scores) \\n best_index = scores.index(best)\\n col = legitimateColumns[best_index]\\n #print(col)\\n return(col)\\n #floor[humanInput]=floor[humanInput]-1 \",\n \"def move(self, row, col, player):\\n if self.winning == True:\\n return\\n self.matrix[row][col] = player\\n n = len(self.matrix)\\n indicator = True\\n for i in range(n):\\n if self.matrix[row][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n indicator = True\\n for i in range(n):\\n if self.matrix[i][col] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n if row == col:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n if row + col == n - 1:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][n - 1 - i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n return 0\",\n \"def check_tie(board):\\n return 0 not in board[0]\",\n \"def get_trial_idx_from_win_idx(spikes, col='win_idx'):\\n return np.ceil(spikes[col].dropna() / 2).astype(np.int) - 1\",\n \"def check_for_winner(self, board):\\n\\n potential_move = (-1, -1)\\n\\n # Find Potential Three in a Row for Rows\\n first_row = [(0, 0), (0, 1), (0, 2)]\\n first_row_index = self.can_complete_three_in_row(first_row, board)\\n if first_row_index[0] >= 0:\\n return first_row[first_row_index[0]]\\n elif first_row_index[1] >= 0:\\n potential_move = first_row[first_row_index[1]]\\n\\n second_row = [(1, 0), (1, 1), (1, 2)]\\n second_row_index = self.can_complete_three_in_row(second_row, board)\\n if second_row_index[0] >= 0:\\n return second_row[second_row_index[0]]\\n elif second_row_index[1] >= 0:\\n potential_move = second_row[second_row_index[1]]\\n\\n third_row = [(2, 0), (2, 1), (2, 2)]\\n third_row_index = self.can_complete_three_in_row(third_row, board)\\n if third_row_index[0] >= 0:\\n return third_row[third_row_index[0]]\\n elif third_row_index[1] >= 0:\\n potential_move = third_row[third_row_index[1]]\\n\\n\\n # Find Potential Three in a Row for Columns\\n first_column = [(0, 0), (1, 0), (2, 0)]\\n first_column_index = self.can_complete_three_in_row(first_column, board)\\n if first_column_index[0] >= 0:\\n return first_column[first_column_index[0]]\\n elif first_column_index[1] >= 0:\\n potential_move = first_column[first_column_index[1]]\\n\\n second_column = [(0, 1), (1, 1), (2, 1)]\\n second_column_index = self.can_complete_three_in_row(second_column, board)\\n if second_column_index[0] >= 0:\\n return second_column[second_column_index[0]]\\n elif second_column_index[1] >= 0:\\n potential_move = second_column[second_column_index[1]]\\n\\n third_column = [(0, 2), (1, 2), (2, 2)]\\n third_column_index = self.can_complete_three_in_row(third_column, board)\\n if third_column_index[0] >= 0:\\n return third_column[third_column_index[0]]\\n elif third_column_index[1] >= 0:\\n potential_move = third_column[third_column_index[1]]\\n\\n\\n # Find Potential Three in a Row for Diagonals\\n first_diagonal = [(0, 0), (1, 1), (2, 2)]\\n first_diagonal_index = self.can_complete_three_in_row(first_diagonal, board)\\n if first_diagonal_index[0] >= 0:\\n return first_diagonal[first_diagonal_index[0]]\\n elif first_diagonal_index[1] >= 0:\\n potential_move = first_diagonal[first_diagonal_index[1]]\\n\\n second_diagonal = [(2, 0), (1, 1), (0, 2)]\\n second_diagonal_index = self.can_complete_three_in_row(second_diagonal, board)\\n\\n if second_diagonal_index[0] >= 0:\\n return second_diagonal[second_diagonal_index[0]]\\n elif second_diagonal_index[1] >= 0:\\n potential_move = second_diagonal[second_diagonal_index[1]]\\n\\n return potential_move\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6576831","0.6555307","0.64840585","0.6481743","0.6447641","0.63892657","0.6347227","0.63392514","0.629483","0.62593347","0.6223977","0.6137701","0.60959685","0.6069051","0.60535437","0.6050567","0.60471857","0.603175","0.59898293","0.5885481","0.58327746","0.58294433","0.57293683","0.5718989","0.5708146","0.57061464","0.56966716","0.5685899","0.5679373","0.5672083","0.567017","0.5668181","0.5653624","0.5651414","0.5647661","0.5643177","0.5640243","0.56192476","0.5616558","0.5598243","0.55710924","0.5565117","0.55571306","0.5556236","0.5539569","0.55374813","0.5528608","0.5520479","0.55168617","0.5512338","0.55074984","0.55045563","0.55030036","0.55010104","0.55007446","0.54837275","0.5479397","0.54667866","0.5462276","0.5445526","0.54362655","0.54347324","0.54314303","0.54311323","0.542681","0.54239094","0.54223657","0.5421056","0.54084605","0.54055065","0.54054797","0.54016876","0.5400234","0.5395059","0.5393566","0.53869843","0.53853416","0.5383406","0.53803897","0.53789705","0.5378895","0.5376024","0.5375751","0.5373033","0.5372531","0.5370725","0.5370283","0.53700596","0.5367853","0.5367303","0.536056","0.5360458","0.5358766","0.53570217","0.53560215","0.53427404","0.5336752","0.5336629","0.5334956","0.53336465"],"string":"[\n \"0.6576831\",\n \"0.6555307\",\n \"0.64840585\",\n \"0.6481743\",\n \"0.6447641\",\n \"0.63892657\",\n \"0.6347227\",\n \"0.63392514\",\n \"0.629483\",\n \"0.62593347\",\n \"0.6223977\",\n \"0.6137701\",\n \"0.60959685\",\n \"0.6069051\",\n \"0.60535437\",\n \"0.6050567\",\n \"0.60471857\",\n \"0.603175\",\n \"0.59898293\",\n \"0.5885481\",\n \"0.58327746\",\n \"0.58294433\",\n \"0.57293683\",\n \"0.5718989\",\n \"0.5708146\",\n \"0.57061464\",\n \"0.56966716\",\n \"0.5685899\",\n \"0.5679373\",\n \"0.5672083\",\n \"0.567017\",\n \"0.5668181\",\n \"0.5653624\",\n \"0.5651414\",\n \"0.5647661\",\n \"0.5643177\",\n \"0.5640243\",\n \"0.56192476\",\n \"0.5616558\",\n \"0.5598243\",\n \"0.55710924\",\n \"0.5565117\",\n \"0.55571306\",\n \"0.5556236\",\n \"0.5539569\",\n \"0.55374813\",\n \"0.5528608\",\n \"0.5520479\",\n \"0.55168617\",\n \"0.5512338\",\n \"0.55074984\",\n \"0.55045563\",\n \"0.55030036\",\n \"0.55010104\",\n \"0.55007446\",\n \"0.54837275\",\n \"0.5479397\",\n \"0.54667866\",\n \"0.5462276\",\n \"0.5445526\",\n \"0.54362655\",\n \"0.54347324\",\n \"0.54314303\",\n \"0.54311323\",\n \"0.542681\",\n \"0.54239094\",\n \"0.54223657\",\n \"0.5421056\",\n \"0.54084605\",\n \"0.54055065\",\n \"0.54054797\",\n \"0.54016876\",\n \"0.5400234\",\n \"0.5395059\",\n \"0.5393566\",\n \"0.53869843\",\n \"0.53853416\",\n \"0.5383406\",\n \"0.53803897\",\n \"0.53789705\",\n \"0.5378895\",\n \"0.5376024\",\n \"0.5375751\",\n \"0.5373033\",\n \"0.5372531\",\n \"0.5370725\",\n \"0.5370283\",\n \"0.53700596\",\n \"0.5367853\",\n \"0.5367303\",\n \"0.536056\",\n \"0.5360458\",\n \"0.5358766\",\n \"0.53570217\",\n \"0.53560215\",\n \"0.53427404\",\n \"0.5336752\",\n \"0.5336629\",\n \"0.5334956\",\n \"0.53336465\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6735366"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9288,"cells":{"query":{"kind":"string","value":"Searches for winning sequence in rows."},"document":{"kind":"string","value":"def check_rows(self, win: list) -> bool:\r\n for row in self.tags:\r\n for j in range(len(row) - len(win) + 1):\r\n if win == row[j:j+self.win_condition]:\r\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def search_next_win(self, player):\n for i, j, k in self.winning_cases:\n if self.game_board[i] == player and \\\n self.game_board[j] == player and \\\n self.game_board[k] == ' ':\n return k\n elif self.game_board[j] == player and \\\n self.game_board[k] == player and \\\n self.game_board[i] == ' ':\n return i\n elif self.game_board[i] == player and \\\n self.game_board[k] == player and \\\n self.game_board[j] == ' ':\n return j\n return None","def row_win(board, player):\n for row in board:\n if check_row(row, player):\n return True\n return False","def _check_row(self):\n match = None\n for row in self._board:\n row_string = ''.join(row)\n match = re.search(WIN_REGEX, row_string)\n if match:\n return match.group()[0]\n return None","def row_win(board):\n\tfor row in range(3):\n\t\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\n\t\t\treturn True\n\treturn False","def check_rows():\n global game_still_going\n # Check if any of the rows have all the same value.\n row1 = board[0] == board[1] == board[2] != '_'\n row2 = board[3] == board[4] == board[5] != '_'\n row3 = board[6] == board[7] == board[8] != '_'\n # If any row does have a match, then game still going to False.\n if row1 or row2 or row3:\n game_still_going = False\n # Return winner 'X' or 'O'.\n if row1:\n return board[0]\n if row2:\n return board[3]\n if row3:\n return board[6]","def check_row(self, row, symbol):\r\n\r\n tally = 0\r\n for column in range(3):\r\n if self.board[row][column][1] == symbol:\r\n tally += 1\r\n if tally == 3:\r\n self.winner = symbol","def check_rows():\n global ongoing_game\n row_1 = board[0] == board[1] == board[2] != \"*\"\n row_2 = board[3] == board[4] == board[5] != \"*\"\n row_3 = board[6] == board[7] == board[8] != \"*\"\n if row_1 or row_2 or row_3:\n ongoing_game = False\n if row_1:\n return board[0]\n elif row_2:\n return board[3]\n elif row_3:\n return board[6]\n else:\n return None","def test_row_col(board, rows):\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0","def col_win(board, player):\n for row in board.T:\n if check_row(row, player):\n return True\n return False","def check_for_win(self, row, col, player): \n\n count = 0\n for i in range(0, len(self.board[0])):\n # Check vertical\n if self.board[row][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n\n count = 0\n for i in range(0, len(self.board)):\n # Check horisontal\n if self.board[:, col][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n \n count = 0\n totoffset = col - row\n for i in np.diagonal(self.board, offset=totoffset):\n # Check diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True\n\n count = 0\n mirrorboard = np.fliplr(self.board)\n col = self.colswitch[col]\n totoffset = col - row\n for i in np.diagonal(mirrorboard, offset=totoffset):\n # Check other diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True","def look_through_rows(board, column, player):\n if board.shape[1] > column:\n count = board.shape[0] - 1\n count2 = 1\n while count >= 0 and count2 == 1:\n if board[count,column] == 0:\n board[count,column] = player\n count2 = count2 - 1\n else:\n count = count - 1\n return board\n else:\n print('Improper Column Given')","def check_rows(self):\r\n for i in range(0, len(self.grid),3):\r\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+1][-1] and self.grid[i+1][-1] == self.grid[i+2][-1]:\r\n return (i, (self.grid[i], self.grid[i+2]))\r\n return (-1, None)","def win_row(playerid):\n if board[0][0] is playerid and board[0][1] is playerid and board[0][2] is playerid:\n return (True, \"Row 1\")\n\n if board[1][0] is playerid and board[1][1] is playerid and board[1][2] is playerid:\n return (True, \"Row 2\")\n\n if board[2][0] is playerid and board[2][1] is playerid and board[2][2] is playerid:\n return (True, \"Row 3\")\n\n return False","def check_for_win_lose(b):\r\n win_move = None\r\n block_win = None\r\n # check for wins based on row\r\n for ri in range(3):\r\n row = b[ri]\r\n if single_move(row):\r\n if row==[1,1,0]:\r\n win_move = (ri+1,3)\r\n elif row==[2,2,0]:\r\n block_win = (ri+1,3)\r\n elif row==[1,0,1]:\r\n win_move = (ri+1,2)\r\n elif row==[2,0,2]:\r\n block_win = (ri+1,2)\r\n elif row==[0,1,1]:\r\n win_move = (ri+1,1)\r\n elif row==[0,2,2]:\r\n block_win = (ri+1,1)\r\n else:\r\n print '144 ERROR!'\r\n print single_move(row)\r\n print row\r\n print ' '\r\n\r\n # check for win based on column\r\n for ci in range(3):\r\n col = get_col(b,ci)\r\n if single_move(col):\r\n if col==[1,1,0]:\r\n win_move = (3,ci+1)\r\n elif col==[2,2,0]:\r\n block_win = (3,ci+1)\r\n elif col==[1,0,1]:\r\n win_move = (2,ci+1)\r\n elif col==[2,0,2]:\r\n block_win = (2,ci+1)\r\n elif col==[0,1,1]:\r\n win_move = (1,ci+1)\r\n elif col==[0,2,2]:\r\n block_win = (1,ci+1)\r\n else:\r\n print '166 ERROR!'\r\n print single_move(col)\r\n print col\r\n print ' '\r\n\r\n # check for win on backward diagonal\r\n diag = get_bw_diag(b)\r\n if single_move(diag):\r\n if diag==[1,1,0]:\r\n win_move = (3,3)\r\n elif diag==[2,2,0]:\r\n block_win (3,3)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,1)\r\n elif diag==[0,2,2]:\r\n block_win = (1,1)\r\n \r\n # check for win on forward diagonal\r\n diag = get_fwd_diag(b)\r\n if single_move(diag):\r\n if diag == [1,1,0]:\r\n win_move = (3,1)\r\n elif diag==[2,2,0]:\r\n block_win = (3,1)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,3)\r\n elif diag==[0,2,2]:\r\n block_win = (1,3)\r\n\r\n if win_move is not None:\r\n return (win_move, True)\r\n elif block_win is not None:\r\n return (block_win, False)\r\n else:\r\n return (None, False)","def winner_found(self):\n\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\n winner_in_rows = first_row or second_row or third_row\n\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\n winner_in_columns = first_column or second_column or third_column\n\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\n winner_in_diagonals = first_diagonal or second_diagonal\n\n return winner_in_rows or winner_in_columns or winner_in_diagonals","def find_best_move(board):\n new_board = board.get_board()\n\n # X | X | X <-- Check for win on this row\n # ---------\n # 3 | 4 | 5\n # ---------\n # 6 | 7 | 9\n if new_board[0] == new_board[1] and new_board[2] == \"2\":\n return 2\n elif new_board[0] == new_board[2] and new_board[1] == \"1\":\n return 1\n elif new_board[1] == new_board[2] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | 2\n # ---------\n # X | X | X <-- Check for win on this row\n # ---------\n # 6 | 7 | 9\n elif new_board[3] == new_board[4] and new_board[5] == \"5\":\n return 5\n elif new_board[3] == new_board[5] and new_board[4] == \"4\":\n return 4\n elif new_board[4] == new_board[5] and new_board[3] == \"3\":\n return 3\n\n # 0 | 1 | 2\n # ---------\n # 3 | 4 | 5\n # ---------\n # X | X | X <-- Check for win on this row\n elif new_board[6] == new_board[7] and new_board[8] == \"8\":\n return 8\n elif new_board[6] == new_board[8] and new_board[7] == \"7\":\n return 7\n elif new_board[7] == new_board[8] and new_board[6] == \"6\":\n return 6\n\n # X | 1 | 2 Check for win on column one\n # ---------\n # X | 4 | 5\n # ---------\n # X | 7 | 9\n elif new_board[0] == new_board[3] and new_board[6] == \"6\":\n return 6\n elif new_board[0] == new_board[6] and new_board[3] == \"3\":\n return 3\n elif new_board[6] == new_board[3] and new_board[0] == \"0\":\n return 0\n\n # 0 | X | 2 Checks for win on column two\n # ---------\n # 3 | X | 5\n # ---------\n # 6 | X | 9\n elif new_board[1] == new_board[4] and new_board[7] == \"7\":\n return 7\n elif new_board[1] == new_board[7] and new_board[4] == \"4\":\n return 4\n elif new_board[7] == new_board[4] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | X\n # ---------\n # 3 | 4 | X\n # ---------\n # 6 | 7 | X\n elif new_board[2] == new_board[5] and new_board[8] == \"8\":\n return 8\n elif new_board[2] == new_board[8] and new_board[5] == \"5\":\n return 5\n elif new_board[8] == new_board[5] and new_board[2] == \"2\":\n return 2\n\n # X | 1 | 2\n # ---------\n # 3 | X | 5\n # ---------\n # 6 | 7 | X\n elif new_board[0] == new_board[4] and new_board[8] == \"8\":\n return 8\n elif new_board[0] == new_board[8] and new_board[4] == \"4\":\n return 4\n elif new_board[8] == new_board[4] and new_board[0] == \"0\":\n return 0\n\n # 0 | 1 | X\n # ---------\n # 3 | X | 5\n # ---------\n # X | 7 | 9\n elif new_board[2] == new_board[4] and new_board[6] == \"6\":\n return 6\n elif new_board[2] == new_board[6] and new_board[4] == \"4\":\n return 4\n elif new_board[6] == new_board[4] and new_board[2] == \"2\":\n return 2\n\n # If corners are empty, play there\n elif new_board[0] == \"0\" or new_board[2] == \"2\" or new_board[6] == \"6\" or new_board[8] == \"8\":\n try_spot = 0\n while True:\n if new_board[try_spot] != \"X\" and new_board[try_spot] != \"O\":\n return try_spot\n else:\n try_spot = try_spot + 2\n\n # If middle is empty, play there\n elif new_board[4] == \"4\":\n return 4\n\n # Finally if edges are empty try there\n elif new_board[1] == \"1\" or new_board[3] == \"3\" or new_board[5] == \"5\" or new_board[7] == \"7\":\n try_spot = 1\n while True:\n if new_board[try_spot] != \"X\" and new_board[try_spot] != \"O\":\n return try_spot\n else:\n try_spot = try_spot + 2","def check_rows(self):\n\t\tfor i in range(len(self.board)):\n\t\t\tpts = 0\n\t\t\tfor j in range(len(self.board[i])):\n\t\t\t\tif self.board[i][j] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('YOU WON')\n\t\t\t\treturn True","def win_check(board, mark):\n win_positions = [\"123\", \"456\", \"789\", \"147\", \"258\", \"369\", \"159\", \"357\"]\n is_winner = False\n for positions in win_positions:\n for idx in positions:\n idx = int(idx)\n if board[idx] != mark:\n break\n else:\n is_winner = True\n\n return is_winner","def checkwin(self):\n w = self.getWidth()\n h = self.getHeight()\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\n for r in range(h):\n for c in range(w):\n if self.cell[c][r] == EMPTY:\n continue # this cell can't be part of winning segment\n # if we reach this point, the cell is occupied by a player stone\n numOccupiedCell = numOccupiedCell+1\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\n for i in range(NWIN):\n # test if there exists a segment of NWIN uniformly coloured cells\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\n break # segment broken\n else:\n # Python remark: notice that the else is attached to the for loop \"for i...\"\n # This block is executed if and only if 'i' arrives at the end of its range \n return self.cell[c][r] , True # found a winning segment \n return EMPTY, numOccupiedCell==w*h","def check_row(row, player):\n for marker in row:\n if marker != player:\n return False\n return True","def search_possible_steps(self):\n if self.ended:\n return False\n possible_steps_turple = (self.board == 0)\n possible_steps = np.transpose(possible_steps_turple.nonzero())\n return possible_steps","def rowWin( self ):\n\n for x in [0,3,6]:\n firstVal = self.__grid[x]\n secondVal = self.__grid[x+1]\n thirdVal = self.__grid[x+2]\n\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\n\n if compiledVal.lower() == 'xxx':\n return 'X'\n\n elif compiledVal.lower() == 'ooo':\n return 'O' \n \n return None","def row_wise_checking(player_):\n if board[0] == board[1] == player_:\n return 2\n elif board[1] == board[2] == player_:\n return 0\n elif board[3] == board[4] == player_:\n return 5\n elif board[4] == board[5] == player_:\n return 3\n elif board[6] == board[7] == player_:\n return 8\n elif board[7] == board[8] == player_:\n return 6\n else:\n return -1","def player(board):\n X_count = 0\n O_count = 0\n\n for row in board:\n X_count += row.count(X)\n O_count += row.count(O)\n\n if X_count <= O_count:\n return X\n else:\n return O","def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\n num_connected = 1 # Tally of how many game pieces were found matching thus far\n\n def increment_connected(step_row, step_col):\n \"\"\"\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\n :param step_row: The amount to move in the Y direction\n :param step_col: The amount to move in the X direction\n :return: The number of adjacent matching tiles found by the function\n \"\"\"\n connected = 0\n current_row = row + step_row\n current_col = col + step_col\n\n while self.board[current_row][current_col] == player_symbol:\n connected += 1\n current_row += step_row\n current_col += step_col\n\n return connected\n\n num_connected += increment_connected(step_row_1, step_col_1)\n num_connected += increment_connected(step_row_2, step_col_2)\n\n if num_connected >= 4:\n self.game_over = True","def winner(row):\r\n x=0\r\n o=0\r\n win=False\r\n winner='X'\r\n empty=False #Better not to do '.' in row\r\n \r\n for char in row:\r\n if char=='X':\r\n x+=1\r\n o=0\r\n if char=='O':\r\n o+=1\r\n x=0\r\n if char=='T':\r\n x+=1\r\n o+=1\r\n if char=='.':\r\n x=0\r\n o=0\r\n empty=True\r\n\r\n #Check Winner\r\n if x==4:\r\n win=True\r\n winner='X'\r\n if o==4:\r\n win=True\r\n winner='O'\r\n return (win,winner,empty)\r\n #Done\r","def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None","def check_for_win(self,board, player_id, action):\n\n row = 0\n\n # check which row was inserted last:\n for i in range(ROWS):\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\n row = ROWS - i\n break\n\n # check horizontal:\n vec = board[row, :] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check vertical:\n vec = board[:, action] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check diagonals:\n vec = np.diagonal(board, action - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n return False","def player(board):\n\n # Game is over\n if terminal(board):\n return None\n\n # Count number of occurences of X and O\n x_count = 0\n o_count = 0\n for row in board:\n for box in row:\n if box == X:\n x_count = x_count + 1\n elif box == O:\n o_count = o_count + 1\n # When move count is tied, X is next\n if x_count <= o_count:\n return X\n # When X has moved once more than O, next move is O\n else:\n return O","def check_win(self):\n win = None\n for pos in self.winning_pos:\n win = self.is_match(set(self.get_cells(pos)))\n if win:\n return win\n if not self.open_tiles():\n return \"Draw\"\n return win","def winner(board):\n x_in_board = []\n o_in_board = []\n winning_positions = [\n [[0, 0], [0, 1], [0, 2]],\n [[1, 0], [1, 1], [1, 2]],\n [[2, 0], [2, 1], [2, 2]],\n [[0, 0], [1, 0], [2, 0]],\n [[0, 1], [1, 1], [2, 1]],\n [[0, 2], [1, 2], [2, 2]],\n [[0, 0], [1, 1], [2, 2]],\n [[0, 2], [1, 1], [2, 0]]\n ]\n\n for i in range(len(board)):\n for j in range(len(board)):\n if board[i][j] == X:\n x_in_board.append([i, j])\n elif board[i][j] == O:\n o_in_board.append([i, j])\n\n for i in winning_positions:\n if i[0] in x_in_board and i[1] in x_in_board and i[2] in x_in_board:\n return X\n elif i[0] in o_in_board and i[1] in o_in_board and i[2] in o_in_board:\n return O\n\n return None","def win_check(table: list) -> (bool, str):\n # Combinations that would lead to a win\n win_list = [\n [0,1,2], [3,4,5],\n [6,7,8], [0,3,6],\n [1,4,7], [2,5,8],\n [0,4,8], [6,4,2],\n ]\n for line in win_list:\n # Check rows, columns, and diagonals\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\n\n if len(combination) == 1 and combination != {\"-\"}: # Which mean we have a straight line of either X or O\n #unpack comb (which is 1 item), which is either \"X\" or \"O\" to know who won\n return True, *combination\n else:\n return False, None","def _get_row_index(self, row: Row) -> int:\n row_index = -1\n for index, table_row in enumerate(self.table_data):\n if table_row.values == row.values:\n row_index = index\n break\n return row_index","def check_columns(self, win: list) -> bool:\r\n for row in range(self.size):\r\n column = [self.tags[x][row] for x in range(self.size)]\r\n for j in range(len(column) - len(win) + 1):\r\n if win == column[j:j+self.win_condition]:\r\n return True","def find_row(table, row):\n for idx in range(len(table)):\n if table[idx][0] == row:\n return idx\n return -1","def row_checker(board, size):\n for i in range(size):\n for j in range(1, size):\n if board[i][0] != board[i][j]:\n break\n else:\n yield f\"'{board[i][j]}' (Row index: {i})\"","def winner(board):\n columns = []\n for row in board:\n xcount = row.count(X)\n ocount = row.count(O)\n if xcount == 3:\n return X\n if ocount == 3:\n return O\n\n for j in range(len(board)):\n column = [row[j] for row in board]\n columns.append(column)\n \n for j in columns:\n xcounter = j.count(X)\n ocounter = j.count(O)\n if xcounter == 3:\n return X\n if ocounter == 3:\n return O\n \n if board[0][0] == O and board[1][1] == O and board[2][2] == O:\n return O\n if board[0][0] == X and board[1][1] == X and board[2][2] == X:\n return X\n if board[0][2] == O and board[1][1] == O and board[2][0] == O:\n return O\n if board[0][2] == X and board[1][1] == X and board[2][0] == X:\n return X\n\n return None","def move(self, row, col, player):\n if self.winning == True:\n return\n self.matrix[row][col] = player\n n = len(self.matrix)\n indicator = True\n for i in range(n):\n if self.matrix[row][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n indicator = True\n for i in range(n):\n if self.matrix[i][col] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n \n if row == col:\n indicator = True\n for i in range(n):\n if self.matrix[i][i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n if row + col == n - 1:\n indicator = True\n for i in range(n):\n if self.matrix[i][n - 1 - i] != player:\n indicator = False\n break\n if indicator == True:\n self.winning = True\n return player\n return 0","def find_row(word):\n idx = 0\n first = 0\n second = 127\n while idx < 7:\n first, second = converter(word[idx], first, second)\n idx += 1\n return first","def isSolved(board):\n for player in [1, 2]:\n if [player]*3 in chain(\n board, # Rows\n zip(board), # Columns\n [ # Diagonals\n [board[i][i] for i in range(len(board))],\n [board[len(board) - i - 1][i] for i in range(len(board))]\n ]\n ):\n return player\n return -1 if 0 in chain(*board) else 0","def player(board):\n number_of_X = 0\n number_of_O = 0\n \n for row in board: \n number_of_X += row.count(\"X\")\n number_of_O += row.count(\"O\")\n \n \n if number_of_X <= number_of_O:\n return(\"X\") \n else: \n return(\"O\")","def check_winner(self):\n if self.history:\n last_move = self.history[-1]\n last_player = self.get_last_player()\n\n connected_token = last_player*self.n_in_row\n # check for row\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for column\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope 1\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope -1\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for draw game\n if len(np.argwhere(self.state==0)) == 0:\n self.winner = [True, 0]\n return self.winner\n return self.winner","def check_win(self, player):\n for win_pos in TicTacToe.win_pos:\n # for each winning position defined we take the set difference to the positions played be player\n # if there are not elements left after resulting set after difference operator\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\n # the winner\n if not win_pos.difference(self.player_played_pos[player]):\n return True\n\n # if after checking for every winning positions if the control still reaches here,\n # the player has not marked the winning positions. returns False\n return False","def evaluate(board):\n winner = 0\n for player in [1, 2]:\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n winner = player\n \n if np.all(board != 0) and winner == 0:\n winner = -1\n return winner","def find_sequence(matrix, pos):\n for direction in [(-1, 1), (0, 1), (1, 1), (1, 0)]:\n is_found = find_sequence_to_direction(matrix, pos, direction)\n if is_found:\n return True\n return False","def check_winner(self):\n for row in self.board.values():\n if all([mark == \"x\" for mark in row]):\n return self.player_1\n elif all([mark == \"o\" for mark in row]):\n return self.player_2\n\n # checks every column\n for i in range(3):\n first_row, second_row, third_row = self.board.values()\n if first_row[i] == \"x\" and second_row[i] == \"x\" and third_row[i] == \"x\":\n return self.player_1\n elif first_row[i] == \"o\" and second_row[i] == \"o\" and third_row[i] == \"o\":\n return self.player_2\n\n # checks the diagonals\n if self.board[\"a\"][0] == \"x\" and self.board[\"b\"][1] == \"x\" and self.board[\"c\"][2] == \"x\":\n return self.player_1\n if self.board[\"a\"][2] == \"o\" and self.board[\"b\"][1] == \"o\" and self.board[\"c\"][0] == \"o\":\n return self.player_2\n\n return None","def winning_move(board, position, player):\n win = list(player*3)\n if get_row(board, position) == win:\n return True\n elif get_column(board, position) == win:\n return True\n elif position % 2 != 0:\n # odd positions are on the diagonals\n return get_diagonal(board, 1) == win or get_diagonal(board, 3) == win\n return False","def check_for_win(self, index):\n\n\t\tpossible_comb = self.cell_combinations[index]\n\n\t\tfor comb in possible_comb:\n\n\t\t\ttokens = []\n\t\t\ttokens.append(self.player_model.grid[comb[0]].token)\n\t\t\ttokens.append(self.player_model.grid[comb[1]].token)\n\t\t\ttokens.append(self.player_model.grid[comb[2]].token)\n\n\t\t\tif all([token == self.player_model.current_player.token for token in tokens]):\n\n\t\t\t\treturn True\n\n\t\treturn False","def winner(board):\n # Hard code winning moves\n # row0\n if board[0][0] == board[0][1] == board[0][2] == X:\n return X\n elif board[0][0] == board[0][1] == board[0][2] == O:\n return O\n # row1\n elif board[1][0] == board[1][1] == board[1][2] == X:\n return X\n elif board[1][0] == board[1][1] == board[1][2] == O:\n return O\n # row2\n elif board[2][0] == board[2][1] == board[2][2] == X:\n return X\n elif board[2][0] == board[2][1] == board[2][2] == O:\n return O\n # col0\n elif board[0][0] == board[1][0] == board[2][0] == X:\n return X\n elif board[0][0] == board[1][0] == board[2][0] == O:\n return O\n # col1\n elif board[0][1] == board[1][1] == board[2][1] == X:\n return X\n elif board[0][1] == board[1][1] == board[2][1] == O:\n return O\n # col2\n elif board[0][2] == board[1][2] == board[2][2] == X:\n return X\n elif board[0][2] == board[1][2] == board[2][2] == O:\n return O\n # diagonal\n elif board[0][0] == board[1][1] == board[2][2] == X:\n return X\n elif board[0][0] == board[1][1] == board[2][2] == O:\n return O\n # inverse diagonal\n elif board[0][2] == board[1][1] == board[2][0] == X:\n return X\n elif board[0][2] == board[1][1] == board[2][0] == O:\n return O\n\n return None","def exitsinrow(self,rows,row,num):\r\n for i in range(9):\r\n if(rows[row][i] == num):\r\n return True\r\n return False","def check_game_status2(board):\n board = np.array(board)\n for i in range(7):\n for j in range(6):\n if checkWin(board, j, i, 1):\n return 1\n if checkWin(board, j, i, 2):\n return 2\n if isfull(board):\n return 0\n return -1","def check_winner(self, row, column, symbol):\r\n self.check_row(row, symbol)\r\n self.check_column(column, symbol)\r\n self.check_diag(row, column, symbol)","def won(self):\n for y in range(self.size):\n winning = []\n for x in range(self.size):\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n for x in range(self.size):\n winning = []\n for y in range(self.size):\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n winning = []\n for y in range(self.size):\n x = y\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n winning = []\n for y in range(self.size):\n x = self.size-1-y\n if self.fields[x, y] == self.opponent:\n winning.append((x, y))\n if len(winning) == self.size:\n return winning\n return None","def checkRow(self, x):\n used = []\n for y in range(len(self.board[0])):\n cur = self.board[x][y]\n if cur not in used:\n if cur !=0:\n used += [cur]\n else:\n return False\n return True","def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False","def check_win(self, board, move):\n for i, j, k in self.winning_cases:\n if board[i] == move and board[j] == move and board[k] == move:\n return True\n return False","def player(board):\n X_count = 0\n O_count = 0\n #to determine the turn, I will make a count of the X and O tokens on the board\n for row in board:\n #I create a dictionary with the count on each row\n player_turns = {i: row.count(i) for i in row}\n #I check if I have X and O tokens in the row, if not, create an entry with 0\n if not (player_turns.get(\"X\")):\n player_turns['X'] = 0\n if not player_turns.get(\"O\"):\n player_turns['O'] = 0\n #I add to my counter the total amount of tokens found for each player in this row\n X_count = X_count + int(player_turns['X'])\n O_count = O_count + int(player_turns['O'])\n\n #if X has the same amount of tokens than O, it means it is X's turn\n if(X_count == O_count):\n #It should be X's turn. \n return \"X\"\n #Otherwise, it is O's turn.\n elif(X_count>O_count):\n #it is O's turn.\n return \"O\"","def check_win(self, player):\n def check_row_win(player):\n for row in self.game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_column_win(player):\n # For doing a column check, transpose the grid and do a row check\n trans_game_state = numpy.transpose(self.game_state)\n for row in trans_game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_diag_win(player):\n # Left to right diagonal\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\n return True\n # Right to left diagonal\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\n return True\n return False\n\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\n return True\n return False","def _check_for_win(self, piece, piece_x, piece_y):\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions = []\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\n for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions.append((x, y))\n # Don't need to check the piece that is being placed\n if (x, y) == (piece_x, piece_y):\n continue\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece != piece:\n winning_piece_positions = None\n break\n if winning_piece_positions:\n # Check if there are additional winning pieces that exceed the number required to win.\n # e.g. a 5-in-a-row when only 4 are required\n if slope_x != 0:\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\n for i in range(1, 1 + num_previous_pieces_to_check)):\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece == piece:\n winning_piece_positions.insert(0, (x, y))\n else:\n break\n return winning_piece_positions\n\n return False","def winner(board):\n chances = [X, O]\n for chance in chances:\n for row in range(3):\n if list(chance)*3 == board[row]:\n return chance\n for column in range(3):\n if [[chance] for i in range(3)] == [[board[row][column]] for row in range(3)]:\n return chance\n if board[0][0] == chance and board[1][1] == chance and board[2][2] == chance:\n return chance\n if board[0][2] == chance and board[1][1] == chance and board[2][0] == chance:\n return chance\n return None","def find_in_a_row(s, n=3):\n for i, v in enumerate(s[:-(n - 1)]):\n if all(v == s[i + j] for j in range(1, n)):\n return v\n return None","def player(board):\n xcount, ocount = 0, 0\n for row in board:\n xcount += row.count(X)\n ocount += row.count(O)\n if xcount > ocount:\n return O\n elif xcount == 0 and ocount == 0:\n return X\n elif xcount == ocount:\n return X","def col_win(board):\n\tfor col in range(3):\n\t\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\n\t\t\treturn True\n\treturn False","def win_condition(self, player):\n\n row_list = []\n column_list = []\n constant_condition = False\n row_sequential_condition = False\n column_sequential_condition = False\n\n # Loop through positions on board for player\n for position_key, position_obj in sorted(self.board.positions.items()):\n if position_obj.value == player.value:\n row_list.append(position_obj.row)\n column_list.append(position_obj.column)\n\n # Either row keys or column keys must stay constant\n row_set = set(row_list)\n column_set = set(column_list)\n if len(row_set) == 1 or len(column_set) == 1:\n constant_condition = True\n\n # The other row keys or column keys must be sequential for number of row or columns\n row_seq_list = [n for n in range(1, self.board.rows + 1)]\n column_seq_list = [n for n in range(1, self.board.columns + 1)]\n if row_list == row_seq_list:\n row_sequential_condition = True\n if column_list == column_seq_list:\n column_sequential_condition = True\n\n if constant_condition and (row_sequential_condition or column_sequential_condition):\n return True\n elif row_sequential_condition and column_sequential_condition:\n return True\n else:\n return False","def check_row(self, number, given_letter):\n count = 0\n avalible_pos = []\n for letter in self.letters:\n if self.positions[letter + number] == given_letter:\n count += 1\n else:\n avalible_pos.append(letter + number)\n return count, avalible_pos","def win(self, player):\n if player == 1:\n a = self.player_one.moves\n else:\n a = self.player_two.moves\n winning_moves = []\n for i in range(1, 9, 3):\n winning_moves.append(range(i, i + 3))\n for i in range(1, 4):\n winning_moves.append(range(i, i + 7, 3))\n winning_moves.append([1, 5, 9])\n winning_moves.append([3, 5, 7])\n for move in winning_moves:\n flg = True\n for index in move:\n if index not in a:\n flg = False\n break\n if flg:\n return True, player\n if len(self.player_one.moves) + len(self.player_two.moves) == 9:\n self.print_space()\n self.display_board()\n self.print_space()\n print \" Games is drawn\"\n self.logging.debug(\"Game is draw, nobody won\")\n self.logging.debug(\"Enjoy the game again :)\")\n sys.exit(100)\n return False, player","def winner(board):\n \n possible_wins = []\n row1 = board[0]\n row2 = board[1]\n row3 = board[2]\n col1 = [board[0][0],board[1][0],board[2][0]]\n col2 = [board[0][1],board[1][1],board[2][1]]\n col3 = [board[0][2],board[1][2],board[2][2]]\n diag1 = [board[0][0],board[1][1],board[2][2]]\n diag2 = [board[2][0],board[1][1],board[0][2]]\n \n possible_wins.append(row1)\n possible_wins.append(row2)\n possible_wins.append(row3)\n possible_wins.append(col1)\n possible_wins.append(col2)\n possible_wins.append(col3)\n possible_wins.append(diag1)\n possible_wins.append(diag2)\n \n for trait in possible_wins:\n if trait.count(\"X\") == 3:\n return \"X\"\n elif trait.count(\"O\") == 3:\n return \"O\"\n \n return None","def winner(board):\n for i in (O, X):\n for j in range(3):\n if (board[j][0] == i and board[j][1] == i and board[j][2] == i):\n return i\n if (board[0][j] == i and board[1][j] == i and board[2][j] == i):\n return i\n if (board[0][0] == i and board[1][1] == i and board[2][2] == i):\n return i\n if (board[2][0] == i and board[1][1] == i and board[0][2] == i):\n return i\n return None","def getWinner(board):\n players = [X, O]\n num_symbols_in_line = 3\n for player in players:\n # check rows\n for row in board:\n line_count = row.count(player)\n if line_count == num_symbols_in_line:\n return player\n \n # check columns\n for col_i in range(len(board[0])):\n line_count = 0\n for row_i in range(len(board)):\n if board[row_i][col_i] == player:\n line_count += 1\n if line_count == num_symbols_in_line:\n return player\n \n # check vertical from top left to bottom right\n line_count = 0\n for vert_cell in range(len(board)):\n if board[vert_cell][vert_cell] == player:\n line_count += 1\n if line_count == num_symbols_in_line:\n return player\n \n # check vertical from top right to bottom left\n line_count = 0\n col_i = len(board) - 1\n for row_i in range(len(board)):\n if board[row_i][col_i] == player:\n line_count += 1\n col_i -= 1\n if line_count == num_symbols_in_line:\n return player\n\n return None","def check_game_over(self, row, col):\n player_symbol = self.board[row][col]\n\n # Top Right: Row -1 Col 1\n # Bottom Left: Row 1 Col -1\n self.check_four_in_a_row(player_symbol, row, col, -1, 1, 1, -1)\n\n # Top Left: Row -1 Col -1\n # Bottom Right Row 1 Col 1\n self.check_four_in_a_row(player_symbol, row, col, -1, -1, 1, 1)\n\n # Horizontal: Row 0 Col 1, Row 0 Col -1\n self.check_four_in_a_row(player_symbol, row, col, 0, 1, 0, -1)\n\n # Vertical: Row 1 Col 0, Row -1 Col 0\n self.check_four_in_a_row(player_symbol, row, col, 1, 0, -1, 0)\n\n if self.turns >= self.num_playable_rows * self.num_playable_columns:\n self.game_over = True\n self.board_full = True","def game_state(matrix):\n\n \"\"\"\n # To set winning tile\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == 2048:\n # return 'win'\n # return 'not over'\n \"\"\"\n for i in range(len(matrix)-1):\n # intentionally reduced to check the row on the right and below\n # more elegant to use exceptions but most likely this will be their solution\n for j in range(len(matrix[0])-1):\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\n return 'not over'\n for i in range(len(matrix)): # check for any zero entries\n for j in range(len(matrix[0])):\n if matrix[i][j] == 0:\n return 'not over'\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\n return 'not over'\n for j in range(len(matrix)-1): # check up/down entries on last column\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\n return 'not over'\n return 'lose'","def main(board, word):\r\n for i, row in enumerate(board):\r\n for j, square in enumerate(row):\r\n if square == word[0]:\r\n res = neighbors(board, word, i, j)\r\n if res:\r\n return True\r\n return False","def winner(board):\r\n\r\n #rows:\r\n if (board[0][0] == board[0][1] == board[0][2]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[1][0] == board[1][1] == board[1][2]) and (board[1][0] == \"X\" or board[1][0] == \"O\"):\r\n return board[1][0]\r\n if (board[2][0] == board[2][1] == board[2][2]) and (board[2][0] == \"X\" or board[2][0] == \"O\"):\r\n return board[2][0]\r\n\r\n #columns\r\n if (board[0][0] == board[1][0] == board[2][0]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[0][1] == board[1][1] == board[2][1]) and (board[0][1] == \"X\" or board[0][1] == \"O\"):\r\n return board[0][1]\r\n if (board[0][2] == board[1][2] == board[2][2]) and (board[0][2] == \"X\" or board[0][2] == \"O\"):\r\n return board[0][2]\r\n\r\n #diagonals\r\n if (board[0][0] == board[1][1] == board[2][2]) and (board[0][0] == \"X\" or board[0][0] == \"O\"):\r\n return board[0][0]\r\n if (board[0][2] == board[1][1] == board[2][0]) and (board[0][2] == \"X\" or board[0][2] == \"O\"):\r\n return board[0][2]\r\n \r\n return None\r\n\r\n raise NotImplementedError","def _check_won(field, col, delta_row):\n player = field[col][-1]\n coord = len(field[col]) - 1\n total = 1\n # negative dir\n cur_coord = coord - delta_row\n for c in range(col - 1, -1, -1):\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\n break\n if field[c][cur_coord] != player:\n break\n total += 1\n if total == COUNT_TO_WIN:\n return True\n cur_coord -= delta_row\n # positive dir\n cur_coord = coord + delta_row\n for c in range(col + 1, GAME_COLS):\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\n break\n if field[c][cur_coord] != player:\n break\n total += 1\n if total == COUNT_TO_WIN:\n return True\n cur_coord += delta_row\n return False","def check_tie(board):\n return 0 not in board[0]","def check_column(self, column, symbol):\r\n\r\n tally = 0\r\n for row in range(3):\r\n if self.board[row][column][1] == symbol:\r\n tally += 1\r\n if tally == 3:\r\n self.winner = symbol","def remove_from_winning(game: List[int]) -> None:\n while True:\n game_copy = game.copy()\n row = randint(1, len(game_copy))\n if game_copy[row-1] < 1:\n continue\n matches = randint(1, game_copy[row-1])\n remove_matches(game_copy, row - 1, matches)\n if not is_winning(game_copy):\n remove_matches(game, row - 1, matches)\n break\n print(\"{} matches on row {} have been removed.\".format(matches, row))","def win(board):\n # COLUMNS\n if board[7] == board[4] == board[1] != ' ': # first column down\n return board[7]\n elif board[8] == board[5] == board[2] != ' ': # second column down\n return board[8]\n elif board[9] == board[6] == board[3] != ' ': # third column down\n return board[9]\n\n # ROWS\n if board[7] == board[8] == board[9] != ' ': # first row across\n return board[7]\n elif board[4] == board[5] == board[6] != ' ': # second row across\n return board[4]\n elif board[1] == board[2] == board[3] != ' ': # third row across\n return board[1]\n\n # DIAGONALS\n if board[7] == board[5] == board[3] != ' ': # diagonal staring on left\n return board[7]\n elif board[9] == board[5] == board[1] != ' ': # diagonal starting on right\n return board[9]\n\n # else no winner\n return \"No\"","def get_winner(board):\n\n def who_won(in_a_row, board_size, cur_player):\n \"\"\" \n a function private to get_winner() (yes you can do this. Cool huh!?) \n that tells get_winner if it has a winner \n \"\"\"\n if in_a_row == board_size:\n return 1 if cur_player == 'X' else 2\n else:\n return 0\n\n def test_row_col(board, rows):\n \"\"\" private function to test the rows and columns \"\"\"\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n def test_diagonal(board, normal):\n \"\"\" private function to test the two diagonals \"\"\"\n cur_player = board[0][0] if normal else board[0][len(board)-1]\n in_a_row = 0\n for i in range(len(board)):\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1 \n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n\n # test rows\n winner = test_row_col(board, True)\n if not winner == 0:\n return winner\n\n # test cols\n winner = test_row_col(board, False)\n if not winner == 0:\n return winner\n\n # test diagonal from top left to bottom right\n winner = test_diagonal(board, True)\n if not winner == 0:\n return winner\n\n # test diagonal from top right to bottom left\n winner = test_diagonal(board, False)\n if not winner == 0:\n return winner\n\n return 0","def utility(board):\n game_winner = \"\"\n #I will analyze every row first\n for i in range(0,3):\n #I check vertically and horizontally if the tokens are the same, meaning any of the two players has 3 in a row.\n if (board[i][0] == board[i][1] and board[i][0] == board[i][2] and (board[i][0] is not EMPTY)):\n #if I find a match vertically, I determine there was a winner and break the for cycle.\n game_winner = board[i][0]\n break\n elif (board[0][i] == board[1][i] and board[0][i] == board[2][i] and (board[0][i] is not EMPTY)):\n #if there is a match horizontally, I determine there was a winner and break the for cycle.\n game_winner = board[0][i]\n break\n #checking diagonals in case there were no winners neither vertically nor horizontally.\n if ((board[0][0] == board[1][1] and board[2][2] == board[0][0]) or (board[0][2] == board[1][1] and board[2][0] == board[0][2])) and (board[1][1] is not EMPTY):\n game_winner = board[1][1]\n #depending on my winning token, I will determine the value I should print. \n if game_winner == \"X\":\n return 1\n elif game_winner == \"O\":\n return -1\n #Since we are assuming we will only receive terminal boards, if no winner was found, we have a tie and should return 0.\n else:\n return 0","def _check_row(self, col, board) -> int:\n score = 0\n for row in range(len(board)):\n if board[col][row] == self.colour:\n score += 1\n return score","def check_win(self):\r\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\r\n for case, pos in wins:\r\n if case != -1:\r\n print('Game over!')\r\n if self.grid[case][-1] == self.computer:\r\n print('The computer won!')\r\n return (True, pos)\r\n print('The player won!')\r\n return (True, pos)\r\n\r\n return (self.check_draw(), None)","def player(board):\n if terminal(board) == True:\n return None \n countO, countX = 0, 0\n for i in range(3):\n for j in range(3):\n if board[i][j] == X:\n countX += 1\n elif board[i][j] == O:\n countO += 1\n if countO >= countX:\n return X\n else:\n return O","def check_win():\r\n for mark in markers:\r\n if loc[0] == mark and loc[1] == mark and loc[2] == mark:\r\n return True\r\n if loc[0] == mark and loc[3] == mark and loc[6] == mark:\r\n return True\r\n if loc[0] == mark and loc[4] == mark and loc[8] == mark:\r\n return True\r\n if loc[1] == mark and loc[4] == mark and loc[7] == mark:\r\n return True\r\n if loc[2] == mark and loc[4] == mark and loc[6] == mark:\r\n return True\r\n if loc[2] == mark and loc[5] == mark and loc[8] == mark:\r\n return True\r\n if loc[3] == mark and loc[4] == mark and loc[5] == mark:\r\n return True\r\n if loc[6] == mark and loc[7] == mark and loc[8] == mark:\r\n return True\r\n else:\r\n return False","def TestRow(SudokuGrid):\r\n for i in range(9):\r\n for j in range(8):\r\n for k in range(j+1,9):\r\n if SudokuGrid[i][j]==SudokuGrid[i][k]:\r\n return False\r\n return True","def check_for_winner(self, board):\n\n potential_move = (-1, -1)\n\n # Find Potential Three in a Row for Rows\n first_row = [(0, 0), (0, 1), (0, 2)]\n first_row_index = self.can_complete_three_in_row(first_row, board)\n if first_row_index[0] >= 0:\n return first_row[first_row_index[0]]\n elif first_row_index[1] >= 0:\n potential_move = first_row[first_row_index[1]]\n\n second_row = [(1, 0), (1, 1), (1, 2)]\n second_row_index = self.can_complete_three_in_row(second_row, board)\n if second_row_index[0] >= 0:\n return second_row[second_row_index[0]]\n elif second_row_index[1] >= 0:\n potential_move = second_row[second_row_index[1]]\n\n third_row = [(2, 0), (2, 1), (2, 2)]\n third_row_index = self.can_complete_three_in_row(third_row, board)\n if third_row_index[0] >= 0:\n return third_row[third_row_index[0]]\n elif third_row_index[1] >= 0:\n potential_move = third_row[third_row_index[1]]\n\n\n # Find Potential Three in a Row for Columns\n first_column = [(0, 0), (1, 0), (2, 0)]\n first_column_index = self.can_complete_three_in_row(first_column, board)\n if first_column_index[0] >= 0:\n return first_column[first_column_index[0]]\n elif first_column_index[1] >= 0:\n potential_move = first_column[first_column_index[1]]\n\n second_column = [(0, 1), (1, 1), (2, 1)]\n second_column_index = self.can_complete_three_in_row(second_column, board)\n if second_column_index[0] >= 0:\n return second_column[second_column_index[0]]\n elif second_column_index[1] >= 0:\n potential_move = second_column[second_column_index[1]]\n\n third_column = [(0, 2), (1, 2), (2, 2)]\n third_column_index = self.can_complete_three_in_row(third_column, board)\n if third_column_index[0] >= 0:\n return third_column[third_column_index[0]]\n elif third_column_index[1] >= 0:\n potential_move = third_column[third_column_index[1]]\n\n\n # Find Potential Three in a Row for Diagonals\n first_diagonal = [(0, 0), (1, 1), (2, 2)]\n first_diagonal_index = self.can_complete_three_in_row(first_diagonal, board)\n if first_diagonal_index[0] >= 0:\n return first_diagonal[first_diagonal_index[0]]\n elif first_diagonal_index[1] >= 0:\n potential_move = first_diagonal[first_diagonal_index[1]]\n\n second_diagonal = [(2, 0), (1, 1), (0, 2)]\n second_diagonal_index = self.can_complete_three_in_row(second_diagonal, board)\n\n if second_diagonal_index[0] >= 0:\n return second_diagonal[second_diagonal_index[0]]\n elif second_diagonal_index[1] >= 0:\n potential_move = second_diagonal[second_diagonal_index[1]]\n\n return potential_move","def win(s):\r\n\r\n # check across\r\n for i in range(3):\r\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\r\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\r\n return True\r\n\r\n # check down\r\n for i in range(3):\r\n if board[i] == board[i + 3] == board[i + 6] == s:\r\n board[i] = board[i + 3] = board[i + 6] = '#'\r\n return True\r\n\r\n # check diagonal right\r\n if board[0] == board[4] == board[8] == s:\r\n board[0] = board[4] = board[8] = '#'\r\n return True\r\n\r\n # check diagonal left\r\n if board[6] == board[4] == board[2] == s:\r\n board[6] = board[4] = board[2] = '#'\r\n return True\r\n\r\n return False","def player(board):\n count = 0\n for row in range(len(board)):\n for col in range(len(board[row])):\n if board[row][col] == X or board[row][col] == O:\n count += 1\n\n if count % 2 == 0:\n return X\n else:\n return O","def move(self, row, col, player):\n score = 1 if player == 1 else -1\n self.rows[row] += score\n self.cols[col] += score\n if row == col:\n self.diagonal1 += score\n if row + col == self.n - 1:\n self.diagonal2 += score\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\n if self.n in win or -self.n in win:\n return player\n return 0","def win_column(playerid):\n\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\n return (True, \"Column 1\")\n\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\n return (True, \"Column 2\")\n\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\n return (True, \"Column 3\")\n\n return False","def check_game_status(self):\n for player in (\"1\", \"2\"):\n row_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 1, self.board\n ).any()\n col_win = np.apply_along_axis(\n lambda x: set(x) == {player}, 0, self.board\n ).any()\n d1_win = set(self.data[[0, 4, 8]]) == {player}\n d2_win = set(self.data[[2, 4, 6]]) == {player}\n if any([row_win, col_win, d1_win, d2_win]):\n return (\"win\", player)\n\n if self.counter[\"_\"] == 0:\n return (\"tie\", None)\n else:\n return (\"turn\", \"1\" if self.counter[\"1\"] == self.counter[\"2\"] else \"2\")","def fn(i):\n for j in range(n):\n if grid[i][j] and not seen[j]: \n seen[j] = True\n if match[j] == -1 or fn(match[j]): \n match[j] = i\n return True \n return False","def player(board):\n\n if terminal(board):\n return 7\n\n numX = 0\n numO = 0\n\n for i in board:\n for j in i:\n if j == X:\n numX = numX + 1\n elif j == O:\n numO = numO + 1\n\n if numX == numO:\n return X\n else:\n return O","def winner(board):\n for turn in [X,O]:\n for i in range(3):\n if board[i] == [turn, turn, turn]:\n return turn\n if board[0][i] == turn and board[1][i] == turn and board[2][i] == turn:\n return turn\n if board[0][0] == turn and board[1][1] == turn and board[2][2] == turn:\n return turn\n if board[0][2] == turn and board[1][1] == turn and board[2][0] == turn:\n return turn\n return None","def record_winner(cls):\n # Determine number of contiguous positions needed to win\n win_length = 3 if cls.size == 3 else 4\n\n # Store all sets of coordinates for contiguous positions\n sets = []\n\n # Loop through all 3x3 squares on the board\n for x in range(0, cls.size-(win_length-1)):\n for y in range(0, cls.size-(win_length-1)):\n # Add sets for rows\n for row in range(x, x+win_length):\n set = []\n for col in range(y, y+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for columns\n for col in range(y, y+win_length):\n set = []\n for row in range(x, x+win_length):\n set.append([row, col])\n sets.append(set)\n # Add sets for diagonals\n if cls.size == 3:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\n else:\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\n\n # Check all sets for winner\n for set in sets:\n d = {}\n for coords in set:\n token = cls.board[coords[0]][coords[1]]\n d[token] = token != cls.empty\n # If the dictionary only has one key and it's not empty, then we have a winner\n tokens = list(d.keys())\n if len(tokens) == 1 and d[tokens[0]]:\n cls.winner = tokens[0]","def check(self):\n winner = None\n count = 0\n\n for y in range(self.gridSize):\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for item in self.grid[y]:\n # Check row of the grid\n if item == \"P1\":\n P1 += 1\n elif item == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for x in range(self.gridSize):\n # Check column of the grid\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check right top to left bottom across the grid\n for x in range(self.gridSize):\n if x == y:\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check the left top to the right bottom across the grid\n for x in range(self.gridSize - 1, -1, -1):\n # Check how many filled spaces there are\n if \".\" not in self.grid[y][x]:\n count += 1\n if x + y == self.gridSize - 1:\n if self.grid[y][x] == \"P1\":\n P1 += 1\n elif self.grid[y][x] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n # Check if there is a winner if so return the winner\n if winner != None:\n return winner\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\n if count == self.gridSize**2:\n return \"Tie\"","def who_won(self, board):\n winners = set()\n for x,y,z in self.wins:\n if board[x] == board[y] and board[y] == board[z]:\n winners.add(board[x])\n if 1 in winners and 2 in winners:\n return 3\n if 1 in winners:\n return 1\n if 2 in winners:\n return 2\n return 0","def winner(self):\n\n\t\tfor player in [1,2]:\n\t\t\twon = np.full((self.boardSize), player)\n\n\t\t\t# Check diagonals\n\t\t\tif(np.array_equal(np.diag(self.board), won)): return player\n\t\t\tif(np.array_equal(np.diag(np.fliplr(self.board)), won)): return player\n\n\t\t\t# Check lines and columns\n\t\t\tfor i in range(self.boardSize):\n\t\t\t\tif(np.array_equal(self.board[i], won)): return player\n\t\t\t\tif(np.array_equal(self.board[:,i], won)): return player\n\n\t\t# Draw\n\t\tif(not(0 in self.board)): return 3\n\n\t\t# No win or draw\n\t\treturn 0","def test_check_win(self):\n # Horizontal wins\n # First row\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n\n # Second row\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(1, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\n\n # Third row\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Vertical wins\n # First column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 0, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n\n # Second column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERX)\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\n\n # Third column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Diagonal wins\n # Upper left to bottom right\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Bottom left to upper right\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n\n # Draw\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 0, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), DRAW)","def _determine_winner(game_result):\n return next(line for line in game_result.splitlines()\n if re.compile(_WINNING_RANK_STRING).search(line)).split(_SPACE_DELIMITER)[_BOT_ID_POSITION]"],"string":"[\n \"def search_next_win(self, player):\\n for i, j, k in self.winning_cases:\\n if self.game_board[i] == player and \\\\\\n self.game_board[j] == player and \\\\\\n self.game_board[k] == ' ':\\n return k\\n elif self.game_board[j] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[i] == ' ':\\n return i\\n elif self.game_board[i] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[j] == ' ':\\n return j\\n return None\",\n \"def row_win(board, player):\\n for row in board:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def _check_row(self):\\n match = None\\n for row in self._board:\\n row_string = ''.join(row)\\n match = re.search(WIN_REGEX, row_string)\\n if match:\\n return match.group()[0]\\n return None\",\n \"def row_win(board):\\n\\tfor row in range(3):\\n\\t\\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def check_rows():\\n global game_still_going\\n # Check if any of the rows have all the same value.\\n row1 = board[0] == board[1] == board[2] != '_'\\n row2 = board[3] == board[4] == board[5] != '_'\\n row3 = board[6] == board[7] == board[8] != '_'\\n # If any row does have a match, then game still going to False.\\n if row1 or row2 or row3:\\n game_still_going = False\\n # Return winner 'X' or 'O'.\\n if row1:\\n return board[0]\\n if row2:\\n return board[3]\\n if row3:\\n return board[6]\",\n \"def check_row(self, row, symbol):\\r\\n\\r\\n tally = 0\\r\\n for column in range(3):\\r\\n if self.board[row][column][1] == symbol:\\r\\n tally += 1\\r\\n if tally == 3:\\r\\n self.winner = symbol\",\n \"def check_rows():\\n global ongoing_game\\n row_1 = board[0] == board[1] == board[2] != \\\"*\\\"\\n row_2 = board[3] == board[4] == board[5] != \\\"*\\\"\\n row_3 = board[6] == board[7] == board[8] != \\\"*\\\"\\n if row_1 or row_2 or row_3:\\n ongoing_game = False\\n if row_1:\\n return board[0]\\n elif row_2:\\n return board[3]\\n elif row_3:\\n return board[6]\\n else:\\n return None\",\n \"def test_row_col(board, rows):\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\",\n \"def col_win(board, player):\\n for row in board.T:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def check_for_win(self, row, col, player): \\n\\n count = 0\\n for i in range(0, len(self.board[0])):\\n # Check vertical\\n if self.board[row][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n\\n count = 0\\n for i in range(0, len(self.board)):\\n # Check horisontal\\n if self.board[:, col][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n \\n count = 0\\n totoffset = col - row\\n for i in np.diagonal(self.board, offset=totoffset):\\n # Check diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\\n\\n count = 0\\n mirrorboard = np.fliplr(self.board)\\n col = self.colswitch[col]\\n totoffset = col - row\\n for i in np.diagonal(mirrorboard, offset=totoffset):\\n # Check other diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\",\n \"def look_through_rows(board, column, player):\\n if board.shape[1] > column:\\n count = board.shape[0] - 1\\n count2 = 1\\n while count >= 0 and count2 == 1:\\n if board[count,column] == 0:\\n board[count,column] = player\\n count2 = count2 - 1\\n else:\\n count = count - 1\\n return board\\n else:\\n print('Improper Column Given')\",\n \"def check_rows(self):\\r\\n for i in range(0, len(self.grid),3):\\r\\n if self.grid[i][-1] != ' ' and self.grid[i][-1] == self.grid[i+1][-1] and self.grid[i+1][-1] == self.grid[i+2][-1]:\\r\\n return (i, (self.grid[i], self.grid[i+2]))\\r\\n return (-1, None)\",\n \"def win_row(playerid):\\n if board[0][0] is playerid and board[0][1] is playerid and board[0][2] is playerid:\\n return (True, \\\"Row 1\\\")\\n\\n if board[1][0] is playerid and board[1][1] is playerid and board[1][2] is playerid:\\n return (True, \\\"Row 2\\\")\\n\\n if board[2][0] is playerid and board[2][1] is playerid and board[2][2] is playerid:\\n return (True, \\\"Row 3\\\")\\n\\n return False\",\n \"def check_for_win_lose(b):\\r\\n win_move = None\\r\\n block_win = None\\r\\n # check for wins based on row\\r\\n for ri in range(3):\\r\\n row = b[ri]\\r\\n if single_move(row):\\r\\n if row==[1,1,0]:\\r\\n win_move = (ri+1,3)\\r\\n elif row==[2,2,0]:\\r\\n block_win = (ri+1,3)\\r\\n elif row==[1,0,1]:\\r\\n win_move = (ri+1,2)\\r\\n elif row==[2,0,2]:\\r\\n block_win = (ri+1,2)\\r\\n elif row==[0,1,1]:\\r\\n win_move = (ri+1,1)\\r\\n elif row==[0,2,2]:\\r\\n block_win = (ri+1,1)\\r\\n else:\\r\\n print '144 ERROR!'\\r\\n print single_move(row)\\r\\n print row\\r\\n print ' '\\r\\n\\r\\n # check for win based on column\\r\\n for ci in range(3):\\r\\n col = get_col(b,ci)\\r\\n if single_move(col):\\r\\n if col==[1,1,0]:\\r\\n win_move = (3,ci+1)\\r\\n elif col==[2,2,0]:\\r\\n block_win = (3,ci+1)\\r\\n elif col==[1,0,1]:\\r\\n win_move = (2,ci+1)\\r\\n elif col==[2,0,2]:\\r\\n block_win = (2,ci+1)\\r\\n elif col==[0,1,1]:\\r\\n win_move = (1,ci+1)\\r\\n elif col==[0,2,2]:\\r\\n block_win = (1,ci+1)\\r\\n else:\\r\\n print '166 ERROR!'\\r\\n print single_move(col)\\r\\n print col\\r\\n print ' '\\r\\n\\r\\n # check for win on backward diagonal\\r\\n diag = get_bw_diag(b)\\r\\n if single_move(diag):\\r\\n if diag==[1,1,0]:\\r\\n win_move = (3,3)\\r\\n elif diag==[2,2,0]:\\r\\n block_win (3,3)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,1)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,1)\\r\\n \\r\\n # check for win on forward diagonal\\r\\n diag = get_fwd_diag(b)\\r\\n if single_move(diag):\\r\\n if diag == [1,1,0]:\\r\\n win_move = (3,1)\\r\\n elif diag==[2,2,0]:\\r\\n block_win = (3,1)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,3)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,3)\\r\\n\\r\\n if win_move is not None:\\r\\n return (win_move, True)\\r\\n elif block_win is not None:\\r\\n return (block_win, False)\\r\\n else:\\r\\n return (None, False)\",\n \"def winner_found(self):\\n\\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\\n winner_in_rows = first_row or second_row or third_row\\n\\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\\n winner_in_columns = first_column or second_column or third_column\\n\\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\\n winner_in_diagonals = first_diagonal or second_diagonal\\n\\n return winner_in_rows or winner_in_columns or winner_in_diagonals\",\n \"def find_best_move(board):\\n new_board = board.get_board()\\n\\n # X | X | X <-- Check for win on this row\\n # ---------\\n # 3 | 4 | 5\\n # ---------\\n # 6 | 7 | 9\\n if new_board[0] == new_board[1] and new_board[2] == \\\"2\\\":\\n return 2\\n elif new_board[0] == new_board[2] and new_board[1] == \\\"1\\\":\\n return 1\\n elif new_board[1] == new_board[2] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | 2\\n # ---------\\n # X | X | X <-- Check for win on this row\\n # ---------\\n # 6 | 7 | 9\\n elif new_board[3] == new_board[4] and new_board[5] == \\\"5\\\":\\n return 5\\n elif new_board[3] == new_board[5] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[4] == new_board[5] and new_board[3] == \\\"3\\\":\\n return 3\\n\\n # 0 | 1 | 2\\n # ---------\\n # 3 | 4 | 5\\n # ---------\\n # X | X | X <-- Check for win on this row\\n elif new_board[6] == new_board[7] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[6] == new_board[8] and new_board[7] == \\\"7\\\":\\n return 7\\n elif new_board[7] == new_board[8] and new_board[6] == \\\"6\\\":\\n return 6\\n\\n # X | 1 | 2 Check for win on column one\\n # ---------\\n # X | 4 | 5\\n # ---------\\n # X | 7 | 9\\n elif new_board[0] == new_board[3] and new_board[6] == \\\"6\\\":\\n return 6\\n elif new_board[0] == new_board[6] and new_board[3] == \\\"3\\\":\\n return 3\\n elif new_board[6] == new_board[3] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | X | 2 Checks for win on column two\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # 6 | X | 9\\n elif new_board[1] == new_board[4] and new_board[7] == \\\"7\\\":\\n return 7\\n elif new_board[1] == new_board[7] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[7] == new_board[4] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | X\\n # ---------\\n # 3 | 4 | X\\n # ---------\\n # 6 | 7 | X\\n elif new_board[2] == new_board[5] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[2] == new_board[8] and new_board[5] == \\\"5\\\":\\n return 5\\n elif new_board[8] == new_board[5] and new_board[2] == \\\"2\\\":\\n return 2\\n\\n # X | 1 | 2\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # 6 | 7 | X\\n elif new_board[0] == new_board[4] and new_board[8] == \\\"8\\\":\\n return 8\\n elif new_board[0] == new_board[8] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[8] == new_board[4] and new_board[0] == \\\"0\\\":\\n return 0\\n\\n # 0 | 1 | X\\n # ---------\\n # 3 | X | 5\\n # ---------\\n # X | 7 | 9\\n elif new_board[2] == new_board[4] and new_board[6] == \\\"6\\\":\\n return 6\\n elif new_board[2] == new_board[6] and new_board[4] == \\\"4\\\":\\n return 4\\n elif new_board[6] == new_board[4] and new_board[2] == \\\"2\\\":\\n return 2\\n\\n # If corners are empty, play there\\n elif new_board[0] == \\\"0\\\" or new_board[2] == \\\"2\\\" or new_board[6] == \\\"6\\\" or new_board[8] == \\\"8\\\":\\n try_spot = 0\\n while True:\\n if new_board[try_spot] != \\\"X\\\" and new_board[try_spot] != \\\"O\\\":\\n return try_spot\\n else:\\n try_spot = try_spot + 2\\n\\n # If middle is empty, play there\\n elif new_board[4] == \\\"4\\\":\\n return 4\\n\\n # Finally if edges are empty try there\\n elif new_board[1] == \\\"1\\\" or new_board[3] == \\\"3\\\" or new_board[5] == \\\"5\\\" or new_board[7] == \\\"7\\\":\\n try_spot = 1\\n while True:\\n if new_board[try_spot] != \\\"X\\\" and new_board[try_spot] != \\\"O\\\":\\n return try_spot\\n else:\\n try_spot = try_spot + 2\",\n \"def check_rows(self):\\n\\t\\tfor i in range(len(self.board)):\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor j in range(len(self.board[i])):\\n\\t\\t\\t\\tif self.board[i][j] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('YOU WON')\\n\\t\\t\\t\\treturn True\",\n \"def win_check(board, mark):\\n win_positions = [\\\"123\\\", \\\"456\\\", \\\"789\\\", \\\"147\\\", \\\"258\\\", \\\"369\\\", \\\"159\\\", \\\"357\\\"]\\n is_winner = False\\n for positions in win_positions:\\n for idx in positions:\\n idx = int(idx)\\n if board[idx] != mark:\\n break\\n else:\\n is_winner = True\\n\\n return is_winner\",\n \"def checkwin(self):\\n w = self.getWidth()\\n h = self.getHeight()\\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\\n for r in range(h):\\n for c in range(w):\\n if self.cell[c][r] == EMPTY:\\n continue # this cell can't be part of winning segment\\n # if we reach this point, the cell is occupied by a player stone\\n numOccupiedCell = numOccupiedCell+1\\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\\n for i in range(NWIN):\\n # test if there exists a segment of NWIN uniformly coloured cells\\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\\n break # segment broken\\n else:\\n # Python remark: notice that the else is attached to the for loop \\\"for i...\\\"\\n # This block is executed if and only if 'i' arrives at the end of its range \\n return self.cell[c][r] , True # found a winning segment \\n return EMPTY, numOccupiedCell==w*h\",\n \"def check_row(row, player):\\n for marker in row:\\n if marker != player:\\n return False\\n return True\",\n \"def search_possible_steps(self):\\n if self.ended:\\n return False\\n possible_steps_turple = (self.board == 0)\\n possible_steps = np.transpose(possible_steps_turple.nonzero())\\n return possible_steps\",\n \"def rowWin( self ):\\n\\n for x in [0,3,6]:\\n firstVal = self.__grid[x]\\n secondVal = self.__grid[x+1]\\n thirdVal = self.__grid[x+2]\\n\\n compiledVal = str(firstVal) + str(secondVal) + str(thirdVal)\\n\\n if compiledVal.lower() == 'xxx':\\n return 'X'\\n\\n elif compiledVal.lower() == 'ooo':\\n return 'O' \\n \\n return None\",\n \"def row_wise_checking(player_):\\n if board[0] == board[1] == player_:\\n return 2\\n elif board[1] == board[2] == player_:\\n return 0\\n elif board[3] == board[4] == player_:\\n return 5\\n elif board[4] == board[5] == player_:\\n return 3\\n elif board[6] == board[7] == player_:\\n return 8\\n elif board[7] == board[8] == player_:\\n return 6\\n else:\\n return -1\",\n \"def player(board):\\n X_count = 0\\n O_count = 0\\n\\n for row in board:\\n X_count += row.count(X)\\n O_count += row.count(O)\\n\\n if X_count <= O_count:\\n return X\\n else:\\n return O\",\n \"def check_four_in_a_row(self, player_symbol, row, col, step_row_1, step_col_1, step_row_2, step_col_2):\\n num_connected = 1 # Tally of how many game pieces were found matching thus far\\n\\n def increment_connected(step_row, step_col):\\n \\\"\\\"\\\"\\n Checks to see if the game is over. This occurs if a player has four pieces in a row, or if the board is full.\\n :param step_row: The amount to move in the Y direction\\n :param step_col: The amount to move in the X direction\\n :return: The number of adjacent matching tiles found by the function\\n \\\"\\\"\\\"\\n connected = 0\\n current_row = row + step_row\\n current_col = col + step_col\\n\\n while self.board[current_row][current_col] == player_symbol:\\n connected += 1\\n current_row += step_row\\n current_col += step_col\\n\\n return connected\\n\\n num_connected += increment_connected(step_row_1, step_col_1)\\n num_connected += increment_connected(step_row_2, step_col_2)\\n\\n if num_connected >= 4:\\n self.game_over = True\",\n \"def winner(row):\\r\\n x=0\\r\\n o=0\\r\\n win=False\\r\\n winner='X'\\r\\n empty=False #Better not to do '.' in row\\r\\n \\r\\n for char in row:\\r\\n if char=='X':\\r\\n x+=1\\r\\n o=0\\r\\n if char=='O':\\r\\n o+=1\\r\\n x=0\\r\\n if char=='T':\\r\\n x+=1\\r\\n o+=1\\r\\n if char=='.':\\r\\n x=0\\r\\n o=0\\r\\n empty=True\\r\\n\\r\\n #Check Winner\\r\\n if x==4:\\r\\n win=True\\r\\n winner='X'\\r\\n if o==4:\\r\\n win=True\\r\\n winner='O'\\r\\n return (win,winner,empty)\\r\\n #Done\\r\",\n \"def check_win(self):\\n lines = []\\n\\n # rows\\n lines.extend(self._board)\\n\\n # cols\\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\\n for colidx in range(self._dim)]\\n lines.extend(cols)\\n\\n # diags\\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\\n diag2 = [self._board[idx][self._dim - idx -1]\\n for idx in range(self._dim)]\\n lines.append(diag1)\\n lines.append(diag2)\\n\\n # check all lines\\n for line in lines:\\n if len(set(line)) == 1 and line[0] != EMPTY:\\n if self._reverse:\\n return switch_player(line[0])\\n else:\\n return line[0]\\n\\n # no winner, check for draw\\n if len(self.get_empty_squares()) == 0:\\n return DRAW\\n\\n # game is still in progress\\n return None\",\n \"def check_for_win(self,board, player_id, action):\\n\\n row = 0\\n\\n # check which row was inserted last:\\n for i in range(ROWS):\\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\\n row = ROWS - i\\n break\\n\\n # check horizontal:\\n vec = board[row, :] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check vertical:\\n vec = board[:, action] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check diagonals:\\n vec = np.diagonal(board, action - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n return False\",\n \"def player(board):\\n\\n # Game is over\\n if terminal(board):\\n return None\\n\\n # Count number of occurences of X and O\\n x_count = 0\\n o_count = 0\\n for row in board:\\n for box in row:\\n if box == X:\\n x_count = x_count + 1\\n elif box == O:\\n o_count = o_count + 1\\n # When move count is tied, X is next\\n if x_count <= o_count:\\n return X\\n # When X has moved once more than O, next move is O\\n else:\\n return O\",\n \"def check_win(self):\\n win = None\\n for pos in self.winning_pos:\\n win = self.is_match(set(self.get_cells(pos)))\\n if win:\\n return win\\n if not self.open_tiles():\\n return \\\"Draw\\\"\\n return win\",\n \"def winner(board):\\n x_in_board = []\\n o_in_board = []\\n winning_positions = [\\n [[0, 0], [0, 1], [0, 2]],\\n [[1, 0], [1, 1], [1, 2]],\\n [[2, 0], [2, 1], [2, 2]],\\n [[0, 0], [1, 0], [2, 0]],\\n [[0, 1], [1, 1], [2, 1]],\\n [[0, 2], [1, 2], [2, 2]],\\n [[0, 0], [1, 1], [2, 2]],\\n [[0, 2], [1, 1], [2, 0]]\\n ]\\n\\n for i in range(len(board)):\\n for j in range(len(board)):\\n if board[i][j] == X:\\n x_in_board.append([i, j])\\n elif board[i][j] == O:\\n o_in_board.append([i, j])\\n\\n for i in winning_positions:\\n if i[0] in x_in_board and i[1] in x_in_board and i[2] in x_in_board:\\n return X\\n elif i[0] in o_in_board and i[1] in o_in_board and i[2] in o_in_board:\\n return O\\n\\n return None\",\n \"def win_check(table: list) -> (bool, str):\\n # Combinations that would lead to a win\\n win_list = [\\n [0,1,2], [3,4,5],\\n [6,7,8], [0,3,6],\\n [1,4,7], [2,5,8],\\n [0,4,8], [6,4,2],\\n ]\\n for line in win_list:\\n # Check rows, columns, and diagonals\\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\\n\\n if len(combination) == 1 and combination != {\\\"-\\\"}: # Which mean we have a straight line of either X or O\\n #unpack comb (which is 1 item), which is either \\\"X\\\" or \\\"O\\\" to know who won\\n return True, *combination\\n else:\\n return False, None\",\n \"def _get_row_index(self, row: Row) -> int:\\n row_index = -1\\n for index, table_row in enumerate(self.table_data):\\n if table_row.values == row.values:\\n row_index = index\\n break\\n return row_index\",\n \"def check_columns(self, win: list) -> bool:\\r\\n for row in range(self.size):\\r\\n column = [self.tags[x][row] for x in range(self.size)]\\r\\n for j in range(len(column) - len(win) + 1):\\r\\n if win == column[j:j+self.win_condition]:\\r\\n return True\",\n \"def find_row(table, row):\\n for idx in range(len(table)):\\n if table[idx][0] == row:\\n return idx\\n return -1\",\n \"def row_checker(board, size):\\n for i in range(size):\\n for j in range(1, size):\\n if board[i][0] != board[i][j]:\\n break\\n else:\\n yield f\\\"'{board[i][j]}' (Row index: {i})\\\"\",\n \"def winner(board):\\n columns = []\\n for row in board:\\n xcount = row.count(X)\\n ocount = row.count(O)\\n if xcount == 3:\\n return X\\n if ocount == 3:\\n return O\\n\\n for j in range(len(board)):\\n column = [row[j] for row in board]\\n columns.append(column)\\n \\n for j in columns:\\n xcounter = j.count(X)\\n ocounter = j.count(O)\\n if xcounter == 3:\\n return X\\n if ocounter == 3:\\n return O\\n \\n if board[0][0] == O and board[1][1] == O and board[2][2] == O:\\n return O\\n if board[0][0] == X and board[1][1] == X and board[2][2] == X:\\n return X\\n if board[0][2] == O and board[1][1] == O and board[2][0] == O:\\n return O\\n if board[0][2] == X and board[1][1] == X and board[2][0] == X:\\n return X\\n\\n return None\",\n \"def move(self, row, col, player):\\n if self.winning == True:\\n return\\n self.matrix[row][col] = player\\n n = len(self.matrix)\\n indicator = True\\n for i in range(n):\\n if self.matrix[row][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n indicator = True\\n for i in range(n):\\n if self.matrix[i][col] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n \\n if row == col:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n if row + col == n - 1:\\n indicator = True\\n for i in range(n):\\n if self.matrix[i][n - 1 - i] != player:\\n indicator = False\\n break\\n if indicator == True:\\n self.winning = True\\n return player\\n return 0\",\n \"def find_row(word):\\n idx = 0\\n first = 0\\n second = 127\\n while idx < 7:\\n first, second = converter(word[idx], first, second)\\n idx += 1\\n return first\",\n \"def isSolved(board):\\n for player in [1, 2]:\\n if [player]*3 in chain(\\n board, # Rows\\n zip(board), # Columns\\n [ # Diagonals\\n [board[i][i] for i in range(len(board))],\\n [board[len(board) - i - 1][i] for i in range(len(board))]\\n ]\\n ):\\n return player\\n return -1 if 0 in chain(*board) else 0\",\n \"def player(board):\\n number_of_X = 0\\n number_of_O = 0\\n \\n for row in board: \\n number_of_X += row.count(\\\"X\\\")\\n number_of_O += row.count(\\\"O\\\")\\n \\n \\n if number_of_X <= number_of_O:\\n return(\\\"X\\\") \\n else: \\n return(\\\"O\\\")\",\n \"def check_winner(self):\\n if self.history:\\n last_move = self.history[-1]\\n last_player = self.get_last_player()\\n\\n connected_token = last_player*self.n_in_row\\n # check for row\\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for column\\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope 1\\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope -1\\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for draw game\\n if len(np.argwhere(self.state==0)) == 0:\\n self.winner = [True, 0]\\n return self.winner\\n return self.winner\",\n \"def check_win(self, player):\\n for win_pos in TicTacToe.win_pos:\\n # for each winning position defined we take the set difference to the positions played be player\\n # if there are not elements left after resulting set after difference operator\\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\\n # the winner\\n if not win_pos.difference(self.player_played_pos[player]):\\n return True\\n\\n # if after checking for every winning positions if the control still reaches here,\\n # the player has not marked the winning positions. returns False\\n return False\",\n \"def evaluate(board):\\n winner = 0\\n for player in [1, 2]:\\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\\n winner = player\\n \\n if np.all(board != 0) and winner == 0:\\n winner = -1\\n return winner\",\n \"def find_sequence(matrix, pos):\\n for direction in [(-1, 1), (0, 1), (1, 1), (1, 0)]:\\n is_found = find_sequence_to_direction(matrix, pos, direction)\\n if is_found:\\n return True\\n return False\",\n \"def check_winner(self):\\n for row in self.board.values():\\n if all([mark == \\\"x\\\" for mark in row]):\\n return self.player_1\\n elif all([mark == \\\"o\\\" for mark in row]):\\n return self.player_2\\n\\n # checks every column\\n for i in range(3):\\n first_row, second_row, third_row = self.board.values()\\n if first_row[i] == \\\"x\\\" and second_row[i] == \\\"x\\\" and third_row[i] == \\\"x\\\":\\n return self.player_1\\n elif first_row[i] == \\\"o\\\" and second_row[i] == \\\"o\\\" and third_row[i] == \\\"o\\\":\\n return self.player_2\\n\\n # checks the diagonals\\n if self.board[\\\"a\\\"][0] == \\\"x\\\" and self.board[\\\"b\\\"][1] == \\\"x\\\" and self.board[\\\"c\\\"][2] == \\\"x\\\":\\n return self.player_1\\n if self.board[\\\"a\\\"][2] == \\\"o\\\" and self.board[\\\"b\\\"][1] == \\\"o\\\" and self.board[\\\"c\\\"][0] == \\\"o\\\":\\n return self.player_2\\n\\n return None\",\n \"def winning_move(board, position, player):\\n win = list(player*3)\\n if get_row(board, position) == win:\\n return True\\n elif get_column(board, position) == win:\\n return True\\n elif position % 2 != 0:\\n # odd positions are on the diagonals\\n return get_diagonal(board, 1) == win or get_diagonal(board, 3) == win\\n return False\",\n \"def check_for_win(self, index):\\n\\n\\t\\tpossible_comb = self.cell_combinations[index]\\n\\n\\t\\tfor comb in possible_comb:\\n\\n\\t\\t\\ttokens = []\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[0]].token)\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[1]].token)\\n\\t\\t\\ttokens.append(self.player_model.grid[comb[2]].token)\\n\\n\\t\\t\\tif all([token == self.player_model.current_player.token for token in tokens]):\\n\\n\\t\\t\\t\\treturn True\\n\\n\\t\\treturn False\",\n \"def winner(board):\\n # Hard code winning moves\\n # row0\\n if board[0][0] == board[0][1] == board[0][2] == X:\\n return X\\n elif board[0][0] == board[0][1] == board[0][2] == O:\\n return O\\n # row1\\n elif board[1][0] == board[1][1] == board[1][2] == X:\\n return X\\n elif board[1][0] == board[1][1] == board[1][2] == O:\\n return O\\n # row2\\n elif board[2][0] == board[2][1] == board[2][2] == X:\\n return X\\n elif board[2][0] == board[2][1] == board[2][2] == O:\\n return O\\n # col0\\n elif board[0][0] == board[1][0] == board[2][0] == X:\\n return X\\n elif board[0][0] == board[1][0] == board[2][0] == O:\\n return O\\n # col1\\n elif board[0][1] == board[1][1] == board[2][1] == X:\\n return X\\n elif board[0][1] == board[1][1] == board[2][1] == O:\\n return O\\n # col2\\n elif board[0][2] == board[1][2] == board[2][2] == X:\\n return X\\n elif board[0][2] == board[1][2] == board[2][2] == O:\\n return O\\n # diagonal\\n elif board[0][0] == board[1][1] == board[2][2] == X:\\n return X\\n elif board[0][0] == board[1][1] == board[2][2] == O:\\n return O\\n # inverse diagonal\\n elif board[0][2] == board[1][1] == board[2][0] == X:\\n return X\\n elif board[0][2] == board[1][1] == board[2][0] == O:\\n return O\\n\\n return None\",\n \"def exitsinrow(self,rows,row,num):\\r\\n for i in range(9):\\r\\n if(rows[row][i] == num):\\r\\n return True\\r\\n return False\",\n \"def check_game_status2(board):\\n board = np.array(board)\\n for i in range(7):\\n for j in range(6):\\n if checkWin(board, j, i, 1):\\n return 1\\n if checkWin(board, j, i, 2):\\n return 2\\n if isfull(board):\\n return 0\\n return -1\",\n \"def check_winner(self, row, column, symbol):\\r\\n self.check_row(row, symbol)\\r\\n self.check_column(column, symbol)\\r\\n self.check_diag(row, column, symbol)\",\n \"def won(self):\\n for y in range(self.size):\\n winning = []\\n for x in range(self.size):\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n for x in range(self.size):\\n winning = []\\n for y in range(self.size):\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n winning = []\\n for y in range(self.size):\\n x = y\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n winning = []\\n for y in range(self.size):\\n x = self.size-1-y\\n if self.fields[x, y] == self.opponent:\\n winning.append((x, y))\\n if len(winning) == self.size:\\n return winning\\n return None\",\n \"def checkRow(self, x):\\n used = []\\n for y in range(len(self.board[0])):\\n cur = self.board[x][y]\\n if cur not in used:\\n if cur !=0:\\n used += [cur]\\n else:\\n return False\\n return True\",\n \"def winning_event(self, player):\\n # vertical check\\n for col in range(GameData.columns):\\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\\n self.draw_vertical_winning_line(col, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # horizontal check\\n for row in range(GameData.rows):\\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\\n self.draw_horizontal_winning_line(row, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # ascending diagonal heck\\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\\n self.draw_asc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # descending diagonal win chek\\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\\n self.draw_desc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n return False\",\n \"def check_win(self, board, move):\\n for i, j, k in self.winning_cases:\\n if board[i] == move and board[j] == move and board[k] == move:\\n return True\\n return False\",\n \"def player(board):\\n X_count = 0\\n O_count = 0\\n #to determine the turn, I will make a count of the X and O tokens on the board\\n for row in board:\\n #I create a dictionary with the count on each row\\n player_turns = {i: row.count(i) for i in row}\\n #I check if I have X and O tokens in the row, if not, create an entry with 0\\n if not (player_turns.get(\\\"X\\\")):\\n player_turns['X'] = 0\\n if not player_turns.get(\\\"O\\\"):\\n player_turns['O'] = 0\\n #I add to my counter the total amount of tokens found for each player in this row\\n X_count = X_count + int(player_turns['X'])\\n O_count = O_count + int(player_turns['O'])\\n\\n #if X has the same amount of tokens than O, it means it is X's turn\\n if(X_count == O_count):\\n #It should be X's turn. \\n return \\\"X\\\"\\n #Otherwise, it is O's turn.\\n elif(X_count>O_count):\\n #it is O's turn.\\n return \\\"O\\\"\",\n \"def check_win(self, player):\\n def check_row_win(player):\\n for row in self.game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_column_win(player):\\n # For doing a column check, transpose the grid and do a row check\\n trans_game_state = numpy.transpose(self.game_state)\\n for row in trans_game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_diag_win(player):\\n # Left to right diagonal\\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\\n return True\\n # Right to left diagonal\\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\\n return True\\n return False\\n\\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\\n return True\\n return False\",\n \"def _check_for_win(self, piece, piece_x, piece_y):\\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions = []\\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\\n for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions.append((x, y))\\n # Don't need to check the piece that is being placed\\n if (x, y) == (piece_x, piece_y):\\n continue\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece != piece:\\n winning_piece_positions = None\\n break\\n if winning_piece_positions:\\n # Check if there are additional winning pieces that exceed the number required to win.\\n # e.g. a 5-in-a-row when only 4 are required\\n if slope_x != 0:\\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\\n for i in range(1, 1 + num_previous_pieces_to_check)):\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece == piece:\\n winning_piece_positions.insert(0, (x, y))\\n else:\\n break\\n return winning_piece_positions\\n\\n return False\",\n \"def winner(board):\\n chances = [X, O]\\n for chance in chances:\\n for row in range(3):\\n if list(chance)*3 == board[row]:\\n return chance\\n for column in range(3):\\n if [[chance] for i in range(3)] == [[board[row][column]] for row in range(3)]:\\n return chance\\n if board[0][0] == chance and board[1][1] == chance and board[2][2] == chance:\\n return chance\\n if board[0][2] == chance and board[1][1] == chance and board[2][0] == chance:\\n return chance\\n return None\",\n \"def find_in_a_row(s, n=3):\\n for i, v in enumerate(s[:-(n - 1)]):\\n if all(v == s[i + j] for j in range(1, n)):\\n return v\\n return None\",\n \"def player(board):\\n xcount, ocount = 0, 0\\n for row in board:\\n xcount += row.count(X)\\n ocount += row.count(O)\\n if xcount > ocount:\\n return O\\n elif xcount == 0 and ocount == 0:\\n return X\\n elif xcount == ocount:\\n return X\",\n \"def col_win(board):\\n\\tfor col in range(3):\\n\\t\\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def win_condition(self, player):\\n\\n row_list = []\\n column_list = []\\n constant_condition = False\\n row_sequential_condition = False\\n column_sequential_condition = False\\n\\n # Loop through positions on board for player\\n for position_key, position_obj in sorted(self.board.positions.items()):\\n if position_obj.value == player.value:\\n row_list.append(position_obj.row)\\n column_list.append(position_obj.column)\\n\\n # Either row keys or column keys must stay constant\\n row_set = set(row_list)\\n column_set = set(column_list)\\n if len(row_set) == 1 or len(column_set) == 1:\\n constant_condition = True\\n\\n # The other row keys or column keys must be sequential for number of row or columns\\n row_seq_list = [n for n in range(1, self.board.rows + 1)]\\n column_seq_list = [n for n in range(1, self.board.columns + 1)]\\n if row_list == row_seq_list:\\n row_sequential_condition = True\\n if column_list == column_seq_list:\\n column_sequential_condition = True\\n\\n if constant_condition and (row_sequential_condition or column_sequential_condition):\\n return True\\n elif row_sequential_condition and column_sequential_condition:\\n return True\\n else:\\n return False\",\n \"def check_row(self, number, given_letter):\\n count = 0\\n avalible_pos = []\\n for letter in self.letters:\\n if self.positions[letter + number] == given_letter:\\n count += 1\\n else:\\n avalible_pos.append(letter + number)\\n return count, avalible_pos\",\n \"def win(self, player):\\n if player == 1:\\n a = self.player_one.moves\\n else:\\n a = self.player_two.moves\\n winning_moves = []\\n for i in range(1, 9, 3):\\n winning_moves.append(range(i, i + 3))\\n for i in range(1, 4):\\n winning_moves.append(range(i, i + 7, 3))\\n winning_moves.append([1, 5, 9])\\n winning_moves.append([3, 5, 7])\\n for move in winning_moves:\\n flg = True\\n for index in move:\\n if index not in a:\\n flg = False\\n break\\n if flg:\\n return True, player\\n if len(self.player_one.moves) + len(self.player_two.moves) == 9:\\n self.print_space()\\n self.display_board()\\n self.print_space()\\n print \\\" Games is drawn\\\"\\n self.logging.debug(\\\"Game is draw, nobody won\\\")\\n self.logging.debug(\\\"Enjoy the game again :)\\\")\\n sys.exit(100)\\n return False, player\",\n \"def winner(board):\\n \\n possible_wins = []\\n row1 = board[0]\\n row2 = board[1]\\n row3 = board[2]\\n col1 = [board[0][0],board[1][0],board[2][0]]\\n col2 = [board[0][1],board[1][1],board[2][1]]\\n col3 = [board[0][2],board[1][2],board[2][2]]\\n diag1 = [board[0][0],board[1][1],board[2][2]]\\n diag2 = [board[2][0],board[1][1],board[0][2]]\\n \\n possible_wins.append(row1)\\n possible_wins.append(row2)\\n possible_wins.append(row3)\\n possible_wins.append(col1)\\n possible_wins.append(col2)\\n possible_wins.append(col3)\\n possible_wins.append(diag1)\\n possible_wins.append(diag2)\\n \\n for trait in possible_wins:\\n if trait.count(\\\"X\\\") == 3:\\n return \\\"X\\\"\\n elif trait.count(\\\"O\\\") == 3:\\n return \\\"O\\\"\\n \\n return None\",\n \"def winner(board):\\n for i in (O, X):\\n for j in range(3):\\n if (board[j][0] == i and board[j][1] == i and board[j][2] == i):\\n return i\\n if (board[0][j] == i and board[1][j] == i and board[2][j] == i):\\n return i\\n if (board[0][0] == i and board[1][1] == i and board[2][2] == i):\\n return i\\n if (board[2][0] == i and board[1][1] == i and board[0][2] == i):\\n return i\\n return None\",\n \"def getWinner(board):\\n players = [X, O]\\n num_symbols_in_line = 3\\n for player in players:\\n # check rows\\n for row in board:\\n line_count = row.count(player)\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check columns\\n for col_i in range(len(board[0])):\\n line_count = 0\\n for row_i in range(len(board)):\\n if board[row_i][col_i] == player:\\n line_count += 1\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check vertical from top left to bottom right\\n line_count = 0\\n for vert_cell in range(len(board)):\\n if board[vert_cell][vert_cell] == player:\\n line_count += 1\\n if line_count == num_symbols_in_line:\\n return player\\n \\n # check vertical from top right to bottom left\\n line_count = 0\\n col_i = len(board) - 1\\n for row_i in range(len(board)):\\n if board[row_i][col_i] == player:\\n line_count += 1\\n col_i -= 1\\n if line_count == num_symbols_in_line:\\n return player\\n\\n return None\",\n \"def check_game_over(self, row, col):\\n player_symbol = self.board[row][col]\\n\\n # Top Right: Row -1 Col 1\\n # Bottom Left: Row 1 Col -1\\n self.check_four_in_a_row(player_symbol, row, col, -1, 1, 1, -1)\\n\\n # Top Left: Row -1 Col -1\\n # Bottom Right Row 1 Col 1\\n self.check_four_in_a_row(player_symbol, row, col, -1, -1, 1, 1)\\n\\n # Horizontal: Row 0 Col 1, Row 0 Col -1\\n self.check_four_in_a_row(player_symbol, row, col, 0, 1, 0, -1)\\n\\n # Vertical: Row 1 Col 0, Row -1 Col 0\\n self.check_four_in_a_row(player_symbol, row, col, 1, 0, -1, 0)\\n\\n if self.turns >= self.num_playable_rows * self.num_playable_columns:\\n self.game_over = True\\n self.board_full = True\",\n \"def game_state(matrix):\\n\\n \\\"\\\"\\\"\\n # To set winning tile\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 2048:\\n # return 'win'\\n # return 'not over'\\n \\\"\\\"\\\"\\n for i in range(len(matrix)-1):\\n # intentionally reduced to check the row on the right and below\\n # more elegant to use exceptions but most likely this will be their solution\\n for j in range(len(matrix[0])-1):\\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\\n return 'not over'\\n for i in range(len(matrix)): # check for any zero entries\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 0:\\n return 'not over'\\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\\n return 'not over'\\n for j in range(len(matrix)-1): # check up/down entries on last column\\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\\n return 'not over'\\n return 'lose'\",\n \"def main(board, word):\\r\\n for i, row in enumerate(board):\\r\\n for j, square in enumerate(row):\\r\\n if square == word[0]:\\r\\n res = neighbors(board, word, i, j)\\r\\n if res:\\r\\n return True\\r\\n return False\",\n \"def winner(board):\\r\\n\\r\\n #rows:\\r\\n if (board[0][0] == board[0][1] == board[0][2]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[1][0] == board[1][1] == board[1][2]) and (board[1][0] == \\\"X\\\" or board[1][0] == \\\"O\\\"):\\r\\n return board[1][0]\\r\\n if (board[2][0] == board[2][1] == board[2][2]) and (board[2][0] == \\\"X\\\" or board[2][0] == \\\"O\\\"):\\r\\n return board[2][0]\\r\\n\\r\\n #columns\\r\\n if (board[0][0] == board[1][0] == board[2][0]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[0][1] == board[1][1] == board[2][1]) and (board[0][1] == \\\"X\\\" or board[0][1] == \\\"O\\\"):\\r\\n return board[0][1]\\r\\n if (board[0][2] == board[1][2] == board[2][2]) and (board[0][2] == \\\"X\\\" or board[0][2] == \\\"O\\\"):\\r\\n return board[0][2]\\r\\n\\r\\n #diagonals\\r\\n if (board[0][0] == board[1][1] == board[2][2]) and (board[0][0] == \\\"X\\\" or board[0][0] == \\\"O\\\"):\\r\\n return board[0][0]\\r\\n if (board[0][2] == board[1][1] == board[2][0]) and (board[0][2] == \\\"X\\\" or board[0][2] == \\\"O\\\"):\\r\\n return board[0][2]\\r\\n \\r\\n return None\\r\\n\\r\\n raise NotImplementedError\",\n \"def _check_won(field, col, delta_row):\\n player = field[col][-1]\\n coord = len(field[col]) - 1\\n total = 1\\n # negative dir\\n cur_coord = coord - delta_row\\n for c in range(col - 1, -1, -1):\\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\\n break\\n if field[c][cur_coord] != player:\\n break\\n total += 1\\n if total == COUNT_TO_WIN:\\n return True\\n cur_coord -= delta_row\\n # positive dir\\n cur_coord = coord + delta_row\\n for c in range(col + 1, GAME_COLS):\\n if len(field[c]) <= cur_coord or cur_coord < 0 or cur_coord >= GAME_ROWS:\\n break\\n if field[c][cur_coord] != player:\\n break\\n total += 1\\n if total == COUNT_TO_WIN:\\n return True\\n cur_coord += delta_row\\n return False\",\n \"def check_tie(board):\\n return 0 not in board[0]\",\n \"def check_column(self, column, symbol):\\r\\n\\r\\n tally = 0\\r\\n for row in range(3):\\r\\n if self.board[row][column][1] == symbol:\\r\\n tally += 1\\r\\n if tally == 3:\\r\\n self.winner = symbol\",\n \"def remove_from_winning(game: List[int]) -> None:\\n while True:\\n game_copy = game.copy()\\n row = randint(1, len(game_copy))\\n if game_copy[row-1] < 1:\\n continue\\n matches = randint(1, game_copy[row-1])\\n remove_matches(game_copy, row - 1, matches)\\n if not is_winning(game_copy):\\n remove_matches(game, row - 1, matches)\\n break\\n print(\\\"{} matches on row {} have been removed.\\\".format(matches, row))\",\n \"def win(board):\\n # COLUMNS\\n if board[7] == board[4] == board[1] != ' ': # first column down\\n return board[7]\\n elif board[8] == board[5] == board[2] != ' ': # second column down\\n return board[8]\\n elif board[9] == board[6] == board[3] != ' ': # third column down\\n return board[9]\\n\\n # ROWS\\n if board[7] == board[8] == board[9] != ' ': # first row across\\n return board[7]\\n elif board[4] == board[5] == board[6] != ' ': # second row across\\n return board[4]\\n elif board[1] == board[2] == board[3] != ' ': # third row across\\n return board[1]\\n\\n # DIAGONALS\\n if board[7] == board[5] == board[3] != ' ': # diagonal staring on left\\n return board[7]\\n elif board[9] == board[5] == board[1] != ' ': # diagonal starting on right\\n return board[9]\\n\\n # else no winner\\n return \\\"No\\\"\",\n \"def get_winner(board):\\n\\n def who_won(in_a_row, board_size, cur_player):\\n \\\"\\\"\\\" \\n a function private to get_winner() (yes you can do this. Cool huh!?) \\n that tells get_winner if it has a winner \\n \\\"\\\"\\\"\\n if in_a_row == board_size:\\n return 1 if cur_player == 'X' else 2\\n else:\\n return 0\\n\\n def test_row_col(board, rows):\\n \\\"\\\"\\\" private function to test the rows and columns \\\"\\\"\\\"\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n def test_diagonal(board, normal):\\n \\\"\\\"\\\" private function to test the two diagonals \\\"\\\"\\\"\\n cur_player = board[0][0] if normal else board[0][len(board)-1]\\n in_a_row = 0\\n for i in range(len(board)):\\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1 \\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n\\n # test rows\\n winner = test_row_col(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test cols\\n winner = test_row_col(board, False)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top left to bottom right\\n winner = test_diagonal(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top right to bottom left\\n winner = test_diagonal(board, False)\\n if not winner == 0:\\n return winner\\n\\n return 0\",\n \"def utility(board):\\n game_winner = \\\"\\\"\\n #I will analyze every row first\\n for i in range(0,3):\\n #I check vertically and horizontally if the tokens are the same, meaning any of the two players has 3 in a row.\\n if (board[i][0] == board[i][1] and board[i][0] == board[i][2] and (board[i][0] is not EMPTY)):\\n #if I find a match vertically, I determine there was a winner and break the for cycle.\\n game_winner = board[i][0]\\n break\\n elif (board[0][i] == board[1][i] and board[0][i] == board[2][i] and (board[0][i] is not EMPTY)):\\n #if there is a match horizontally, I determine there was a winner and break the for cycle.\\n game_winner = board[0][i]\\n break\\n #checking diagonals in case there were no winners neither vertically nor horizontally.\\n if ((board[0][0] == board[1][1] and board[2][2] == board[0][0]) or (board[0][2] == board[1][1] and board[2][0] == board[0][2])) and (board[1][1] is not EMPTY):\\n game_winner = board[1][1]\\n #depending on my winning token, I will determine the value I should print. \\n if game_winner == \\\"X\\\":\\n return 1\\n elif game_winner == \\\"O\\\":\\n return -1\\n #Since we are assuming we will only receive terminal boards, if no winner was found, we have a tie and should return 0.\\n else:\\n return 0\",\n \"def _check_row(self, col, board) -> int:\\n score = 0\\n for row in range(len(board)):\\n if board[col][row] == self.colour:\\n score += 1\\n return score\",\n \"def check_win(self):\\r\\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\\r\\n for case, pos in wins:\\r\\n if case != -1:\\r\\n print('Game over!')\\r\\n if self.grid[case][-1] == self.computer:\\r\\n print('The computer won!')\\r\\n return (True, pos)\\r\\n print('The player won!')\\r\\n return (True, pos)\\r\\n\\r\\n return (self.check_draw(), None)\",\n \"def player(board):\\n if terminal(board) == True:\\n return None \\n countO, countX = 0, 0\\n for i in range(3):\\n for j in range(3):\\n if board[i][j] == X:\\n countX += 1\\n elif board[i][j] == O:\\n countO += 1\\n if countO >= countX:\\n return X\\n else:\\n return O\",\n \"def check_win():\\r\\n for mark in markers:\\r\\n if loc[0] == mark and loc[1] == mark and loc[2] == mark:\\r\\n return True\\r\\n if loc[0] == mark and loc[3] == mark and loc[6] == mark:\\r\\n return True\\r\\n if loc[0] == mark and loc[4] == mark and loc[8] == mark:\\r\\n return True\\r\\n if loc[1] == mark and loc[4] == mark and loc[7] == mark:\\r\\n return True\\r\\n if loc[2] == mark and loc[4] == mark and loc[6] == mark:\\r\\n return True\\r\\n if loc[2] == mark and loc[5] == mark and loc[8] == mark:\\r\\n return True\\r\\n if loc[3] == mark and loc[4] == mark and loc[5] == mark:\\r\\n return True\\r\\n if loc[6] == mark and loc[7] == mark and loc[8] == mark:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def TestRow(SudokuGrid):\\r\\n for i in range(9):\\r\\n for j in range(8):\\r\\n for k in range(j+1,9):\\r\\n if SudokuGrid[i][j]==SudokuGrid[i][k]:\\r\\n return False\\r\\n return True\",\n \"def check_for_winner(self, board):\\n\\n potential_move = (-1, -1)\\n\\n # Find Potential Three in a Row for Rows\\n first_row = [(0, 0), (0, 1), (0, 2)]\\n first_row_index = self.can_complete_three_in_row(first_row, board)\\n if first_row_index[0] >= 0:\\n return first_row[first_row_index[0]]\\n elif first_row_index[1] >= 0:\\n potential_move = first_row[first_row_index[1]]\\n\\n second_row = [(1, 0), (1, 1), (1, 2)]\\n second_row_index = self.can_complete_three_in_row(second_row, board)\\n if second_row_index[0] >= 0:\\n return second_row[second_row_index[0]]\\n elif second_row_index[1] >= 0:\\n potential_move = second_row[second_row_index[1]]\\n\\n third_row = [(2, 0), (2, 1), (2, 2)]\\n third_row_index = self.can_complete_three_in_row(third_row, board)\\n if third_row_index[0] >= 0:\\n return third_row[third_row_index[0]]\\n elif third_row_index[1] >= 0:\\n potential_move = third_row[third_row_index[1]]\\n\\n\\n # Find Potential Three in a Row for Columns\\n first_column = [(0, 0), (1, 0), (2, 0)]\\n first_column_index = self.can_complete_three_in_row(first_column, board)\\n if first_column_index[0] >= 0:\\n return first_column[first_column_index[0]]\\n elif first_column_index[1] >= 0:\\n potential_move = first_column[first_column_index[1]]\\n\\n second_column = [(0, 1), (1, 1), (2, 1)]\\n second_column_index = self.can_complete_three_in_row(second_column, board)\\n if second_column_index[0] >= 0:\\n return second_column[second_column_index[0]]\\n elif second_column_index[1] >= 0:\\n potential_move = second_column[second_column_index[1]]\\n\\n third_column = [(0, 2), (1, 2), (2, 2)]\\n third_column_index = self.can_complete_three_in_row(third_column, board)\\n if third_column_index[0] >= 0:\\n return third_column[third_column_index[0]]\\n elif third_column_index[1] >= 0:\\n potential_move = third_column[third_column_index[1]]\\n\\n\\n # Find Potential Three in a Row for Diagonals\\n first_diagonal = [(0, 0), (1, 1), (2, 2)]\\n first_diagonal_index = self.can_complete_three_in_row(first_diagonal, board)\\n if first_diagonal_index[0] >= 0:\\n return first_diagonal[first_diagonal_index[0]]\\n elif first_diagonal_index[1] >= 0:\\n potential_move = first_diagonal[first_diagonal_index[1]]\\n\\n second_diagonal = [(2, 0), (1, 1), (0, 2)]\\n second_diagonal_index = self.can_complete_three_in_row(second_diagonal, board)\\n\\n if second_diagonal_index[0] >= 0:\\n return second_diagonal[second_diagonal_index[0]]\\n elif second_diagonal_index[1] >= 0:\\n potential_move = second_diagonal[second_diagonal_index[1]]\\n\\n return potential_move\",\n \"def win(s):\\r\\n\\r\\n # check across\\r\\n for i in range(3):\\r\\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\\r\\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\\r\\n return True\\r\\n\\r\\n # check down\\r\\n for i in range(3):\\r\\n if board[i] == board[i + 3] == board[i + 6] == s:\\r\\n board[i] = board[i + 3] = board[i + 6] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal right\\r\\n if board[0] == board[4] == board[8] == s:\\r\\n board[0] = board[4] = board[8] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal left\\r\\n if board[6] == board[4] == board[2] == s:\\r\\n board[6] = board[4] = board[2] = '#'\\r\\n return True\\r\\n\\r\\n return False\",\n \"def player(board):\\n count = 0\\n for row in range(len(board)):\\n for col in range(len(board[row])):\\n if board[row][col] == X or board[row][col] == O:\\n count += 1\\n\\n if count % 2 == 0:\\n return X\\n else:\\n return O\",\n \"def move(self, row, col, player):\\n score = 1 if player == 1 else -1\\n self.rows[row] += score\\n self.cols[col] += score\\n if row == col:\\n self.diagonal1 += score\\n if row + col == self.n - 1:\\n self.diagonal2 += score\\n win = {self.rows[row], self.cols[col], self.diagonal1, self.diagonal2}\\n if self.n in win or -self.n in win:\\n return player\\n return 0\",\n \"def win_column(playerid):\\n\\n if board[0][0] is playerid and board[1][0] is playerid and board[2][0] is playerid:\\n return (True, \\\"Column 1\\\")\\n\\n if board[0][1] is playerid and board[1][1] is playerid and board[2][1] is playerid:\\n return (True, \\\"Column 2\\\")\\n\\n if board[0][2] is playerid and board[1][2] is playerid and board[2][2] is playerid:\\n return (True, \\\"Column 3\\\")\\n\\n return False\",\n \"def check_game_status(self):\\n for player in (\\\"1\\\", \\\"2\\\"):\\n row_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 1, self.board\\n ).any()\\n col_win = np.apply_along_axis(\\n lambda x: set(x) == {player}, 0, self.board\\n ).any()\\n d1_win = set(self.data[[0, 4, 8]]) == {player}\\n d2_win = set(self.data[[2, 4, 6]]) == {player}\\n if any([row_win, col_win, d1_win, d2_win]):\\n return (\\\"win\\\", player)\\n\\n if self.counter[\\\"_\\\"] == 0:\\n return (\\\"tie\\\", None)\\n else:\\n return (\\\"turn\\\", \\\"1\\\" if self.counter[\\\"1\\\"] == self.counter[\\\"2\\\"] else \\\"2\\\")\",\n \"def fn(i):\\n for j in range(n):\\n if grid[i][j] and not seen[j]: \\n seen[j] = True\\n if match[j] == -1 or fn(match[j]): \\n match[j] = i\\n return True \\n return False\",\n \"def player(board):\\n\\n if terminal(board):\\n return 7\\n\\n numX = 0\\n numO = 0\\n\\n for i in board:\\n for j in i:\\n if j == X:\\n numX = numX + 1\\n elif j == O:\\n numO = numO + 1\\n\\n if numX == numO:\\n return X\\n else:\\n return O\",\n \"def winner(board):\\n for turn in [X,O]:\\n for i in range(3):\\n if board[i] == [turn, turn, turn]:\\n return turn\\n if board[0][i] == turn and board[1][i] == turn and board[2][i] == turn:\\n return turn\\n if board[0][0] == turn and board[1][1] == turn and board[2][2] == turn:\\n return turn\\n if board[0][2] == turn and board[1][1] == turn and board[2][0] == turn:\\n return turn\\n return None\",\n \"def record_winner(cls):\\n # Determine number of contiguous positions needed to win\\n win_length = 3 if cls.size == 3 else 4\\n\\n # Store all sets of coordinates for contiguous positions\\n sets = []\\n\\n # Loop through all 3x3 squares on the board\\n for x in range(0, cls.size-(win_length-1)):\\n for y in range(0, cls.size-(win_length-1)):\\n # Add sets for rows\\n for row in range(x, x+win_length):\\n set = []\\n for col in range(y, y+win_length):\\n set.append([row, col])\\n sets.append(set)\\n # Add sets for columns\\n for col in range(y, y+win_length):\\n set = []\\n for row in range(x, x+win_length):\\n set.append([row, col])\\n sets.append(set)\\n # Add sets for diagonals\\n if cls.size == 3:\\n sets.append([[x,y],[x+1,y+1],[x+2,y+2]])\\n sets.append([[x,y+2],[x+1,y+1],[x+2,y]])\\n else:\\n sets.append([[x,y],[x+1,y+1],[x+2,y+2],[x+3,y+3]])\\n sets.append([[x,y+3],[x+1,y+2],[x+2,y+1],[x+3,y]])\\n\\n # Check all sets for winner\\n for set in sets:\\n d = {}\\n for coords in set:\\n token = cls.board[coords[0]][coords[1]]\\n d[token] = token != cls.empty\\n # If the dictionary only has one key and it's not empty, then we have a winner\\n tokens = list(d.keys())\\n if len(tokens) == 1 and d[tokens[0]]:\\n cls.winner = tokens[0]\",\n \"def check(self):\\n winner = None\\n count = 0\\n\\n for y in range(self.gridSize):\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for item in self.grid[y]:\\n # Check row of the grid\\n if item == \\\"P1\\\":\\n P1 += 1\\n elif item == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for x in range(self.gridSize):\\n # Check column of the grid\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check right top to left bottom across the grid\\n for x in range(self.gridSize):\\n if x == y:\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check the left top to the right bottom across the grid\\n for x in range(self.gridSize - 1, -1, -1):\\n # Check how many filled spaces there are\\n if \\\".\\\" not in self.grid[y][x]:\\n count += 1\\n if x + y == self.gridSize - 1:\\n if self.grid[y][x] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[y][x] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n # Check if there is a winner if so return the winner\\n if winner != None:\\n return winner\\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\\n if count == self.gridSize**2:\\n return \\\"Tie\\\"\",\n \"def who_won(self, board):\\n winners = set()\\n for x,y,z in self.wins:\\n if board[x] == board[y] and board[y] == board[z]:\\n winners.add(board[x])\\n if 1 in winners and 2 in winners:\\n return 3\\n if 1 in winners:\\n return 1\\n if 2 in winners:\\n return 2\\n return 0\",\n \"def winner(self):\\n\\n\\t\\tfor player in [1,2]:\\n\\t\\t\\twon = np.full((self.boardSize), player)\\n\\n\\t\\t\\t# Check diagonals\\n\\t\\t\\tif(np.array_equal(np.diag(self.board), won)): return player\\n\\t\\t\\tif(np.array_equal(np.diag(np.fliplr(self.board)), won)): return player\\n\\n\\t\\t\\t# Check lines and columns\\n\\t\\t\\tfor i in range(self.boardSize):\\n\\t\\t\\t\\tif(np.array_equal(self.board[i], won)): return player\\n\\t\\t\\t\\tif(np.array_equal(self.board[:,i], won)): return player\\n\\n\\t\\t# Draw\\n\\t\\tif(not(0 in self.board)): return 3\\n\\n\\t\\t# No win or draw\\n\\t\\treturn 0\",\n \"def test_check_win(self):\\n # Horizontal wins\\n # First row\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n\\n # Second row\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(1, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\\n\\n # Third row\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Vertical wins\\n # First column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 0, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n\\n # Second column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\\n\\n # Third column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Diagonal wins\\n # Upper left to bottom right\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Bottom left to upper right\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n\\n # Draw\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 0, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), DRAW)\",\n \"def _determine_winner(game_result):\\n return next(line for line in game_result.splitlines()\\n if re.compile(_WINNING_RANK_STRING).search(line)).split(_SPACE_DELIMITER)[_BOT_ID_POSITION]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6718347","0.6526012","0.6286749","0.6253905","0.62017727","0.61693555","0.6116269","0.6089422","0.6063677","0.60391885","0.6026189","0.59956145","0.59509","0.5940875","0.5902935","0.58904356","0.5852451","0.58488286","0.58410406","0.5821735","0.58202726","0.58030033","0.57781136","0.5761934","0.5751047","0.57395387","0.57238036","0.57165825","0.57146275","0.56829566","0.56425","0.5636353","0.5636324","0.5633095","0.56286097","0.56113803","0.5610444","0.5593519","0.559252","0.5590602","0.5583235","0.55711","0.55655825","0.555136","0.5548919","0.5537336","0.5532979","0.5530944","0.5503749","0.55035365","0.5502388","0.54998744","0.5489806","0.5484706","0.5470186","0.5447717","0.5440636","0.5439154","0.54359424","0.5432144","0.5427835","0.54231477","0.54180956","0.54171276","0.5413808","0.5413176","0.54126817","0.5410263","0.5403616","0.5392542","0.5389799","0.53873175","0.53755116","0.5359682","0.5351793","0.53514606","0.53508914","0.53466034","0.5344941","0.53436273","0.5339064","0.53379804","0.53348005","0.5329223","0.53289926","0.5325195","0.5324905","0.53208447","0.5315594","0.5312199","0.5311027","0.53042877","0.53016573","0.53004074","0.52977276","0.52974284","0.5287998","0.5283962","0.5283758","0.52833617"],"string":"[\n \"0.6718347\",\n \"0.6526012\",\n \"0.6286749\",\n \"0.6253905\",\n \"0.62017727\",\n \"0.61693555\",\n \"0.6116269\",\n \"0.6089422\",\n \"0.6063677\",\n \"0.60391885\",\n \"0.6026189\",\n \"0.59956145\",\n \"0.59509\",\n \"0.5940875\",\n \"0.5902935\",\n \"0.58904356\",\n \"0.5852451\",\n \"0.58488286\",\n \"0.58410406\",\n \"0.5821735\",\n \"0.58202726\",\n \"0.58030033\",\n \"0.57781136\",\n \"0.5761934\",\n \"0.5751047\",\n \"0.57395387\",\n \"0.57238036\",\n \"0.57165825\",\n \"0.57146275\",\n \"0.56829566\",\n \"0.56425\",\n \"0.5636353\",\n \"0.5636324\",\n \"0.5633095\",\n \"0.56286097\",\n \"0.56113803\",\n \"0.5610444\",\n \"0.5593519\",\n \"0.559252\",\n \"0.5590602\",\n \"0.5583235\",\n \"0.55711\",\n \"0.55655825\",\n \"0.555136\",\n \"0.5548919\",\n \"0.5537336\",\n \"0.5532979\",\n \"0.5530944\",\n \"0.5503749\",\n \"0.55035365\",\n \"0.5502388\",\n \"0.54998744\",\n \"0.5489806\",\n \"0.5484706\",\n \"0.5470186\",\n \"0.5447717\",\n \"0.5440636\",\n \"0.5439154\",\n \"0.54359424\",\n \"0.5432144\",\n \"0.5427835\",\n \"0.54231477\",\n \"0.54180956\",\n \"0.54171276\",\n \"0.5413808\",\n \"0.5413176\",\n \"0.54126817\",\n \"0.5410263\",\n \"0.5403616\",\n \"0.5392542\",\n \"0.5389799\",\n \"0.53873175\",\n \"0.53755116\",\n \"0.5359682\",\n \"0.5351793\",\n \"0.53514606\",\n \"0.53508914\",\n \"0.53466034\",\n \"0.5344941\",\n \"0.53436273\",\n \"0.5339064\",\n \"0.53379804\",\n \"0.53348005\",\n \"0.5329223\",\n \"0.53289926\",\n \"0.5325195\",\n \"0.5324905\",\n \"0.53208447\",\n \"0.5315594\",\n \"0.5312199\",\n \"0.5311027\",\n \"0.53042877\",\n \"0.53016573\",\n \"0.53004074\",\n \"0.52977276\",\n \"0.52974284\",\n \"0.5287998\",\n \"0.5283962\",\n \"0.5283758\",\n \"0.52833617\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65215236"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":9289,"cells":{"query":{"kind":"string","value":"Check for winning sequence in all possible diagonals that are at least as long as winning condition."},"document":{"kind":"string","value":"def check_diagonals(self, win: list) -> bool:\r\n for i in range(self.size - self.win_condition + 1):\r\n # [x x ]\r\n # [ x x ]\r\n # [ x x]\r\n # [ x]\r\n diagonal = []\r\n x = i\r\n y = 0\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x += 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n # [x ]\r\n # [x x ]\r\n # [ x x ]\r\n # [ x x]\r\n diagonal = []\r\n x = 0\r\n y = i\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x += 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n\r\n # [ x x]\r\n # [ x x ]\r\n # [x x ]\r\n # [x ]\r\n diagonal = []\r\n x = self.size - 1 - i\r\n y = 0\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x -= 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n # [ x]\r\n # [ x x]\r\n # [ x x ]\r\n # [x x ]\r\n diagonal = []\r\n x = self.size - 1\r\n y = 0 + i\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x -= 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_winning(self, curr_state):\n rows = [[0,1,2], [3,4,5], [6,7,8]]\n columns = [[0,3,6], [1,4,7], [2,5,8]]\n diagonal = [[0,4,8], [2,4,6]]\n total_checks = rows + columns + diagonal\n for row in total_checks:\n sum = 0\n count = 0\n for pos in row:\n if np.isnan(curr_state[pos]):\n break\n else:\n sum = sum + curr_state[pos]\n count = count + 1\n if sum == 15 and count == 3:\n return True\n return False","def diag_win(board):\n\tif board[1][1] != EMPTY and (board[1][1] == board[0][2] == board[2][0] or board[1][1] == board[0][0] == board[2][2]):\n\t\treturn True\n\treturn False","def is_winning(self):\n\n current_board = self.current_board\n\n # check rows\n for row in current_board:\n row = set(row)\n if (\"X\" not in row and \"-\" not in row) or (\"O\" not in row and \"-\" not in row):\n return True\n\n # check columns\n for i in range(len(current_board)):\n column_to_check = set()\n \n for j in range(len(current_board)):\n column_to_check.add(current_board[j][i])\n\n if (\"X\" not in column_to_check and \"-\" not in column_to_check) or (\"O\" not in column_to_check and \"-\" not in column_to_check):\n return True\n \n # check diagonals\n forward_diagonal_check = set()\n backward_diagonal_check = set()\n \n for i in range(len(current_board)):\n forward_diagonal_check.add(current_board[i][i])\n backward_diagonal_check.add(current_board[i][len(current_board)-1-i])\n\n if forward_diagonal_check == {\"X\"} or forward_diagonal_check == {\"O\"}:\n return True\n\n if backward_diagonal_check == {\"X\"} or backward_diagonal_check == {\"O\"}:\n return True","def check_diagonals():\n global game_still_going\n # Check if any of the rows have all the same value.\n diagonal1 = board[0] == board[4] == board[8] != '_'\n diagonal2 = board[6] == board[4] == board[2] != '_'\n # If any diagonals does have a match, then game still going to False.\n if diagonal1 or diagonal2:\n game_still_going = False\n # Return winner 'X' or 'O'.\n if diagonal1:\n return board[0]\n if diagonal2:\n return board[6]","def check_diagonals(self):\n\t\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\n\n\t\tfor diag in diags:\n\t\t\tpts = 0\n\t\t\tfor loc in diag:\n\t\t\t\tif self.board[loc[0]][loc[1]] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('WE WON')\n\t\t\t\treturn True","def check_win(self):\n for pos in self.win_set:\n # s would be all 1 if all positions of a winning move is fulfilled\n # otherwise 1s and 0s\n s = set([self.grid[p] for p in pos])\n if len(s) == 1 and (0 not in s):\n return True\n return False","def is_down_diagonal_win(self, checker):\n for row in range(self.height-3):\n for col in range(self.width-3):\n if self.slots[row][col] == checker and \\\n self.slots[row+1][col+1] == checker and \\\n self.slots[row+2][col+2] == checker and \\\n self.slots[row+3][col+3] == checker:\n return True\n return False","def is_winning(self, curr_state):\n winning_combinations = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]\n # We will check only for the above 8 combinations to see any of them sums up to 15 which implies winning\n for combination in winning_combinations:\n #print('Combination:',combination)\n if not np.isnan(curr_state[combination[0]]) and not np.isnan(curr_state[combination[1]]) and not np.isnan(curr_state[combination[2]]) :\n if curr_state[combination[0]] + curr_state[combination[1]] + curr_state[combination[2]] == 15 :\n return True\n \n #If none of the above condition is True return False \n return False","def diagonal_win():\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True","def winGame(sub_state):\n for i in range(sub_state.shape[0] - 4):\n for j in range(sub_state.shape[1] - 4):\n\n horizontal = sub_state[i][j: j+5]\n if (horizontal == 1).all():\n return True\n\n vertical = [sub_state[i+k, j] for k in range(5)]\n if (np.array(vertical) == 1).all():\n return True\n\n diagonal = [sub_state[(i+k, j+k)] for k in range(5)]\n if (np.array(diagonal) == 1).all():\n return True\n\n return False","def is_up_diagonal_win(self, checker):\n for row in range(3, self.height):\n for col in range(self.width-3):\n if self.slots[row][col] == checker and \\\n self.slots[row-1][col+1] == checker and \\\n self.slots[row-2][col+2] == checker and \\\n self.slots[row-3][col+3] == checker:\n return True\n return False","def check_winner(self):\n if self.history:\n last_move = self.history[-1]\n last_player = self.get_last_player()\n\n connected_token = last_player*self.n_in_row\n # check for row\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for column\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope 1\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for diagonal with slope -1\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\n self.winner = [True, last_player]\n return self.winner\n\n # check for draw game\n if len(np.argwhere(self.state==0)) == 0:\n self.winner = [True, 0]\n return self.winner\n return self.winner","def is_down_diagonal_win(self, checker):\r\n for row in range(self.height - self.win_condition + 1):\r\n for col in range(self.width - self.win_condition + 1):\r\n num_checkers = 0\r\n for i in range(self.win_condition):\r\n if self.grid[row + i][col + i] == checker:\r\n num_checkers += 1\r\n\r\n if num_checkers == self.win_condition:\r\n return True\r\n\r\n # if we get here, there's no horizontal win\r\n return False","def terminal(self):\n # Horizontal check\n for i in range(3):\n b_ = True\n for j in range(2):\n if self.board[i][j] == None or self.board[i][j] != self.board[i][j + 1]:\n b_ = False\n \n if b_:\n self.winner = self.board[i][0]\n return True\n \n # Vertical check\n for j in range(3):\n b_ = True\n for i in range(2):\n if self.board[i][j] == None or self.board[i][j] != self.board[i + 1][j]:\n b_ = False\n \n if b_:\n self.winner = self.board[0][j]\n return True\n \n # Diagonal check\n if self.board[1][1] != None:\n if self.board[0][0] == self.board[1][1] == self.board[2][2]:\n self.winner = self.board[1][1]\n return True\n\n if self.board[2][0] == self.board[1][1] == self.board[0][2]:\n self.winner = self.board[1][1]\n return True\n\n # Draw check\n if sum([row.count(None) for row in self.board]) == 0:\n self.winner = None\n return True\n \n return False","def check_for_win(self, row, col, player): \n\n count = 0\n for i in range(0, len(self.board[0])):\n # Check vertical\n if self.board[row][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n\n count = 0\n for i in range(0, len(self.board)):\n # Check horisontal\n if self.board[:, col][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n \n count = 0\n totoffset = col - row\n for i in np.diagonal(self.board, offset=totoffset):\n # Check diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True\n\n count = 0\n mirrorboard = np.fliplr(self.board)\n col = self.colswitch[col]\n totoffset = col - row\n for i in np.diagonal(mirrorboard, offset=totoffset):\n # Check other diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True","def check_won (grid):\r\n w=False\r\n for row in range(4):\r\n for col in range(4):\r\n if grid[row][col]>=32:\r\n w=True\r\n break\r\n return w","def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None","def check_win(self, board, move):\n for i, j, k in self.winning_cases:\n if board[i] == move and board[j] == move and board[k] == move:\n return True\n return False","def check_for_win_lose(b):\r\n win_move = None\r\n block_win = None\r\n # check for wins based on row\r\n for ri in range(3):\r\n row = b[ri]\r\n if single_move(row):\r\n if row==[1,1,0]:\r\n win_move = (ri+1,3)\r\n elif row==[2,2,0]:\r\n block_win = (ri+1,3)\r\n elif row==[1,0,1]:\r\n win_move = (ri+1,2)\r\n elif row==[2,0,2]:\r\n block_win = (ri+1,2)\r\n elif row==[0,1,1]:\r\n win_move = (ri+1,1)\r\n elif row==[0,2,2]:\r\n block_win = (ri+1,1)\r\n else:\r\n print '144 ERROR!'\r\n print single_move(row)\r\n print row\r\n print ' '\r\n\r\n # check for win based on column\r\n for ci in range(3):\r\n col = get_col(b,ci)\r\n if single_move(col):\r\n if col==[1,1,0]:\r\n win_move = (3,ci+1)\r\n elif col==[2,2,0]:\r\n block_win = (3,ci+1)\r\n elif col==[1,0,1]:\r\n win_move = (2,ci+1)\r\n elif col==[2,0,2]:\r\n block_win = (2,ci+1)\r\n elif col==[0,1,1]:\r\n win_move = (1,ci+1)\r\n elif col==[0,2,2]:\r\n block_win = (1,ci+1)\r\n else:\r\n print '166 ERROR!'\r\n print single_move(col)\r\n print col\r\n print ' '\r\n\r\n # check for win on backward diagonal\r\n diag = get_bw_diag(b)\r\n if single_move(diag):\r\n if diag==[1,1,0]:\r\n win_move = (3,3)\r\n elif diag==[2,2,0]:\r\n block_win (3,3)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,1)\r\n elif diag==[0,2,2]:\r\n block_win = (1,1)\r\n \r\n # check for win on forward diagonal\r\n diag = get_fwd_diag(b)\r\n if single_move(diag):\r\n if diag == [1,1,0]:\r\n win_move = (3,1)\r\n elif diag==[2,2,0]:\r\n block_win = (3,1)\r\n elif diag == [1,0,1]:\r\n win_move = (2,2)\r\n elif diag==[2,0,2]:\r\n block_win = (2,2)\r\n elif diag == [0,1,1]:\r\n win_move = (1,3)\r\n elif diag==[0,2,2]:\r\n block_win = (1,3)\r\n\r\n if win_move is not None:\r\n return (win_move, True)\r\n elif block_win is not None:\r\n return (block_win, False)\r\n else:\r\n return (None, False)","def win_check(table: list) -> (bool, str):\n # Combinations that would lead to a win\n win_list = [\n [0,1,2], [3,4,5],\n [6,7,8], [0,3,6],\n [1,4,7], [2,5,8],\n [0,4,8], [6,4,2],\n ]\n for line in win_list:\n # Check rows, columns, and diagonals\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\n\n if len(combination) == 1 and combination != {\"-\"}: # Which mean we have a straight line of either X or O\n #unpack comb (which is 1 item), which is either \"X\" or \"O\" to know who won\n return True, *combination\n else:\n return False, None","def check_diag(self, row, column, symbol):\r\n\r\n # get the current state of buttons..\r\n # tl -> top left; mm -> middle middle; etc...\r\n tl = self.board[0][0][1]\r\n mm = self.board[1][1][1]\r\n br = self.board[2][2][1]\r\n bl = self.board[0][2][1]\r\n tr = self.board[0][2][1]\r\n\r\n # we know if mm isn't on then we can return early\r\n if mm == symbol:\r\n if tl == symbol and br == symbol:\r\n self.winner = symbol\r\n return\r\n if tr == symbol and bl == symbol:\r\n self.winner = symbol\r\n return\r\n else:\r\n return\r\n else:\r\n return","def is_up_diagonal_win(self, checker):\r\n for row in range(self.height - self.win_condition + 1):\r\n for col in range(self.width - self.win_condition + 1):\r\n num_checkers = 0\r\n for i in range(self.win_condition):\r\n if self.grid[self.height - row - 1 - i][col+i] == checker:\r\n num_checkers += 1\r\n\r\n if num_checkers == self.win_condition:\r\n return True\r\n\r\n # if we get here, there's no horizontal win\r\n return False","def __win(self, a):\n for i in range(len(a)-self.k+1):\n flag = True\n for j in range(self.k):\n if not a[i+j]:\n flag = False\n break\n if flag: return True","def check_game_status2(board):\n board = np.array(board)\n for i in range(7):\n for j in range(6):\n if checkWin(board, j, i, 1):\n return 1\n if checkWin(board, j, i, 2):\n return 2\n if isfull(board):\n return 0\n return -1","def _check_winning_combinations(board, player):\n winning_combinations = (\n ((0, 0), (0, 1), (0, 2)),\n ((1, 0), (1, 1), (1, 2)),\n ((2, 0), (2, 1), (2, 2)),\n ((0, 0), (1, 0), (2, 0)),\n ((0, 1), (1, 1), (2, 1)),\n ((0, 2), (1, 2), (2, 2)),\n ((0, 0), (1, 1), (2, 2)),\n ((0, 2), (1, 1), (2, 0))\n )\n\n if any(combination for combination in winning_combinations if _is_winning_combination(board, combination, player)):\n return player\n\n return None","def checkAll(self, player, board):\n #retrieve current moves of the player who made the last move\n currentMoves = self.getPlayerMoves(player,board)\n\n #check column win\n is_col_win = self.checkWin(currentMoves, self.columnWins)\n if is_col_win != False:\n return True\n\n #check row win\n is_row_win = self.checkWin(currentMoves, self.rowWins)\n if is_row_win != False:\n return True\n\n #check diagonal win\n is_diag_win = self.checkWin(currentMoves, self.diagonalWins)\n if is_diag_win != False:\n return True\n else:\n return False","def row_win(board):\n\tfor row in range(3):\n\t\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\n\t\t\treturn True\n\treturn False","def check_diagonals():\n global ongoing_game\n diagonal_1 = board[0] == board[4] == board[8] != \"*\"\n diagonal_2 = board[2] == board[4] == board[6] != \"*\"\n if diagonal_1 or diagonal_2:\n ongoing_game = False\n if diagonal_1:\n return board[0]\n elif diagonal_2:\n return board[2]\n else:\n return None","def check_won (grid):\r\n for i in range (4):\r\n for j in range (4):\r\n if grid[i][j] >= 32:\r\n return True\r\n return False","def is_winning(self, curr_state):\n \n winning_idx_lists = [\n [0, 1, 2],\n [3, 4, 5],\n [6, 7, 8],\n [0, 3, 6],\n [1, 4, 7],\n [2, 5, 8],\n [0, 4, 8],\n [2, 4, 6]\n ]\n is_winning = False\n for winning_idx_list in winning_idx_lists:\n result_list = [curr_state[index] for index in winning_idx_list]\n if (sum(result_list) == 15):\n is_winning = True \n break\n\n return is_winning","def check_won (grid):\r\n for i in range(4): \r\n for j in range(4):\r\n if grid[i][j] >= 32:\r\n return True\r\n return False","def checkwin(self):\n w = self.getWidth()\n h = self.getHeight()\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\n for r in range(h):\n for c in range(w):\n if self.cell[c][r] == EMPTY:\n continue # this cell can't be part of winning segment\n # if we reach this point, the cell is occupied by a player stone\n numOccupiedCell = numOccupiedCell+1\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\n for i in range(NWIN):\n # test if there exists a segment of NWIN uniformly coloured cells\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\n break # segment broken\n else:\n # Python remark: notice that the else is attached to the for loop \"for i...\"\n # This block is executed if and only if 'i' arrives at the end of its range \n return self.cell[c][r] , True # found a winning segment \n return EMPTY, numOccupiedCell==w*h","def win_game(self):\n\n def horizontal_win():\n \"\"\"Return whether there is horizontal win\"\"\"\n\n for i in range(0, board_size):\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\n print \"horizontal win\"\n return True\n\n def vertical_win():\n \"\"\"Return whether there is vertical win\"\"\"\n\n vert_set = set()\n for i in range(0, board_size):\n for j in range(0, board_size):\n vert_set.add(self.board[j][i])\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\n print \"vertical win\"\n return True \n vert_set = set()\n\n def diagonal_win():\n \"\"\"Return whether there is diagonal win\"\"\"\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True\n\n if horizontal_win() or vertical_win() or diagonal_win():\n print \"You have won.\"\n return True","def check_for_win(self,board, player_id, action):\n\n row = 0\n\n # check which row was inserted last:\n for i in range(ROWS):\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\n row = ROWS - i\n break\n\n # check horizontal:\n vec = board[row, :] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check vertical:\n vec = board[:, action] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check diagonals:\n vec = np.diagonal(board, action - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n return False","def col_win(board):\n\tfor col in range(3):\n\t\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\n\t\t\treturn True\n\treturn False","def check_win(self, player):\n def check_row_win(player):\n for row in self.game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_column_win(player):\n # For doing a column check, transpose the grid and do a row check\n trans_game_state = numpy.transpose(self.game_state)\n for row in trans_game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_diag_win(player):\n # Left to right diagonal\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\n return True\n # Right to left diagonal\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\n return True\n return False\n\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\n return True\n return False","def check_won (grid):\r\n p=0\r\n for k in range(len(grid)):\r\n for g in range(len(grid[k])): \r\n if grid[k][g]>=32:\r\n p+=1\r\n else:\r\n ()\r\n if p>0:\r\n return True\r\n else:\r\n return False","def check_winner(self, row, column, symbol):\r\n self.check_row(row, symbol)\r\n self.check_column(column, symbol)\r\n self.check_diag(row, column, symbol)","def check(self):\n winner = None\n count = 0\n\n for y in range(self.gridSize):\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for item in self.grid[y]:\n # Check row of the grid\n if item == \"P1\":\n P1 += 1\n elif item == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for x in range(self.gridSize):\n # Check column of the grid\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check right top to left bottom across the grid\n for x in range(self.gridSize):\n if x == y:\n if self.grid[x][y] == \"P1\":\n P1 += 1\n elif self.grid[x][y] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n if winner != None:\n return winner\n P1, P2 = 0, 0\n for y in range(self.gridSize):\n # Check the left top to the right bottom across the grid\n for x in range(self.gridSize - 1, -1, -1):\n # Check how many filled spaces there are\n if \".\" not in self.grid[y][x]:\n count += 1\n if x + y == self.gridSize - 1:\n if self.grid[y][x] == \"P1\":\n P1 += 1\n elif self.grid[y][x] == \"P2\":\n P2 += 1\n winner = self.checkval(P1, P2, self.gridSize)\n # Check if there is a winner if so return the winner\n if winner != None:\n return winner\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\n if count == self.gridSize**2:\n return \"Tie\"","def checkWin(self):\n winstates = [(0, 1, 2),\n (3, 4, 5),\n (6, 7, 8),\n (0, 3, 6),\n (1, 4, 7),\n (2, 5, 8),\n (0, 4, 8),\n (2, 4, 6)]\n win = False\n for state in winstates:\n if (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == 3:\n self.handleWin(1)\n win = True\n elif (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == -3:\n self.handleWin(-1)\n win = True\n\n if len([i for i in range(9) if self.gameState[i] == 0]) == 0 and not win:\n print(\"Draw yo\")\n self.handleDraw()\n return None","def is_win(my_board):\n return np.count_nonzero(my_board == CLOSED) == NUM_MINES","def check_boards(self):\n succesful = True\n marker = self.game.player\n print(f\"-----Starting check_winning_boards-----\")\n winning_boards= [\n [\n [marker]*3,\n [\" \"]*3,\n [\" \"]*3\n ],\n [\n [\" \"]*3,\n [marker]*3,\n [\" \"]*3\n ],\n [\n [\" \"]*3,\n [\" \"]*3,\n [marker]*3\n ],\n [\n [marker, \" \", \" \"],\n [marker, \" \", \" \"],\n [marker, \" \", \" \"]\n ],\n [\n [\" \",marker, \" \"],\n [\" \",marker, \" \"],\n [\" \",marker, \" \"]\n ],\n [\n [\" \", \" \",marker],\n [\" \", \" \",marker],\n [\" \", \" \",marker]\n ],\n [\n [marker, \" \", \" \"]\n ,[\" \", marker,\" \"],\n [\" \", \" \",marker]\n ],\n [\n [\" \", \" \", marker],\n [\" \",marker, \" \"],\n [marker, \" \", \" \"]\n ]\n ]\n for board in winning_boards:\n if self.game.check_win_conditions(board) != -10:\n succesful = False\n print(f\"board failed checkWins \\n{board}\")\n marker = self.game.ai_player\n print(f\"-----Starting check_winning_boards-----\")\n winning_boards= [\n [\n [marker]*3,\n [\" \"]*3,\n [\" \"]*3\n ],\n [\n [\" \"]*3,\n [marker]*3,\n [\" \"]*3\n ],\n [\n [\" \"]*3,\n [\" \"]*3,\n [marker]*3\n ],\n [\n [marker, \" \", \" \"],\n [marker, \" \", \" \"],\n [marker, \" \", \" \"]\n ],\n [\n [\" \",marker, \" \"],\n [\" \",marker, \" \"],\n [\" \",marker, \" \"]\n ],\n [\n [\" \", \" \",marker],\n [\" \", \" \",marker],\n [\" \", \" \",marker]\n ],\n [\n [marker, \" \", \" \"]\n ,[\" \", marker,\" \"],\n [\" \", \" \",marker]\n ],\n [\n [\" \", \" \", marker],\n [\" \",marker, \" \"],\n [marker, \" \", \" \"]\n ]\n ]\n for board in winning_boards:\n if self.game.check_win_conditions(board) != 10:\n succesful = False\n print(f\"board failed checkWins \\n{board}\")\n \n tie_boards = [\n [ \n [\"O\",\"O\",\"X\"],\n [\"X\",\"O\",\"O\"],\n [\"X\",\"X\",\" \"]\n ],\n [\n [\"O\",\"X\",\" \"],\n [\" \",\"X\",\" \"],\n [\" \",\"O\",\" \"]\n ],\n [\n ['O', 'O', 'X'],\n ['X', 'X', 'O'],\n ['O', 'O', 'X']\n ]\n ]\n for board in tie_boards:\n if self.game.check_win_conditions(board) != 0:\n succesful = False\n print(f\"board failed checkWins \\n{board}\")\n\n print(f\"-----Ending check_winning_boards-----\")","def search_possible_steps(self):\n if self.ended:\n return False\n possible_steps_turple = (self.board == 0)\n possible_steps = np.transpose(possible_steps_turple.nonzero())\n return possible_steps","def check_won(grid):\r\n for i in range(len(grid)):\r\n for j in range(len(grid[i])):\r\n if grid[i][j] >= 32:\r\n return True \r\n return False","def loss_condition(self):\n possible_combinations = [[1,2,3], [4,5,6], [7,8,9],\n [1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]\n\n return any([all([(self.board[i-1] == self.nopponent)\n for i in combination]) for combination in possible_combinations])","def check_lost (grid):\r\n for row in range(4):\r\n for col in range(4):\r\n if grid[row][col]==0:\r\n return False\r\n if grid[0][0]==grid[0][1] or grid[0][0]==grid[1][0]:\r\n return False \r\n if grid[0][3]==grid[0][2] or grid[0][3]==grid[1][3]:\r\n return False \r\n if grid[3][0]==grid[2][0] or grid[3][0]==grid[3][1]:\r\n return False\r\n if grid[3][3]==grid[2][3] or grid[3][3]==grid[3][2]:\r\n return False \r\n if grid[0][1]==grid[0][2] or grid[0][1]==grid[1][1]:\r\n return False \r\n if grid[0][2]==grid[1][2]:\r\n return False \r\n if grid[1][1]==grid[2][1] or grid[1][1]==grid[1][2] or grid[1][1]==grid[1][0]:\r\n return False\r\n if grid[2][1]==grid[2][0] or grid[2][1]==grid[2][2] or grid[2][1]==grid[3][1]:\r\n return False \r\n if grid[1][0]==grid[2][0]:\r\n return False\r\n if grid[1][2]==grid[1][3] or grid[1][2]==grid[2][2]:\r\n return False\r\n if grid[2][2]==grid[2][3] or grid[2][2]==grid[3][2]:\r\n return False\r\n if grid[3][1]==grid[3][2]:\r\n return False\r\n else:\r\n return True","def check_win_condition(board) -> bool:\n if _check_vertical_win_condition(board) or _check_horizontal_win_condition(board) or _check_diagonal_win_condition(\n board):\n return True\n else:\n board.alternate_current_player()\n return False","def multipleQueensAlongDiagonals(board):\n if (multipleQueensOnRightDiagonals(board) or\n multipleQueensOnLeftDiagonals(board)):\n return True\n\n return False","def check_win(self):\r\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\r\n for case, pos in wins:\r\n if case != -1:\r\n print('Game over!')\r\n if self.grid[case][-1] == self.computer:\r\n print('The computer won!')\r\n return (True, pos)\r\n print('The player won!')\r\n return (True, pos)\r\n\r\n return (self.check_draw(), None)","def __check_win_condition(self,token,coordinate):\n # Check if it's even possible to win yet\n if self._turn_counter >= 8 and self._turn_counter+1 < self._board_size**2:\n # Disable win\n # return False\n\n # Up and up right vectors\n vec1=(1,0)\n vec2=(1,1)\n\n # Loop both directions of vector\n for _ in range(2):\n if self.__check_direction(vec1,coordinate):\n self.__declare_winner()\n return True\n if self.__check_direction(vec2,coordinate):\n self.__declare_winner()\n return True\n\n # Turn vector directions\n vec1 = -vec1[1], vec1[0]\n vec2 = -vec2[1], vec2[0]\n\n # Check for draw\n elif self._turn_counter+1 >= self._board_size**2:\n if (self._gui):\n self.__turn_counter_label[\"text\"] = \"Draw!\"\n self.__status[\"text\"] = \"\"\n self.__status.update()\n self.__turn_counter_label.update()\n self._winner = 3\n if (self._state == PLAY): showerror(\"Draw\",\"Draw!\")\n return True","def _check_for_win(self, piece, piece_x, piece_y):\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions = []\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\n for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions.append((x, y))\n # Don't need to check the piece that is being placed\n if (x, y) == (piece_x, piece_y):\n continue\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece != piece:\n winning_piece_positions = None\n break\n if winning_piece_positions:\n # Check if there are additional winning pieces that exceed the number required to win.\n # e.g. a 5-in-a-row when only 4 are required\n if slope_x != 0:\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\n for i in range(1, 1 + num_previous_pieces_to_check)):\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece == piece:\n winning_piece_positions.insert(0, (x, y))\n else:\n break\n return winning_piece_positions\n\n return False","def _check_winner(self) -> Optional[int]:\n\n if self._is_red_active:\n temp_board = self.board_array.clip(min=0, max=1) # Turns all -1's into 0's\n for kernel in self._detection_kernels_red:\n # For each of the patterns that produce a win, do a 2d convolution on the copy\n # of the board. If there 4's in the resulting array, one of the kernels found a\n # match and so there is a 4 in a row somewhere. This is done this way to save\n # as much time as possible, because optimisation is very important to the\n # AI's performance and python is already quite slow\n if np.any(convolve2d(temp_board, kernel, mode='valid') == 4):\n return 1\n else:\n temp_board = self.board_array.clip(min=-1, max=0) # Turns all 1's into 0's\n for kernel in self._detection_kernels_yellow:\n # Same as before\n if np.any(convolve2d(temp_board, kernel, mode='valid') == 4):\n return -1\n\n if len(self._valid_moves) == 0:\n return 0\n\n return None","def checkSolution(self):\n movesToEndblock = self.gridSize - self.changeable[0] - 2\n if self.checkMove(0,movesToEndblock) == 0:\n return 0\n return 1","def check_lost (grid):\r\n t=0\r\n for o in range(len(grid)):\r\n for e in range(len(grid[o])):\r\n if grid[o][e]==0:\r\n t+=1\r\n else:\r\n ()\r\n r=0\r\n for o in range(len(grid)):\r\n for e in range(len(grid[o])-1):\r\n if grid[o][e]==grid[o][e+1]:\r\n r+=1\r\n elif grid[o][3]==grid[o][2]:\r\n r+=1 \r\n else:\r\n ()\r\n \r\n v=0\r\n for o in range(len(grid)):\r\n for e in range(len(grid[o])-1):\r\n if grid[e][o]==grid[e+1][o]:\r\n v+=1\r\n elif grid[3][o]==grid[2][o]:\r\n v+=1 \r\n else:\r\n () \r\n \r\n if t==0 and r==0 and v==0:\r\n return True\r\n else:\r\n return False","def win(s):\r\n\r\n # check across\r\n for i in range(3):\r\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\r\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\r\n return True\r\n\r\n # check down\r\n for i in range(3):\r\n if board[i] == board[i + 3] == board[i + 6] == s:\r\n board[i] = board[i + 3] = board[i + 6] = '#'\r\n return True\r\n\r\n # check diagonal right\r\n if board[0] == board[4] == board[8] == s:\r\n board[0] = board[4] = board[8] = '#'\r\n return True\r\n\r\n # check diagonal left\r\n if board[6] == board[4] == board[2] == s:\r\n board[6] = board[4] = board[2] = '#'\r\n return True\r\n\r\n return False","def winner_found(self):\n\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\n winner_in_rows = first_row or second_row or third_row\n\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\n winner_in_columns = first_column or second_column or third_column\n\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\n winner_in_diagonals = first_diagonal or second_diagonal\n\n return winner_in_rows or winner_in_columns or winner_in_diagonals","def test_check_win(self):\n # Horizontal wins\n # First row\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n\n # Second row\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(1, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\n\n # Third row\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Vertical wins\n # First column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 0, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n\n # Second column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERX)\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\n\n # Third column\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Diagonal wins\n # Upper left to bottom right\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERX)\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\n\n # Bottom left to upper right\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERX)\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\n\n # Draw\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.game._board[row][col] = EMPTY\n\n self.game.move(0, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 1, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(0, 2, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 0, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 1, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(1, 2, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 0, PLAYERX)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 1, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\n self.game.move(2, 2, PLAYERO)\n for row in range(self.game._dim):\n for col in range(self.game._dim):\n self.assertEqual(self.game.check_win(row, col, PLAYERX), DRAW)","def check_lost(grid):\r\n for i in range(len(grid)):\r\n for j in range(len(grid[i])):\r\n if grid[i][j] == 0:\r\n return False\r\n elif i+1 < len(grid):\r\n if grid[i][j] == grid[i+1][j]:\r\n return False\r\n elif j+1 < len(grid[i]):\r\n if grid[i][j] == grid[i][j+1]:\r\n return False \r\n return True","def winsFor(self, ox):\n for row in range(self.height):\n for col in range(self.width):\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\n return True\n return False","def win_check(self):\n\t\t# Create a temp var to capture the number of correct matches\n\t\tright = 0\n\t\t# retrieve peg_guess_color_list for current round\n\t\tguess = self.model.guesses[self.model.status]\n\t\t# retreive solution list\n\t\tsolution = self.model.guesses[\"solution\"]\n\t\t# compare values in each index for both lists against eachother\n\t\tfor i in range(len(solution.pegs)):\n\t\t\t# \n\t\t\tif solution.pegs[i].peg_color == guess.pegs[i].peg_color:\n\t\t\t\tright += 1\n\n\t\t\t\tprint(\"Yay, it works!\")\n\n\t\t# If all indexes of the peg_colors in the solution and guess are True:\n\t\tif right == 4:\n\t\t\treturn True\n\n\t\telse:\n\t\t\treturn False","def check_win(self):\n for pos in self.win_set:\n s = set([self.grid[p] for p in pos])\n if len(s) == 1 and (0 not in s):\n return True\n return False","def get_winner(board):\n\n def who_won(in_a_row, board_size, cur_player):\n \"\"\" \n a function private to get_winner() (yes you can do this. Cool huh!?) \n that tells get_winner if it has a winner \n \"\"\"\n if in_a_row == board_size:\n return 1 if cur_player == 'X' else 2\n else:\n return 0\n\n def test_row_col(board, rows):\n \"\"\" private function to test the rows and columns \"\"\"\n for i in range(len(board)):\n cur_player = board[i][0] if rows else board[0][i]\n in_a_row = 0\n for j in range(len(board)):\n symbol = board[i][j] if rows else board[j][i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1\n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n def test_diagonal(board, normal):\n \"\"\" private function to test the two diagonals \"\"\"\n cur_player = board[0][0] if normal else board[0][len(board)-1]\n in_a_row = 0\n for i in range(len(board)):\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\n if (not symbol == '-') and (symbol == cur_player):\n in_a_row += 1 \n else:\n break\n winner = who_won(in_a_row, len(board), cur_player)\n if not winner == 0:\n return winner\n return 0\n\n\n # test rows\n winner = test_row_col(board, True)\n if not winner == 0:\n return winner\n\n # test cols\n winner = test_row_col(board, False)\n if not winner == 0:\n return winner\n\n # test diagonal from top left to bottom right\n winner = test_diagonal(board, True)\n if not winner == 0:\n return winner\n\n # test diagonal from top right to bottom left\n winner = test_diagonal(board, False)\n if not winner == 0:\n return winner\n\n return 0","def check_winner(self):\n\t\tif self.check_diagonals() or self.check_rows() or self.check_columns():\n\t\t\treturn True\n\t\telif self.board_is_full():\n\t\t\tprint(\"There was a draw, everyone lost\")\n\t\t\treturn None\n\t\treturn False","def __check_winner(self):\n for i in range(0, 3):\n col = self.__get_col(i)\n if col.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if col.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n row = self.__get_row(i)\n if row.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if row.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n for i in range(0, 2):\n diag = self.__get_diag(i)\n if diag.get(self.player_char) == 3:\n print('\\nYou win!')\n self.game_ended = True\n return\n if diag.get(self.opponent_char) == 3:\n print('\\nYou lose.')\n self.game_ended = True\n return\n if self.state.count(' ') == 0:\n print('\\nDraw!')\n self.game_ended = True","def terminal(board):\n if winner(board):\n return True\n for i in range(3):\n for j in range(3):\n if not board[i][j]:\n return False\n return True","def check_diagonal(self, has_player_got_4, board, pos, player_no):\n for i in range(1, 4):\n if pos[0] + i < self.width // 80 and pos[1] - i >= 0:\n if board[(pos[0] + i, pos[1] - i)] == player_no:\n has_player_got_4.add((pos[0] + i, pos[1] - i))\n print(\"Added top-right: \" + str((pos[0] + i, pos[1] - i)))\n else:\n break\n for i in range(1, 4):\n if (self.height // 80 > pos[1] + i >= 0) and pos[0] - i >= 0:\n if board[(pos[0] - i, pos[1] + i)] == player_no:\n has_player_got_4.add((pos[0] - i, pos[1] + i))\n print(\"Added bottom-left: \" + str((pos[0] - i, pos[1] + i)))\n else:\n break","def check_rows(self):\n\t\tfor i in range(len(self.board)):\n\t\t\tpts = 0\n\t\t\tfor j in range(len(self.board[i])):\n\t\t\t\tif self.board[i][j] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('YOU WON')\n\t\t\t\treturn True","def conflicts(board):\r\n \r\n board = np.array(board)\r\n \r\n n = len(board)\r\n conflicts = 0\r\n\r\n # check horizontal (we do not check vertical since the state space is restricted to one queen per col)\r\n for i in range(n): conflicts += math.comb(np.sum(board == i), 2)\r\n #print(f\"Horizontal conflicts: {conflicts}\")\r\n \r\n # check for each queen diagonally up and down (only to the right side of the queen)\r\n for j in range(n):\r\n q_up = board[j]\r\n q_down = board[j]\r\n \r\n for jj in range(j+1, n):\r\n q_up -= 1\r\n q_down += 1\r\n if board[jj] == q_up: conflicts += 1\r\n if board[jj] == q_down: conflicts += 1\r\n #print(f\"Conflicts after queen {j}: {conflicts}\")\r\n \r\n return(conflicts)","def check_board(board_state, player_symbol, display_message = False):\n\n is_board_completely_filled = board_state.isalpha()\n\n indices_set = set([ind+1 for ind, val in enumerate(board_state) if val == player_symbol])\n\n if {1, 2, 3}.issubset(indices_set) or {4, 5, 6}.issubset(indices_set) or {7, 8, 9}.issubset(indices_set):\n\n if display_message:\n print(\"Row completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n\n if {1, 4, 7}.issubset(indices_set) or {2, 5, 8}.issubset(indices_set) or {3, 6, 9}.issubset(indices_set):\n\n if display_message:\n print(\"Column completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n if {1, 5, 9}.issubset(indices_set) or {3, 5, 7}.issubset(indices_set):\n\n if display_message:\n print(\"Diagonal completed..!!!\")\n print(\"Player \"+player_symbol+\" won the game.\")\n\n return True\n\n if is_board_completely_filled:\n\n if display_message:\n print(\"Game is drawn...!\")\n\n return \"Draw\"\n\n return False","def win_for(self, side):\n # Testing rows\n for row in range(self.height):\n for col in range(self.width - 3):\n if ( self.data[row][col] == side\n and self.data[row][col+1] == side\n and self.data[row][col+2] == side\n and self.data[row][col+3] == side):\n return True\n\n # Testing columns\n for col in range(self.width):\n for row in range(self.height - 3):\n if ( self.data[row][col] == side\n and self.data[row+1][col] == side\n and self.data[row+2][col] == side\n and self.data[row+3][col] == side):\n return True\n\n # Testing left diagonal\n for row in range(self.height - 3):\n for col in range(self.width - 3):\n if ( self.data[row][col] == side\n and self.data[row+1][col+1] == side\n and self.data[row+2][col+2] == side\n and self.data[row+3][col+3] == side):\n return True\n\n # Testing right diagonal\n for row in range(self.height - 3):\n for col in range(3, self.width):\n if ( self.data[row][col] == side\n and self.data[row+1][col-1] == side\n and self.data[row+2][col-2] == side\n and self.data[row+3][col-3] == side):\n return True\n\n return False","def checkPossibleMoves():\n for row in range(9):\n for column in range(7):\n if board[row][column] == board[row][column+1]: #A\n a = board[row][column]\n if column != 6: #column +3 would lead to an error\n if a == board[row+1][column+2] or a == board[row][column+3] or a == board[row-1][column+2] or a == board[row-1][column-1] or a == board[row][column-2] or a ==board[row+1][column-1]:\n return False\n else: \n if a == board[row+1][column+2] or a == board[row-1][column+2] or a == board[row-1][column-1] or a == board[row][column-2] or a ==board[row+1][column-1]:\n return False\n if board[row][column] == board[row][column+2]: # B\n if board[row][column] == board[row+1][column+1] or board[row][column] == board[row-1][column+1]:\n return False\n\n if board[row][column] == board[row+1][column]: #C\n a = board[row][column]\n if row != 8: #row +3 would lead to an error\n if a == board[row-1][column+1] or a == board[row-2][column] or a == board[row-1][column-1] or a == board[row+2][column-1] or a == board[row+3][column] or a == board[row+2][column+1]:\n return False\n else:\n if a == board[row-1][column+1] or a == board[row-2][column] or a == board[row-1][column-1] or a == board[row+2][column-1] or a == board[row+2][column+1]:\n return False\n\n if board[row][column] == board[row+2][column]: #D\n if board[row][column] == board[row+1][column-1] or board[row][column] == board[row+1][column+1]:\n return False\n return True","def is_winning(game: List[int]) -> bool:\n # performs the Vertical XOR by reducing as list of bool (lst) with xor lambda\n reduce_xor = (lambda lst: reduce(__xor__, lst, False))\n\n # converts game into binary and the converts/permutes the row and col\n game_bin_row_col = row_to_col(game_to_bin(game))\n\n # performs Vertical XOR on every column\n res_vert_xor = list(map(reduce_xor, game_bin_row_col))\n\n return reduce(__or__, res_vert_xor, False)","def check_win():\r\n for mark in markers:\r\n if loc[0] == mark and loc[1] == mark and loc[2] == mark:\r\n return True\r\n if loc[0] == mark and loc[3] == mark and loc[6] == mark:\r\n return True\r\n if loc[0] == mark and loc[4] == mark and loc[8] == mark:\r\n return True\r\n if loc[1] == mark and loc[4] == mark and loc[7] == mark:\r\n return True\r\n if loc[2] == mark and loc[4] == mark and loc[6] == mark:\r\n return True\r\n if loc[2] == mark and loc[5] == mark and loc[8] == mark:\r\n return True\r\n if loc[3] == mark and loc[4] == mark and loc[5] == mark:\r\n return True\r\n if loc[6] == mark and loc[7] == mark and loc[8] == mark:\r\n return True\r\n else:\r\n return False","def terminal(board):\n #I need to check if any won or if I don't have any spaces left\n game_ended = False\n found_empty = False\n #first of all, I check if I have empties.\n for row in board:\n if EMPTY in row:\n #if I do have empties, I flag it. It is likely that I have not finished yet.\n found_empty = True\n #we check on the rows and columns for a winner\n for i in range(0,3):\n if (board[i][0] == board[i][1] and board[i][0] == board[i][2] and (board[i][0] is not EMPTY)) or (board[0][i] == board[1][i] and board[0][i] == board[2][i] and (board[0][i] is not EMPTY)):\n game_ended = True\n #we flag the game as ended if there is a winner and break the loop.\n break\n else:\n #otherwise, we state that the game has no winners yet\n game_ended = False\n #If my game has no vertical or horizontal winners, I still have to check the diagonals.\n if not game_ended: \n #there were no horizontal nor vertical wins. I need to check diagonals\n if (((board[0][0] == board[1][1] and board[2][2] == board[0][0]) or (board[0][2] == board[1][1] and board[2][0] == board[0][2]) ) and (board[1][1] is not EMPTY)):\n game_ended = True\n\n #Finally, if I found and empty and my game has no winners yet, it means I can keep playing\n if found_empty and not game_ended: \n return False\n else:\n #otherwise, I have a winner and the game ended either due to a winner or a tie.\n return True","def checkWinner(board, plyr):\n winner = False\n winX = []\n sideLen = len(board)\n for i in range(sideLen):\n winX.append(plyr)\n winX = tuple(winX)\n print('WinX: {}'.format(winX))\n\n for row in board:\n print('Row :{0}'.format(row))\n if tuple(row) == winX:\n print('Winner: {}'.format(row))\n winner = True\n break\n\n for i in range(sideLen):\n col = []\n for j in range(sideLen):\n col.append(board[j][i])\n print('Col {0}'.format(col))\n if tuple(col) == winX:\n print('Winner: {}'.format(col))\n winner = True\n break\n\n if not winner:\n leftDiag = []\n for i in range(sideLen):\n leftDiag.append(board[i][i])\n print('left Diag:{}'.format(leftDiag))\n if tuple(leftDiag) == winX:\n print('Winner: {}'.format(leftDiag))\n winner = True\n else:\n rightDiag = []\n for i in range(sideLen):\n rightDiag.append(board[i][sideLen-1-i])\n print('right Diag:{}'.format(rightDiag))\n if tuple(rightDiag) == winX:\n print('Winner: {}'.format(rightDiag))\n winner = True\n \n return winner","def col_win(board, player):\n for row in board.T:\n if check_row(row, player):\n return True\n return False","def gameWon(self):\n \n wins = [ threeInARow( self.squares[0], self.squares[1], self.squares[2] ),\n threeInARow( self.squares[3], self.squares[4], self.squares[5] ),\n threeInARow( self.squares[6], self.squares[7], self.squares[8] ),\n threeInARow( self.squares[0], self.squares[3], self.squares[6] ),\n threeInARow( self.squares[1], self.squares[4], self.squares[7] ),\n threeInARow( self.squares[2], self.squares[5], self.squares[8] ),\n threeInARow( self.squares[0], self.squares[4], self.squares[8] ),\n threeInARow( self.squares[2], self.squares[4], self.squares[6] ) ]\n \n return any(wins)","def solveOneStep(self):\n ### Student code goes here\n\n if (self.currentState.state == self.victoryCondition):\n self.visited[self.currentState] = True\n win_or_not = (self.currentState.state == self.victoryCondition)\n return win_or_not\n\n game_depth = self.currentState.depth\n continue_game = True\n test_its = 0\n while continue_game:\n test_its += 1\n # too long \n # time test\n if test_its == \"too long\":\n return \"too long\"\n result = self.solveOneStep_helper(game_depth)\n if result:\n victory_satisfied = (self.currentState.state == self.victoryCondition)\n if victory_satisfied:\n result_bool = True\n return result_bool\n else:\n game_depth = game_depth + 1\n else:\n return False","def draw(arr):\n return int((np.count_nonzero(arr) == 9) and (not win(arr)))","def evaluate(board):\n winner = 0\n for player in [1, 2]:\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n winner = player\n \n if np.all(board != 0) and winner == 0:\n winner = -1\n return winner","def check(self):\n for row in self.grid:\n for i in range(1, 10):\n if row.count(i) != 1:\n return False\n\n for col in range(9):\n lst = [row[col] for row in self.grid]\n for i in range(1, 10):\n if lst.count(i) != 1:\n return False\n \n for i in range(3):\n for j in range(3):\n lst = [row[j* 3:(j*3) + 3] for row in self.grid[i * 3:(i*3) + 3]] \n flat_list = []\n for k in lst:\n for number in k:\n flat_list.append(number)\n \n for check_number in range(1, 10):\n if flat_list.count(check_number) != 1:\n return False\n return True","def check_lost (grid):\r\n adjacent = False\r\n zero_value = False\r\n for i in range(4): \r\n for j in range(4):\r\n if grid[i][j] == 0:\r\n zero_value = True\r\n break\r\n for i in range(3):\r\n for j in range(3):\r\n if grid[i][j] == grid[i][j+1]:\r\n adjacent = True\r\n break\r\n if grid[i][j] == grid[i+1][j]:\r\n adjacent = True\r\n break\r\n if not adjacent and not zero_value:\r\n return True\r\n return False","def check_win(board_list):\n\n for i in range(0, 3):\n\n # rows\n if board_list[i][0] == board_list[i][1] == board_list[i][2]:\n if board_list[i][0] != 0:\n return board_list[i][0]\n\n # columns\n elif board_list[0][i] == board_list[1][i] == board_list[2][i]:\n if board_list[0][i] != 0:\n return board_list[0][i]\n\n # diagonal (top left to bottom right)\n elif board_list[0][0] == board_list[1][1] == board_list[2][2]:\n if board_list[0][0] != 0:\n return board_list[0][0]\n\n # diagonal (bottom left to top right)\n elif board_list[0][2] == board_list[1][1] == board_list[2][0]:\n if board_list[0][2] != 0:\n return board_list[0][2]\n\n return None","def terminal(board):\n if sum(row.count(EMPTY) for row in board) == 0 or winner(board) == X or winner(board) == O:\n return True\n else:\n return False","def check(self):\n\n ok = True\n\n # check that each pair is ok on its own\n for winp in self.winps:\n if not winp.check():\n ok = False\n\n # check that no pairs overlap in the Y direction\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\n for winp in self.winps[1:]:\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\n ystart1 < ystart0 + ny0:\n winp.ystart.config(bg=COL_WARN)\n ok = False\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\n\n return ok","def is_win_for(self, checker):\n assert(checker == 'X' or checker == 'O')\n if self.is_vertical_win(checker) or\\\n self.is_down_diagonal_win(checker) or\\\n self.is_up_diagonal_win(checker) or\\\n self.is_horizontal_win(checker):\n return True\n return False","def check_win(self, player):\n for win_pos in TicTacToe.win_pos:\n # for each winning position defined we take the set difference to the positions played be player\n # if there are not elements left after resulting set after difference operator\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\n # the winner\n if not win_pos.difference(self.player_played_pos[player]):\n return True\n\n # if after checking for every winning positions if the control still reaches here,\n # the player has not marked the winning positions. returns False\n return False","def does_move_win(self, x, y):\n me = self.board[x][y]\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\n p = 1\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\n p += 1\n n = 1\n while self.is_on_board(x-n*dx, y-n*dy) and self.board[x-n*dx][y-n*dy] == me:\n n += 1\n\n if p + n >= (self.connect + 1): # want (p-1) + (n-1) + 1 >= 4, or more simply p + n >- 5\n return True\n\n return False","def check_opponent_winning(self):\n valid_actions = self.get_valid_actions()\n copy_board = np.copy(self.board)\n for action in list(valid_actions):\n height = self.get_height(action, board=copy_board)\n self.set(action, height=height, value=self.current_player * -1, board=copy_board)\n\n if self.check_winner(copy_board, action, height) != 0:\n return True\n\n self.set(action, height=height, value=0, board=copy_board)\n\n return False","def check_for_winner():\n global winner\n # Check rows.\n row_winner = check_rows()\n # Check columns.\n column_winner = check_columns()\n # Check diagonals.\n diagonal_winner = check_diagonals()\n if row_winner:\n winner = row_winner\n elif column_winner:\n winner = column_winner\n elif diagonal_winner:\n winner = diagonal_winner\n else:\n winner = None","def checkWinAll(self, model, previousWin):\r\n previous = self.__render\r\n self.__render = Render.NOTHING # avoid rendering anything during execution of the check games\r\n\r\n win = 0\r\n lose = 0\r\n \r\n cellsRanking = {}\r\n sumForProb = 0\r\n for cell in self.allowableCells:\r\n if self.play(model, cell)[0] == Status.WIN:\r\n win += 1\r\n else:\r\n lose += 1\r\n\r\n self.__render = previous # restore previous rendering setting\r\n\r\n logging.info(\"won: {} | lost: {} | win rate: {:.5f}\".format(win, lose, win / (win + lose)))\r\n\r\n result = True if lose == 0 else False\r\n \r\n if lose == 0:\r\n previousWin += 1\r\n else:\r\n previousWin = 0 \r\n\r\n return result, win / (win + lose), previousWin","def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False","def globalcheck(xx, checktimes, thres, n, nn):\n result = np.zeros((3, n))\n checkstep = nn // checktimes\n absxx = np.abs(xx)\n for i in range(n):\n for k in range(2):\n for j in range(checktimes):\n if absxx[1 + j * checkstep, k * n + i] > thres[k]:\n result[k, i] = 1\n break\n result[2, i] = np.max(result[:, i])\n\n return result","def is_winner(self):\n for i in range(3):\n if (self.board[i][0] == self.board[i][1] == self.board[i][2]) \\\n and (self.board[i][0] != 0):\n return True, self.board[i][0]\n\n if self.board[0][i] == self.board[1][i] == self.board[2][i] \\\n and (self.board[0][i] != 0):\n return True, self.board[0][i]\n\n if self.board[0][0] == self.board[1][1] == self.board[2][2] \\\n and (self.board[0][0] != 0):\n return True, self.board[0][0]\n\n if self.board[2][0] == self.board[1][1] == self.board[0][2] \\\n and (self.board[2][0] != 0):\n return True, self.board[2][0]\n\n if self.available_combinations() == []:\n return False, 'end'\n\n return False, None","def check_victory(board):\n\n for idx in range(3):\n if board[idx][0] != ' ' and board[idx][0] == board[idx][1] == board[idx][2]:\n # This checks if all items in each horizontal row is complete.\n print('Victory to ' + board[idx][0])\n return True\n elif board[0][idx] != ' ' and board[0][idx] == board[1][idx] == board[2][idx]:\n # This checks if all the items in each vertical column is complete.\n print('Victory to ' + board[0][idx])\n return True\n\n if board[0][0] != ' ' and board[0][0] == board[1][1] == board[2][2]:\n # This checks if the left to right diagonal is complete.\n print('Victory to ' + board[0][0])\n return True\n elif board[2][0] != ' ' and board[2][0] == board[1][1] == board[0][2]:\n # This checks if the right to left diagonal is complete.\n print('Victory to ' + board[2][0])\n return True\n\n return False","def terminal(board):\n if not winner(board):\n for i in range(3):\n for j in range(3):\n if board[i][j] == EMPTY:\n return False\n return True","def game_state(matrix):\n\n \"\"\"\n # To set winning tile\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == 2048:\n # return 'win'\n # return 'not over'\n \"\"\"\n for i in range(len(matrix)-1):\n # intentionally reduced to check the row on the right and below\n # more elegant to use exceptions but most likely this will be their solution\n for j in range(len(matrix[0])-1):\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\n return 'not over'\n for i in range(len(matrix)): # check for any zero entries\n for j in range(len(matrix[0])):\n if matrix[i][j] == 0:\n return 'not over'\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\n return 'not over'\n for j in range(len(matrix)-1): # check up/down entries on last column\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\n return 'not over'\n return 'lose'","def is_done(la):\r\n win = 'notdone'\r\n winner = 0\r\n if sum(x.count(0) for x in la)==0:win = False\r\n for i in range(3):\r\n if la[i][0] == la[i][1] == la[i][2] and la[i][0]!=0:\r\n win = True\r\n winner = la[i][0]\r\n if la[0][i] == la[1][i] == la[2][i] and la[0][i]!=0:\r\n win = True\r\n winner = la[0][i]\r\n if la[0][0] == la[1][1] == la[2][2] and la[0][0]!=0:\r\n win = True\r\n winner = la[0][0] \r\n elif la[0][2] == la[1][1] == la[2][0] and la[0][2]!=0:\r\n win = True\r\n winner = la[i][0]\r\n return win,winner","def diagnol(self, ox, curRow, curCol):\n count = 0\n while count < 4 and curRow < self.height and curCol < self.width and self.board[curRow][curCol] == ox:\n count += 1\n curRow += 1\n curCol += 1\n return count == 4","def states_filter(state):\n if state.count(0) < state.count(1) or state.count(1) < state.count(0) - 1:\n return False\n\n rows = [[i, i+1, i+2] for i in [0, 3, 6]]\n cols = [[i, i+3, i+6] for i in [0, 1, 2]]\n\n winners = set()\n\n for row_indexes in rows:\n row = [state[ind] for ind in row_indexes]\n if row[0] >= 0 and are_same(row):\n winners.add(row[0])\n\n for col_indexes in cols:\n col = [state[ind] for ind in col_indexes]\n if col[0] >= 0 and are_same(col):\n winners.add(col[0])\n\n # We don't look at diags\n return len(winners) <= 1"],"string":"[\n \"def is_winning(self, curr_state):\\n rows = [[0,1,2], [3,4,5], [6,7,8]]\\n columns = [[0,3,6], [1,4,7], [2,5,8]]\\n diagonal = [[0,4,8], [2,4,6]]\\n total_checks = rows + columns + diagonal\\n for row in total_checks:\\n sum = 0\\n count = 0\\n for pos in row:\\n if np.isnan(curr_state[pos]):\\n break\\n else:\\n sum = sum + curr_state[pos]\\n count = count + 1\\n if sum == 15 and count == 3:\\n return True\\n return False\",\n \"def diag_win(board):\\n\\tif board[1][1] != EMPTY and (board[1][1] == board[0][2] == board[2][0] or board[1][1] == board[0][0] == board[2][2]):\\n\\t\\treturn True\\n\\treturn False\",\n \"def is_winning(self):\\n\\n current_board = self.current_board\\n\\n # check rows\\n for row in current_board:\\n row = set(row)\\n if (\\\"X\\\" not in row and \\\"-\\\" not in row) or (\\\"O\\\" not in row and \\\"-\\\" not in row):\\n return True\\n\\n # check columns\\n for i in range(len(current_board)):\\n column_to_check = set()\\n \\n for j in range(len(current_board)):\\n column_to_check.add(current_board[j][i])\\n\\n if (\\\"X\\\" not in column_to_check and \\\"-\\\" not in column_to_check) or (\\\"O\\\" not in column_to_check and \\\"-\\\" not in column_to_check):\\n return True\\n \\n # check diagonals\\n forward_diagonal_check = set()\\n backward_diagonal_check = set()\\n \\n for i in range(len(current_board)):\\n forward_diagonal_check.add(current_board[i][i])\\n backward_diagonal_check.add(current_board[i][len(current_board)-1-i])\\n\\n if forward_diagonal_check == {\\\"X\\\"} or forward_diagonal_check == {\\\"O\\\"}:\\n return True\\n\\n if backward_diagonal_check == {\\\"X\\\"} or backward_diagonal_check == {\\\"O\\\"}:\\n return True\",\n \"def check_diagonals():\\n global game_still_going\\n # Check if any of the rows have all the same value.\\n diagonal1 = board[0] == board[4] == board[8] != '_'\\n diagonal2 = board[6] == board[4] == board[2] != '_'\\n # If any diagonals does have a match, then game still going to False.\\n if diagonal1 or diagonal2:\\n game_still_going = False\\n # Return winner 'X' or 'O'.\\n if diagonal1:\\n return board[0]\\n if diagonal2:\\n return board[6]\",\n \"def check_diagonals(self):\\n\\t\\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\\n\\n\\t\\tfor diag in diags:\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor loc in diag:\\n\\t\\t\\t\\tif self.board[loc[0]][loc[1]] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('WE WON')\\n\\t\\t\\t\\treturn True\",\n \"def check_win(self):\\n for pos in self.win_set:\\n # s would be all 1 if all positions of a winning move is fulfilled\\n # otherwise 1s and 0s\\n s = set([self.grid[p] for p in pos])\\n if len(s) == 1 and (0 not in s):\\n return True\\n return False\",\n \"def is_down_diagonal_win(self, checker):\\n for row in range(self.height-3):\\n for col in range(self.width-3):\\n if self.slots[row][col] == checker and \\\\\\n self.slots[row+1][col+1] == checker and \\\\\\n self.slots[row+2][col+2] == checker and \\\\\\n self.slots[row+3][col+3] == checker:\\n return True\\n return False\",\n \"def is_winning(self, curr_state):\\n winning_combinations = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]\\n # We will check only for the above 8 combinations to see any of them sums up to 15 which implies winning\\n for combination in winning_combinations:\\n #print('Combination:',combination)\\n if not np.isnan(curr_state[combination[0]]) and not np.isnan(curr_state[combination[1]]) and not np.isnan(curr_state[combination[2]]) :\\n if curr_state[combination[0]] + curr_state[combination[1]] + curr_state[combination[2]] == 15 :\\n return True\\n \\n #If none of the above condition is True return False \\n return False\",\n \"def diagonal_win():\\n\\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][i]) \\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 1\\\"\\n return True\\n \\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][board_size - 1 - i])\\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 2\\\"\\n return True\",\n \"def winGame(sub_state):\\n for i in range(sub_state.shape[0] - 4):\\n for j in range(sub_state.shape[1] - 4):\\n\\n horizontal = sub_state[i][j: j+5]\\n if (horizontal == 1).all():\\n return True\\n\\n vertical = [sub_state[i+k, j] for k in range(5)]\\n if (np.array(vertical) == 1).all():\\n return True\\n\\n diagonal = [sub_state[(i+k, j+k)] for k in range(5)]\\n if (np.array(diagonal) == 1).all():\\n return True\\n\\n return False\",\n \"def is_up_diagonal_win(self, checker):\\n for row in range(3, self.height):\\n for col in range(self.width-3):\\n if self.slots[row][col] == checker and \\\\\\n self.slots[row-1][col+1] == checker and \\\\\\n self.slots[row-2][col+2] == checker and \\\\\\n self.slots[row-3][col+3] == checker:\\n return True\\n return False\",\n \"def check_winner(self):\\n if self.history:\\n last_move = self.history[-1]\\n last_player = self.get_last_player()\\n\\n connected_token = last_player*self.n_in_row\\n # check for row\\n if connected_token in [sum(self.state[last_move[0]][j:j+self.n_in_row]) for j in range(0, self.width-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for column\\n if connected_token in [sum(self.state.T[last_move[1]][i:i+self.n_in_row]) for i in range(0, self.height-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope 1\\n diagonal = np.diag(self.state, last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for diagonal with slope -1\\n diagonal = np.diag(self.state[:,::-1], self.width-1-last_move[1]-last_move[0])\\n if connected_token in [sum(diagonal[i:i+self.n_in_row]) for i in range(0, len(diagonal)-self.n_in_row+1, 1)]:\\n self.winner = [True, last_player]\\n return self.winner\\n\\n # check for draw game\\n if len(np.argwhere(self.state==0)) == 0:\\n self.winner = [True, 0]\\n return self.winner\\n return self.winner\",\n \"def is_down_diagonal_win(self, checker):\\r\\n for row in range(self.height - self.win_condition + 1):\\r\\n for col in range(self.width - self.win_condition + 1):\\r\\n num_checkers = 0\\r\\n for i in range(self.win_condition):\\r\\n if self.grid[row + i][col + i] == checker:\\r\\n num_checkers += 1\\r\\n\\r\\n if num_checkers == self.win_condition:\\r\\n return True\\r\\n\\r\\n # if we get here, there's no horizontal win\\r\\n return False\",\n \"def terminal(self):\\n # Horizontal check\\n for i in range(3):\\n b_ = True\\n for j in range(2):\\n if self.board[i][j] == None or self.board[i][j] != self.board[i][j + 1]:\\n b_ = False\\n \\n if b_:\\n self.winner = self.board[i][0]\\n return True\\n \\n # Vertical check\\n for j in range(3):\\n b_ = True\\n for i in range(2):\\n if self.board[i][j] == None or self.board[i][j] != self.board[i + 1][j]:\\n b_ = False\\n \\n if b_:\\n self.winner = self.board[0][j]\\n return True\\n \\n # Diagonal check\\n if self.board[1][1] != None:\\n if self.board[0][0] == self.board[1][1] == self.board[2][2]:\\n self.winner = self.board[1][1]\\n return True\\n\\n if self.board[2][0] == self.board[1][1] == self.board[0][2]:\\n self.winner = self.board[1][1]\\n return True\\n\\n # Draw check\\n if sum([row.count(None) for row in self.board]) == 0:\\n self.winner = None\\n return True\\n \\n return False\",\n \"def check_for_win(self, row, col, player): \\n\\n count = 0\\n for i in range(0, len(self.board[0])):\\n # Check vertical\\n if self.board[row][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n\\n count = 0\\n for i in range(0, len(self.board)):\\n # Check horisontal\\n if self.board[:, col][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n \\n count = 0\\n totoffset = col - row\\n for i in np.diagonal(self.board, offset=totoffset):\\n # Check diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\\n\\n count = 0\\n mirrorboard = np.fliplr(self.board)\\n col = self.colswitch[col]\\n totoffset = col - row\\n for i in np.diagonal(mirrorboard, offset=totoffset):\\n # Check other diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\",\n \"def check_won (grid):\\r\\n w=False\\r\\n for row in range(4):\\r\\n for col in range(4):\\r\\n if grid[row][col]>=32:\\r\\n w=True\\r\\n break\\r\\n return w\",\n \"def check_win(self):\\n lines = []\\n\\n # rows\\n lines.extend(self._board)\\n\\n # cols\\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\\n for colidx in range(self._dim)]\\n lines.extend(cols)\\n\\n # diags\\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\\n diag2 = [self._board[idx][self._dim - idx -1]\\n for idx in range(self._dim)]\\n lines.append(diag1)\\n lines.append(diag2)\\n\\n # check all lines\\n for line in lines:\\n if len(set(line)) == 1 and line[0] != EMPTY:\\n if self._reverse:\\n return switch_player(line[0])\\n else:\\n return line[0]\\n\\n # no winner, check for draw\\n if len(self.get_empty_squares()) == 0:\\n return DRAW\\n\\n # game is still in progress\\n return None\",\n \"def check_win(self, board, move):\\n for i, j, k in self.winning_cases:\\n if board[i] == move and board[j] == move and board[k] == move:\\n return True\\n return False\",\n \"def check_for_win_lose(b):\\r\\n win_move = None\\r\\n block_win = None\\r\\n # check for wins based on row\\r\\n for ri in range(3):\\r\\n row = b[ri]\\r\\n if single_move(row):\\r\\n if row==[1,1,0]:\\r\\n win_move = (ri+1,3)\\r\\n elif row==[2,2,0]:\\r\\n block_win = (ri+1,3)\\r\\n elif row==[1,0,1]:\\r\\n win_move = (ri+1,2)\\r\\n elif row==[2,0,2]:\\r\\n block_win = (ri+1,2)\\r\\n elif row==[0,1,1]:\\r\\n win_move = (ri+1,1)\\r\\n elif row==[0,2,2]:\\r\\n block_win = (ri+1,1)\\r\\n else:\\r\\n print '144 ERROR!'\\r\\n print single_move(row)\\r\\n print row\\r\\n print ' '\\r\\n\\r\\n # check for win based on column\\r\\n for ci in range(3):\\r\\n col = get_col(b,ci)\\r\\n if single_move(col):\\r\\n if col==[1,1,0]:\\r\\n win_move = (3,ci+1)\\r\\n elif col==[2,2,0]:\\r\\n block_win = (3,ci+1)\\r\\n elif col==[1,0,1]:\\r\\n win_move = (2,ci+1)\\r\\n elif col==[2,0,2]:\\r\\n block_win = (2,ci+1)\\r\\n elif col==[0,1,1]:\\r\\n win_move = (1,ci+1)\\r\\n elif col==[0,2,2]:\\r\\n block_win = (1,ci+1)\\r\\n else:\\r\\n print '166 ERROR!'\\r\\n print single_move(col)\\r\\n print col\\r\\n print ' '\\r\\n\\r\\n # check for win on backward diagonal\\r\\n diag = get_bw_diag(b)\\r\\n if single_move(diag):\\r\\n if diag==[1,1,0]:\\r\\n win_move = (3,3)\\r\\n elif diag==[2,2,0]:\\r\\n block_win (3,3)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,1)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,1)\\r\\n \\r\\n # check for win on forward diagonal\\r\\n diag = get_fwd_diag(b)\\r\\n if single_move(diag):\\r\\n if diag == [1,1,0]:\\r\\n win_move = (3,1)\\r\\n elif diag==[2,2,0]:\\r\\n block_win = (3,1)\\r\\n elif diag == [1,0,1]:\\r\\n win_move = (2,2)\\r\\n elif diag==[2,0,2]:\\r\\n block_win = (2,2)\\r\\n elif diag == [0,1,1]:\\r\\n win_move = (1,3)\\r\\n elif diag==[0,2,2]:\\r\\n block_win = (1,3)\\r\\n\\r\\n if win_move is not None:\\r\\n return (win_move, True)\\r\\n elif block_win is not None:\\r\\n return (block_win, False)\\r\\n else:\\r\\n return (None, False)\",\n \"def win_check(table: list) -> (bool, str):\\n # Combinations that would lead to a win\\n win_list = [\\n [0,1,2], [3,4,5],\\n [6,7,8], [0,3,6],\\n [1,4,7], [2,5,8],\\n [0,4,8], [6,4,2],\\n ]\\n for line in win_list:\\n # Check rows, columns, and diagonals\\n combination = set([table[line[0]], table[line[1]], table[line[2]]])\\n\\n if len(combination) == 1 and combination != {\\\"-\\\"}: # Which mean we have a straight line of either X or O\\n #unpack comb (which is 1 item), which is either \\\"X\\\" or \\\"O\\\" to know who won\\n return True, *combination\\n else:\\n return False, None\",\n \"def check_diag(self, row, column, symbol):\\r\\n\\r\\n # get the current state of buttons..\\r\\n # tl -> top left; mm -> middle middle; etc...\\r\\n tl = self.board[0][0][1]\\r\\n mm = self.board[1][1][1]\\r\\n br = self.board[2][2][1]\\r\\n bl = self.board[0][2][1]\\r\\n tr = self.board[0][2][1]\\r\\n\\r\\n # we know if mm isn't on then we can return early\\r\\n if mm == symbol:\\r\\n if tl == symbol and br == symbol:\\r\\n self.winner = symbol\\r\\n return\\r\\n if tr == symbol and bl == symbol:\\r\\n self.winner = symbol\\r\\n return\\r\\n else:\\r\\n return\\r\\n else:\\r\\n return\",\n \"def is_up_diagonal_win(self, checker):\\r\\n for row in range(self.height - self.win_condition + 1):\\r\\n for col in range(self.width - self.win_condition + 1):\\r\\n num_checkers = 0\\r\\n for i in range(self.win_condition):\\r\\n if self.grid[self.height - row - 1 - i][col+i] == checker:\\r\\n num_checkers += 1\\r\\n\\r\\n if num_checkers == self.win_condition:\\r\\n return True\\r\\n\\r\\n # if we get here, there's no horizontal win\\r\\n return False\",\n \"def __win(self, a):\\n for i in range(len(a)-self.k+1):\\n flag = True\\n for j in range(self.k):\\n if not a[i+j]:\\n flag = False\\n break\\n if flag: return True\",\n \"def check_game_status2(board):\\n board = np.array(board)\\n for i in range(7):\\n for j in range(6):\\n if checkWin(board, j, i, 1):\\n return 1\\n if checkWin(board, j, i, 2):\\n return 2\\n if isfull(board):\\n return 0\\n return -1\",\n \"def _check_winning_combinations(board, player):\\n winning_combinations = (\\n ((0, 0), (0, 1), (0, 2)),\\n ((1, 0), (1, 1), (1, 2)),\\n ((2, 0), (2, 1), (2, 2)),\\n ((0, 0), (1, 0), (2, 0)),\\n ((0, 1), (1, 1), (2, 1)),\\n ((0, 2), (1, 2), (2, 2)),\\n ((0, 0), (1, 1), (2, 2)),\\n ((0, 2), (1, 1), (2, 0))\\n )\\n\\n if any(combination for combination in winning_combinations if _is_winning_combination(board, combination, player)):\\n return player\\n\\n return None\",\n \"def checkAll(self, player, board):\\n #retrieve current moves of the player who made the last move\\n currentMoves = self.getPlayerMoves(player,board)\\n\\n #check column win\\n is_col_win = self.checkWin(currentMoves, self.columnWins)\\n if is_col_win != False:\\n return True\\n\\n #check row win\\n is_row_win = self.checkWin(currentMoves, self.rowWins)\\n if is_row_win != False:\\n return True\\n\\n #check diagonal win\\n is_diag_win = self.checkWin(currentMoves, self.diagonalWins)\\n if is_diag_win != False:\\n return True\\n else:\\n return False\",\n \"def row_win(board):\\n\\tfor row in range(3):\\n\\t\\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def check_diagonals():\\n global ongoing_game\\n diagonal_1 = board[0] == board[4] == board[8] != \\\"*\\\"\\n diagonal_2 = board[2] == board[4] == board[6] != \\\"*\\\"\\n if diagonal_1 or diagonal_2:\\n ongoing_game = False\\n if diagonal_1:\\n return board[0]\\n elif diagonal_2:\\n return board[2]\\n else:\\n return None\",\n \"def check_won (grid):\\r\\n for i in range (4):\\r\\n for j in range (4):\\r\\n if grid[i][j] >= 32:\\r\\n return True\\r\\n return False\",\n \"def is_winning(self, curr_state):\\n \\n winning_idx_lists = [\\n [0, 1, 2],\\n [3, 4, 5],\\n [6, 7, 8],\\n [0, 3, 6],\\n [1, 4, 7],\\n [2, 5, 8],\\n [0, 4, 8],\\n [2, 4, 6]\\n ]\\n is_winning = False\\n for winning_idx_list in winning_idx_lists:\\n result_list = [curr_state[index] for index in winning_idx_list]\\n if (sum(result_list) == 15):\\n is_winning = True \\n break\\n\\n return is_winning\",\n \"def check_won (grid):\\r\\n for i in range(4): \\r\\n for j in range(4):\\r\\n if grid[i][j] >= 32:\\r\\n return True\\r\\n return False\",\n \"def checkwin(self):\\n w = self.getWidth()\\n h = self.getHeight()\\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\\n for r in range(h):\\n for c in range(w):\\n if self.cell[c][r] == EMPTY:\\n continue # this cell can't be part of winning segment\\n # if we reach this point, the cell is occupied by a player stone\\n numOccupiedCell = numOccupiedCell+1\\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\\n for i in range(NWIN):\\n # test if there exists a segment of NWIN uniformly coloured cells\\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\\n break # segment broken\\n else:\\n # Python remark: notice that the else is attached to the for loop \\\"for i...\\\"\\n # This block is executed if and only if 'i' arrives at the end of its range \\n return self.cell[c][r] , True # found a winning segment \\n return EMPTY, numOccupiedCell==w*h\",\n \"def win_game(self):\\n\\n def horizontal_win():\\n \\\"\\\"\\\"Return whether there is horizontal win\\\"\\\"\\\"\\n\\n for i in range(0, board_size):\\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\\n print \\\"horizontal win\\\"\\n return True\\n\\n def vertical_win():\\n \\\"\\\"\\\"Return whether there is vertical win\\\"\\\"\\\"\\n\\n vert_set = set()\\n for i in range(0, board_size):\\n for j in range(0, board_size):\\n vert_set.add(self.board[j][i])\\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\\n print \\\"vertical win\\\"\\n return True \\n vert_set = set()\\n\\n def diagonal_win():\\n \\\"\\\"\\\"Return whether there is diagonal win\\\"\\\"\\\"\\n\\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][i]) \\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 1\\\"\\n return True\\n \\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][board_size - 1 - i])\\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 2\\\"\\n return True\\n\\n if horizontal_win() or vertical_win() or diagonal_win():\\n print \\\"You have won.\\\"\\n return True\",\n \"def check_for_win(self,board, player_id, action):\\n\\n row = 0\\n\\n # check which row was inserted last:\\n for i in range(ROWS):\\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\\n row = ROWS - i\\n break\\n\\n # check horizontal:\\n vec = board[row, :] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check vertical:\\n vec = board[:, action] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check diagonals:\\n vec = np.diagonal(board, action - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n return False\",\n \"def col_win(board):\\n\\tfor col in range(3):\\n\\t\\tif board[0][col] != EMPTY and board[0][col] == board[1][col] == board[2][col]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def check_win(self, player):\\n def check_row_win(player):\\n for row in self.game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_column_win(player):\\n # For doing a column check, transpose the grid and do a row check\\n trans_game_state = numpy.transpose(self.game_state)\\n for row in trans_game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_diag_win(player):\\n # Left to right diagonal\\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\\n return True\\n # Right to left diagonal\\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\\n return True\\n return False\\n\\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\\n return True\\n return False\",\n \"def check_won (grid):\\r\\n p=0\\r\\n for k in range(len(grid)):\\r\\n for g in range(len(grid[k])): \\r\\n if grid[k][g]>=32:\\r\\n p+=1\\r\\n else:\\r\\n ()\\r\\n if p>0:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def check_winner(self, row, column, symbol):\\r\\n self.check_row(row, symbol)\\r\\n self.check_column(column, symbol)\\r\\n self.check_diag(row, column, symbol)\",\n \"def check(self):\\n winner = None\\n count = 0\\n\\n for y in range(self.gridSize):\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for item in self.grid[y]:\\n # Check row of the grid\\n if item == \\\"P1\\\":\\n P1 += 1\\n elif item == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for x in range(self.gridSize):\\n # Check column of the grid\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check right top to left bottom across the grid\\n for x in range(self.gridSize):\\n if x == y:\\n if self.grid[x][y] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[x][y] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n if winner != None:\\n return winner\\n P1, P2 = 0, 0\\n for y in range(self.gridSize):\\n # Check the left top to the right bottom across the grid\\n for x in range(self.gridSize - 1, -1, -1):\\n # Check how many filled spaces there are\\n if \\\".\\\" not in self.grid[y][x]:\\n count += 1\\n if x + y == self.gridSize - 1:\\n if self.grid[y][x] == \\\"P1\\\":\\n P1 += 1\\n elif self.grid[y][x] == \\\"P2\\\":\\n P2 += 1\\n winner = self.checkval(P1, P2, self.gridSize)\\n # Check if there is a winner if so return the winner\\n if winner != None:\\n return winner\\n # Check if the fields that are filled are equal to the possible spaces to be filled in the grid\\n if count == self.gridSize**2:\\n return \\\"Tie\\\"\",\n \"def checkWin(self):\\n winstates = [(0, 1, 2),\\n (3, 4, 5),\\n (6, 7, 8),\\n (0, 3, 6),\\n (1, 4, 7),\\n (2, 5, 8),\\n (0, 4, 8),\\n (2, 4, 6)]\\n win = False\\n for state in winstates:\\n if (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == 3:\\n self.handleWin(1)\\n win = True\\n elif (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == -3:\\n self.handleWin(-1)\\n win = True\\n\\n if len([i for i in range(9) if self.gameState[i] == 0]) == 0 and not win:\\n print(\\\"Draw yo\\\")\\n self.handleDraw()\\n return None\",\n \"def is_win(my_board):\\n return np.count_nonzero(my_board == CLOSED) == NUM_MINES\",\n \"def check_boards(self):\\n succesful = True\\n marker = self.game.player\\n print(f\\\"-----Starting check_winning_boards-----\\\")\\n winning_boards= [\\n [\\n [marker]*3,\\n [\\\" \\\"]*3,\\n [\\\" \\\"]*3\\n ],\\n [\\n [\\\" \\\"]*3,\\n [marker]*3,\\n [\\\" \\\"]*3\\n ],\\n [\\n [\\\" \\\"]*3,\\n [\\\" \\\"]*3,\\n [marker]*3\\n ],\\n [\\n [marker, \\\" \\\", \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"]\\n ],\\n [\\n [\\\" \\\",marker, \\\" \\\"],\\n [\\\" \\\",marker, \\\" \\\"],\\n [\\\" \\\",marker, \\\" \\\"]\\n ],\\n [\\n [\\\" \\\", \\\" \\\",marker],\\n [\\\" \\\", \\\" \\\",marker],\\n [\\\" \\\", \\\" \\\",marker]\\n ],\\n [\\n [marker, \\\" \\\", \\\" \\\"]\\n ,[\\\" \\\", marker,\\\" \\\"],\\n [\\\" \\\", \\\" \\\",marker]\\n ],\\n [\\n [\\\" \\\", \\\" \\\", marker],\\n [\\\" \\\",marker, \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"]\\n ]\\n ]\\n for board in winning_boards:\\n if self.game.check_win_conditions(board) != -10:\\n succesful = False\\n print(f\\\"board failed checkWins \\\\n{board}\\\")\\n marker = self.game.ai_player\\n print(f\\\"-----Starting check_winning_boards-----\\\")\\n winning_boards= [\\n [\\n [marker]*3,\\n [\\\" \\\"]*3,\\n [\\\" \\\"]*3\\n ],\\n [\\n [\\\" \\\"]*3,\\n [marker]*3,\\n [\\\" \\\"]*3\\n ],\\n [\\n [\\\" \\\"]*3,\\n [\\\" \\\"]*3,\\n [marker]*3\\n ],\\n [\\n [marker, \\\" \\\", \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"]\\n ],\\n [\\n [\\\" \\\",marker, \\\" \\\"],\\n [\\\" \\\",marker, \\\" \\\"],\\n [\\\" \\\",marker, \\\" \\\"]\\n ],\\n [\\n [\\\" \\\", \\\" \\\",marker],\\n [\\\" \\\", \\\" \\\",marker],\\n [\\\" \\\", \\\" \\\",marker]\\n ],\\n [\\n [marker, \\\" \\\", \\\" \\\"]\\n ,[\\\" \\\", marker,\\\" \\\"],\\n [\\\" \\\", \\\" \\\",marker]\\n ],\\n [\\n [\\\" \\\", \\\" \\\", marker],\\n [\\\" \\\",marker, \\\" \\\"],\\n [marker, \\\" \\\", \\\" \\\"]\\n ]\\n ]\\n for board in winning_boards:\\n if self.game.check_win_conditions(board) != 10:\\n succesful = False\\n print(f\\\"board failed checkWins \\\\n{board}\\\")\\n \\n tie_boards = [\\n [ \\n [\\\"O\\\",\\\"O\\\",\\\"X\\\"],\\n [\\\"X\\\",\\\"O\\\",\\\"O\\\"],\\n [\\\"X\\\",\\\"X\\\",\\\" \\\"]\\n ],\\n [\\n [\\\"O\\\",\\\"X\\\",\\\" \\\"],\\n [\\\" \\\",\\\"X\\\",\\\" \\\"],\\n [\\\" \\\",\\\"O\\\",\\\" \\\"]\\n ],\\n [\\n ['O', 'O', 'X'],\\n ['X', 'X', 'O'],\\n ['O', 'O', 'X']\\n ]\\n ]\\n for board in tie_boards:\\n if self.game.check_win_conditions(board) != 0:\\n succesful = False\\n print(f\\\"board failed checkWins \\\\n{board}\\\")\\n\\n print(f\\\"-----Ending check_winning_boards-----\\\")\",\n \"def search_possible_steps(self):\\n if self.ended:\\n return False\\n possible_steps_turple = (self.board == 0)\\n possible_steps = np.transpose(possible_steps_turple.nonzero())\\n return possible_steps\",\n \"def check_won(grid):\\r\\n for i in range(len(grid)):\\r\\n for j in range(len(grid[i])):\\r\\n if grid[i][j] >= 32:\\r\\n return True \\r\\n return False\",\n \"def loss_condition(self):\\n possible_combinations = [[1,2,3], [4,5,6], [7,8,9],\\n [1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]\\n\\n return any([all([(self.board[i-1] == self.nopponent)\\n for i in combination]) for combination in possible_combinations])\",\n \"def check_lost (grid):\\r\\n for row in range(4):\\r\\n for col in range(4):\\r\\n if grid[row][col]==0:\\r\\n return False\\r\\n if grid[0][0]==grid[0][1] or grid[0][0]==grid[1][0]:\\r\\n return False \\r\\n if grid[0][3]==grid[0][2] or grid[0][3]==grid[1][3]:\\r\\n return False \\r\\n if grid[3][0]==grid[2][0] or grid[3][0]==grid[3][1]:\\r\\n return False\\r\\n if grid[3][3]==grid[2][3] or grid[3][3]==grid[3][2]:\\r\\n return False \\r\\n if grid[0][1]==grid[0][2] or grid[0][1]==grid[1][1]:\\r\\n return False \\r\\n if grid[0][2]==grid[1][2]:\\r\\n return False \\r\\n if grid[1][1]==grid[2][1] or grid[1][1]==grid[1][2] or grid[1][1]==grid[1][0]:\\r\\n return False\\r\\n if grid[2][1]==grid[2][0] or grid[2][1]==grid[2][2] or grid[2][1]==grid[3][1]:\\r\\n return False \\r\\n if grid[1][0]==grid[2][0]:\\r\\n return False\\r\\n if grid[1][2]==grid[1][3] or grid[1][2]==grid[2][2]:\\r\\n return False\\r\\n if grid[2][2]==grid[2][3] or grid[2][2]==grid[3][2]:\\r\\n return False\\r\\n if grid[3][1]==grid[3][2]:\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def check_win_condition(board) -> bool:\\n if _check_vertical_win_condition(board) or _check_horizontal_win_condition(board) or _check_diagonal_win_condition(\\n board):\\n return True\\n else:\\n board.alternate_current_player()\\n return False\",\n \"def multipleQueensAlongDiagonals(board):\\n if (multipleQueensOnRightDiagonals(board) or\\n multipleQueensOnLeftDiagonals(board)):\\n return True\\n\\n return False\",\n \"def check_win(self):\\r\\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\\r\\n for case, pos in wins:\\r\\n if case != -1:\\r\\n print('Game over!')\\r\\n if self.grid[case][-1] == self.computer:\\r\\n print('The computer won!')\\r\\n return (True, pos)\\r\\n print('The player won!')\\r\\n return (True, pos)\\r\\n\\r\\n return (self.check_draw(), None)\",\n \"def __check_win_condition(self,token,coordinate):\\n # Check if it's even possible to win yet\\n if self._turn_counter >= 8 and self._turn_counter+1 < self._board_size**2:\\n # Disable win\\n # return False\\n\\n # Up and up right vectors\\n vec1=(1,0)\\n vec2=(1,1)\\n\\n # Loop both directions of vector\\n for _ in range(2):\\n if self.__check_direction(vec1,coordinate):\\n self.__declare_winner()\\n return True\\n if self.__check_direction(vec2,coordinate):\\n self.__declare_winner()\\n return True\\n\\n # Turn vector directions\\n vec1 = -vec1[1], vec1[0]\\n vec2 = -vec2[1], vec2[0]\\n\\n # Check for draw\\n elif self._turn_counter+1 >= self._board_size**2:\\n if (self._gui):\\n self.__turn_counter_label[\\\"text\\\"] = \\\"Draw!\\\"\\n self.__status[\\\"text\\\"] = \\\"\\\"\\n self.__status.update()\\n self.__turn_counter_label.update()\\n self._winner = 3\\n if (self._state == PLAY): showerror(\\\"Draw\\\",\\\"Draw!\\\")\\n return True\",\n \"def _check_for_win(self, piece, piece_x, piece_y):\\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions = []\\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\\n for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions.append((x, y))\\n # Don't need to check the piece that is being placed\\n if (x, y) == (piece_x, piece_y):\\n continue\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece != piece:\\n winning_piece_positions = None\\n break\\n if winning_piece_positions:\\n # Check if there are additional winning pieces that exceed the number required to win.\\n # e.g. a 5-in-a-row when only 4 are required\\n if slope_x != 0:\\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\\n for i in range(1, 1 + num_previous_pieces_to_check)):\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece == piece:\\n winning_piece_positions.insert(0, (x, y))\\n else:\\n break\\n return winning_piece_positions\\n\\n return False\",\n \"def _check_winner(self) -> Optional[int]:\\n\\n if self._is_red_active:\\n temp_board = self.board_array.clip(min=0, max=1) # Turns all -1's into 0's\\n for kernel in self._detection_kernels_red:\\n # For each of the patterns that produce a win, do a 2d convolution on the copy\\n # of the board. If there 4's in the resulting array, one of the kernels found a\\n # match and so there is a 4 in a row somewhere. This is done this way to save\\n # as much time as possible, because optimisation is very important to the\\n # AI's performance and python is already quite slow\\n if np.any(convolve2d(temp_board, kernel, mode='valid') == 4):\\n return 1\\n else:\\n temp_board = self.board_array.clip(min=-1, max=0) # Turns all 1's into 0's\\n for kernel in self._detection_kernels_yellow:\\n # Same as before\\n if np.any(convolve2d(temp_board, kernel, mode='valid') == 4):\\n return -1\\n\\n if len(self._valid_moves) == 0:\\n return 0\\n\\n return None\",\n \"def checkSolution(self):\\n movesToEndblock = self.gridSize - self.changeable[0] - 2\\n if self.checkMove(0,movesToEndblock) == 0:\\n return 0\\n return 1\",\n \"def check_lost (grid):\\r\\n t=0\\r\\n for o in range(len(grid)):\\r\\n for e in range(len(grid[o])):\\r\\n if grid[o][e]==0:\\r\\n t+=1\\r\\n else:\\r\\n ()\\r\\n r=0\\r\\n for o in range(len(grid)):\\r\\n for e in range(len(grid[o])-1):\\r\\n if grid[o][e]==grid[o][e+1]:\\r\\n r+=1\\r\\n elif grid[o][3]==grid[o][2]:\\r\\n r+=1 \\r\\n else:\\r\\n ()\\r\\n \\r\\n v=0\\r\\n for o in range(len(grid)):\\r\\n for e in range(len(grid[o])-1):\\r\\n if grid[e][o]==grid[e+1][o]:\\r\\n v+=1\\r\\n elif grid[3][o]==grid[2][o]:\\r\\n v+=1 \\r\\n else:\\r\\n () \\r\\n \\r\\n if t==0 and r==0 and v==0:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def win(s):\\r\\n\\r\\n # check across\\r\\n for i in range(3):\\r\\n if board[0 + 3 * i] == board[1 + 3 * i] == board[2 + 3 * i] == s:\\r\\n board[0 + 3 * i] = board[1 + 3 * i] = board[2 + 3 * i] = '#'\\r\\n return True\\r\\n\\r\\n # check down\\r\\n for i in range(3):\\r\\n if board[i] == board[i + 3] == board[i + 6] == s:\\r\\n board[i] = board[i + 3] = board[i + 6] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal right\\r\\n if board[0] == board[4] == board[8] == s:\\r\\n board[0] = board[4] = board[8] = '#'\\r\\n return True\\r\\n\\r\\n # check diagonal left\\r\\n if board[6] == board[4] == board[2] == s:\\r\\n board[6] = board[4] = board[2] = '#'\\r\\n return True\\r\\n\\r\\n return False\",\n \"def winner_found(self):\\n\\n first_row = self.find_three_in_row([self._board[0][0], self._board[0][1], self._board[0][2]])\\n second_row = self.find_three_in_row([self._board[1][0], self._board[1][1], self._board[1][2]])\\n third_row = self.find_three_in_row([self._board[2][0], self._board[2][1], self._board[2][2]])\\n winner_in_rows = first_row or second_row or third_row\\n\\n first_column = self.find_three_in_row([self._board[0][0], self._board[1][0], self._board[2][0]])\\n second_column = self.find_three_in_row([self._board[0][1], self._board[1][1], self._board[2][1]])\\n third_column = self.find_three_in_row([self._board[0][2], self._board[1][2], self._board[2][2]])\\n winner_in_columns = first_column or second_column or third_column\\n\\n first_diagonal = self.find_three_in_row([self._board[0][0], self._board[1][1], self._board[2][2]])\\n second_diagonal = self.find_three_in_row([self._board[2][0], self._board[1][1], self._board[0][2]])\\n winner_in_diagonals = first_diagonal or second_diagonal\\n\\n return winner_in_rows or winner_in_columns or winner_in_diagonals\",\n \"def test_check_win(self):\\n # Horizontal wins\\n # First row\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n\\n # Second row\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(1, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\\n\\n # Third row\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Vertical wins\\n # First column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 0, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n\\n # Second column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 1, PLAYERX), PLAYERX)\\n\\n # Third column\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 2, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Diagonal wins\\n # Upper left to bottom right\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(0, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(2, 2, PLAYERX), PLAYERX)\\n\\n # Bottom left to upper right\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERX)\\n self.assertEqual(self.game.check_win(2, 0, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(1, 1, PLAYERX), PLAYERX)\\n self.assertEqual(self.game.check_win(0, 2, PLAYERX), PLAYERX)\\n\\n # Draw\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.game._board[row][col] = EMPTY\\n\\n self.game.move(0, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 1, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(0, 2, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 0, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 1, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(1, 2, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 0, PLAYERX)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 1, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), None)\\n self.game.move(2, 2, PLAYERO)\\n for row in range(self.game._dim):\\n for col in range(self.game._dim):\\n self.assertEqual(self.game.check_win(row, col, PLAYERX), DRAW)\",\n \"def check_lost(grid):\\r\\n for i in range(len(grid)):\\r\\n for j in range(len(grid[i])):\\r\\n if grid[i][j] == 0:\\r\\n return False\\r\\n elif i+1 < len(grid):\\r\\n if grid[i][j] == grid[i+1][j]:\\r\\n return False\\r\\n elif j+1 < len(grid[i]):\\r\\n if grid[i][j] == grid[i][j+1]:\\r\\n return False \\r\\n return True\",\n \"def winsFor(self, ox):\\n for row in range(self.height):\\n for col in range(self.width):\\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\\n return True\\n return False\",\n \"def win_check(self):\\n\\t\\t# Create a temp var to capture the number of correct matches\\n\\t\\tright = 0\\n\\t\\t# retrieve peg_guess_color_list for current round\\n\\t\\tguess = self.model.guesses[self.model.status]\\n\\t\\t# retreive solution list\\n\\t\\tsolution = self.model.guesses[\\\"solution\\\"]\\n\\t\\t# compare values in each index for both lists against eachother\\n\\t\\tfor i in range(len(solution.pegs)):\\n\\t\\t\\t# \\n\\t\\t\\tif solution.pegs[i].peg_color == guess.pegs[i].peg_color:\\n\\t\\t\\t\\tright += 1\\n\\n\\t\\t\\t\\tprint(\\\"Yay, it works!\\\")\\n\\n\\t\\t# If all indexes of the peg_colors in the solution and guess are True:\\n\\t\\tif right == 4:\\n\\t\\t\\treturn True\\n\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def check_win(self):\\n for pos in self.win_set:\\n s = set([self.grid[p] for p in pos])\\n if len(s) == 1 and (0 not in s):\\n return True\\n return False\",\n \"def get_winner(board):\\n\\n def who_won(in_a_row, board_size, cur_player):\\n \\\"\\\"\\\" \\n a function private to get_winner() (yes you can do this. Cool huh!?) \\n that tells get_winner if it has a winner \\n \\\"\\\"\\\"\\n if in_a_row == board_size:\\n return 1 if cur_player == 'X' else 2\\n else:\\n return 0\\n\\n def test_row_col(board, rows):\\n \\\"\\\"\\\" private function to test the rows and columns \\\"\\\"\\\"\\n for i in range(len(board)):\\n cur_player = board[i][0] if rows else board[0][i]\\n in_a_row = 0\\n for j in range(len(board)):\\n symbol = board[i][j] if rows else board[j][i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1\\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n def test_diagonal(board, normal):\\n \\\"\\\"\\\" private function to test the two diagonals \\\"\\\"\\\"\\n cur_player = board[0][0] if normal else board[0][len(board)-1]\\n in_a_row = 0\\n for i in range(len(board)):\\n symbol = board[i][i] if normal else board[i][len(board)-1-i]\\n if (not symbol == '-') and (symbol == cur_player):\\n in_a_row += 1 \\n else:\\n break\\n winner = who_won(in_a_row, len(board), cur_player)\\n if not winner == 0:\\n return winner\\n return 0\\n\\n\\n # test rows\\n winner = test_row_col(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test cols\\n winner = test_row_col(board, False)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top left to bottom right\\n winner = test_diagonal(board, True)\\n if not winner == 0:\\n return winner\\n\\n # test diagonal from top right to bottom left\\n winner = test_diagonal(board, False)\\n if not winner == 0:\\n return winner\\n\\n return 0\",\n \"def check_winner(self):\\n\\t\\tif self.check_diagonals() or self.check_rows() or self.check_columns():\\n\\t\\t\\treturn True\\n\\t\\telif self.board_is_full():\\n\\t\\t\\tprint(\\\"There was a draw, everyone lost\\\")\\n\\t\\t\\treturn None\\n\\t\\treturn False\",\n \"def __check_winner(self):\\n for i in range(0, 3):\\n col = self.__get_col(i)\\n if col.get(self.player_char) == 3:\\n print('\\\\nYou win!')\\n self.game_ended = True\\n return\\n if col.get(self.opponent_char) == 3:\\n print('\\\\nYou lose.')\\n self.game_ended = True\\n return\\n row = self.__get_row(i)\\n if row.get(self.player_char) == 3:\\n print('\\\\nYou win!')\\n self.game_ended = True\\n return\\n if row.get(self.opponent_char) == 3:\\n print('\\\\nYou lose.')\\n self.game_ended = True\\n return\\n for i in range(0, 2):\\n diag = self.__get_diag(i)\\n if diag.get(self.player_char) == 3:\\n print('\\\\nYou win!')\\n self.game_ended = True\\n return\\n if diag.get(self.opponent_char) == 3:\\n print('\\\\nYou lose.')\\n self.game_ended = True\\n return\\n if self.state.count(' ') == 0:\\n print('\\\\nDraw!')\\n self.game_ended = True\",\n \"def terminal(board):\\n if winner(board):\\n return True\\n for i in range(3):\\n for j in range(3):\\n if not board[i][j]:\\n return False\\n return True\",\n \"def check_diagonal(self, has_player_got_4, board, pos, player_no):\\n for i in range(1, 4):\\n if pos[0] + i < self.width // 80 and pos[1] - i >= 0:\\n if board[(pos[0] + i, pos[1] - i)] == player_no:\\n has_player_got_4.add((pos[0] + i, pos[1] - i))\\n print(\\\"Added top-right: \\\" + str((pos[0] + i, pos[1] - i)))\\n else:\\n break\\n for i in range(1, 4):\\n if (self.height // 80 > pos[1] + i >= 0) and pos[0] - i >= 0:\\n if board[(pos[0] - i, pos[1] + i)] == player_no:\\n has_player_got_4.add((pos[0] - i, pos[1] + i))\\n print(\\\"Added bottom-left: \\\" + str((pos[0] - i, pos[1] + i)))\\n else:\\n break\",\n \"def check_rows(self):\\n\\t\\tfor i in range(len(self.board)):\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor j in range(len(self.board[i])):\\n\\t\\t\\t\\tif self.board[i][j] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('YOU WON')\\n\\t\\t\\t\\treturn True\",\n \"def conflicts(board):\\r\\n \\r\\n board = np.array(board)\\r\\n \\r\\n n = len(board)\\r\\n conflicts = 0\\r\\n\\r\\n # check horizontal (we do not check vertical since the state space is restricted to one queen per col)\\r\\n for i in range(n): conflicts += math.comb(np.sum(board == i), 2)\\r\\n #print(f\\\"Horizontal conflicts: {conflicts}\\\")\\r\\n \\r\\n # check for each queen diagonally up and down (only to the right side of the queen)\\r\\n for j in range(n):\\r\\n q_up = board[j]\\r\\n q_down = board[j]\\r\\n \\r\\n for jj in range(j+1, n):\\r\\n q_up -= 1\\r\\n q_down += 1\\r\\n if board[jj] == q_up: conflicts += 1\\r\\n if board[jj] == q_down: conflicts += 1\\r\\n #print(f\\\"Conflicts after queen {j}: {conflicts}\\\")\\r\\n \\r\\n return(conflicts)\",\n \"def check_board(board_state, player_symbol, display_message = False):\\n\\n is_board_completely_filled = board_state.isalpha()\\n\\n indices_set = set([ind+1 for ind, val in enumerate(board_state) if val == player_symbol])\\n\\n if {1, 2, 3}.issubset(indices_set) or {4, 5, 6}.issubset(indices_set) or {7, 8, 9}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Row completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n\\n if {1, 4, 7}.issubset(indices_set) or {2, 5, 8}.issubset(indices_set) or {3, 6, 9}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Column completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n if {1, 5, 9}.issubset(indices_set) or {3, 5, 7}.issubset(indices_set):\\n\\n if display_message:\\n print(\\\"Diagonal completed..!!!\\\")\\n print(\\\"Player \\\"+player_symbol+\\\" won the game.\\\")\\n\\n return True\\n\\n if is_board_completely_filled:\\n\\n if display_message:\\n print(\\\"Game is drawn...!\\\")\\n\\n return \\\"Draw\\\"\\n\\n return False\",\n \"def win_for(self, side):\\n # Testing rows\\n for row in range(self.height):\\n for col in range(self.width - 3):\\n if ( self.data[row][col] == side\\n and self.data[row][col+1] == side\\n and self.data[row][col+2] == side\\n and self.data[row][col+3] == side):\\n return True\\n\\n # Testing columns\\n for col in range(self.width):\\n for row in range(self.height - 3):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col] == side\\n and self.data[row+2][col] == side\\n and self.data[row+3][col] == side):\\n return True\\n\\n # Testing left diagonal\\n for row in range(self.height - 3):\\n for col in range(self.width - 3):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col+1] == side\\n and self.data[row+2][col+2] == side\\n and self.data[row+3][col+3] == side):\\n return True\\n\\n # Testing right diagonal\\n for row in range(self.height - 3):\\n for col in range(3, self.width):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col-1] == side\\n and self.data[row+2][col-2] == side\\n and self.data[row+3][col-3] == side):\\n return True\\n\\n return False\",\n \"def checkPossibleMoves():\\n for row in range(9):\\n for column in range(7):\\n if board[row][column] == board[row][column+1]: #A\\n a = board[row][column]\\n if column != 6: #column +3 would lead to an error\\n if a == board[row+1][column+2] or a == board[row][column+3] or a == board[row-1][column+2] or a == board[row-1][column-1] or a == board[row][column-2] or a ==board[row+1][column-1]:\\n return False\\n else: \\n if a == board[row+1][column+2] or a == board[row-1][column+2] or a == board[row-1][column-1] or a == board[row][column-2] or a ==board[row+1][column-1]:\\n return False\\n if board[row][column] == board[row][column+2]: # B\\n if board[row][column] == board[row+1][column+1] or board[row][column] == board[row-1][column+1]:\\n return False\\n\\n if board[row][column] == board[row+1][column]: #C\\n a = board[row][column]\\n if row != 8: #row +3 would lead to an error\\n if a == board[row-1][column+1] or a == board[row-2][column] or a == board[row-1][column-1] or a == board[row+2][column-1] or a == board[row+3][column] or a == board[row+2][column+1]:\\n return False\\n else:\\n if a == board[row-1][column+1] or a == board[row-2][column] or a == board[row-1][column-1] or a == board[row+2][column-1] or a == board[row+2][column+1]:\\n return False\\n\\n if board[row][column] == board[row+2][column]: #D\\n if board[row][column] == board[row+1][column-1] or board[row][column] == board[row+1][column+1]:\\n return False\\n return True\",\n \"def is_winning(game: List[int]) -> bool:\\n # performs the Vertical XOR by reducing as list of bool (lst) with xor lambda\\n reduce_xor = (lambda lst: reduce(__xor__, lst, False))\\n\\n # converts game into binary and the converts/permutes the row and col\\n game_bin_row_col = row_to_col(game_to_bin(game))\\n\\n # performs Vertical XOR on every column\\n res_vert_xor = list(map(reduce_xor, game_bin_row_col))\\n\\n return reduce(__or__, res_vert_xor, False)\",\n \"def check_win():\\r\\n for mark in markers:\\r\\n if loc[0] == mark and loc[1] == mark and loc[2] == mark:\\r\\n return True\\r\\n if loc[0] == mark and loc[3] == mark and loc[6] == mark:\\r\\n return True\\r\\n if loc[0] == mark and loc[4] == mark and loc[8] == mark:\\r\\n return True\\r\\n if loc[1] == mark and loc[4] == mark and loc[7] == mark:\\r\\n return True\\r\\n if loc[2] == mark and loc[4] == mark and loc[6] == mark:\\r\\n return True\\r\\n if loc[2] == mark and loc[5] == mark and loc[8] == mark:\\r\\n return True\\r\\n if loc[3] == mark and loc[4] == mark and loc[5] == mark:\\r\\n return True\\r\\n if loc[6] == mark and loc[7] == mark and loc[8] == mark:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def terminal(board):\\n #I need to check if any won or if I don't have any spaces left\\n game_ended = False\\n found_empty = False\\n #first of all, I check if I have empties.\\n for row in board:\\n if EMPTY in row:\\n #if I do have empties, I flag it. It is likely that I have not finished yet.\\n found_empty = True\\n #we check on the rows and columns for a winner\\n for i in range(0,3):\\n if (board[i][0] == board[i][1] and board[i][0] == board[i][2] and (board[i][0] is not EMPTY)) or (board[0][i] == board[1][i] and board[0][i] == board[2][i] and (board[0][i] is not EMPTY)):\\n game_ended = True\\n #we flag the game as ended if there is a winner and break the loop.\\n break\\n else:\\n #otherwise, we state that the game has no winners yet\\n game_ended = False\\n #If my game has no vertical or horizontal winners, I still have to check the diagonals.\\n if not game_ended: \\n #there were no horizontal nor vertical wins. I need to check diagonals\\n if (((board[0][0] == board[1][1] and board[2][2] == board[0][0]) or (board[0][2] == board[1][1] and board[2][0] == board[0][2]) ) and (board[1][1] is not EMPTY)):\\n game_ended = True\\n\\n #Finally, if I found and empty and my game has no winners yet, it means I can keep playing\\n if found_empty and not game_ended: \\n return False\\n else:\\n #otherwise, I have a winner and the game ended either due to a winner or a tie.\\n return True\",\n \"def checkWinner(board, plyr):\\n winner = False\\n winX = []\\n sideLen = len(board)\\n for i in range(sideLen):\\n winX.append(plyr)\\n winX = tuple(winX)\\n print('WinX: {}'.format(winX))\\n\\n for row in board:\\n print('Row :{0}'.format(row))\\n if tuple(row) == winX:\\n print('Winner: {}'.format(row))\\n winner = True\\n break\\n\\n for i in range(sideLen):\\n col = []\\n for j in range(sideLen):\\n col.append(board[j][i])\\n print('Col {0}'.format(col))\\n if tuple(col) == winX:\\n print('Winner: {}'.format(col))\\n winner = True\\n break\\n\\n if not winner:\\n leftDiag = []\\n for i in range(sideLen):\\n leftDiag.append(board[i][i])\\n print('left Diag:{}'.format(leftDiag))\\n if tuple(leftDiag) == winX:\\n print('Winner: {}'.format(leftDiag))\\n winner = True\\n else:\\n rightDiag = []\\n for i in range(sideLen):\\n rightDiag.append(board[i][sideLen-1-i])\\n print('right Diag:{}'.format(rightDiag))\\n if tuple(rightDiag) == winX:\\n print('Winner: {}'.format(rightDiag))\\n winner = True\\n \\n return winner\",\n \"def col_win(board, player):\\n for row in board.T:\\n if check_row(row, player):\\n return True\\n return False\",\n \"def gameWon(self):\\n \\n wins = [ threeInARow( self.squares[0], self.squares[1], self.squares[2] ),\\n threeInARow( self.squares[3], self.squares[4], self.squares[5] ),\\n threeInARow( self.squares[6], self.squares[7], self.squares[8] ),\\n threeInARow( self.squares[0], self.squares[3], self.squares[6] ),\\n threeInARow( self.squares[1], self.squares[4], self.squares[7] ),\\n threeInARow( self.squares[2], self.squares[5], self.squares[8] ),\\n threeInARow( self.squares[0], self.squares[4], self.squares[8] ),\\n threeInARow( self.squares[2], self.squares[4], self.squares[6] ) ]\\n \\n return any(wins)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n\\n if (self.currentState.state == self.victoryCondition):\\n self.visited[self.currentState] = True\\n win_or_not = (self.currentState.state == self.victoryCondition)\\n return win_or_not\\n\\n game_depth = self.currentState.depth\\n continue_game = True\\n test_its = 0\\n while continue_game:\\n test_its += 1\\n # too long \\n # time test\\n if test_its == \\\"too long\\\":\\n return \\\"too long\\\"\\n result = self.solveOneStep_helper(game_depth)\\n if result:\\n victory_satisfied = (self.currentState.state == self.victoryCondition)\\n if victory_satisfied:\\n result_bool = True\\n return result_bool\\n else:\\n game_depth = game_depth + 1\\n else:\\n return False\",\n \"def draw(arr):\\n return int((np.count_nonzero(arr) == 9) and (not win(arr)))\",\n \"def evaluate(board):\\n winner = 0\\n for player in [1, 2]:\\n if row_win(board, player) or col_win(board, player) or diag_win(board, player):\\n winner = player\\n \\n if np.all(board != 0) and winner == 0:\\n winner = -1\\n return winner\",\n \"def check(self):\\n for row in self.grid:\\n for i in range(1, 10):\\n if row.count(i) != 1:\\n return False\\n\\n for col in range(9):\\n lst = [row[col] for row in self.grid]\\n for i in range(1, 10):\\n if lst.count(i) != 1:\\n return False\\n \\n for i in range(3):\\n for j in range(3):\\n lst = [row[j* 3:(j*3) + 3] for row in self.grid[i * 3:(i*3) + 3]] \\n flat_list = []\\n for k in lst:\\n for number in k:\\n flat_list.append(number)\\n \\n for check_number in range(1, 10):\\n if flat_list.count(check_number) != 1:\\n return False\\n return True\",\n \"def check_lost (grid):\\r\\n adjacent = False\\r\\n zero_value = False\\r\\n for i in range(4): \\r\\n for j in range(4):\\r\\n if grid[i][j] == 0:\\r\\n zero_value = True\\r\\n break\\r\\n for i in range(3):\\r\\n for j in range(3):\\r\\n if grid[i][j] == grid[i][j+1]:\\r\\n adjacent = True\\r\\n break\\r\\n if grid[i][j] == grid[i+1][j]:\\r\\n adjacent = True\\r\\n break\\r\\n if not adjacent and not zero_value:\\r\\n return True\\r\\n return False\",\n \"def check_win(board_list):\\n\\n for i in range(0, 3):\\n\\n # rows\\n if board_list[i][0] == board_list[i][1] == board_list[i][2]:\\n if board_list[i][0] != 0:\\n return board_list[i][0]\\n\\n # columns\\n elif board_list[0][i] == board_list[1][i] == board_list[2][i]:\\n if board_list[0][i] != 0:\\n return board_list[0][i]\\n\\n # diagonal (top left to bottom right)\\n elif board_list[0][0] == board_list[1][1] == board_list[2][2]:\\n if board_list[0][0] != 0:\\n return board_list[0][0]\\n\\n # diagonal (bottom left to top right)\\n elif board_list[0][2] == board_list[1][1] == board_list[2][0]:\\n if board_list[0][2] != 0:\\n return board_list[0][2]\\n\\n return None\",\n \"def terminal(board):\\n if sum(row.count(EMPTY) for row in board) == 0 or winner(board) == X or winner(board) == O:\\n return True\\n else:\\n return False\",\n \"def check(self):\\n\\n ok = True\\n\\n # check that each pair is ok on its own\\n for winp in self.winps:\\n if not winp.check():\\n ok = False\\n\\n # check that no pairs overlap in the Y direction\\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\\n for winp in self.winps[1:]:\\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\\\\n ystart1 < ystart0 + ny0:\\n winp.ystart.config(bg=COL_WARN)\\n ok = False\\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\\n\\n return ok\",\n \"def is_win_for(self, checker):\\n assert(checker == 'X' or checker == 'O')\\n if self.is_vertical_win(checker) or\\\\\\n self.is_down_diagonal_win(checker) or\\\\\\n self.is_up_diagonal_win(checker) or\\\\\\n self.is_horizontal_win(checker):\\n return True\\n return False\",\n \"def check_win(self, player):\\n for win_pos in TicTacToe.win_pos:\\n # for each winning position defined we take the set difference to the positions played be player\\n # if there are not elements left after resulting set after difference operator\\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\\n # the winner\\n if not win_pos.difference(self.player_played_pos[player]):\\n return True\\n\\n # if after checking for every winning positions if the control still reaches here,\\n # the player has not marked the winning positions. returns False\\n return False\",\n \"def does_move_win(self, x, y):\\n me = self.board[x][y]\\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\\n p = 1\\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\\n p += 1\\n n = 1\\n while self.is_on_board(x-n*dx, y-n*dy) and self.board[x-n*dx][y-n*dy] == me:\\n n += 1\\n\\n if p + n >= (self.connect + 1): # want (p-1) + (n-1) + 1 >= 4, or more simply p + n >- 5\\n return True\\n\\n return False\",\n \"def check_opponent_winning(self):\\n valid_actions = self.get_valid_actions()\\n copy_board = np.copy(self.board)\\n for action in list(valid_actions):\\n height = self.get_height(action, board=copy_board)\\n self.set(action, height=height, value=self.current_player * -1, board=copy_board)\\n\\n if self.check_winner(copy_board, action, height) != 0:\\n return True\\n\\n self.set(action, height=height, value=0, board=copy_board)\\n\\n return False\",\n \"def check_for_winner():\\n global winner\\n # Check rows.\\n row_winner = check_rows()\\n # Check columns.\\n column_winner = check_columns()\\n # Check diagonals.\\n diagonal_winner = check_diagonals()\\n if row_winner:\\n winner = row_winner\\n elif column_winner:\\n winner = column_winner\\n elif diagonal_winner:\\n winner = diagonal_winner\\n else:\\n winner = None\",\n \"def checkWinAll(self, model, previousWin):\\r\\n previous = self.__render\\r\\n self.__render = Render.NOTHING # avoid rendering anything during execution of the check games\\r\\n\\r\\n win = 0\\r\\n lose = 0\\r\\n \\r\\n cellsRanking = {}\\r\\n sumForProb = 0\\r\\n for cell in self.allowableCells:\\r\\n if self.play(model, cell)[0] == Status.WIN:\\r\\n win += 1\\r\\n else:\\r\\n lose += 1\\r\\n\\r\\n self.__render = previous # restore previous rendering setting\\r\\n\\r\\n logging.info(\\\"won: {} | lost: {} | win rate: {:.5f}\\\".format(win, lose, win / (win + lose)))\\r\\n\\r\\n result = True if lose == 0 else False\\r\\n \\r\\n if lose == 0:\\r\\n previousWin += 1\\r\\n else:\\r\\n previousWin = 0 \\r\\n\\r\\n return result, win / (win + lose), previousWin\",\n \"def winning_event(self, player):\\n # vertical check\\n for col in range(GameData.columns):\\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\\n self.draw_vertical_winning_line(col, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # horizontal check\\n for row in range(GameData.rows):\\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\\n self.draw_horizontal_winning_line(row, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # ascending diagonal heck\\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\\n self.draw_asc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # descending diagonal win chek\\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\\n self.draw_desc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n return False\",\n \"def globalcheck(xx, checktimes, thres, n, nn):\\n result = np.zeros((3, n))\\n checkstep = nn // checktimes\\n absxx = np.abs(xx)\\n for i in range(n):\\n for k in range(2):\\n for j in range(checktimes):\\n if absxx[1 + j * checkstep, k * n + i] > thres[k]:\\n result[k, i] = 1\\n break\\n result[2, i] = np.max(result[:, i])\\n\\n return result\",\n \"def is_winner(self):\\n for i in range(3):\\n if (self.board[i][0] == self.board[i][1] == self.board[i][2]) \\\\\\n and (self.board[i][0] != 0):\\n return True, self.board[i][0]\\n\\n if self.board[0][i] == self.board[1][i] == self.board[2][i] \\\\\\n and (self.board[0][i] != 0):\\n return True, self.board[0][i]\\n\\n if self.board[0][0] == self.board[1][1] == self.board[2][2] \\\\\\n and (self.board[0][0] != 0):\\n return True, self.board[0][0]\\n\\n if self.board[2][0] == self.board[1][1] == self.board[0][2] \\\\\\n and (self.board[2][0] != 0):\\n return True, self.board[2][0]\\n\\n if self.available_combinations() == []:\\n return False, 'end'\\n\\n return False, None\",\n \"def check_victory(board):\\n\\n for idx in range(3):\\n if board[idx][0] != ' ' and board[idx][0] == board[idx][1] == board[idx][2]:\\n # This checks if all items in each horizontal row is complete.\\n print('Victory to ' + board[idx][0])\\n return True\\n elif board[0][idx] != ' ' and board[0][idx] == board[1][idx] == board[2][idx]:\\n # This checks if all the items in each vertical column is complete.\\n print('Victory to ' + board[0][idx])\\n return True\\n\\n if board[0][0] != ' ' and board[0][0] == board[1][1] == board[2][2]:\\n # This checks if the left to right diagonal is complete.\\n print('Victory to ' + board[0][0])\\n return True\\n elif board[2][0] != ' ' and board[2][0] == board[1][1] == board[0][2]:\\n # This checks if the right to left diagonal is complete.\\n print('Victory to ' + board[2][0])\\n return True\\n\\n return False\",\n \"def terminal(board):\\n if not winner(board):\\n for i in range(3):\\n for j in range(3):\\n if board[i][j] == EMPTY:\\n return False\\n return True\",\n \"def game_state(matrix):\\n\\n \\\"\\\"\\\"\\n # To set winning tile\\n for i in range(len(matrix)):\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 2048:\\n # return 'win'\\n # return 'not over'\\n \\\"\\\"\\\"\\n for i in range(len(matrix)-1):\\n # intentionally reduced to check the row on the right and below\\n # more elegant to use exceptions but most likely this will be their solution\\n for j in range(len(matrix[0])-1):\\n if matrix[i][j] == matrix[i+1][j] or matrix[i][j+1] == matrix[i][j]:\\n return 'not over'\\n for i in range(len(matrix)): # check for any zero entries\\n for j in range(len(matrix[0])):\\n if matrix[i][j] == 0:\\n return 'not over'\\n for k in range(len(matrix)-1): # to check the left/right entries on the last row\\n if matrix[len(matrix)-1][k] == matrix[len(matrix)-1][k+1]:\\n return 'not over'\\n for j in range(len(matrix)-1): # check up/down entries on last column\\n if matrix[j][len(matrix)-1] == matrix[j+1][len(matrix)-1]:\\n return 'not over'\\n return 'lose'\",\n \"def is_done(la):\\r\\n win = 'notdone'\\r\\n winner = 0\\r\\n if sum(x.count(0) for x in la)==0:win = False\\r\\n for i in range(3):\\r\\n if la[i][0] == la[i][1] == la[i][2] and la[i][0]!=0:\\r\\n win = True\\r\\n winner = la[i][0]\\r\\n if la[0][i] == la[1][i] == la[2][i] and la[0][i]!=0:\\r\\n win = True\\r\\n winner = la[0][i]\\r\\n if la[0][0] == la[1][1] == la[2][2] and la[0][0]!=0:\\r\\n win = True\\r\\n winner = la[0][0] \\r\\n elif la[0][2] == la[1][1] == la[2][0] and la[0][2]!=0:\\r\\n win = True\\r\\n winner = la[i][0]\\r\\n return win,winner\",\n \"def diagnol(self, ox, curRow, curCol):\\n count = 0\\n while count < 4 and curRow < self.height and curCol < self.width and self.board[curRow][curCol] == ox:\\n count += 1\\n curRow += 1\\n curCol += 1\\n return count == 4\",\n \"def states_filter(state):\\n if state.count(0) < state.count(1) or state.count(1) < state.count(0) - 1:\\n return False\\n\\n rows = [[i, i+1, i+2] for i in [0, 3, 6]]\\n cols = [[i, i+3, i+6] for i in [0, 1, 2]]\\n\\n winners = set()\\n\\n for row_indexes in rows:\\n row = [state[ind] for ind in row_indexes]\\n if row[0] >= 0 and are_same(row):\\n winners.add(row[0])\\n\\n for col_indexes in cols:\\n col = [state[ind] for ind in col_indexes]\\n if col[0] >= 0 and are_same(col):\\n winners.add(col[0])\\n\\n # We don't look at diags\\n return len(winners) <= 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69447654","0.68922657","0.6877511","0.6859907","0.6785897","0.6660476","0.66416174","0.66363674","0.6619749","0.6578498","0.65732425","0.65712273","0.653169","0.6508","0.6497785","0.64893246","0.64755654","0.6452486","0.6433075","0.64247596","0.64144456","0.6397901","0.6393368","0.6380367","0.63419425","0.63253975","0.63222104","0.6309371","0.63081","0.6307517","0.63062644","0.6294719","0.6274337","0.6271948","0.6266964","0.62641716","0.6254284","0.62492234","0.62404484","0.6235214","0.62278867","0.6223936","0.62186724","0.62142086","0.6212669","0.6208907","0.61965424","0.6172595","0.617057","0.61645573","0.6146211","0.6135151","0.6129328","0.6121585","0.61213255","0.61062026","0.6091229","0.6089602","0.60893923","0.6080181","0.60705596","0.6065388","0.6064718","0.60581875","0.6049661","0.60467845","0.60444784","0.60402846","0.60329026","0.6029898","0.602621","0.60192657","0.60138845","0.60016733","0.599158","0.59913504","0.5987281","0.59831315","0.59770775","0.5975482","0.5963825","0.59617895","0.59587604","0.59418887","0.59395033","0.593575","0.5935635","0.592924","0.59264684","0.59227973","0.5922","0.5917986","0.59159446","0.5905652","0.5903105","0.59026396","0.5900744","0.5896195","0.58944017","0.5892356"],"string":"[\n \"0.69447654\",\n \"0.68922657\",\n \"0.6877511\",\n \"0.6859907\",\n \"0.6785897\",\n \"0.6660476\",\n \"0.66416174\",\n \"0.66363674\",\n \"0.6619749\",\n \"0.6578498\",\n \"0.65732425\",\n \"0.65712273\",\n \"0.653169\",\n \"0.6508\",\n \"0.6497785\",\n \"0.64893246\",\n \"0.64755654\",\n \"0.6452486\",\n \"0.6433075\",\n \"0.64247596\",\n \"0.64144456\",\n \"0.6397901\",\n \"0.6393368\",\n \"0.6380367\",\n \"0.63419425\",\n \"0.63253975\",\n \"0.63222104\",\n \"0.6309371\",\n \"0.63081\",\n \"0.6307517\",\n \"0.63062644\",\n \"0.6294719\",\n \"0.6274337\",\n \"0.6271948\",\n \"0.6266964\",\n \"0.62641716\",\n \"0.6254284\",\n \"0.62492234\",\n \"0.62404484\",\n \"0.6235214\",\n \"0.62278867\",\n \"0.6223936\",\n \"0.62186724\",\n \"0.62142086\",\n \"0.6212669\",\n \"0.6208907\",\n \"0.61965424\",\n \"0.6172595\",\n \"0.617057\",\n \"0.61645573\",\n \"0.6146211\",\n \"0.6135151\",\n \"0.6129328\",\n \"0.6121585\",\n \"0.61213255\",\n \"0.61062026\",\n \"0.6091229\",\n \"0.6089602\",\n \"0.60893923\",\n \"0.6080181\",\n \"0.60705596\",\n \"0.6065388\",\n \"0.6064718\",\n \"0.60581875\",\n \"0.6049661\",\n \"0.60467845\",\n \"0.60444784\",\n \"0.60402846\",\n \"0.60329026\",\n \"0.6029898\",\n \"0.602621\",\n \"0.60192657\",\n \"0.60138845\",\n \"0.60016733\",\n \"0.599158\",\n \"0.59913504\",\n \"0.5987281\",\n \"0.59831315\",\n \"0.59770775\",\n \"0.5975482\",\n \"0.5963825\",\n \"0.59617895\",\n \"0.59587604\",\n \"0.59418887\",\n \"0.59395033\",\n \"0.593575\",\n \"0.5935635\",\n \"0.592924\",\n \"0.59264684\",\n \"0.59227973\",\n \"0.5922\",\n \"0.5917986\",\n \"0.59159446\",\n \"0.5905652\",\n \"0.5903105\",\n \"0.59026396\",\n \"0.5900744\",\n \"0.5896195\",\n \"0.58944017\",\n \"0.5892356\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73726594"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9290,"cells":{"query":{"kind":"string","value":"Checks if in any dimension the winning line is achieved."},"document":{"kind":"string","value":"def check_if_win(self, tag: str) -> bool:\r\n win_line = [tag]*self.win_condition\r\n return self.check_rows(win_line) or self.check_columns(win_line) or self.check_diagonals(win_line)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def isLineAt(self, x, y, dx, dy):\n\n initialValue = self.board[x][y]\n #checks a cell to see if there is a piece there\n if initialValue != 0:\n #loops though 3 times in a certain direction to see\n #if there is a winning configuration\n for i in range(3):\n xIndex = x + (dx * (i+1))\n yIndex = y + (dy * (i+1))\n if (-1 < xIndex < self.h) and (-1 < yIndex < self.w):\n if initialValue == self.board[xIndex][yIndex]:\n continue\n else:\n return False\n else:\n return False\n return True\n else:\n return False","def __game_is_over(self, x, y):\n\t\tif np.count_nonzero(self.board) >= 42:\n\t\t\treturn True\n\n\t\tlines = self.__extract_lines(x, y)\n\n\t\tfor line in lines:\n\t\t\tif self.__winner_in_line(line) != 0:\n\t\t\t\treturn True\n\n\t\treturn False","def check_win(self):\n for pos in self.win_set:\n s = set([self.grid[p] for p in pos])\n if len(s) == 1 and (0 not in s):\n return True\n return False","def is_winning(self):\n\n current_board = self.current_board\n\n # check rows\n for row in current_board:\n row = set(row)\n if (\"X\" not in row and \"-\" not in row) or (\"O\" not in row and \"-\" not in row):\n return True\n\n # check columns\n for i in range(len(current_board)):\n column_to_check = set()\n \n for j in range(len(current_board)):\n column_to_check.add(current_board[j][i])\n\n if (\"X\" not in column_to_check and \"-\" not in column_to_check) or (\"O\" not in column_to_check and \"-\" not in column_to_check):\n return True\n \n # check diagonals\n forward_diagonal_check = set()\n backward_diagonal_check = set()\n \n for i in range(len(current_board)):\n forward_diagonal_check.add(current_board[i][i])\n backward_diagonal_check.add(current_board[i][len(current_board)-1-i])\n\n if forward_diagonal_check == {\"X\"} or forward_diagonal_check == {\"O\"}:\n return True\n\n if backward_diagonal_check == {\"X\"} or backward_diagonal_check == {\"O\"}:\n return True","def check_win(self):\n for pos in self.win_set:\n # s would be all 1 if all positions of a winning move is fulfilled\n # otherwise 1s and 0s\n s = set([self.grid[p] for p in pos])\n if len(s) == 1 and (0 not in s):\n return True\n return False","def is_win(self, color):\n win = self.n\n # check y-strips\n for y in range(self.n):\n count = 0\n for x in range(self.n):\n if self[x][y] == color:\n count += 1\n if count == win:\n return True\n # check x-strips\n for x in range(self.n):\n count = 0\n for y in range(self.n):\n if self[x][y] == color:\n count += 1\n if count == win:\n return True\n # check two diagonal strips\n count = 0\n for d in range(self.n):\n if self[d][d] == color:\n count += 1\n if count == win:\n return True\n count = 0\n for d in range(self.n):\n if self[d][self.n - d - 1] == color:\n count += 1\n if count == win:\n return True\n\n return False","def _isLine(self):\n return (self.width == 0 and self.height > 1) or (self.height == 0 and self.width > 1)","def _isLine(self):\n return (self.width == 0 and self.height > 1) or (self.height == 0 and self.width > 1)","def is_winning(self, curr_state):\n rows = [[0,1,2], [3,4,5], [6,7,8]]\n columns = [[0,3,6], [1,4,7], [2,5,8]]\n diagonal = [[0,4,8], [2,4,6]]\n total_checks = rows + columns + diagonal\n for row in total_checks:\n sum = 0\n count = 0\n for pos in row:\n if np.isnan(curr_state[pos]):\n break\n else:\n sum = sum + curr_state[pos]\n count = count + 1\n if sum == 15 and count == 3:\n return True\n return False","def check_win(self):\n lines = []\n\n # rows\n lines.extend(self._board)\n\n # cols\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\n for colidx in range(self._dim)]\n lines.extend(cols)\n\n # diags\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\n diag2 = [self._board[idx][self._dim - idx -1]\n for idx in range(self._dim)]\n lines.append(diag1)\n lines.append(diag2)\n\n # check all lines\n for line in lines:\n if len(set(line)) == 1 and line[0] != EMPTY:\n if self._reverse:\n return switch_player(line[0])\n else:\n return line[0]\n\n # no winner, check for draw\n if len(self.get_empty_squares()) == 0:\n return DRAW\n\n # game is still in progress\n return None","def check_for_win(self, row, col, player): \n\n count = 0\n for i in range(0, len(self.board[0])):\n # Check vertical\n if self.board[row][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n\n count = 0\n for i in range(0, len(self.board)):\n # Check horisontal\n if self.board[:, col][i] == player:\n count += 1\n else:\n count = 0\n \n if count == self.max_count:\n return True\n \n count = 0\n totoffset = col - row\n for i in np.diagonal(self.board, offset=totoffset):\n # Check diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True\n\n count = 0\n mirrorboard = np.fliplr(self.board)\n col = self.colswitch[col]\n totoffset = col - row\n for i in np.diagonal(mirrorboard, offset=totoffset):\n # Check other diagonal\n if i == player:\n count += 1\n else:\n count = 0\n\n if count == self.max_count:\n return True","def game_won(self):\n\n # Makes sure every tile is colored,\n for column in self.board:\n for tile in column:\n if not tile.color:\n return False\n\n # Makes sure each color has a line.\n colors = set()\n for dot in self.dots:\n dot_tile = self.board[dot.x][dot.y]\n colors.add(dot.color)\n for dot in self.dots:\n dot_tile = self.board[dot.x][dot.y]\n # If we've already found a line for this color.\n if dot.color not in colors:\n continue\n # If this dot starts a line and ends at the other dot.\n if dot_tile.next and not dot_tile.line_end().is_dot:\n return False\n elif dot_tile.next:\n colors.remove(dot.color)\n # If colors isn't empty, not all colors have lines.\n return not colors","def is_win_for(self, checker):\n assert(checker == 'X' or checker == 'O')\n if self.is_vertical_win(checker) or\\\n self.is_down_diagonal_win(checker) or\\\n self.is_up_diagonal_win(checker) or\\\n self.is_horizontal_win(checker):\n return True\n return False","def check_win(self):\n return UNEXPOSED not in self.get_game() and self.get_game().count(FLAG) == len(self.get_pokemon_location)","def isAnyLineAt(self, x, y):\n return (self.isLineAt(x, y, 1, 0) or # Horizontal\n self.isLineAt(x, y, 0, 1) or # Vertical\n self.isLineAt(x, y, 1, 1) or # Diagonal up\n self.isLineAt(x, y, 1, -1)) # Diagonal down","def is_win(my_board):\n return np.count_nonzero(my_board == CLOSED) == NUM_MINES","def check_win_condition(board) -> bool:\n if _check_vertical_win_condition(board) or _check_horizontal_win_condition(board) or _check_diagonal_win_condition(\n board):\n return True\n else:\n board.alternate_current_player()\n return False","def __check_row(self, x: int, y: int) -> bool:\n return not any([self.__maze[x, y + i] for i in (-1, 0, 1)])","def is_win_for(self, checker):\r\n assert(checker == 'X' or checker == 'O')\r\n\r\n return self.is_horizontal_win(checker) or \\\r\n self.is_vertical_win(checker) or \\\r\n self.is_down_diagonal_win(checker) or \\\r\n self.is_up_diagonal_win(checker)","def check_win(self, color):\n if dijkstra(self, color) == 0:\n return True\n else:\n return False","def check(self):\n\n ok = True\n\n # check that each pair is ok on its own\n for winp in self.winps:\n if not winp.check():\n ok = False\n\n # check that no pairs overlap in the Y direction\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\n for winp in self.winps[1:]:\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\n ystart1 < ystart0 + ny0:\n winp.ystart.config(bg=COL_WARN)\n ok = False\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\n\n return ok","def isGoal(self):\n for index in range(self.DIM):\n if not self.values('r',index).count(0) is 0:\n return False\n if not self.isValid():\n return False\n return True","def check_win(self, player):\n def check_row_win(player):\n for row in self.game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_column_win(player):\n # For doing a column check, transpose the grid and do a row check\n trans_game_state = numpy.transpose(self.game_state)\n for row in trans_game_state:\n if player == row[0] == row[1] == row[2]:\n return True\n return False\n\n def check_diag_win(player):\n # Left to right diagonal\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\n return True\n # Right to left diagonal\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\n return True\n return False\n\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\n return True\n return False","def checkWin(self):\n winstates = [(0, 1, 2),\n (3, 4, 5),\n (6, 7, 8),\n (0, 3, 6),\n (1, 4, 7),\n (2, 5, 8),\n (0, 4, 8),\n (2, 4, 6)]\n win = False\n for state in winstates:\n if (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == 3:\n self.handleWin(1)\n win = True\n elif (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == -3:\n self.handleWin(-1)\n win = True\n\n if len([i for i in range(9) if self.gameState[i] == 0]) == 0 and not win:\n print(\"Draw yo\")\n self.handleDraw()\n return None","def game_tie(self):\n\n shape = self.board.shape\n if np.count_nonzero(self.board) == (shape[0] * shape[1]):\n # The board is full\n player = 0\n return True\n else:\n return False","def does_move_win(self, x, y):\n me = self.board[x][y]\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\n p = 1\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\n p += 1\n n = 1\n while self.is_on_board(x-n*dx, y-n*dy) and self.board[x-n*dx][y-n*dy] == me:\n n += 1\n\n if p + n >= (self.connect + 1): # want (p-1) + (n-1) + 1 >= 4, or more simply p + n >- 5\n return True\n\n return False","def winsFor(self, ox):\n for row in range(self.height):\n for col in range(self.width):\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\n return True\n return False","def check_diagonals(self, win: list) -> bool:\r\n for i in range(self.size - self.win_condition + 1):\r\n # [x x ]\r\n # [ x x ]\r\n # [ x x]\r\n # [ x]\r\n diagonal = []\r\n x = i\r\n y = 0\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x += 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n # [x ]\r\n # [x x ]\r\n # [ x x ]\r\n # [ x x]\r\n diagonal = []\r\n x = 0\r\n y = i\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x += 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n\r\n # [ x x]\r\n # [ x x ]\r\n # [x x ]\r\n # [x ]\r\n diagonal = []\r\n x = self.size - 1 - i\r\n y = 0\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x -= 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True\r\n # [ x]\r\n # [ x x]\r\n # [ x x ]\r\n # [x x ]\r\n diagonal = []\r\n x = self.size - 1\r\n y = 0 + i\r\n for j in range(self.size - i):\r\n diagonal.append(self.tags[x][y])\r\n x -= 1\r\n y += 1\r\n for j in range(len(diagonal) - len(win) + 1):\r\n if win == diagonal[j:j + self.win_condition]:\r\n return True","def diagonal_win():\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True","def on_board(hexe):\n\n cube = axial_to_cube(hexe)\n\n # check each bound\n for axis in cube:\n if abs(axis) > BOARD_BOUND:\n return False\n return True","def visible(self):\n return -PipePair.WIDTH < self.x < WIN_WIDTH","def winning_event(self, player):\n # vertical check\n for col in range(GameData.columns):\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\n self.draw_vertical_winning_line(col, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # horizontal check\n for row in range(GameData.rows):\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\n self.draw_horizontal_winning_line(row, player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # ascending diagonal heck\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\n self.draw_asc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n # descending diagonal win chek\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\n self.draw_desc_diagonal(player)\n print(\"Player {} has won the game!\".format(player))\n self.game_over = True\n return True\n\n return False","def _check(self, x, y):\n n = self.n\n # x direction\n xline = self.arr[y]\n if not self.x_regexes[y].match(xline):\n return False\n\n # y direction\n ypos = x + max(0, y + 1 - n)\n yline = []\n x1, y1 = ypos, 0\n while x1 >= 0 and y1 < 2 * n - 1:\n if x1 < len(self.arr[y1]):\n yline.append(self.arr[y1][x1])\n if y1 >= n - 1:\n x1 -= 1\n y1 += 1\n\n if not self.y_regexes[ypos].match(yline):\n return False\n\n # z direction\n zpos = x + max(0, n - 1 - y)\n zline = []\n x1, y1 = zpos, 2 * n - 2\n while x1 >= 0 and y1 >= 0:\n if x1 < len(self.arr[y1]):\n zline.append(self.arr[y1][x1])\n if y1 <= n - 1:\n x1 -= 1\n y1 -= 1\n\n if not self.z_regexes[zpos].match(zline):\n return False\n\n return True","def check_won (grid):\r\n w=False\r\n for row in range(4):\r\n for col in range(4):\r\n if grid[row][col]>=32:\r\n w=True\r\n break\r\n return w","def __check_win_condition(self,token,coordinate):\n # Check if it's even possible to win yet\n if self._turn_counter >= 8 and self._turn_counter+1 < self._board_size**2:\n # Disable win\n # return False\n\n # Up and up right vectors\n vec1=(1,0)\n vec2=(1,1)\n\n # Loop both directions of vector\n for _ in range(2):\n if self.__check_direction(vec1,coordinate):\n self.__declare_winner()\n return True\n if self.__check_direction(vec2,coordinate):\n self.__declare_winner()\n return True\n\n # Turn vector directions\n vec1 = -vec1[1], vec1[0]\n vec2 = -vec2[1], vec2[0]\n\n # Check for draw\n elif self._turn_counter+1 >= self._board_size**2:\n if (self._gui):\n self.__turn_counter_label[\"text\"] = \"Draw!\"\n self.__status[\"text\"] = \"\"\n self.__status.update()\n self.__turn_counter_label.update()\n self._winner = 3\n if (self._state == PLAY): showerror(\"Draw\",\"Draw!\")\n return True","def check_winner(self):\n\t\tif self.check_diagonals() or self.check_rows() or self.check_columns():\n\t\t\treturn True\n\t\telif self.board_is_full():\n\t\t\tprint(\"There was a draw, everyone lost\")\n\t\t\treturn None\n\t\treturn False","def inCamp(self):\n return (((self.myTeam==1) and (self.ballPos.x <= self.width/2))\n | ((self.myTeam==2) and (self.ballPos.x >= self.width/2)))","def is_in_the_grid(self, row: int, col: int) -> bool:\n return 0 <= row < self.n_row and 0 <= col < self.n_col","def check_won (grid):\r\n for i in range (4):\r\n for j in range (4):\r\n if grid[i][j] >= 32:\r\n return True\r\n return False","def check(self,a,x,y):\r\n return not self.exitsinrow(self.rows,x,a) and not self.existsincol(self.rows,y,a) and \\\r\n not self.exitsinblock(self.rows, x - x % 3, y - y % 3,a)","def game_on(self):\n doc = self.documentation\n return (self.draw.accepted or doc[len(doc)-1].accepted) and (self.board.stones_set < self.board.max_nr_stones) and (self.board.score[opponent(self.draw.player)] > 0)","def is_game_over(self):\n if max([max(row) for row in self.grid]) == 2 ** (self.grid_size ** 2):\n raise GameException('Congrats, You won !')\n\n # If there is a zero then the game is not over\n for row in self.grid:\n if 0 in row:\n return False\n\n # Check if two consecutive number (vertically or horizontally) are\n # equal. In this case the game is not over.\n for i in range(self.grid_size):\n for j in range(self.grid_size):\n # horizontal check\n if (i < self.grid_size - 1 and\n self.grid[i][j] == self.grid[i + 1][j]):\n return False\n # vertical check\n if (j < self.grid_size - 1 and\n self.grid[i][j] == self.grid[i][j + 1]):\n return False\n\n return True","def check_pos(self, x, y):\n if x >= WINDOWWIDTH or y >= WINDOWHEIGHT or x <=0 or y <= 0:\n return True","def check_rows(self):\n\t\tfor i in range(len(self.board)):\n\t\t\tpts = 0\n\t\t\tfor j in range(len(self.board[i])):\n\t\t\t\tif self.board[i][j] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('YOU WON')\n\t\t\t\treturn True","def check_won (grid):\r\n for i in range(4): \r\n for j in range(4):\r\n if grid[i][j] >= 32:\r\n return True\r\n return False","def check_grid_full(self):\n for row in self.game_state:\n for e in row:\n if e is None:\n return False\n return True","def onlyrow(self):\n return self.y <= 1","def checkwin(self):\n w = self.getWidth()\n h = self.getHeight()\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\n for r in range(h):\n for c in range(w):\n if self.cell[c][r] == EMPTY:\n continue # this cell can't be part of winning segment\n # if we reach this point, the cell is occupied by a player stone\n numOccupiedCell = numOccupiedCell+1\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\n for i in range(NWIN):\n # test if there exists a segment of NWIN uniformly coloured cells\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\n break # segment broken\n else:\n # Python remark: notice that the else is attached to the for loop \"for i...\"\n # This block is executed if and only if 'i' arrives at the end of its range \n return self.cell[c][r] , True # found a winning segment \n return EMPTY, numOccupiedCell==w*h","def victory_checker() -> bool:\r\n conflict_check()\r\n for x in range(shape):\r\n for y in range(shape):\r\n if conflict_space[x, y] != 0:\r\n return False\r\n if separation_crawler(False):\r\n return False\r\n return True","def test(self, grid, flag):\n x = self.x+SPEED_X[flag]\n y = self.y+SPEED_Y[flag]\n return 0 <= x < self.n and 0 <= y < self.n and grid[y][x] == 1","def is_game_won(self):\n if self.game_is_tied():\n return False\n my_available_steps = self.steps_available(self.loc)\n opp_available_steps = self.steps_available(self.opponent_loc)\n if my_available_steps == 0 or opp_available_steps == 0:\n return True\n else:\n return False","def isWin(self):\n\n return self.tiles == self.winCdt","def is_on_board(x: int, y: int) -> bool:\n return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT","def check_diagonals(self):\n\t\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\n\n\t\tfor diag in diags:\n\t\t\tpts = 0\n\t\t\tfor loc in diag:\n\t\t\t\tif self.board[loc[0]][loc[1]] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('WE WON')\n\t\t\t\treturn True","def check_for_win(self,board, player_id, action):\n\n row = 0\n\n # check which row was inserted last:\n for i in range(ROWS):\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\n row = ROWS - i\n break\n\n # check horizontal:\n vec = board[row, :] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check vertical:\n vec = board[:, action] == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n # check diagonals:\n vec = np.diagonal(board, action - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\n if np.any(np.convolve(WIN_MASK, vec, mode=\"valid\") == 4):\n return True\n\n return False","def check_won(grid):\r\n for i in range(len(grid)):\r\n for j in range(len(grid[i])):\r\n if grid[i][j] >= 32:\r\n return True \r\n return False","def check_draw(winner, board):\n if not winner and all(\"_\" not in row for row in board):\n print(\"Game Over, game is a tie\")\n return True","def satifiesWinConditions(self, coordinates):\n if self.treasureCaptured and (self.x, self.y) in coordinates:\n return True\n else:\n return False","def check_win(self):\r\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\r\n for case, pos in wins:\r\n if case != -1:\r\n print('Game over!')\r\n if self.grid[case][-1] == self.computer:\r\n print('The computer won!')\r\n return (True, pos)\r\n print('The player won!')\r\n return (True, pos)\r\n\r\n return (self.check_draw(), None)","def _inside(self, x, y):\n wx, wy, w, h = self._raw_graph_window_dim()\n if wx <= x < wx + w and wy <= y < wy + h:\n return True\n return False","def win_for(self, side):\n # Testing rows\n for row in range(self.height):\n for col in range(self.width - 3):\n if ( self.data[row][col] == side\n and self.data[row][col+1] == side\n and self.data[row][col+2] == side\n and self.data[row][col+3] == side):\n return True\n\n # Testing columns\n for col in range(self.width):\n for row in range(self.height - 3):\n if ( self.data[row][col] == side\n and self.data[row+1][col] == side\n and self.data[row+2][col] == side\n and self.data[row+3][col] == side):\n return True\n\n # Testing left diagonal\n for row in range(self.height - 3):\n for col in range(self.width - 3):\n if ( self.data[row][col] == side\n and self.data[row+1][col+1] == side\n and self.data[row+2][col+2] == side\n and self.data[row+3][col+3] == side):\n return True\n\n # Testing right diagonal\n for row in range(self.height - 3):\n for col in range(3, self.width):\n if ( self.data[row][col] == side\n and self.data[row+1][col-1] == side\n and self.data[row+2][col-2] == side\n and self.data[row+3][col-3] == side):\n return True\n\n return False","def check_win(self, player):\n for win_pos in TicTacToe.win_pos:\n # for each winning position defined we take the set difference to the positions played be player\n # if there are not elements left after resulting set after difference operator\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\n # the winner\n if not win_pos.difference(self.player_played_pos[player]):\n return True\n\n # if after checking for every winning positions if the control still reaches here,\n # the player has not marked the winning positions. returns False\n return False","def is_over(self, state: StonehengeState) -> bool:\n total_result = state.hori_result + state.left_result + state.right_result\n total_line = len(total_result)\n p1_taken = 0\n p2_taken = 0\n # all_taken = True\n for item in total_result:\n if item == '1':\n p1_taken+=1\n elif item =='2':\n p2_taken += 1\n # else:\n # all_taken = False\n # print('p1 taken:' + str(p1_taken))\n # print('p2 taken:' + str(p2_taken))\n # print('p1_taken more than half?')\n # print(float(p1_taken) >= total_line/2)\n # print('p2_taken more than half?')\n # print(float(p2_taken) >= total_line/2)\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2","def is_complete_line(board: list, y: int) -> bool:\n for x in range(BOARDWIDTH):\n # if there is a blank box then the line is not complete\n if board[y][x] == BLANK:\n return False\n\n return True","def __check_col(self, x: int, y: int) -> bool:\n return not any([self.__maze[x + i, y] for i in (-1, 0, 1)])","def check_won (grid):\r\n p=0\r\n for k in range(len(grid)):\r\n for g in range(len(grid[k])): \r\n if grid[k][g]>=32:\r\n p+=1\r\n else:\r\n ()\r\n if p>0:\r\n return True\r\n else:\r\n return False","def game_over(self) -> bool:\n for row in range(9):\n for col in range(9):\n if self._grid_sol[row][col] != self.get_cell(row, col):\n return False\n return True","def is_over(self, state) -> bool:\n\n p1_count = 0\n p2_count = 0\n ley_line_total = (state.side_length + 1) * 3\n for itype in state.current_ley_lines:\n for line in itype:\n if line[0] == '1':\n p1_count += 1\n if line[0] == '2':\n p2_count += 1\n\n if p1_count >= ley_line_total/2 or p2_count >= ley_line_total/2:\n return True\n return False","def valid_ray(self, row, col):\n # if row nor col is at an edge space, returns False\n if row != 0 and row != 9 and col != 0 and col != 9:\n return False\n # ensures no corner spaces have been selected\n if row == 0 or row == 9:\n if col > 8 or col < 1:\n return False\n if col == 0 or col == 9:\n if row > 8 or row < 1:\n return False\n return True","def draw(self):\n\n for row in self._board:\n for slot in row:\n if slot == 0:\n return False\n print \"It's a draw!\"\n return True","def isGameOver(self):\n for row in range(0, self.rows):\n for col in range(0, self.cols):\n if self.isMine(row, col) and self.isClicked(row, col):\n return True\n return False","def check_win(self):\n win = None\n for pos in self.winning_pos:\n win = self.is_match(set(self.get_cells(pos)))\n if win:\n return win\n if not self.open_tiles():\n return \"Draw\"\n return win","def board_tiles_availability(self):\n for row in range(GameData.rows):\n for col in range(GameData.columns):\n if self.board[row][col] == 0:\n return False\n # Game is draw, no more moves left!\n return True","def check_2x2_solved(self):\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)","def _check_for_win(self, piece, piece_x, piece_y):\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions = []\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\n for i in range(self.consecutive_pieces_to_win)):\n winning_piece_positions.append((x, y))\n # Don't need to check the piece that is being placed\n if (x, y) == (piece_x, piece_y):\n continue\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece != piece:\n winning_piece_positions = None\n break\n if winning_piece_positions:\n # Check if there are additional winning pieces that exceed the number required to win.\n # e.g. a 5-in-a-row when only 4 are required\n if slope_x != 0:\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\n for i in range(1, 1 + num_previous_pieces_to_check)):\n current_piece = self._get_piece_at_opening_or_none(x, y)\n if current_piece == piece:\n winning_piece_positions.insert(0, (x, y))\n else:\n break\n return winning_piece_positions\n\n return False","def diag_win(board):\n\tif board[1][1] != EMPTY and (board[1][1] == board[0][2] == board[2][0] or board[1][1] == board[0][0] == board[2][2]):\n\t\treturn True\n\treturn False","def is_over(self):\n for el1, el2, el3 in self.WINNING_POSITIONS:\n if self.board[el1] == self.board[el2] == self.board[el3]:\n if self.board[el1] == 0:\n continue\n\n self.winner = self.board[el1]\n return True\n\n if self.__class__.EMPTY_POSITION_COUNTER not in self.board:\n return True\n\n return False","def _check_window(x: int, y: int, z: int) -> bool:\n return (x + y) == z","def row_win(board):\n\tfor row in range(3):\n\t\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\n\t\t\treturn True\n\treturn False","def is_winning_state(self):\n return self.game.is_winning_state()","def IsGameOver(self):\n return any(c.cX + c.width >= self.end_location for c in self.enemies)","def finished(self) -> bool:\n p1_count = 0\n p2_count = 0\n ley_line_total = (self.side_length + 1) * 3\n for itype in self.current_ley_lines:\n for line in itype:\n if line[0] == '1':\n p1_count += 1\n if line[0] == '2':\n p2_count += 1\n return p1_count >= ley_line_total / 2 or p2_count >= ley_line_total / 2","def is_border(self, threshold):\n\n def dist_to_line(p1, p2, p3):\n return np.linalg.norm(np.cross(p2 - p1, p1 - p3)) / np.linalg.norm(p2 - p1)\n\n total_dist = 0\n for p in self.shape:\n total_dist += dist_to_line(self.shape[0], self.shape[-1], p)\n return total_dist < threshold","def validate_in(self, xcoord, ycoord):\r\n x = int(xcoord/(self.tr.bd.TILE_WIDTH + self.tr.bd.LINE_WIDTH))\r\n y = int(ycoord/(self.tr.bd.TILE_WIDTH + self.tr.bd.LINE_WIDTH))\r\n if not self.tr.turn_tracker and self.tr.bd.disks[x][y].halo_tag:\r\n return True, x, y\r\n else:\r\n return False, x, y","def __win(self, a):\n for i in range(len(a)-self.k+1):\n flag = True\n for j in range(self.k):\n if not a[i+j]:\n flag = False\n break\n if flag: return True","def did_hal_win_yet(self, current_board):\r\n if self.check_for_win(current_board, 'O'):\r\n print(\"It can only be attributable to human error, Dave.\\033[5;31m You LOSE.\\033[0m\")\r\n return True\r\n elif self.check_for_draw(current_board):\r\n print(\"Thank you for a very enjoyable game, Dave.\\033[5;31m It's a DRAW\\033[0m\")\r\n return True\r\n\r\n return False","def is_horizontal_win(self, checker):\n for row in range(self.height):\n for col in range(self.width - 3):\n # Check if the next four columns in this row\n # contain the specified checker.\n if self.slots[row][col] == checker and \\\n self.slots[row][col + 1] == checker and \\\n self.slots[row][col + 2] == checker and \\\n self.slots[row][col + 3] == checker:\n return True\n \n # if we make it here, there were no horizontal wins\n return False","def wall_check(x: int, y: int, state: bool) -> bool:\r\n if state:\r\n if x == 0 or x == shape-1 or y == 0 or y == shape-1:\r\n return True\r\n else:\r\n if x < 0 or x >= shape or y < 0 or y >= shape:\r\n return True\r\n return False","def horizontal_win():\n\n for i in range(0, board_size):\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\n print \"horizontal win\"\n return True","def is_valid_room(self, x, y):\r\n return 0 <= x < self.__nx and 0 <= y < self.__ny","def isOnCanvas(self, x, y):\n return 0 <= x < self.width and 0 <= y < self.height","def __is_board_full(self):\r\n for row in self.__board:\r\n if {self.PLAYER1, self.PLAYER2} & set(row) != 0:\r\n return False\r\n return True","def win_game(self):\n\n def horizontal_win():\n \"\"\"Return whether there is horizontal win\"\"\"\n\n for i in range(0, board_size):\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\n print \"horizontal win\"\n return True\n\n def vertical_win():\n \"\"\"Return whether there is vertical win\"\"\"\n\n vert_set = set()\n for i in range(0, board_size):\n for j in range(0, board_size):\n vert_set.add(self.board[j][i])\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\n print \"vertical win\"\n return True \n vert_set = set()\n\n def diagonal_win():\n \"\"\"Return whether there is diagonal win\"\"\"\n\n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][i]) \n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 1\"\n return True\n \n diagonal_set = set()\n for i in range(0, board_size):\n diagonal_set.add(self.board[i][board_size - 1 - i])\n\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\n print \"diagonal win 2\"\n return True\n\n if horizontal_win() or vertical_win() or diagonal_win():\n print \"You have won.\"\n return True","def draw(arr):\n return int((np.count_nonzero(arr) == 9) and (not win(arr)))","def check_empty(self, coord):\n x, y, z = coord\n if self.perlin_3d(x, y, z) <= 0:\n return True\n else:\n return False","def check_win(self):\n\n # Sets rings initially to False\n black_ring = False\n white_ring = False\n\n # Gets board\n board = self._game_board.get_board_area()\n\n # Iterate through stone-holding points\n for i in range(1, 19):\n for j in range(1, 19):\n # Get the surroundings of each point\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\n\n # If the point is empty and surrounded by \"B\", there's a black ring\n if board[i][j] == \" \" and surround == {\"B\"}:\n black_ring = True\n\n # If the point is empty and surrounded by \"W\", there's a white ring\n if board[i][j] == \" \" and surround == {\"W\"}:\n white_ring = True\n\n if not black_ring:\n return \"WHITE_WON\"\n\n if not white_ring:\n return \"BLACK_WON\"\n\n return \"UNFINISHED\"","def check_edges(self):\n if self.rect.right >= self.screen_rect.right or self.rect.left <= 0:\n return True","def goal_test(self, state):\n for x, y in state.alvos:\n if state.tabuleiro[x][y] is not BOX_ON_TARGET:\n return False\n return True","def coordinates_within_board(n: int, x: int, y: int) -> bool:\n\n return x < n and y < n and x >= 0 and y >= 0","def gameOver(self):\n i = 0 # accumulator for the number of None objects\n for x in range(ALIEN_ROWS):\n for y in range(ALIENS_IN_ROW):\n if self._aliens[x][y] ==None:\n i +=1\n if i == ALIEN_ROWS * ALIENS_IN_ROW:\n self._gameOver = True\n\n for x in range(ALIEN_ROWS):\n for y in range(ALIENS_IN_ROW):\n if self._aliens[x][y] !=None:\n positiony = self._aliens[x][y].getAY() - ALIEN_HEIGHT/2\n if posy<= self._dline:\n self._gameOver = False"],"string":"[\n \"def isLineAt(self, x, y, dx, dy):\\n\\n initialValue = self.board[x][y]\\n #checks a cell to see if there is a piece there\\n if initialValue != 0:\\n #loops though 3 times in a certain direction to see\\n #if there is a winning configuration\\n for i in range(3):\\n xIndex = x + (dx * (i+1))\\n yIndex = y + (dy * (i+1))\\n if (-1 < xIndex < self.h) and (-1 < yIndex < self.w):\\n if initialValue == self.board[xIndex][yIndex]:\\n continue\\n else:\\n return False\\n else:\\n return False\\n return True\\n else:\\n return False\",\n \"def __game_is_over(self, x, y):\\n\\t\\tif np.count_nonzero(self.board) >= 42:\\n\\t\\t\\treturn True\\n\\n\\t\\tlines = self.__extract_lines(x, y)\\n\\n\\t\\tfor line in lines:\\n\\t\\t\\tif self.__winner_in_line(line) != 0:\\n\\t\\t\\t\\treturn True\\n\\n\\t\\treturn False\",\n \"def check_win(self):\\n for pos in self.win_set:\\n s = set([self.grid[p] for p in pos])\\n if len(s) == 1 and (0 not in s):\\n return True\\n return False\",\n \"def is_winning(self):\\n\\n current_board = self.current_board\\n\\n # check rows\\n for row in current_board:\\n row = set(row)\\n if (\\\"X\\\" not in row and \\\"-\\\" not in row) or (\\\"O\\\" not in row and \\\"-\\\" not in row):\\n return True\\n\\n # check columns\\n for i in range(len(current_board)):\\n column_to_check = set()\\n \\n for j in range(len(current_board)):\\n column_to_check.add(current_board[j][i])\\n\\n if (\\\"X\\\" not in column_to_check and \\\"-\\\" not in column_to_check) or (\\\"O\\\" not in column_to_check and \\\"-\\\" not in column_to_check):\\n return True\\n \\n # check diagonals\\n forward_diagonal_check = set()\\n backward_diagonal_check = set()\\n \\n for i in range(len(current_board)):\\n forward_diagonal_check.add(current_board[i][i])\\n backward_diagonal_check.add(current_board[i][len(current_board)-1-i])\\n\\n if forward_diagonal_check == {\\\"X\\\"} or forward_diagonal_check == {\\\"O\\\"}:\\n return True\\n\\n if backward_diagonal_check == {\\\"X\\\"} or backward_diagonal_check == {\\\"O\\\"}:\\n return True\",\n \"def check_win(self):\\n for pos in self.win_set:\\n # s would be all 1 if all positions of a winning move is fulfilled\\n # otherwise 1s and 0s\\n s = set([self.grid[p] for p in pos])\\n if len(s) == 1 and (0 not in s):\\n return True\\n return False\",\n \"def is_win(self, color):\\n win = self.n\\n # check y-strips\\n for y in range(self.n):\\n count = 0\\n for x in range(self.n):\\n if self[x][y] == color:\\n count += 1\\n if count == win:\\n return True\\n # check x-strips\\n for x in range(self.n):\\n count = 0\\n for y in range(self.n):\\n if self[x][y] == color:\\n count += 1\\n if count == win:\\n return True\\n # check two diagonal strips\\n count = 0\\n for d in range(self.n):\\n if self[d][d] == color:\\n count += 1\\n if count == win:\\n return True\\n count = 0\\n for d in range(self.n):\\n if self[d][self.n - d - 1] == color:\\n count += 1\\n if count == win:\\n return True\\n\\n return False\",\n \"def _isLine(self):\\n return (self.width == 0 and self.height > 1) or (self.height == 0 and self.width > 1)\",\n \"def _isLine(self):\\n return (self.width == 0 and self.height > 1) or (self.height == 0 and self.width > 1)\",\n \"def is_winning(self, curr_state):\\n rows = [[0,1,2], [3,4,5], [6,7,8]]\\n columns = [[0,3,6], [1,4,7], [2,5,8]]\\n diagonal = [[0,4,8], [2,4,6]]\\n total_checks = rows + columns + diagonal\\n for row in total_checks:\\n sum = 0\\n count = 0\\n for pos in row:\\n if np.isnan(curr_state[pos]):\\n break\\n else:\\n sum = sum + curr_state[pos]\\n count = count + 1\\n if sum == 15 and count == 3:\\n return True\\n return False\",\n \"def check_win(self):\\n lines = []\\n\\n # rows\\n lines.extend(self._board)\\n\\n # cols\\n cols = [[self._board[rowidx][colidx] for rowidx in range(self._dim)]\\n for colidx in range(self._dim)]\\n lines.extend(cols)\\n\\n # diags\\n diag1 = [self._board[idx][idx] for idx in range(self._dim)]\\n diag2 = [self._board[idx][self._dim - idx -1]\\n for idx in range(self._dim)]\\n lines.append(diag1)\\n lines.append(diag2)\\n\\n # check all lines\\n for line in lines:\\n if len(set(line)) == 1 and line[0] != EMPTY:\\n if self._reverse:\\n return switch_player(line[0])\\n else:\\n return line[0]\\n\\n # no winner, check for draw\\n if len(self.get_empty_squares()) == 0:\\n return DRAW\\n\\n # game is still in progress\\n return None\",\n \"def check_for_win(self, row, col, player): \\n\\n count = 0\\n for i in range(0, len(self.board[0])):\\n # Check vertical\\n if self.board[row][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n\\n count = 0\\n for i in range(0, len(self.board)):\\n # Check horisontal\\n if self.board[:, col][i] == player:\\n count += 1\\n else:\\n count = 0\\n \\n if count == self.max_count:\\n return True\\n \\n count = 0\\n totoffset = col - row\\n for i in np.diagonal(self.board, offset=totoffset):\\n # Check diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\\n\\n count = 0\\n mirrorboard = np.fliplr(self.board)\\n col = self.colswitch[col]\\n totoffset = col - row\\n for i in np.diagonal(mirrorboard, offset=totoffset):\\n # Check other diagonal\\n if i == player:\\n count += 1\\n else:\\n count = 0\\n\\n if count == self.max_count:\\n return True\",\n \"def game_won(self):\\n\\n # Makes sure every tile is colored,\\n for column in self.board:\\n for tile in column:\\n if not tile.color:\\n return False\\n\\n # Makes sure each color has a line.\\n colors = set()\\n for dot in self.dots:\\n dot_tile = self.board[dot.x][dot.y]\\n colors.add(dot.color)\\n for dot in self.dots:\\n dot_tile = self.board[dot.x][dot.y]\\n # If we've already found a line for this color.\\n if dot.color not in colors:\\n continue\\n # If this dot starts a line and ends at the other dot.\\n if dot_tile.next and not dot_tile.line_end().is_dot:\\n return False\\n elif dot_tile.next:\\n colors.remove(dot.color)\\n # If colors isn't empty, not all colors have lines.\\n return not colors\",\n \"def is_win_for(self, checker):\\n assert(checker == 'X' or checker == 'O')\\n if self.is_vertical_win(checker) or\\\\\\n self.is_down_diagonal_win(checker) or\\\\\\n self.is_up_diagonal_win(checker) or\\\\\\n self.is_horizontal_win(checker):\\n return True\\n return False\",\n \"def check_win(self):\\n return UNEXPOSED not in self.get_game() and self.get_game().count(FLAG) == len(self.get_pokemon_location)\",\n \"def isAnyLineAt(self, x, y):\\n return (self.isLineAt(x, y, 1, 0) or # Horizontal\\n self.isLineAt(x, y, 0, 1) or # Vertical\\n self.isLineAt(x, y, 1, 1) or # Diagonal up\\n self.isLineAt(x, y, 1, -1)) # Diagonal down\",\n \"def is_win(my_board):\\n return np.count_nonzero(my_board == CLOSED) == NUM_MINES\",\n \"def check_win_condition(board) -> bool:\\n if _check_vertical_win_condition(board) or _check_horizontal_win_condition(board) or _check_diagonal_win_condition(\\n board):\\n return True\\n else:\\n board.alternate_current_player()\\n return False\",\n \"def __check_row(self, x: int, y: int) -> bool:\\n return not any([self.__maze[x, y + i] for i in (-1, 0, 1)])\",\n \"def is_win_for(self, checker):\\r\\n assert(checker == 'X' or checker == 'O')\\r\\n\\r\\n return self.is_horizontal_win(checker) or \\\\\\r\\n self.is_vertical_win(checker) or \\\\\\r\\n self.is_down_diagonal_win(checker) or \\\\\\r\\n self.is_up_diagonal_win(checker)\",\n \"def check_win(self, color):\\n if dijkstra(self, color) == 0:\\n return True\\n else:\\n return False\",\n \"def check(self):\\n\\n ok = True\\n\\n # check that each pair is ok on its own\\n for winp in self.winps:\\n if not winp.check():\\n ok = False\\n\\n # check that no pairs overlap in the Y direction\\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\\n for winp in self.winps[1:]:\\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\\\\n ystart1 < ystart0 + ny0:\\n winp.ystart.config(bg=COL_WARN)\\n ok = False\\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\\n\\n return ok\",\n \"def isGoal(self):\\n for index in range(self.DIM):\\n if not self.values('r',index).count(0) is 0:\\n return False\\n if not self.isValid():\\n return False\\n return True\",\n \"def check_win(self, player):\\n def check_row_win(player):\\n for row in self.game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_column_win(player):\\n # For doing a column check, transpose the grid and do a row check\\n trans_game_state = numpy.transpose(self.game_state)\\n for row in trans_game_state:\\n if player == row[0] == row[1] == row[2]:\\n return True\\n return False\\n\\n def check_diag_win(player):\\n # Left to right diagonal\\n if player == self.game_state[0][0] == self.game_state[1][1] == self.game_state[2][2]:\\n return True\\n # Right to left diagonal\\n if player == self.game_state[0][2] == self.game_state[1][1] == self.game_state[2][0]:\\n return True\\n return False\\n\\n if check_column_win(player) or check_diag_win(player) or check_row_win(player):\\n return True\\n return False\",\n \"def checkWin(self):\\n winstates = [(0, 1, 2),\\n (3, 4, 5),\\n (6, 7, 8),\\n (0, 3, 6),\\n (1, 4, 7),\\n (2, 5, 8),\\n (0, 4, 8),\\n (2, 4, 6)]\\n win = False\\n for state in winstates:\\n if (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == 3:\\n self.handleWin(1)\\n win = True\\n elif (self.gameState[state[0]] + self.gameState[state[1]] + self.gameState[state[2]]) == -3:\\n self.handleWin(-1)\\n win = True\\n\\n if len([i for i in range(9) if self.gameState[i] == 0]) == 0 and not win:\\n print(\\\"Draw yo\\\")\\n self.handleDraw()\\n return None\",\n \"def game_tie(self):\\n\\n shape = self.board.shape\\n if np.count_nonzero(self.board) == (shape[0] * shape[1]):\\n # The board is full\\n player = 0\\n return True\\n else:\\n return False\",\n \"def does_move_win(self, x, y):\\n me = self.board[x][y]\\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\\n p = 1\\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\\n p += 1\\n n = 1\\n while self.is_on_board(x-n*dx, y-n*dy) and self.board[x-n*dx][y-n*dy] == me:\\n n += 1\\n\\n if p + n >= (self.connect + 1): # want (p-1) + (n-1) + 1 >= 4, or more simply p + n >- 5\\n return True\\n\\n return False\",\n \"def winsFor(self, ox):\\n for row in range(self.height):\\n for col in range(self.width):\\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\\n return True\\n return False\",\n \"def check_diagonals(self, win: list) -> bool:\\r\\n for i in range(self.size - self.win_condition + 1):\\r\\n # [x x ]\\r\\n # [ x x ]\\r\\n # [ x x]\\r\\n # [ x]\\r\\n diagonal = []\\r\\n x = i\\r\\n y = 0\\r\\n for j in range(self.size - i):\\r\\n diagonal.append(self.tags[x][y])\\r\\n x += 1\\r\\n y += 1\\r\\n for j in range(len(diagonal) - len(win) + 1):\\r\\n if win == diagonal[j:j + self.win_condition]:\\r\\n return True\\r\\n # [x ]\\r\\n # [x x ]\\r\\n # [ x x ]\\r\\n # [ x x]\\r\\n diagonal = []\\r\\n x = 0\\r\\n y = i\\r\\n for j in range(self.size - i):\\r\\n diagonal.append(self.tags[x][y])\\r\\n x += 1\\r\\n y += 1\\r\\n for j in range(len(diagonal) - len(win) + 1):\\r\\n if win == diagonal[j:j + self.win_condition]:\\r\\n return True\\r\\n\\r\\n # [ x x]\\r\\n # [ x x ]\\r\\n # [x x ]\\r\\n # [x ]\\r\\n diagonal = []\\r\\n x = self.size - 1 - i\\r\\n y = 0\\r\\n for j in range(self.size - i):\\r\\n diagonal.append(self.tags[x][y])\\r\\n x -= 1\\r\\n y += 1\\r\\n for j in range(len(diagonal) - len(win) + 1):\\r\\n if win == diagonal[j:j + self.win_condition]:\\r\\n return True\\r\\n # [ x]\\r\\n # [ x x]\\r\\n # [ x x ]\\r\\n # [x x ]\\r\\n diagonal = []\\r\\n x = self.size - 1\\r\\n y = 0 + i\\r\\n for j in range(self.size - i):\\r\\n diagonal.append(self.tags[x][y])\\r\\n x -= 1\\r\\n y += 1\\r\\n for j in range(len(diagonal) - len(win) + 1):\\r\\n if win == diagonal[j:j + self.win_condition]:\\r\\n return True\",\n \"def diagonal_win():\\n\\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][i]) \\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 1\\\"\\n return True\\n \\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][board_size - 1 - i])\\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 2\\\"\\n return True\",\n \"def on_board(hexe):\\n\\n cube = axial_to_cube(hexe)\\n\\n # check each bound\\n for axis in cube:\\n if abs(axis) > BOARD_BOUND:\\n return False\\n return True\",\n \"def visible(self):\\n return -PipePair.WIDTH < self.x < WIN_WIDTH\",\n \"def winning_event(self, player):\\n # vertical check\\n for col in range(GameData.columns):\\n if self.board[0][col] == player and self.board[1][col] == player and self.board[2][col] == player:\\n self.draw_vertical_winning_line(col, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # horizontal check\\n for row in range(GameData.rows):\\n if self.board[row][0] == player and self.board[row][1] == player and self.board[row][2] == player:\\n self.draw_horizontal_winning_line(row, player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # ascending diagonal heck\\n if self.board[2][0] == player and self.board[1][1] == player and self.board[0][2] == player:\\n self.draw_asc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n # descending diagonal win chek\\n if self.board[0][0] == player and self.board[1][1] == player and self.board[2][2] == player:\\n self.draw_desc_diagonal(player)\\n print(\\\"Player {} has won the game!\\\".format(player))\\n self.game_over = True\\n return True\\n\\n return False\",\n \"def _check(self, x, y):\\n n = self.n\\n # x direction\\n xline = self.arr[y]\\n if not self.x_regexes[y].match(xline):\\n return False\\n\\n # y direction\\n ypos = x + max(0, y + 1 - n)\\n yline = []\\n x1, y1 = ypos, 0\\n while x1 >= 0 and y1 < 2 * n - 1:\\n if x1 < len(self.arr[y1]):\\n yline.append(self.arr[y1][x1])\\n if y1 >= n - 1:\\n x1 -= 1\\n y1 += 1\\n\\n if not self.y_regexes[ypos].match(yline):\\n return False\\n\\n # z direction\\n zpos = x + max(0, n - 1 - y)\\n zline = []\\n x1, y1 = zpos, 2 * n - 2\\n while x1 >= 0 and y1 >= 0:\\n if x1 < len(self.arr[y1]):\\n zline.append(self.arr[y1][x1])\\n if y1 <= n - 1:\\n x1 -= 1\\n y1 -= 1\\n\\n if not self.z_regexes[zpos].match(zline):\\n return False\\n\\n return True\",\n \"def check_won (grid):\\r\\n w=False\\r\\n for row in range(4):\\r\\n for col in range(4):\\r\\n if grid[row][col]>=32:\\r\\n w=True\\r\\n break\\r\\n return w\",\n \"def __check_win_condition(self,token,coordinate):\\n # Check if it's even possible to win yet\\n if self._turn_counter >= 8 and self._turn_counter+1 < self._board_size**2:\\n # Disable win\\n # return False\\n\\n # Up and up right vectors\\n vec1=(1,0)\\n vec2=(1,1)\\n\\n # Loop both directions of vector\\n for _ in range(2):\\n if self.__check_direction(vec1,coordinate):\\n self.__declare_winner()\\n return True\\n if self.__check_direction(vec2,coordinate):\\n self.__declare_winner()\\n return True\\n\\n # Turn vector directions\\n vec1 = -vec1[1], vec1[0]\\n vec2 = -vec2[1], vec2[0]\\n\\n # Check for draw\\n elif self._turn_counter+1 >= self._board_size**2:\\n if (self._gui):\\n self.__turn_counter_label[\\\"text\\\"] = \\\"Draw!\\\"\\n self.__status[\\\"text\\\"] = \\\"\\\"\\n self.__status.update()\\n self.__turn_counter_label.update()\\n self._winner = 3\\n if (self._state == PLAY): showerror(\\\"Draw\\\",\\\"Draw!\\\")\\n return True\",\n \"def check_winner(self):\\n\\t\\tif self.check_diagonals() or self.check_rows() or self.check_columns():\\n\\t\\t\\treturn True\\n\\t\\telif self.board_is_full():\\n\\t\\t\\tprint(\\\"There was a draw, everyone lost\\\")\\n\\t\\t\\treturn None\\n\\t\\treturn False\",\n \"def inCamp(self):\\n return (((self.myTeam==1) and (self.ballPos.x <= self.width/2))\\n | ((self.myTeam==2) and (self.ballPos.x >= self.width/2)))\",\n \"def is_in_the_grid(self, row: int, col: int) -> bool:\\n return 0 <= row < self.n_row and 0 <= col < self.n_col\",\n \"def check_won (grid):\\r\\n for i in range (4):\\r\\n for j in range (4):\\r\\n if grid[i][j] >= 32:\\r\\n return True\\r\\n return False\",\n \"def check(self,a,x,y):\\r\\n return not self.exitsinrow(self.rows,x,a) and not self.existsincol(self.rows,y,a) and \\\\\\r\\n not self.exitsinblock(self.rows, x - x % 3, y - y % 3,a)\",\n \"def game_on(self):\\n doc = self.documentation\\n return (self.draw.accepted or doc[len(doc)-1].accepted) and (self.board.stones_set < self.board.max_nr_stones) and (self.board.score[opponent(self.draw.player)] > 0)\",\n \"def is_game_over(self):\\n if max([max(row) for row in self.grid]) == 2 ** (self.grid_size ** 2):\\n raise GameException('Congrats, You won !')\\n\\n # If there is a zero then the game is not over\\n for row in self.grid:\\n if 0 in row:\\n return False\\n\\n # Check if two consecutive number (vertically or horizontally) are\\n # equal. In this case the game is not over.\\n for i in range(self.grid_size):\\n for j in range(self.grid_size):\\n # horizontal check\\n if (i < self.grid_size - 1 and\\n self.grid[i][j] == self.grid[i + 1][j]):\\n return False\\n # vertical check\\n if (j < self.grid_size - 1 and\\n self.grid[i][j] == self.grid[i][j + 1]):\\n return False\\n\\n return True\",\n \"def check_pos(self, x, y):\\n if x >= WINDOWWIDTH or y >= WINDOWHEIGHT or x <=0 or y <= 0:\\n return True\",\n \"def check_rows(self):\\n\\t\\tfor i in range(len(self.board)):\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor j in range(len(self.board[i])):\\n\\t\\t\\t\\tif self.board[i][j] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('YOU WON')\\n\\t\\t\\t\\treturn True\",\n \"def check_won (grid):\\r\\n for i in range(4): \\r\\n for j in range(4):\\r\\n if grid[i][j] >= 32:\\r\\n return True\\r\\n return False\",\n \"def check_grid_full(self):\\n for row in self.game_state:\\n for e in row:\\n if e is None:\\n return False\\n return True\",\n \"def onlyrow(self):\\n return self.y <= 1\",\n \"def checkwin(self):\\n w = self.getWidth()\\n h = self.getHeight()\\n numOccupiedCell = 0 # counter for the number of occupied cells (use to detect a terminal condition of the game)\\n for r in range(h):\\n for c in range(w):\\n if self.cell[c][r] == EMPTY:\\n continue # this cell can't be part of winning segment\\n # if we reach this point, the cell is occupied by a player stone\\n numOccupiedCell = numOccupiedCell+1\\n for dr,dc in [(1,0),(0,1),(1,1),(-1,1)]: # direction of search\\n for i in range(NWIN):\\n # test if there exists a segment of NWIN uniformly coloured cells\\n if not(r+i*dr>=0) or not(r+i*dr<h) or not(c+i*dc<w) or not(self.cell[c+i*dc][r+i*dr] == self.cell[c][r]):\\n break # segment broken\\n else:\\n # Python remark: notice that the else is attached to the for loop \\\"for i...\\\"\\n # This block is executed if and only if 'i' arrives at the end of its range \\n return self.cell[c][r] , True # found a winning segment \\n return EMPTY, numOccupiedCell==w*h\",\n \"def victory_checker() -> bool:\\r\\n conflict_check()\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n return False\\r\\n if separation_crawler(False):\\r\\n return False\\r\\n return True\",\n \"def test(self, grid, flag):\\n x = self.x+SPEED_X[flag]\\n y = self.y+SPEED_Y[flag]\\n return 0 <= x < self.n and 0 <= y < self.n and grid[y][x] == 1\",\n \"def is_game_won(self):\\n if self.game_is_tied():\\n return False\\n my_available_steps = self.steps_available(self.loc)\\n opp_available_steps = self.steps_available(self.opponent_loc)\\n if my_available_steps == 0 or opp_available_steps == 0:\\n return True\\n else:\\n return False\",\n \"def isWin(self):\\n\\n return self.tiles == self.winCdt\",\n \"def is_on_board(x: int, y: int) -> bool:\\n return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT\",\n \"def check_diagonals(self):\\n\\t\\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\\n\\n\\t\\tfor diag in diags:\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor loc in diag:\\n\\t\\t\\t\\tif self.board[loc[0]][loc[1]] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('WE WON')\\n\\t\\t\\t\\treturn True\",\n \"def check_for_win(self,board, player_id, action):\\n\\n row = 0\\n\\n # check which row was inserted last:\\n for i in range(ROWS):\\n if board[ROWS - 1 - i, action] == EMPTY_VAL:\\n row = ROWS - i\\n break\\n\\n # check horizontal:\\n vec = board[row, :] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check vertical:\\n vec = board[:, action] == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n # check diagonals:\\n vec = np.diagonal(board, action - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n vec = np.diagonal(np.fliplr(board), ACTION_DIM - action - 1 - row) == player_id\\n if np.any(np.convolve(WIN_MASK, vec, mode=\\\"valid\\\") == 4):\\n return True\\n\\n return False\",\n \"def check_won(grid):\\r\\n for i in range(len(grid)):\\r\\n for j in range(len(grid[i])):\\r\\n if grid[i][j] >= 32:\\r\\n return True \\r\\n return False\",\n \"def check_draw(winner, board):\\n if not winner and all(\\\"_\\\" not in row for row in board):\\n print(\\\"Game Over, game is a tie\\\")\\n return True\",\n \"def satifiesWinConditions(self, coordinates):\\n if self.treasureCaptured and (self.x, self.y) in coordinates:\\n return True\\n else:\\n return False\",\n \"def check_win(self):\\r\\n wins = [self.check_rows(), self.check_cols(), self.check_diag()]\\r\\n for case, pos in wins:\\r\\n if case != -1:\\r\\n print('Game over!')\\r\\n if self.grid[case][-1] == self.computer:\\r\\n print('The computer won!')\\r\\n return (True, pos)\\r\\n print('The player won!')\\r\\n return (True, pos)\\r\\n\\r\\n return (self.check_draw(), None)\",\n \"def _inside(self, x, y):\\n wx, wy, w, h = self._raw_graph_window_dim()\\n if wx <= x < wx + w and wy <= y < wy + h:\\n return True\\n return False\",\n \"def win_for(self, side):\\n # Testing rows\\n for row in range(self.height):\\n for col in range(self.width - 3):\\n if ( self.data[row][col] == side\\n and self.data[row][col+1] == side\\n and self.data[row][col+2] == side\\n and self.data[row][col+3] == side):\\n return True\\n\\n # Testing columns\\n for col in range(self.width):\\n for row in range(self.height - 3):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col] == side\\n and self.data[row+2][col] == side\\n and self.data[row+3][col] == side):\\n return True\\n\\n # Testing left diagonal\\n for row in range(self.height - 3):\\n for col in range(self.width - 3):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col+1] == side\\n and self.data[row+2][col+2] == side\\n and self.data[row+3][col+3] == side):\\n return True\\n\\n # Testing right diagonal\\n for row in range(self.height - 3):\\n for col in range(3, self.width):\\n if ( self.data[row][col] == side\\n and self.data[row+1][col-1] == side\\n and self.data[row+2][col-2] == side\\n and self.data[row+3][col-3] == side):\\n return True\\n\\n return False\",\n \"def check_win(self, player):\\n for win_pos in TicTacToe.win_pos:\\n # for each winning position defined we take the set difference to the positions played be player\\n # if there are not elements left after resulting set after difference operator\\n # we get False as return. ie he has placed his marker in the winning positions which in turn makes him\\n # the winner\\n if not win_pos.difference(self.player_played_pos[player]):\\n return True\\n\\n # if after checking for every winning positions if the control still reaches here,\\n # the player has not marked the winning positions. returns False\\n return False\",\n \"def is_over(self, state: StonehengeState) -> bool:\\n total_result = state.hori_result + state.left_result + state.right_result\\n total_line = len(total_result)\\n p1_taken = 0\\n p2_taken = 0\\n # all_taken = True\\n for item in total_result:\\n if item == '1':\\n p1_taken+=1\\n elif item =='2':\\n p2_taken += 1\\n # else:\\n # all_taken = False\\n # print('p1 taken:' + str(p1_taken))\\n # print('p2 taken:' + str(p2_taken))\\n # print('p1_taken more than half?')\\n # print(float(p1_taken) >= total_line/2)\\n # print('p2_taken more than half?')\\n # print(float(p2_taken) >= total_line/2)\\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2\",\n \"def is_complete_line(board: list, y: int) -> bool:\\n for x in range(BOARDWIDTH):\\n # if there is a blank box then the line is not complete\\n if board[y][x] == BLANK:\\n return False\\n\\n return True\",\n \"def __check_col(self, x: int, y: int) -> bool:\\n return not any([self.__maze[x + i, y] for i in (-1, 0, 1)])\",\n \"def check_won (grid):\\r\\n p=0\\r\\n for k in range(len(grid)):\\r\\n for g in range(len(grid[k])): \\r\\n if grid[k][g]>=32:\\r\\n p+=1\\r\\n else:\\r\\n ()\\r\\n if p>0:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def game_over(self) -> bool:\\n for row in range(9):\\n for col in range(9):\\n if self._grid_sol[row][col] != self.get_cell(row, col):\\n return False\\n return True\",\n \"def is_over(self, state) -> bool:\\n\\n p1_count = 0\\n p2_count = 0\\n ley_line_total = (state.side_length + 1) * 3\\n for itype in state.current_ley_lines:\\n for line in itype:\\n if line[0] == '1':\\n p1_count += 1\\n if line[0] == '2':\\n p2_count += 1\\n\\n if p1_count >= ley_line_total/2 or p2_count >= ley_line_total/2:\\n return True\\n return False\",\n \"def valid_ray(self, row, col):\\n # if row nor col is at an edge space, returns False\\n if row != 0 and row != 9 and col != 0 and col != 9:\\n return False\\n # ensures no corner spaces have been selected\\n if row == 0 or row == 9:\\n if col > 8 or col < 1:\\n return False\\n if col == 0 or col == 9:\\n if row > 8 or row < 1:\\n return False\\n return True\",\n \"def draw(self):\\n\\n for row in self._board:\\n for slot in row:\\n if slot == 0:\\n return False\\n print \\\"It's a draw!\\\"\\n return True\",\n \"def isGameOver(self):\\n for row in range(0, self.rows):\\n for col in range(0, self.cols):\\n if self.isMine(row, col) and self.isClicked(row, col):\\n return True\\n return False\",\n \"def check_win(self):\\n win = None\\n for pos in self.winning_pos:\\n win = self.is_match(set(self.get_cells(pos)))\\n if win:\\n return win\\n if not self.open_tiles():\\n return \\\"Draw\\\"\\n return win\",\n \"def board_tiles_availability(self):\\n for row in range(GameData.rows):\\n for col in range(GameData.columns):\\n if self.board[row][col] == 0:\\n return False\\n # Game is draw, no more moves left!\\n return True\",\n \"def check_2x2_solved(self):\\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\\\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)\",\n \"def _check_for_win(self, piece, piece_x, piece_y):\\n for slope_x, slope_y in ((1,0), (0,1), (1,1), (1,-1)):\\n for start_x, start_y in ((piece_x - slope_x*i, piece_y - slope_y*i) for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions = []\\n for x, y in ((start_x + slope_x*i, start_y + slope_y*i)\\n for i in range(self.consecutive_pieces_to_win)):\\n winning_piece_positions.append((x, y))\\n # Don't need to check the piece that is being placed\\n if (x, y) == (piece_x, piece_y):\\n continue\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece != piece:\\n winning_piece_positions = None\\n break\\n if winning_piece_positions:\\n # Check if there are additional winning pieces that exceed the number required to win.\\n # e.g. a 5-in-a-row when only 4 are required\\n if slope_x != 0:\\n num_previous_pieces_to_check = self.consecutive_pieces_to_win + (start_x - piece_x)\\n for x, y in ((start_x - slope_x*i, start_y - slope_y*i)\\n for i in range(1, 1 + num_previous_pieces_to_check)):\\n current_piece = self._get_piece_at_opening_or_none(x, y)\\n if current_piece == piece:\\n winning_piece_positions.insert(0, (x, y))\\n else:\\n break\\n return winning_piece_positions\\n\\n return False\",\n \"def diag_win(board):\\n\\tif board[1][1] != EMPTY and (board[1][1] == board[0][2] == board[2][0] or board[1][1] == board[0][0] == board[2][2]):\\n\\t\\treturn True\\n\\treturn False\",\n \"def is_over(self):\\n for el1, el2, el3 in self.WINNING_POSITIONS:\\n if self.board[el1] == self.board[el2] == self.board[el3]:\\n if self.board[el1] == 0:\\n continue\\n\\n self.winner = self.board[el1]\\n return True\\n\\n if self.__class__.EMPTY_POSITION_COUNTER not in self.board:\\n return True\\n\\n return False\",\n \"def _check_window(x: int, y: int, z: int) -> bool:\\n return (x + y) == z\",\n \"def row_win(board):\\n\\tfor row in range(3):\\n\\t\\tif board[row][0] != EMPTY and board[row][0] == board[row][1] == board[row][2]:\\n\\t\\t\\treturn True\\n\\treturn False\",\n \"def is_winning_state(self):\\n return self.game.is_winning_state()\",\n \"def IsGameOver(self):\\n return any(c.cX + c.width >= self.end_location for c in self.enemies)\",\n \"def finished(self) -> bool:\\n p1_count = 0\\n p2_count = 0\\n ley_line_total = (self.side_length + 1) * 3\\n for itype in self.current_ley_lines:\\n for line in itype:\\n if line[0] == '1':\\n p1_count += 1\\n if line[0] == '2':\\n p2_count += 1\\n return p1_count >= ley_line_total / 2 or p2_count >= ley_line_total / 2\",\n \"def is_border(self, threshold):\\n\\n def dist_to_line(p1, p2, p3):\\n return np.linalg.norm(np.cross(p2 - p1, p1 - p3)) / np.linalg.norm(p2 - p1)\\n\\n total_dist = 0\\n for p in self.shape:\\n total_dist += dist_to_line(self.shape[0], self.shape[-1], p)\\n return total_dist < threshold\",\n \"def validate_in(self, xcoord, ycoord):\\r\\n x = int(xcoord/(self.tr.bd.TILE_WIDTH + self.tr.bd.LINE_WIDTH))\\r\\n y = int(ycoord/(self.tr.bd.TILE_WIDTH + self.tr.bd.LINE_WIDTH))\\r\\n if not self.tr.turn_tracker and self.tr.bd.disks[x][y].halo_tag:\\r\\n return True, x, y\\r\\n else:\\r\\n return False, x, y\",\n \"def __win(self, a):\\n for i in range(len(a)-self.k+1):\\n flag = True\\n for j in range(self.k):\\n if not a[i+j]:\\n flag = False\\n break\\n if flag: return True\",\n \"def did_hal_win_yet(self, current_board):\\r\\n if self.check_for_win(current_board, 'O'):\\r\\n print(\\\"It can only be attributable to human error, Dave.\\\\033[5;31m You LOSE.\\\\033[0m\\\")\\r\\n return True\\r\\n elif self.check_for_draw(current_board):\\r\\n print(\\\"Thank you for a very enjoyable game, Dave.\\\\033[5;31m It's a DRAW\\\\033[0m\\\")\\r\\n return True\\r\\n\\r\\n return False\",\n \"def is_horizontal_win(self, checker):\\n for row in range(self.height):\\n for col in range(self.width - 3):\\n # Check if the next four columns in this row\\n # contain the specified checker.\\n if self.slots[row][col] == checker and \\\\\\n self.slots[row][col + 1] == checker and \\\\\\n self.slots[row][col + 2] == checker and \\\\\\n self.slots[row][col + 3] == checker:\\n return True\\n \\n # if we make it here, there were no horizontal wins\\n return False\",\n \"def wall_check(x: int, y: int, state: bool) -> bool:\\r\\n if state:\\r\\n if x == 0 or x == shape-1 or y == 0 or y == shape-1:\\r\\n return True\\r\\n else:\\r\\n if x < 0 or x >= shape or y < 0 or y >= shape:\\r\\n return True\\r\\n return False\",\n \"def horizontal_win():\\n\\n for i in range(0, board_size):\\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\\n print \\\"horizontal win\\\"\\n return True\",\n \"def is_valid_room(self, x, y):\\r\\n return 0 <= x < self.__nx and 0 <= y < self.__ny\",\n \"def isOnCanvas(self, x, y):\\n return 0 <= x < self.width and 0 <= y < self.height\",\n \"def __is_board_full(self):\\r\\n for row in self.__board:\\r\\n if {self.PLAYER1, self.PLAYER2} & set(row) != 0:\\r\\n return False\\r\\n return True\",\n \"def win_game(self):\\n\\n def horizontal_win():\\n \\\"\\\"\\\"Return whether there is horizontal win\\\"\\\"\\\"\\n\\n for i in range(0, board_size):\\n if set(self.board[i]) == set([o_symbol]) or set(self.board[i]) == set([x_symbol]):\\n print \\\"horizontal win\\\"\\n return True\\n\\n def vertical_win():\\n \\\"\\\"\\\"Return whether there is vertical win\\\"\\\"\\\"\\n\\n vert_set = set()\\n for i in range(0, board_size):\\n for j in range(0, board_size):\\n vert_set.add(self.board[j][i])\\n if vert_set == set([o_symbol]) or vert_set == set([x_symbol]):\\n print \\\"vertical win\\\"\\n return True \\n vert_set = set()\\n\\n def diagonal_win():\\n \\\"\\\"\\\"Return whether there is diagonal win\\\"\\\"\\\"\\n\\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][i]) \\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 1\\\"\\n return True\\n \\n diagonal_set = set()\\n for i in range(0, board_size):\\n diagonal_set.add(self.board[i][board_size - 1 - i])\\n\\n if diagonal_set == set([o_symbol]) or diagonal_set == set([x_symbol]):\\n print \\\"diagonal win 2\\\"\\n return True\\n\\n if horizontal_win() or vertical_win() or diagonal_win():\\n print \\\"You have won.\\\"\\n return True\",\n \"def draw(arr):\\n return int((np.count_nonzero(arr) == 9) and (not win(arr)))\",\n \"def check_empty(self, coord):\\n x, y, z = coord\\n if self.perlin_3d(x, y, z) <= 0:\\n return True\\n else:\\n return False\",\n \"def check_win(self):\\n\\n # Sets rings initially to False\\n black_ring = False\\n white_ring = False\\n\\n # Gets board\\n board = self._game_board.get_board_area()\\n\\n # Iterate through stone-holding points\\n for i in range(1, 19):\\n for j in range(1, 19):\\n # Get the surroundings of each point\\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\\n\\n # If the point is empty and surrounded by \\\"B\\\", there's a black ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"B\\\"}:\\n black_ring = True\\n\\n # If the point is empty and surrounded by \\\"W\\\", there's a white ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"W\\\"}:\\n white_ring = True\\n\\n if not black_ring:\\n return \\\"WHITE_WON\\\"\\n\\n if not white_ring:\\n return \\\"BLACK_WON\\\"\\n\\n return \\\"UNFINISHED\\\"\",\n \"def check_edges(self):\\n if self.rect.right >= self.screen_rect.right or self.rect.left <= 0:\\n return True\",\n \"def goal_test(self, state):\\n for x, y in state.alvos:\\n if state.tabuleiro[x][y] is not BOX_ON_TARGET:\\n return False\\n return True\",\n \"def coordinates_within_board(n: int, x: int, y: int) -> bool:\\n\\n return x < n and y < n and x >= 0 and y >= 0\",\n \"def gameOver(self):\\n i = 0 # accumulator for the number of None objects\\n for x in range(ALIEN_ROWS):\\n for y in range(ALIENS_IN_ROW):\\n if self._aliens[x][y] ==None:\\n i +=1\\n if i == ALIEN_ROWS * ALIENS_IN_ROW:\\n self._gameOver = True\\n\\n for x in range(ALIEN_ROWS):\\n for y in range(ALIENS_IN_ROW):\\n if self._aliens[x][y] !=None:\\n positiony = self._aliens[x][y].getAY() - ALIEN_HEIGHT/2\\n if posy<= self._dline:\\n self._gameOver = False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7173354","0.70985824","0.6997996","0.6947743","0.68140584","0.6719319","0.6712507","0.6712507","0.6701225","0.6684429","0.6665015","0.665667","0.66564786","0.662193","0.6610499","0.6598199","0.65881664","0.6571598","0.6556325","0.6543641","0.6531366","0.6526199","0.6524892","0.65230054","0.6507518","0.6507062","0.6467454","0.64515454","0.6430841","0.6413236","0.63977534","0.6395379","0.638891","0.6380261","0.6347352","0.6346004","0.6343956","0.63367057","0.63343805","0.6314073","0.6311955","0.6310303","0.6307767","0.6307259","0.6306508","0.6303333","0.6298033","0.6294144","0.62875736","0.6285255","0.627916","0.6273763","0.62469864","0.62440777","0.6240554","0.6238448","0.62287915","0.62268","0.62235934","0.6218908","0.62187356","0.6217447","0.6215238","0.6215079","0.6209885","0.6209237","0.6206628","0.6206089","0.62047535","0.620215","0.6199505","0.61988336","0.6195088","0.61912435","0.6189899","0.61889344","0.6187144","0.61847883","0.61801374","0.6170256","0.61685014","0.61668944","0.6162439","0.61601835","0.61548764","0.61527824","0.61499995","0.61329794","0.6130683","0.61295503","0.6123893","0.61222726","0.61162055","0.6115267","0.6108938","0.6102189","0.60935146","0.6091377","0.60887253","0.60868794"],"string":"[\n \"0.7173354\",\n \"0.70985824\",\n \"0.6997996\",\n \"0.6947743\",\n \"0.68140584\",\n \"0.6719319\",\n \"0.6712507\",\n \"0.6712507\",\n \"0.6701225\",\n \"0.6684429\",\n \"0.6665015\",\n \"0.665667\",\n \"0.66564786\",\n \"0.662193\",\n \"0.6610499\",\n \"0.6598199\",\n \"0.65881664\",\n \"0.6571598\",\n \"0.6556325\",\n \"0.6543641\",\n \"0.6531366\",\n \"0.6526199\",\n \"0.6524892\",\n \"0.65230054\",\n \"0.6507518\",\n \"0.6507062\",\n \"0.6467454\",\n \"0.64515454\",\n \"0.6430841\",\n \"0.6413236\",\n \"0.63977534\",\n \"0.6395379\",\n \"0.638891\",\n \"0.6380261\",\n \"0.6347352\",\n \"0.6346004\",\n \"0.6343956\",\n \"0.63367057\",\n \"0.63343805\",\n \"0.6314073\",\n \"0.6311955\",\n \"0.6310303\",\n \"0.6307767\",\n \"0.6307259\",\n \"0.6306508\",\n \"0.6303333\",\n \"0.6298033\",\n \"0.6294144\",\n \"0.62875736\",\n \"0.6285255\",\n \"0.627916\",\n \"0.6273763\",\n \"0.62469864\",\n \"0.62440777\",\n \"0.6240554\",\n \"0.6238448\",\n \"0.62287915\",\n \"0.62268\",\n \"0.62235934\",\n \"0.6218908\",\n \"0.62187356\",\n \"0.6217447\",\n \"0.6215238\",\n \"0.6215079\",\n \"0.6209885\",\n \"0.6209237\",\n \"0.6206628\",\n \"0.6206089\",\n \"0.62047535\",\n \"0.620215\",\n \"0.6199505\",\n \"0.61988336\",\n \"0.6195088\",\n \"0.61912435\",\n \"0.6189899\",\n \"0.61889344\",\n \"0.6187144\",\n \"0.61847883\",\n \"0.61801374\",\n \"0.6170256\",\n \"0.61685014\",\n \"0.61668944\",\n \"0.6162439\",\n \"0.61601835\",\n \"0.61548764\",\n \"0.61527824\",\n \"0.61499995\",\n \"0.61329794\",\n \"0.6130683\",\n \"0.61295503\",\n \"0.6123893\",\n \"0.61222726\",\n \"0.61162055\",\n \"0.6115267\",\n \"0.6108938\",\n \"0.6102189\",\n \"0.60935146\",\n \"0.6091377\",\n \"0.60887253\",\n \"0.60868794\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6457668"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":9291,"cells":{"query":{"kind":"string","value":"Checks if the board is fully packed with figures, which in practice means => if the tags array is full."},"document":{"kind":"string","value":"def full_board(self) -> bool:\r\n counter = 0\r\n for column in self.tags:\r\n if None in column:\r\n counter += 1\r\n return counter == 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _board_is_full(self):\n return (self.get_counts()[0] + self.get_counts()[1] == self._num_rows * self._num_cols)","def is_full(board):\r\n return False","def is_full(board):\n return False","def check_grid_full(self):\n for row in self.game_state:\n for e in row:\n if e is None:\n return False\n return True","def is_full(self):\n return self.top == self.size - 1","def is_board_full(board):\n for i in range(1, 10):\n if check_empty_space(board, i):\n return False\n return True","def is_full(self):\n for i in range(self.width):\n if self.can_add_to(i) == True:\n return False\n return True","def is_full(self):\r\n return self.num_checkers == self.width * self.height","def full():\r\n\r\n count = 0\r\n for slot in board:\r\n if slot not in '012345678':\r\n count += 1\r\n return count == 9","def board_is_full(self):\n\t\tfor i in range(len(self.board)):\n\t\t\tfor j in range(len(self.board[i])):\n\t\t\t\tif self.board[i][j] == '-':\n\t\t\t\t\treturn False\n\t\treturn True","def is_full(self):\n full = True\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n if self.board[i][j] == \"\":\n full = False\n return full","def is_full(self):\n\n current_board = self.current_board\n remaining_rows = 0\n\n for row in current_board:\n if \"-\" in set(row):\n remaining_rows += 1\n\n if remaining_rows == 0:\n return True\n else:\n return False","def is_complete(self):\n for i in range(9):\n if len(self.rows[i]) != 0 or len(self.columns[i]) != 0 or len(self.groups[i]) != 0:\n return False\n\n for row in self.board:\n for col in row:\n if col == self.empty_cell_flag:\n return False\n\n return True","def _board_is_full(board):\n\n # looks for \"-\" in every position in the board\n # returns False if it finds one\n for row in board:\n if any(column for column in row if column == \"-\"):\n return False\n\n return True","def isFull(self) -> bool:\n return self._elems == self._k","def is_board_full(self):\n for position in self.positions:\n if self.is_position_availible(position):\n return False\n return True","def is_full(self):\n return len(self.__occupied_slots__) >= self.__size__","def is_full(self):\n return len(self.walls) == 4","def check_if_board_full(self, board):\n for i in range(self.height // 80):\n for j in range(self.width // 80):\n if board[(j, i)] == 0:\n return False\n elif j == self.width // 80:\n break\n else:\n pass\n print(\"Board full! :(\")\n return True","def is_full(self): #checks to see if stack is full by comparing it to the capacity\n if self.num_items == self.capacity:\n return True\n else:\n return False","def check_full_board(self): #rows then columns\n for row in self.board:\n for column_of_row in row:\n if column_of_row == ' ':\n return False\n return True","def is_board_full(board):\n return not any(0 in val for val in board)","def is_full(self) -> bool:","def checkFull(self, board):\n full = True\n for i in board:\n if i == ' ': full = False\n return full","def full_board( self ):\n\n for x in self.__grid:\n if isinstance(x, int):\n return False\n else:\n continue\n\n return True","def __is_board_full(self):\r\n for row in self.__board:\r\n if {self.PLAYER1, self.PLAYER2} & set(row) != 0:\r\n return False\r\n return True","def check_for_empty(self):\n return ' ' in self.game_board","def is_full(self):\n return all(map(lambda x: x != self.CELL_EMPTY, self.__values))","def not_empty(entry):\n gt_boxes = entry['boxes']\n return gt_boxes.shape[0] > 0","def isFull(self):\n return self.rear == self.size","def is_full(self) -> bool:\n return self._array[0].all()","def is_full(self) -> bool:\r\n return self.size == self.capacity","def check_grid(self) -> None:\n if not len(self.grid) == 81:\n raise ValueError(\"Grid does not have 81 elements. Aborting\")","def is_full(self):\n\n return self.count == len(self.array)","def is_full(self):","def board_is_empty():\n if STATE[-1].strip() == '-' * 7:\n return True\n else:\n return False","def check_if_win(self, tag: str) -> bool:\r\n win_line = [tag]*self.win_condition\r\n return self.check_rows(win_line) or self.check_columns(win_line) or self.check_diagonals(win_line)","def full_board_check(board):\n is_full = True\n for i in range(1, 10):\n if str(board[i]).strip() == \"\":\n is_full = False\n break\n return is_full","def game_tie(self):\n\n shape = self.board.shape\n if np.count_nonzero(self.board) == (shape[0] * shape[1]):\n # The board is full\n player = 0\n return True\n else:\n return False","def isFull(self):\n return self.rear - self.front == self.size","def check_bag_size(self):\r\n return len(self.db.tilestring)","def check_if_full(self):\n pass","def no_bricks(self):\n if self.brick_count == self.total_bricks:\n return True\n else:\n return False","def board_full(board):\n\n for row in board:\n for piece in row:\n if piece == '*': return False;\n\n return True;","def is_full_board(board):\n return config.NO_PLAYER not in board","def is_full(self):\r\n if self.size == self.capacity:\r\n return True\r\n return False","def isComplete(grid):\n for row in range(0,9):\n for col in range(0,9):\n if grid[row][col]==0:\n return False\n return True","def checking_stack(stack={}, database='ENDF_VIII'):\n for _keys in stack:\n _elements = stack[_keys]['elements']\n for _element in _elements:\n if not is_element_in_database(element=_element):\n raise ValueError(\"Element {} can not be found in the database\".format(_element))\n\n _thickness = stack[_keys]['thickness']['value']\n if not isinstance(_thickness, numbers.Number):\n raise ValueError(\"Thickness {} should be a number!\".format(_thickness))\n \n _stoichiometric_ratio = stack[_keys]['stoichiometric_ratio']\n if len(_stoichiometric_ratio) != len(_elements):\n raise ValueError(\"stoichiometric Ratio and Elements should have the same size!\")\n \n return True","def is_blank( self ):\n for bit in self.pixels:\n if bit:\n return False\n # if we got here, all bits are False\n return True","def _is_full(self):\n if self.allocated_spaces == self.capacity:\n return True\n elif self.allocated_spaces < self.capacity:\n return False","def isFull(self):\n\t\treturn self.size == self.capacity","def PartiallyEmpty(self):\n return None==self.piecesToRecover","def isFull(self) -> bool:\n return (self.rear + 1) % self.capacity == self.front","def is_full(self):\n elements_in_sects = sum(\n map(opr.attrgetter(\"size\"), self.sects.values())\n )\n elements_in_total = fct.reduce(\n opr.mul, type(self).flatten_shape(self.shape), 1\n )\n res = elements_in_sects >= elements_in_total\n return res","def _check_occupied(self, col, row):\n if self.board[row - 1][col - 1] == EMPTY:\n return False\n else:\n return True","def test_constructed_is_small(self):\n self.assertTrue(all(elt<10 for elt in goodwinsheaf.checkradii()))#check all entries have small radii","def isOver(self):\n\t\tisFull = Piece.BLANK\n\t\tfor a,b,c in [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]]:\n\t\t\tif (self.board[a] is self.board[b] is self.board[c] and self.board[a] is not Piece.BLANK):\n\t\t\t\treturn self.board[a]\n\t\t\tif (self.board[a] is Piece.BLANK or self.board[b] is Piece.BLANK or self.board[c] is Piece.BLANK):\n\t\t\t\tisFull = False\n\t\treturn isFull","def is_populated(self) -> bool:\n return 0 < self.count_compounds()","def full(self):\n for x in range(0,3):\n for y in range(0,3):\n if self[x,y] is None:\n return False\n return True","def is_full(self):\n return self.remaining_space_in_hold() == 0","def is_full(self):\n return False","def test_room_has_tiles(self):\n self.assertEqual(self.room.tile_set.count(), self.room.grid_size ** 2)","def filled(self):\n return len(self) == self.length","def full_board(self,p):\n board = self.get_element(p)\n for row in board:\n for col in row:\n if col == ' ':\n return False\n return True","def isFull(self) -> bool:\n return self.size == self.maxlen","def board_tiles_availability(self):\n for row in range(GameData.rows):\n for col in range(GameData.columns):\n if self.board[row][col] == 0:\n return False\n # Game is draw, no more moves left!\n return True","def is_packed(self):\n return self.__class__._packed_place_","def check_finished_boxes(self):\n finished_boxes = 0\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n if self.board[i][j] == \" \":\n if self.board[i - 1][j] != \"\" and self.board[i + 1][j] != \"\" and self.board[i][j - 1] != \"\" and self.board[i][j + 1] != \"\":\n finished_boxes += 1\n return finished_boxes","def is_board_valid(bd):\n return is_rows_valid(bd) and is_cols_valid(bd) and is_sqrs_valid(bd)","def is_full(self) -> bool:\n pass","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def is_full(self):\n return len(self._data) == 1","def has_cells(self):\n return len(self._cells) > 0","def isComplete(self):\n for n in range(9):\n for m in range(9):\n if self.puzzle[n][m] == 0:\n return False\n return True","def canSwipeBase (self) :\n for columnNbr in range(4) :\n currentColumn = self.grid[:,columnNbr]\n nbrNonZero = np.count_nonzero(currentColumn)\n if nbrNonZero == 0 : #if empty, go to next\n #print(\"isEmpty\")\n continue\n if nbrNonZero == 4 : #if full, go to next\n #print(\"isFull\")\n continue\n\n for lineNbr in range(3, -1 + nbrNonZero, -1) :\n if currentColumn[lineNbr] != 0 :\n return True\n\n for lineNbr in range(0, 3) :\n if currentColumn[lineNbr] == currentColumn[lineNbr+1] :\n return True\n\n return False","def assert_data_fragments_correct(self) -> bool:\n read_path = Path(os.environ[\"DATA_PATH\"]) / \"fragments\"\n if not read_path.exists():\n return False\n bin_images = [img for img in read_path.iterdir() if \"binarized\" in img.name]\n if len(bin_images) == 0:\n return False\n return True","def isTileBlank(tile):\n for b in tile:\n if b: return False\n return True","def check(self):\n for row in self.grid:\n for i in range(1, 10):\n if row.count(i) != 1:\n return False\n\n for col in range(9):\n lst = [row[col] for row in self.grid]\n for i in range(1, 10):\n if lst.count(i) != 1:\n return False\n \n for i in range(3):\n for j in range(3):\n lst = [row[j* 3:(j*3) + 3] for row in self.grid[i * 3:(i*3) + 3]] \n flat_list = []\n for k in lst:\n for number in k:\n flat_list.append(number)\n \n for check_number in range(1, 10):\n if flat_list.count(check_number) != 1:\n return False\n return True","def _is_tie(self):\n for y in range(self.size_y):\n for x in range(self.size_x):\n piece = self.get_piece_at_opening(x, y)\n if piece == Piece.NONE:\n return False\n return True","def is_full(self):\n # If at least one of the columns permits a move, then the board is\n # not full\n for i in range(self.width):\n if self.allows_move(i):\n return False\n return True","def full(self):\n return self._current_size == self._size","def isFull(self) -> bool:\n q, k, front, rear, empty = self.q, self.k, self.front, self.rear, self.empty\n\n if front == rear and not empty:\n return True\n\n return False","def check_won(grid):\r\n for i in range(len(grid)):\r\n for j in range(len(grid[i])):\r\n if grid[i][j] >= 32:\r\n return True \r\n return False","def _area_is_empty(self, screen: Screen, write_position: WritePosition) -> bool:\n wp = write_position\n\n for y in range(wp.ypos, wp.ypos + wp.height):\n if y in screen.data_buffer:\n row = screen.data_buffer[y]\n\n for x in range(wp.xpos, wp.xpos + wp.width):\n c = row[x]\n if c.char != \" \":\n return False\n\n return True","def _check_number_of_bells(self) -> bool:\n if self.row_generator.stage == 0:\n self.logger.debug(\"Place holder row generator. Wheatley will not ring!\")\n return False\n if self._tower.number_of_bells < self.row_generator.stage:\n self.logger.warning(f\"Row generation requires at least {self.row_generator.stage} bells, \"\n + f\"but the current tower has {self._tower.number_of_bells}. \"\n + \"Wheatley will not ring!\")\n return False\n if self._tower.number_of_bells > self.row_generator.stage + 1:\n if self.row_generator.stage % 2:\n expected = self.row_generator.stage + 1\n else:\n expected = self.row_generator.stage\n self.logger.info(f\"Current tower has more bells ({self._tower.number_of_bells}) than expected \"\n + f\"({expected}). Wheatley will add extra cover bells.\")\n return True","def tied(self):\n for (x, y) in self.fields:\n if self.fields[x, y] == self.empty:\n return False\n return True","def full(self):\n return self.size >= self.maxsize","def test_is_filled(self):\n n = 10\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\n not_matrix = g.np.logical_not(matrix)\n pitch = 1. / n\n origin = g.np.random.uniform(size=(3,))\n vox = g.trimesh.voxel.VoxelGrid(matrix)\n vox = vox.apply_scale(pitch).apply_translation(origin)\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\n for a, b in ((vox, not_vox), (not_vox, vox)):\n points = a.points\n # slight jitter - shouldn't change indices\n points += (\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\n g.np.random.shuffle(points)\n\n # all points are filled, and no empty points are filled\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))\n\n # test different number of dimensions\n points = g.np.stack([points, points[-1::-1]], axis=1)\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))","def test_room_has_tiles(self):\n self.assertGreaterEqual(self.room.tile_set.count(), 2)","def _unbalanced(self):\n if self.internal():\n if self.full():\n if abs(self._leftchild._height-self._rightchild._height) >= 2:\n return True\n elif self._leftchild and not self._rightchild:\n if self._leftchild._height >= 2:\n return True\n elif self._rightchild._height >= 2:\n return True\n return False","def isFull(self) -> bool:\n return self.count == self.capacity","def isFull(self) -> bool:\n return self.count == self.capacity","def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True","def any_empty_tiles(self):\n for i in range(self.TILES_PER_ROW):\n for j in range(self.TILES_PER_ROW):\n if self.main_grid_values[i][j] == 0:\n return True\n\n return False","def empty(self):\r\n return self.stack == []","def full(self) -> bool:\n return self.maxsize and self.qsize() >= self.maxsize","def full(self) -> bool:\n\n return (self._size == self._capacity)","def is_tile_empty(self, y_pos, x_pos):\n if 15 > y_pos >= 0 and 0 <= x_pos < 15:\n return self.map[y_pos][x_pos] == ' '\n return False","def _is_screen(grid):\n for e in range(grid.edges.shape[1]):\n if len([j for i in grid.element_edges for j in i if j == e]) < 2:\n return True\n return False"],"string":"[\n \"def _board_is_full(self):\\n return (self.get_counts()[0] + self.get_counts()[1] == self._num_rows * self._num_cols)\",\n \"def is_full(board):\\r\\n return False\",\n \"def is_full(board):\\n return False\",\n \"def check_grid_full(self):\\n for row in self.game_state:\\n for e in row:\\n if e is None:\\n return False\\n return True\",\n \"def is_full(self):\\n return self.top == self.size - 1\",\n \"def is_board_full(board):\\n for i in range(1, 10):\\n if check_empty_space(board, i):\\n return False\\n return True\",\n \"def is_full(self):\\n for i in range(self.width):\\n if self.can_add_to(i) == True:\\n return False\\n return True\",\n \"def is_full(self):\\r\\n return self.num_checkers == self.width * self.height\",\n \"def full():\\r\\n\\r\\n count = 0\\r\\n for slot in board:\\r\\n if slot not in '012345678':\\r\\n count += 1\\r\\n return count == 9\",\n \"def board_is_full(self):\\n\\t\\tfor i in range(len(self.board)):\\n\\t\\t\\tfor j in range(len(self.board[i])):\\n\\t\\t\\t\\tif self.board[i][j] == '-':\\n\\t\\t\\t\\t\\treturn False\\n\\t\\treturn True\",\n \"def is_full(self):\\n full = True\\n for i in range(len(self.board)):\\n for j in range(len(self.board[i])):\\n if self.board[i][j] == \\\"\\\":\\n full = False\\n return full\",\n \"def is_full(self):\\n\\n current_board = self.current_board\\n remaining_rows = 0\\n\\n for row in current_board:\\n if \\\"-\\\" in set(row):\\n remaining_rows += 1\\n\\n if remaining_rows == 0:\\n return True\\n else:\\n return False\",\n \"def is_complete(self):\\n for i in range(9):\\n if len(self.rows[i]) != 0 or len(self.columns[i]) != 0 or len(self.groups[i]) != 0:\\n return False\\n\\n for row in self.board:\\n for col in row:\\n if col == self.empty_cell_flag:\\n return False\\n\\n return True\",\n \"def _board_is_full(board):\\n\\n # looks for \\\"-\\\" in every position in the board\\n # returns False if it finds one\\n for row in board:\\n if any(column for column in row if column == \\\"-\\\"):\\n return False\\n\\n return True\",\n \"def isFull(self) -> bool:\\n return self._elems == self._k\",\n \"def is_board_full(self):\\n for position in self.positions:\\n if self.is_position_availible(position):\\n return False\\n return True\",\n \"def is_full(self):\\n return len(self.__occupied_slots__) >= self.__size__\",\n \"def is_full(self):\\n return len(self.walls) == 4\",\n \"def check_if_board_full(self, board):\\n for i in range(self.height // 80):\\n for j in range(self.width // 80):\\n if board[(j, i)] == 0:\\n return False\\n elif j == self.width // 80:\\n break\\n else:\\n pass\\n print(\\\"Board full! :(\\\")\\n return True\",\n \"def is_full(self): #checks to see if stack is full by comparing it to the capacity\\n if self.num_items == self.capacity:\\n return True\\n else:\\n return False\",\n \"def check_full_board(self): #rows then columns\\n for row in self.board:\\n for column_of_row in row:\\n if column_of_row == ' ':\\n return False\\n return True\",\n \"def is_board_full(board):\\n return not any(0 in val for val in board)\",\n \"def is_full(self) -> bool:\",\n \"def checkFull(self, board):\\n full = True\\n for i in board:\\n if i == ' ': full = False\\n return full\",\n \"def full_board( self ):\\n\\n for x in self.__grid:\\n if isinstance(x, int):\\n return False\\n else:\\n continue\\n\\n return True\",\n \"def __is_board_full(self):\\r\\n for row in self.__board:\\r\\n if {self.PLAYER1, self.PLAYER2} & set(row) != 0:\\r\\n return False\\r\\n return True\",\n \"def check_for_empty(self):\\n return ' ' in self.game_board\",\n \"def is_full(self):\\n return all(map(lambda x: x != self.CELL_EMPTY, self.__values))\",\n \"def not_empty(entry):\\n gt_boxes = entry['boxes']\\n return gt_boxes.shape[0] > 0\",\n \"def isFull(self):\\n return self.rear == self.size\",\n \"def is_full(self) -> bool:\\n return self._array[0].all()\",\n \"def is_full(self) -> bool:\\r\\n return self.size == self.capacity\",\n \"def check_grid(self) -> None:\\n if not len(self.grid) == 81:\\n raise ValueError(\\\"Grid does not have 81 elements. Aborting\\\")\",\n \"def is_full(self):\\n\\n return self.count == len(self.array)\",\n \"def is_full(self):\",\n \"def board_is_empty():\\n if STATE[-1].strip() == '-' * 7:\\n return True\\n else:\\n return False\",\n \"def check_if_win(self, tag: str) -> bool:\\r\\n win_line = [tag]*self.win_condition\\r\\n return self.check_rows(win_line) or self.check_columns(win_line) or self.check_diagonals(win_line)\",\n \"def full_board_check(board):\\n is_full = True\\n for i in range(1, 10):\\n if str(board[i]).strip() == \\\"\\\":\\n is_full = False\\n break\\n return is_full\",\n \"def game_tie(self):\\n\\n shape = self.board.shape\\n if np.count_nonzero(self.board) == (shape[0] * shape[1]):\\n # The board is full\\n player = 0\\n return True\\n else:\\n return False\",\n \"def isFull(self):\\n return self.rear - self.front == self.size\",\n \"def check_bag_size(self):\\r\\n return len(self.db.tilestring)\",\n \"def check_if_full(self):\\n pass\",\n \"def no_bricks(self):\\n if self.brick_count == self.total_bricks:\\n return True\\n else:\\n return False\",\n \"def board_full(board):\\n\\n for row in board:\\n for piece in row:\\n if piece == '*': return False;\\n\\n return True;\",\n \"def is_full_board(board):\\n return config.NO_PLAYER not in board\",\n \"def is_full(self):\\r\\n if self.size == self.capacity:\\r\\n return True\\r\\n return False\",\n \"def isComplete(grid):\\n for row in range(0,9):\\n for col in range(0,9):\\n if grid[row][col]==0:\\n return False\\n return True\",\n \"def checking_stack(stack={}, database='ENDF_VIII'):\\n for _keys in stack:\\n _elements = stack[_keys]['elements']\\n for _element in _elements:\\n if not is_element_in_database(element=_element):\\n raise ValueError(\\\"Element {} can not be found in the database\\\".format(_element))\\n\\n _thickness = stack[_keys]['thickness']['value']\\n if not isinstance(_thickness, numbers.Number):\\n raise ValueError(\\\"Thickness {} should be a number!\\\".format(_thickness))\\n \\n _stoichiometric_ratio = stack[_keys]['stoichiometric_ratio']\\n if len(_stoichiometric_ratio) != len(_elements):\\n raise ValueError(\\\"stoichiometric Ratio and Elements should have the same size!\\\")\\n \\n return True\",\n \"def is_blank( self ):\\n for bit in self.pixels:\\n if bit:\\n return False\\n # if we got here, all bits are False\\n return True\",\n \"def _is_full(self):\\n if self.allocated_spaces == self.capacity:\\n return True\\n elif self.allocated_spaces < self.capacity:\\n return False\",\n \"def isFull(self):\\n\\t\\treturn self.size == self.capacity\",\n \"def PartiallyEmpty(self):\\n return None==self.piecesToRecover\",\n \"def isFull(self) -> bool:\\n return (self.rear + 1) % self.capacity == self.front\",\n \"def is_full(self):\\n elements_in_sects = sum(\\n map(opr.attrgetter(\\\"size\\\"), self.sects.values())\\n )\\n elements_in_total = fct.reduce(\\n opr.mul, type(self).flatten_shape(self.shape), 1\\n )\\n res = elements_in_sects >= elements_in_total\\n return res\",\n \"def _check_occupied(self, col, row):\\n if self.board[row - 1][col - 1] == EMPTY:\\n return False\\n else:\\n return True\",\n \"def test_constructed_is_small(self):\\n self.assertTrue(all(elt<10 for elt in goodwinsheaf.checkradii()))#check all entries have small radii\",\n \"def isOver(self):\\n\\t\\tisFull = Piece.BLANK\\n\\t\\tfor a,b,c in [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]]:\\n\\t\\t\\tif (self.board[a] is self.board[b] is self.board[c] and self.board[a] is not Piece.BLANK):\\n\\t\\t\\t\\treturn self.board[a]\\n\\t\\t\\tif (self.board[a] is Piece.BLANK or self.board[b] is Piece.BLANK or self.board[c] is Piece.BLANK):\\n\\t\\t\\t\\tisFull = False\\n\\t\\treturn isFull\",\n \"def is_populated(self) -> bool:\\n return 0 < self.count_compounds()\",\n \"def full(self):\\n for x in range(0,3):\\n for y in range(0,3):\\n if self[x,y] is None:\\n return False\\n return True\",\n \"def is_full(self):\\n return self.remaining_space_in_hold() == 0\",\n \"def is_full(self):\\n return False\",\n \"def test_room_has_tiles(self):\\n self.assertEqual(self.room.tile_set.count(), self.room.grid_size ** 2)\",\n \"def filled(self):\\n return len(self) == self.length\",\n \"def full_board(self,p):\\n board = self.get_element(p)\\n for row in board:\\n for col in row:\\n if col == ' ':\\n return False\\n return True\",\n \"def isFull(self) -> bool:\\n return self.size == self.maxlen\",\n \"def board_tiles_availability(self):\\n for row in range(GameData.rows):\\n for col in range(GameData.columns):\\n if self.board[row][col] == 0:\\n return False\\n # Game is draw, no more moves left!\\n return True\",\n \"def is_packed(self):\\n return self.__class__._packed_place_\",\n \"def check_finished_boxes(self):\\n finished_boxes = 0\\n for i in range(len(self.board)):\\n for j in range(len(self.board[i])):\\n if self.board[i][j] == \\\" \\\":\\n if self.board[i - 1][j] != \\\"\\\" and self.board[i + 1][j] != \\\"\\\" and self.board[i][j - 1] != \\\"\\\" and self.board[i][j + 1] != \\\"\\\":\\n finished_boxes += 1\\n return finished_boxes\",\n \"def is_board_valid(bd):\\n return is_rows_valid(bd) and is_cols_valid(bd) and is_sqrs_valid(bd)\",\n \"def is_full(self) -> bool:\\n pass\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def is_full(self):\\n return len(self._data) == 1\",\n \"def has_cells(self):\\n return len(self._cells) > 0\",\n \"def isComplete(self):\\n for n in range(9):\\n for m in range(9):\\n if self.puzzle[n][m] == 0:\\n return False\\n return True\",\n \"def canSwipeBase (self) :\\n for columnNbr in range(4) :\\n currentColumn = self.grid[:,columnNbr]\\n nbrNonZero = np.count_nonzero(currentColumn)\\n if nbrNonZero == 0 : #if empty, go to next\\n #print(\\\"isEmpty\\\")\\n continue\\n if nbrNonZero == 4 : #if full, go to next\\n #print(\\\"isFull\\\")\\n continue\\n\\n for lineNbr in range(3, -1 + nbrNonZero, -1) :\\n if currentColumn[lineNbr] != 0 :\\n return True\\n\\n for lineNbr in range(0, 3) :\\n if currentColumn[lineNbr] == currentColumn[lineNbr+1] :\\n return True\\n\\n return False\",\n \"def assert_data_fragments_correct(self) -> bool:\\n read_path = Path(os.environ[\\\"DATA_PATH\\\"]) / \\\"fragments\\\"\\n if not read_path.exists():\\n return False\\n bin_images = [img for img in read_path.iterdir() if \\\"binarized\\\" in img.name]\\n if len(bin_images) == 0:\\n return False\\n return True\",\n \"def isTileBlank(tile):\\n for b in tile:\\n if b: return False\\n return True\",\n \"def check(self):\\n for row in self.grid:\\n for i in range(1, 10):\\n if row.count(i) != 1:\\n return False\\n\\n for col in range(9):\\n lst = [row[col] for row in self.grid]\\n for i in range(1, 10):\\n if lst.count(i) != 1:\\n return False\\n \\n for i in range(3):\\n for j in range(3):\\n lst = [row[j* 3:(j*3) + 3] for row in self.grid[i * 3:(i*3) + 3]] \\n flat_list = []\\n for k in lst:\\n for number in k:\\n flat_list.append(number)\\n \\n for check_number in range(1, 10):\\n if flat_list.count(check_number) != 1:\\n return False\\n return True\",\n \"def _is_tie(self):\\n for y in range(self.size_y):\\n for x in range(self.size_x):\\n piece = self.get_piece_at_opening(x, y)\\n if piece == Piece.NONE:\\n return False\\n return True\",\n \"def is_full(self):\\n # If at least one of the columns permits a move, then the board is\\n # not full\\n for i in range(self.width):\\n if self.allows_move(i):\\n return False\\n return True\",\n \"def full(self):\\n return self._current_size == self._size\",\n \"def isFull(self) -> bool:\\n q, k, front, rear, empty = self.q, self.k, self.front, self.rear, self.empty\\n\\n if front == rear and not empty:\\n return True\\n\\n return False\",\n \"def check_won(grid):\\r\\n for i in range(len(grid)):\\r\\n for j in range(len(grid[i])):\\r\\n if grid[i][j] >= 32:\\r\\n return True \\r\\n return False\",\n \"def _area_is_empty(self, screen: Screen, write_position: WritePosition) -> bool:\\n wp = write_position\\n\\n for y in range(wp.ypos, wp.ypos + wp.height):\\n if y in screen.data_buffer:\\n row = screen.data_buffer[y]\\n\\n for x in range(wp.xpos, wp.xpos + wp.width):\\n c = row[x]\\n if c.char != \\\" \\\":\\n return False\\n\\n return True\",\n \"def _check_number_of_bells(self) -> bool:\\n if self.row_generator.stage == 0:\\n self.logger.debug(\\\"Place holder row generator. Wheatley will not ring!\\\")\\n return False\\n if self._tower.number_of_bells < self.row_generator.stage:\\n self.logger.warning(f\\\"Row generation requires at least {self.row_generator.stage} bells, \\\"\\n + f\\\"but the current tower has {self._tower.number_of_bells}. \\\"\\n + \\\"Wheatley will not ring!\\\")\\n return False\\n if self._tower.number_of_bells > self.row_generator.stage + 1:\\n if self.row_generator.stage % 2:\\n expected = self.row_generator.stage + 1\\n else:\\n expected = self.row_generator.stage\\n self.logger.info(f\\\"Current tower has more bells ({self._tower.number_of_bells}) than expected \\\"\\n + f\\\"({expected}). Wheatley will add extra cover bells.\\\")\\n return True\",\n \"def tied(self):\\n for (x, y) in self.fields:\\n if self.fields[x, y] == self.empty:\\n return False\\n return True\",\n \"def full(self):\\n return self.size >= self.maxsize\",\n \"def test_is_filled(self):\\n n = 10\\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\\n not_matrix = g.np.logical_not(matrix)\\n pitch = 1. / n\\n origin = g.np.random.uniform(size=(3,))\\n vox = g.trimesh.voxel.VoxelGrid(matrix)\\n vox = vox.apply_scale(pitch).apply_translation(origin)\\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\\n for a, b in ((vox, not_vox), (not_vox, vox)):\\n points = a.points\\n # slight jitter - shouldn't change indices\\n points += (\\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\\n g.np.random.shuffle(points)\\n\\n # all points are filled, and no empty points are filled\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\\n\\n # test different number of dimensions\\n points = g.np.stack([points, points[-1::-1]], axis=1)\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\",\n \"def test_room_has_tiles(self):\\n self.assertGreaterEqual(self.room.tile_set.count(), 2)\",\n \"def _unbalanced(self):\\n if self.internal():\\n if self.full():\\n if abs(self._leftchild._height-self._rightchild._height) >= 2:\\n return True\\n elif self._leftchild and not self._rightchild:\\n if self._leftchild._height >= 2:\\n return True\\n elif self._rightchild._height >= 2:\\n return True\\n return False\",\n \"def isFull(self) -> bool:\\n return self.count == self.capacity\",\n \"def isFull(self) -> bool:\\n return self.count == self.capacity\",\n \"def _check_dimensions(self, workspace_to_check):\\n for i in range(self._raw_ws.getNumDims()):\\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\\n return False\\n return True\",\n \"def any_empty_tiles(self):\\n for i in range(self.TILES_PER_ROW):\\n for j in range(self.TILES_PER_ROW):\\n if self.main_grid_values[i][j] == 0:\\n return True\\n\\n return False\",\n \"def empty(self):\\r\\n return self.stack == []\",\n \"def full(self) -> bool:\\n return self.maxsize and self.qsize() >= self.maxsize\",\n \"def full(self) -> bool:\\n\\n return (self._size == self._capacity)\",\n \"def is_tile_empty(self, y_pos, x_pos):\\n if 15 > y_pos >= 0 and 0 <= x_pos < 15:\\n return self.map[y_pos][x_pos] == ' '\\n return False\",\n \"def _is_screen(grid):\\n for e in range(grid.edges.shape[1]):\\n if len([j for i in grid.element_edges for j in i if j == e]) < 2:\\n return True\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6820874","0.676673","0.6736874","0.6717051","0.6591668","0.65669096","0.6556075","0.6527779","0.6506026","0.6469064","0.64647114","0.6442245","0.6417079","0.6390676","0.63876194","0.637983","0.6371609","0.6350671","0.6347817","0.6293271","0.62686855","0.6224456","0.62235546","0.62179506","0.6209308","0.6203418","0.6186902","0.61837053","0.6158378","0.6107692","0.6042024","0.6032656","0.60007584","0.5992219","0.59916383","0.5970232","0.5960245","0.595437","0.5950315","0.59449124","0.5929308","0.58990324","0.5898292","0.5891847","0.58907753","0.5870332","0.5868284","0.5867099","0.5858351","0.5854683","0.58467364","0.5829912","0.5826431","0.58255506","0.5820273","0.58147603","0.5809856","0.58031195","0.5801695","0.57925576","0.57730067","0.5764436","0.5763841","0.5757861","0.5756147","0.5753042","0.5752181","0.5724576","0.5723187","0.57226276","0.57162213","0.57162213","0.57150584","0.5710747","0.5705537","0.57046884","0.5700383","0.5697972","0.5696271","0.5691451","0.568059","0.5678422","0.5678409","0.5674421","0.56633043","0.5654595","0.56499654","0.56487036","0.5640999","0.5639829","0.56335163","0.56235","0.56235","0.5616815","0.560868","0.5606571","0.56059355","0.5601167","0.5600124","0.55976516"],"string":"[\n \"0.6820874\",\n \"0.676673\",\n \"0.6736874\",\n \"0.6717051\",\n \"0.6591668\",\n \"0.65669096\",\n \"0.6556075\",\n \"0.6527779\",\n \"0.6506026\",\n \"0.6469064\",\n \"0.64647114\",\n \"0.6442245\",\n \"0.6417079\",\n \"0.6390676\",\n \"0.63876194\",\n \"0.637983\",\n \"0.6371609\",\n \"0.6350671\",\n \"0.6347817\",\n \"0.6293271\",\n \"0.62686855\",\n \"0.6224456\",\n \"0.62235546\",\n \"0.62179506\",\n \"0.6209308\",\n \"0.6203418\",\n \"0.6186902\",\n \"0.61837053\",\n \"0.6158378\",\n \"0.6107692\",\n \"0.6042024\",\n \"0.6032656\",\n \"0.60007584\",\n \"0.5992219\",\n \"0.59916383\",\n \"0.5970232\",\n \"0.5960245\",\n \"0.595437\",\n \"0.5950315\",\n \"0.59449124\",\n \"0.5929308\",\n \"0.58990324\",\n \"0.5898292\",\n \"0.5891847\",\n \"0.58907753\",\n \"0.5870332\",\n \"0.5868284\",\n \"0.5867099\",\n \"0.5858351\",\n \"0.5854683\",\n \"0.58467364\",\n \"0.5829912\",\n \"0.5826431\",\n \"0.58255506\",\n \"0.5820273\",\n \"0.58147603\",\n \"0.5809856\",\n \"0.58031195\",\n \"0.5801695\",\n \"0.57925576\",\n \"0.57730067\",\n \"0.5764436\",\n \"0.5763841\",\n \"0.5757861\",\n \"0.5756147\",\n \"0.5753042\",\n \"0.5752181\",\n \"0.5724576\",\n \"0.5723187\",\n \"0.57226276\",\n \"0.57162213\",\n \"0.57162213\",\n \"0.57150584\",\n \"0.5710747\",\n \"0.5705537\",\n \"0.57046884\",\n \"0.5700383\",\n \"0.5697972\",\n \"0.5696271\",\n \"0.5691451\",\n \"0.568059\",\n \"0.5678422\",\n \"0.5678409\",\n \"0.5674421\",\n \"0.56633043\",\n \"0.5654595\",\n \"0.56499654\",\n \"0.56487036\",\n \"0.5640999\",\n \"0.5639829\",\n \"0.56335163\",\n \"0.56235\",\n \"0.56235\",\n \"0.5616815\",\n \"0.560868\",\n \"0.5606571\",\n \"0.56059355\",\n \"0.5601167\",\n \"0.5600124\",\n \"0.55976516\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74219203"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9292,"cells":{"query":{"kind":"string","value":"Checks for empty spaces in the tags list. If the empty space is found it's coordinates are being packed into tuple and into new list."},"document":{"kind":"string","value":"def check_for_moves(self) -> list:\r\n avail_moves = []\r\n for x in range(self.size):\r\n for y in range(self.size):\r\n if self.tags[x][y] is None:\r\n avail_moves.append((x, y))\r\n return avail_moves"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _preprocess(self, tagged: List[Tuple]) -> Tuple:\n ori = \" \".join([tag[0] for tag in tagged])\n tags = [tag[1] for tag in tagged]\n # Mapping into general tagset\n tags = [self._map[tag] if tag in self._map else \"X\" for tag in tags]\n return \" \".join(tags), ori","def empty_spots(self):\n\t\tret = []\n\t\tfor i in range(0, self.size):\n\t\t\tfor j in range(0, self.size):\n\t\t\t\tif(self.grid[i][j] == self.terminal):\n\t\t\t\t\tret.append((i,j))\n\t\treturn ret","def make_empty_lists(tags):\n all_lists = {}\n\n #these are the first ones listed in sub groups of tags\n main_tags = []\n\n #if no nested groups of tags, this will work:\n ## all_tags = tags.split()\n ## for tag in all_tags:\n ## all_lists[tag] = []\n\n all_tags = parse_tags(tags)\n for tag in all_tags:\n if isinstance(tag, list):\n main_tags.append(tag[0])\n shared_list = []\n for sub_tag in tag:\n all_lists[sub_tag] = shared_list\n else:\n main_tags.append(tag)\n all_lists[tag] = []\n\n #pick up unmatched tags that have a '+' in any tag:\n all_lists['good'] = []\n main_tags.append('good')\n #for everything else:\n all_lists['misc'] = []\n main_tags.append('misc')\n\n return all_lists, main_tags","def clean_nodes_no_names(tag, data):\n\tif not isinstance(tag, tuple):\n\t\tfor each in data:\n\t\t\tif each['k'] != [] and each['v'] != []:\n\t\t\t\tif tag in each['k'] and 'name' not in each['k']:\n\t\t\t\t\teach['removed'] = 'true'\n\t\t\t\t\ttagValueData = dict(zip(each['k'], each['v']))\n\t\t\t\t\tif tagValueData.get('amenity') == 'atm':\n\t\t\t\t\t\teach['removed'] = 'false'\n\t\t\tyield each\n\telse:\n\t\tfor each in data:\n\t\t\tif each['k'] != [] and each['v'] != []:\n\t\t\t\tif tag[0] in each['k'] and tag[1] in each['v'] and 'name' not in each['k']:\n\t\t\t\t\teach['removed'] = 'true'\n\t\t\tyield each","def validateTags(self, tags):\n\t\treturn tags.replace(', ',' ')","def sanitise_tags(tags):\n\n # hack out all kinds of whitespace, then split on ,\n # if you run into more illegal characters (simplenote does not want to sync them)\n # add them to the regular expression above.\n illegals_removed = tags_illegal_chars.sub('', tags)\n if len(illegals_removed) == 0:\n # special case for empty string ''\n # split turns that into [''], which is not valid\n return []\n\n else:\n return illegals_removed.split(',')","def autoreveal_empty_spaces(self, position):\n revealed = []\n zero_spaces = []\n check_stack = [position]\n checked = []\n\n while len(check_stack) > 0:\n pos = x, y = check_stack.pop()\n if self.get_num_mines_around_position(x, y) == 0:\n zero_spaces.append(pos)\n \n # Add spaces around\n for ay in range(y-1, y+2):\n for ax in range(x-1, x+2):\n if ay >= 0 and ax >= 0 and ay < len(self.mine_map) and ax < len(self.mine_map[ay]): # Don't check spaces that are outside of the array\n apos = ax, ay\n if apos not in checked:\n check_stack.append(apos)\n revealed.append(apos)\n checked.append(pos)\n \n self.revealed.extend(revealed)","def find_empty_space(self, state):\r\n for i in range(3):\r\n for j in range(3):\r\n if state[i][j] == 0:\r\n return (i, j)","def _postprocess(self, tags: List[str], words: List[str], pos: List[str]):\n result = list()\n\n i = 0\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n if pos:\n result.append(f\"{words[i]}/{pos[i]}\")\n else:\n result.append(words[i])\n i += 1\n else:\n result.append(tag)\n\n return \" \".join(result)","def process_tags(tags=list):\n new_tag_list = list()\n for tag in tags:\n new_tag = tag.replace(\"<\", \" \")\n new_tag = new_tag.replace(\">\", \" \")\n new_tag = new_tag.split()\n # sort elements by string length (this to avoid 'c' being checked before 'c++', etc)\n new_tag.sort(key=len, reverse=True)\n new_tag_list.append(new_tag)\n return new_tag_list","def get_empty_positions(self):\n\n empty_positions = []\n\n for i in range(self._dimension):\n for j in range(self._dimension):\n if self._board[i][j] == ' ':\n empty_positions.append((i, j))\n\n return empty_positions","def get_empty_cells(grid):\n\tempty = []\n\tfor j,row in enumerate(grid):\n\t\tfor i,val in enumerate(row):\n\t\t\tif not val:\n\t\t\t\tempty.append((j,i))\n\treturn empty","def _postprocess(\n self,\n tags: List[str],\n words: List[str],\n pos: bool = False,\n ):\n result = list()\n\n i = 0\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n if pos:\n result.append(f\"{words[i]}/{pos[i]}\")\n else:\n result.append(words[i])\n i += 1\n else:\n result.append(tag)\n\n return \" \".join(result)","def get_empty_cells(grid):\n empty = []\n for j,row in enumerate(grid):\n for i,val in enumerate(row):\n if not val:\n empty.append((j,i))\n return empty","def normalized_pos_tags(self):\n pos_list = []\n for pos in self.pos_tags:\n pos_list.extend([i for i in re.split('[:;]', pos) if i != ''])\n return pos_list","def mps_null_spaces(mpslist):\n AL, C, AR = mpslist\n d, chi, _ = AL.shape\n NLshp = (d, chi, (d-1)*chi)\n ALdag = fuse_left(AL).T.conj()\n NLm = null_space(ALdag)\n NL = NLm.reshape(NLshp)\n\n ARmat = fuse_right(AR)\n NRm_dag = null_space(ARmat)\n NRm = NRm_dag.conj()\n NR = NRm.reshape((d, chi, (d-1)*chi))\n NR = NR.transpose((0, 2, 1))\n return (NL, NR)","def _filter_empty(lst):\n return [cell for cell in lst if cell is not Sudoku.EMPTY_CELL]","def test_format_bad_tags(self):\n tags = self.c._format_tags(None)\n self.assertEqual(0, len(tags))","def find_empty_space(board: list) -> tuple:\n board_length = len(board)\n for i in range(board_length):\n for j in range(board_length):\n if board[i][j] == 0:\n return (i,j)","def _py3_safe(parsed_list):\n if len(parsed_list) < 2:\n return parsed_list\n else:\n new_list = [parsed_list[0]]\n nl_append = new_list.append\n for before, after in py23_zip(islice(parsed_list, 0, len(parsed_list)-1),\n islice(parsed_list, 1, None)):\n if isinstance(before, Number) and isinstance(after, Number):\n nl_append(\"\")\n nl_append(after)\n return tuple(new_list)","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def empty_cells(self) -> List[Cell]:\n return list(ob.pos[0] for ob in self.new_obs())","def splitTags(user_input):\n \n elements = []\n if ',' in user_input:\n elements = user_input.split(',')\n elif ' ' in user_input:\n elements = user_input.split(' ')\n else:\n elements.append(user_input)\n\n tags = []\n for element in elements:\n element = element.strip(' \\t\\n\\r').lower()\n if(len(element) == 0): continue\n if element not in tags:\n tags.append(element)\n return tags","def expand_empty_tags(tokens, keep_minimized=None):\n for token in tokens:\n if isinstance(token, Empty):\n if keep_minimized and token.name in keep_minimized:\n yield token\n else:\n token.__class__ = Start\n token.reserialize()\n yield Start(token.xml.replace('/', ''))\n yield End('</%s>' % token.name)\n else:\n yield token","def next_empty(checker): # checker is dictionary\n min_len = 100 # arbitrary large assignment\n position = ' '\n values = []\n for element in checker:\n if len(checker[element]) < min_len:\n min_len = len(checker[element])\n position = element\n values = checker[element]\n return position, values","def get_empty_tiles(self) -> List[Point]:\n\t\tempty_tiles = []\n\t\tfor x in range(self.size):\n\t\t\tfor y in range(self.size):\n\t\t\t\tif self.tiles[x][y] == 0:\n\t\t\t\t\tempty_tiles.append(Point(x,y))\n\t\treturn empty_tiles","def make_free_cell_list():\r\n for row in range(9):\r\n for col in range(9):\r\n if (application.ui.__getattribute__(f'cell{col+1}{row+1}')).text() == \"\":\r\n lst_free_cells.append(Point(row, col))","def clean_recording_gaps(self, pos_xy: np.ndarray, pos_times: np.ndarray):\n (\n position_gap_inds_above_threshold\n ) = self.check_for_position_gaps_above_threshold(pos_times)\n cleaned_pos_xy = pos_xy[:]\n for ind in position_gap_inds_above_threshold:\n cleaned_pos_xy[ind - 5 : ind + 5] = np.nan\n return (cleaned_pos_xy, position_gap_inds_above_threshold)","def _genPosTags(self, tagged):\n return [pos for (token, pos) in tagged]","def tags(self):\n return tuple([x.strip() for x in self._dict.get('tags').split(',')])","def parser(self):\n hold = [i for i, val in enumerate(self.board) if val != self.empty and val.colour == BLACK]\n hold2 = [i for i, val in enumerate(self.board) if val != self.empty and val.colour == WHITE]\n \n #This is why dictionaries are better\n black_coords = []\n white_coords = []\n \n for i in hold:\n black_coords.append(self.coords[i])\n\n for i in hold2:\n white_coords.append(self.coords[i])\n \n return black_coords, white_coords","def add_ignore_empty(x, y):\n\n def _ignore(t):\n return t is None or (isinstance(t, tuple) and len(t) == 0)\n\n if _ignore(y):\n return x\n elif _ignore(x):\n return y\n else:\n return x + y","def _fix_treetags(self, tree):\n for element in tree:\n element.tag = element.tag.split('}')[1]\n if len(element.getchildren()) > 0:\n self._fix_treetags(element)\n return tree","def _transform_known_tags(self):\n self.missing_known_tags = []\n\n for k, tf in self._known_tags.items():\n v = self.tags.get(k, [])\n if not v:\n self.missing_known_tags.append(k)\n continue\n\n if len(v) > 1:\n raise Exception(f\"multiple instances of tag {k}\")\n\n setattr(self, k, v[0])","def tags_list_should_have_no_duplicates(context):\n assert context.tags\n # converting a list to a set will remove all the duplicates\n # then we need to:\n # * convert it back to a list\n # * sort both lists\n # and finally compare both lists\n unique_tags = list(set(context.tags))\n assert sorted(context.tags) == sorted(unique_tags)\n logging.debug(\n 'Saved list of all tags does not contain duplicates:\\n%s',\n pformat(sorted(context.tags)))","def empty(self):\n return [cell for cell in self.compact if not cell.peg]","def get_empty_square(self) -> list:\n empty_square = []\n for line_index in range(len(self.grid)):\n for col_index in range(len(self.grid[line_index])):\n if self.grid[line_index][col_index].color is None:\n empty_square.append((line_index, col_index))\n\n return empty_square","def empty_cells(state):\r\n cells = []\r\n for x, row in enumerate(state):\r\n for y, cell in enumerate(row):\r\n if cell == 0:\r\n cells.append([x, y])\r\n\r\n return cells","def get_empty_squares(self):\n empty = []\n for row in range(self._dim):\n for col in range(self._dim):\n if self._board[row][col] == EMPTY:\n empty.append((row, col))\n return empty","def check_for_whitespace(data):\n for keys, value in data.items():\n if keys != 'tags':\n if not value.strip():\n abort(make_response(jsonify({\n 'status': 400,\n 'error':'{} field cannot be left blank'.format(keys)}), 400))\n if keys == 'tags':\n for tags in data['tags']:\n if not tags.strip():\n abort(make_response(jsonify({\n 'status': 400,\n 'error':'tags field cannot be left blank'}), 400))\n return True","def getEmpty(self):\n emptyList = []\n for spot in self.parkingSpots:\n if spot.status == 'empty':\n emptyList.append(spot)\n return emptyList","def find_empty(puzzle):\r\n empty_squares = []\r\n for y in range(len(puzzle.squares)):\r\n for x in range(len(puzzle.squares[0])):\r\n if puzzle.squares[y][x].is_editable() is True:\r\n empty_squares.append((x, y))\r\n return empty_squares","def __wrap_with_tuple(self) -> tuple:\r\n l = list()\r\n length = len(self.data)\r\n while self.idx < length:\r\n l.append(self.__parse())\r\n return tuple(l)","def discardBlanks (texts, scores):\n\tnew_texts = []\n\tnew_scores = []\n\tfor i,text in enumerate(texts):\n\t\tif text != '' or text != ' ':\n\t\t\tnew_texts.append(text)\n\t\t\tnew_scores.append(scores[i])\n\treturn new_texts,new_scores","def _canProcessTags(self, grammar, pos_tags):\n badTags = []\n for tag in pos_tags:\n if tag not in grammar.tags:\n badTags.append(tag)\n logger.debug(\"Grammar can't handle tag:\" + tag)\n if badTags:\n return False\n else:\n return True","def split_commaseparated_tags(cls, commaseparatedtags):\n if commaseparatedtags.strip() == '':\n return []\n else:\n return [\n cls.normalize_tag(tagstring)\n for tagstring in list([_f for _f in re.split(r'[,\\s]', commaseparatedtags) if _f])]","def _clean_list(self, items):\n itemlist = list(filter(None, items))\n if len(itemlist) < 3:\n itemlist.append(\"\")\n return itemlist\n\n return itemlist","def getNonEmptyCells(self):\n nonemptys = []\n for ri in range(self.nRow):\n for ci in range(self.nCol):\n val = self.vals[ri][ci]\n if not self.isEmpty(val):\n row = ri+1\n col = ci+1\n nonemptys.append(CellDesc(row=row, col=col, val=val))\n return nonemptys","def clean(self):\n for i in range(len(self.asteroid_type) - 1, -1, -1):\n x, y = self.get_coords(self.asteroid_type[i])\n if x < -self.gap:\n self.del_asteroid(i)","def build_all(nodes=[]):\n\n if nodes:\n nodes = [n for n in mc.ls(nodes) if mc.objExists(n+'.tagSpaces')]\n else:\n nodes = mc.ls('*.tagSpaces')\n nodes = [n.replace('.tagSpaces','') for n in nodes if mc.getAttr(n)]\n\n for node in nodes:\n space_obj = Space(node)\n space_obj.build_space()","def fill_in_empty_tags(prior, tags):\n print \"filling in empty entries for tags\"\n for key in tags:\n if not key in prior:\n prior[key] = {}\n for key1 in tags:\n for key2 in tags:\n prior[key1].setdefault(key2, 0.0)","def _fix_examples(examples):\n if len(examples) > 0 and len(examples[0]) > 0 and len(examples[0][0]) > 2:\n # Assumes all elements use the same format of tuple of length 3 (so we only check [0][0])\n return [\n [(tuple_ex[0], tuple_ex[1]) for tuple_ex in example]\n for example in examples\n ]\n else:\n return examples","def filter_empty(word_list):\n new_list = []\n for x in word_list:\n if(x):\n new_list.append(x)\n return new_list","def _get_available_spaces(world):\n spaces = []\n for y, row in enumerate(world):\n for x, column in enumerate(row):\n if column == eg.NONE:\n spaces.append((x, y))\n\n return spaces","def test_merge_list_empty(short_ll, empty_ll):\n assert ml(short_ll, empty_ll) == 8\n assert len(short_ll) == 4","def cleanup(self):\n for element in self.root.iter():\n element.tag = element.tag.partition('}')[-1]","def pad_tuple_list(cls, tuple_list, pad_len):\n\n return [tuple(x)+('',)*(pad_len-len(x)) for x in tuple_list]","def validate(self):\n for search_tag_name in self.get_search_tag_names():\n search_tag_obj = Tag(search_tag_name)\n for search_tag_value in self.get_search_tag_values(search_tag_name):\n for new_tag_name in self.get_new_tag_names(search_tag_name, search_tag_value):\n new_tag_obj = Tag(new_tag_name)\n new_tag_value = self.get_new_tag_value(search_tag_name, search_tag_value, new_tag_name)\n if new_tag_obj.repeatable:\n if not isinstance(new_tag_value, list):\n raise KeyError('%s needs a list'%(new_tag_name))\n else:\n if isinstance(new_tag_value, list):\n raise KeyError('%s needs a scalar value'%(new_tag_name))","def __iter__(self):\n for item in(self.data_):\n if(item!= None):#We dont want to yield spaces that have not been filled yet \n yield item","def filtered_xyz(self) -> tuple[int, int, int]:","def _align_tagged_sentence(self, ne_tagged_sentence):\n omitted_tokens = self.task_config[\"OMITTED_TOKENS_FOR_ALIGNMENT\"]\n\n return [\n (word, tag)\n for word, tag in ne_tagged_sentence\n if word not in omitted_tokens\n ]","def change_tags_format(page_tags):\n\treturn [tags.replace('\\n', ', ') if not tags == None else None for tags in page_tags]","def process_dictionary(self, _list):\n try:\n del _list[_list.index('<unknown>')]\n except ValueError:\n pass\n\n try:\n del _list[_list.index('<unk>')]\n except ValueError:\n pass\n _list.insert(0, '<pad>')\n _list.insert(0, '<unknown>')\n\n return _list","def clean_tag(elmt_with_commas, max_lenght):\r\n elmt_list = elmt_with_commas.split(\",\")\r\n elmt_list = [e.strip() for e in elmt_list if len(e) < max_lenght]\r\n return elmt_list","def remove_empty(ifiles, xvar, yvar):\r\n\r\n # Do nothing if keyword '_bbox' not in file name \r\n if '_bbox' not in ifiles[0]:\r\n return ifiles\r\n\r\n ifiles_ = []\r\n for ifile in ifiles:\r\n\r\n with h5py.File(ifile, 'r') as fi:\r\n lon = fi[xvar][:]\r\n lat = fi[yvar][:]\r\n\r\n bbox = get_bbox(ifile)\r\n proj = get_proj(ifile)\r\n\r\n xmin, xmax, ymin, ymax = bbox\r\n\r\n x, y = transform_coord('4326', proj, lon, lat)\r\n\r\n idx, = np.where( (x >= xmin) & (x <= xmax) & \r\n (y >= ymin) & (y <= ymax) )\r\n \r\n if len(idx) > 0:\r\n ifiles_.append(ifile)\r\n\r\n return ifiles_","def _make_list_islot_otuples_from_nodelist(self):\n if self.node_list is None:\n raise ValueError(\"`node_list` attribute undefined\")\n return [[('loc', 'scale')] for _ in self.node_list]","def board_empty_positions(self, x, y):\n board = self.boards[x][y]\n coords = [(x, y, i, j) for (i, j) in board.empty_squares]\n return self.coords_to_positions(coords)","def find_empty(self):\n min_num_choices = 10\n ret_x, ret_y = (-1, -1)\n\n for x in range(0, 9):\n for y in range(0, 9):\n if self.field[x][y] != -1:\n continue\n\n if (min_num_choices > len(self.choices[x][y])):\n min_num_choices = len(self.choices[x][y])\n ret_x = x\n ret_y = y\n\n return (ret_x, ret_y)","def test_parse_restricted_tags():\n invalid_tags = {'*', '**', '***', 'a*', '*a', 'a*a*', '*a*a', '*aa*', 'a**a', '}'}\n combined_tags = valid_tags | invalid_tags\n\n # Function under test\n resultant_tags = searchtag.parse_restricted_tags(\" \".join(combined_tags))\n\n # Verify that we have the tags in the valid list\n assert resultant_tags == valid_tags","def get_empty_slots(self):\n slots = np.reshape(range(0, self.size * self.size), (self.size, self.size))\n\n return slots[~self.tiles_taken]","def pos_tag(self,sentence):\n tagged = self.brill_tagger.tag(sentence.split())\n tagged_sentence = \" \".join([nltk.tag.tuple2str(tok) for tok in tagged])\n print tagged_sentence\n\n tag_list = [(each.split(\"/\")[0],each.split(\"/\")[1]) for each in tagged_sentence.split()]\n return tag_list","def is_tile_empty(self, y_pos, x_pos):\n if 15 > y_pos >= 0 and 0 <= x_pos < 15:\n return self.map[y_pos][x_pos] == ' '\n return False","def _convert_tags_to_wordpiece_tags(tags: List[str], offsets: List[int]) -> List[str]:\n new_tags = []\n j = 0\n for i, offset in enumerate(offsets):\n tag = tags[i]\n is_o = tag == \"O\"\n is_start = True\n while j < offset:\n if is_o:\n new_tags.append(\"O\")\n\n elif tag.startswith(\"I\"):\n new_tags.append(tag)\n\n elif is_start and tag.startswith(\"B\"):\n new_tags.append(tag)\n is_start = False\n\n elif tag.startswith(\"B\"):\n _, label = tag.split(\"-\", 1)\n new_tags.append(\"I-\" + label)\n j += 1\n\n # Add O tags for cls and sep tokens.\n return [\"O\"] + new_tags + [\"O\"]","def nonull(inputlist):\n return clean(inputlist, isnull, True)","def phrase_list_filler():\n return (Parse.word('we').possibly() + first_word('put write have know see') + \n Parse.word('that').possibly()).nil()","def check_end(self) -> Optional[List[Point]]:\n\t\tfor x in range(self.size):\n\t\t\tfor y in range(self.size):\n\t\t\t\tif not self.tiles[x][y] == 0:\n\t\t\t\t\tresult = self.check_around(x, y)\n\t\t\t\t\tif result is not None:\n\t\t\t\t\t\treturn result\n\t\tif len(self.get_empty_tiles()) == 0:\n\t\t\treturn []\n\t\treturn None","def empty_tuple():\n empty = ()\n print(type(empty)) # <type 'tuple'>","def not_empty(entry):\n gt_boxes = entry['boxes']\n return gt_boxes.shape[0] > 0","def _ConsolidateKnownOverlappingTags(self, typ_tags: FrozenSet[str]\n ) -> FrozenSet[str]:\n return typ_tags","def _convert_tags_to_wordpiece_tags(tags: List[str], offsets: List[int]) -> List[str]:\r\n new_tags = []\r\n j = 0\r\n for i, offset in enumerate(offsets):\r\n tag = tags[i]\r\n is_o = tag == \"O\"\r\n is_start = True\r\n while j < offset:\r\n if is_o:\r\n new_tags.append(\"O\")\r\n\r\n elif tag.startswith(\"I\"):\r\n new_tags.append(tag)\r\n\r\n elif is_start and tag.startswith(\"B\"):\r\n new_tags.append(tag)\r\n is_start = False\r\n\r\n elif tag.startswith(\"B\"):\r\n _, label = tag.split(\"-\", 1)\r\n new_tags.append(\"I-\" + label)\r\n j += 1\r\n\r\n # Add O tags for cls and sep tokens.\r\n return [\"O\"] + new_tags + [\"O\"]","def parse(m: tuple):\n directions = ['across', 'down']\n word = list() # Used to store the word we're working on\n word_list = list() # Stores the growing list of words\n\n for direction in directions:\n\n for y in range(len(m)): # number of rows (size of outer tuple)\n # word = list() # todo: can probably be deleted as word is reset at end of row already\n\n for x in range(len(m[0])): # number of columns (size of inner tuple)\n\n if direction == 'down': # flips so x is rows and y is columns if we are reading down\n x, y = y, x\n\n square = matrix[y][x]\n\n if square != 0: # Encountered a letter\n if len(word) == 0:\n word.append((direction, y, x), ) # If start of a word, start with direction & coordinates\n word.append(square) # First letter\n\n if direction == 'down': # flips x and y back before we reach the loop tests\n x, y = y, x\n\n if square == 0 or x == 10: # Encountered a blank space\n if len(word) > 3: # Then we collected a word and have come to the end of it\n word_list.append(word) # Add it to the list of words\n word = list() # Reset word\n\n word = list()\n\n return word_list","def space_join(*items):\n valid_items = []\n for item in items:\n if item is None:\n continue\n if isinstance(item, tuple):\n if item[0] is None:\n continue\n stripped = strip_if_not_blank(item[0])\n if not is_null(stripped):\n if len(item) == 2:\n if not is_null(item[1]):\n valid_items.append(\"%s%s\" % (item[1], stripped))\n else:\n valid_items.append(stripped)\n elif len(item) >= 3:\n if not is_null(item[1]) and not is_null(item[2]):\n valid_items.append(\"%s%s%s\" % (\n item[1], stripped, item[2]))\n elif not is_null(item[1]):\n valid_items.append(\"%s%s\" % (item[1], stripped))\n elif not is_null(item[2]):\n valid_items.append(\"%s%s\" % (stripped, item[2]))\n else:\n stripped = strip_if_not_blank(item)\n if stripped != \"\":\n valid_items.append(stripped)\n return \" \".join(valid_items)","def store_empty_graphic_box(self):\n for box in self.laby.empty_box():\n x = box[0] * 40\n y = box[1] * 40\n self.store_emptyBox.append((y, x))\n return self.store_emptyBox","def wordoftuples_to_tupleofwords(wordoftuples):\n if not equal(len(t) for t in wordoftuples):\n raise ValueError(\"Not all entries of input have the same length.\")\n def remove_empty_letters(word):\n return [letter for letter in word if letter is not None]\n return tuple(remove_empty_letters(word)\n for word in zip(*wordoftuples))","def find_free_ortho_spaces(self):\r\n for pos, ortho in ORTHOGONAL_POSITIONS.items():\r\n if self.board[pos[0]][pos[1]].color != 0:\r\n for p in ortho:\r\n if self.board[p[0]][p[1]].color == 0:\r\n if (pos[0], pos[1]) in self.free_pos.keys():\r\n self.free_pos[(pos[0], pos[1])].add(p)\r\n else:\r\n self.free_pos[(pos[0], pos[1])] = {p}","def known_safes(self):\n #if the bomb count is zero\n if(self.count == 0):\n #all spaces are safe, which returns all spots that are safe\n return (self.cells)\n else:\n return set()","def _set_list_tuple_only_structure(self, key):\n ## Change to list and whatever it was\n self.set_neighs([e[0] for e in key])\n self.set_sp_rel_pos([e[1] for e in key])","def clean_coordinates(coords, silent=False):\n l1 = len(coords)\n coords = coords[~N.isnan(coords).any(axis=1)] # remove NaN values\n l2 = len(coords)\n if not silent:\n msg = \"{0} coordinates\".format(l2)\n if l2 < l1:\n msg += \" ({0} removed as invalid)\".format(l1-l2)\n print(msg)\n return coords","def test_merge_list_empty_first(empty_ll, short_ll):\n assert ml(empty_ll, short_ll) == 8\n assert len(short_ll) == 4","def test_insertion_for_each_element_in_iterable_tuple(empty_list):\n b = (1, 2, 3)\n bb = LinkedList([])\n bb.insert(b)\n assert len(bb) == 3","def filled_positions(self):\n return [x for x in assignable_positions if self.grid[x][0]]","def cleanup(self):\n for j in range(len(self.endTagList)):\n self.result = self.result + self.endTagList[j]","def _empty(self, w_beg, w_end):\n\n tmp = np.arange(w_beg + self.pre_pad,\n w_end - self.post_pad + (1 / self.sampling_rate),\n 1 / self.sampling_rate)\n daten = [x.datetime for x in tmp]\n\n max_coa = max_coa_norm = np.full(len(daten), 0)\n\n coord = np.full((len(daten), 3), 0)\n\n return daten, max_coa, max_coa_norm, coord","def get_empty_cells(board):\n empty_cells = [idx for idx, e in enumerate(board) if e == ' ']\n return empty_cells","def non_empty_children(self) -> Tuple[CombinatorialClassType, ...]:\n if self._non_empty_children is None:\n self._non_empty_children = tuple(\n child for child in self.children if not child.is_empty()\n )\n return self._non_empty_children","def remove_empty(data):\n out = []\n for item in data:\n if item == '':\n continue\n out.append(item)\n return out","def getSpaceTokenList(token, listSEs, jobCloud, analysisJob, fileListLength, si, alt=False):\n\n # check if there are any space tokens\n if token == [''] and fileListLength > 1:\n # correct length of empty list\n token = token*fileListLength\n tolog(\"Corrected length of empty space token list from 0 to %d\" % len(token))\n\n # no space tokens for tier 3s\n if not si.isTier3():\n token_list = getProperSpaceTokenList(token, listSEs, jobCloud, analysisJob, alt=alt)\n else:\n token_list = None\n\n return token_list","def _normalize_together(self, together):\n if not together:\n return []\n\n if not isinstance(together[0], (tuple, list)):\n together = (together,)\n\n return [\n tuple(item)\n for item in together\n ]","def checked_positions():\n for base_position in chain([me.shipyard], me.get_dropoffs()):\n x_shipyard = base_position.position.x\n y_shipyard = base_position.position.y\n for x in range(-search_range, search_range):\n for y in range(-search_range, search_range):\n yield hlt.Position(\n x=x_shipyard + x,\n y=y_shipyard + y)"],"string":"[\n \"def _preprocess(self, tagged: List[Tuple]) -> Tuple:\\n ori = \\\" \\\".join([tag[0] for tag in tagged])\\n tags = [tag[1] for tag in tagged]\\n # Mapping into general tagset\\n tags = [self._map[tag] if tag in self._map else \\\"X\\\" for tag in tags]\\n return \\\" \\\".join(tags), ori\",\n \"def empty_spots(self):\\n\\t\\tret = []\\n\\t\\tfor i in range(0, self.size):\\n\\t\\t\\tfor j in range(0, self.size):\\n\\t\\t\\t\\tif(self.grid[i][j] == self.terminal):\\n\\t\\t\\t\\t\\tret.append((i,j))\\n\\t\\treturn ret\",\n \"def make_empty_lists(tags):\\n all_lists = {}\\n\\n #these are the first ones listed in sub groups of tags\\n main_tags = []\\n\\n #if no nested groups of tags, this will work:\\n ## all_tags = tags.split()\\n ## for tag in all_tags:\\n ## all_lists[tag] = []\\n\\n all_tags = parse_tags(tags)\\n for tag in all_tags:\\n if isinstance(tag, list):\\n main_tags.append(tag[0])\\n shared_list = []\\n for sub_tag in tag:\\n all_lists[sub_tag] = shared_list\\n else:\\n main_tags.append(tag)\\n all_lists[tag] = []\\n\\n #pick up unmatched tags that have a '+' in any tag:\\n all_lists['good'] = []\\n main_tags.append('good')\\n #for everything else:\\n all_lists['misc'] = []\\n main_tags.append('misc')\\n\\n return all_lists, main_tags\",\n \"def clean_nodes_no_names(tag, data):\\n\\tif not isinstance(tag, tuple):\\n\\t\\tfor each in data:\\n\\t\\t\\tif each['k'] != [] and each['v'] != []:\\n\\t\\t\\t\\tif tag in each['k'] and 'name' not in each['k']:\\n\\t\\t\\t\\t\\teach['removed'] = 'true'\\n\\t\\t\\t\\t\\ttagValueData = dict(zip(each['k'], each['v']))\\n\\t\\t\\t\\t\\tif tagValueData.get('amenity') == 'atm':\\n\\t\\t\\t\\t\\t\\teach['removed'] = 'false'\\n\\t\\t\\tyield each\\n\\telse:\\n\\t\\tfor each in data:\\n\\t\\t\\tif each['k'] != [] and each['v'] != []:\\n\\t\\t\\t\\tif tag[0] in each['k'] and tag[1] in each['v'] and 'name' not in each['k']:\\n\\t\\t\\t\\t\\teach['removed'] = 'true'\\n\\t\\t\\tyield each\",\n \"def validateTags(self, tags):\\n\\t\\treturn tags.replace(', ',' ')\",\n \"def sanitise_tags(tags):\\n\\n # hack out all kinds of whitespace, then split on ,\\n # if you run into more illegal characters (simplenote does not want to sync them)\\n # add them to the regular expression above.\\n illegals_removed = tags_illegal_chars.sub('', tags)\\n if len(illegals_removed) == 0:\\n # special case for empty string ''\\n # split turns that into [''], which is not valid\\n return []\\n\\n else:\\n return illegals_removed.split(',')\",\n \"def autoreveal_empty_spaces(self, position):\\n revealed = []\\n zero_spaces = []\\n check_stack = [position]\\n checked = []\\n\\n while len(check_stack) > 0:\\n pos = x, y = check_stack.pop()\\n if self.get_num_mines_around_position(x, y) == 0:\\n zero_spaces.append(pos)\\n \\n # Add spaces around\\n for ay in range(y-1, y+2):\\n for ax in range(x-1, x+2):\\n if ay >= 0 and ax >= 0 and ay < len(self.mine_map) and ax < len(self.mine_map[ay]): # Don't check spaces that are outside of the array\\n apos = ax, ay\\n if apos not in checked:\\n check_stack.append(apos)\\n revealed.append(apos)\\n checked.append(pos)\\n \\n self.revealed.extend(revealed)\",\n \"def find_empty_space(self, state):\\r\\n for i in range(3):\\r\\n for j in range(3):\\r\\n if state[i][j] == 0:\\r\\n return (i, j)\",\n \"def _postprocess(self, tags: List[str], words: List[str], pos: List[str]):\\n result = list()\\n\\n i = 0\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n if pos:\\n result.append(f\\\"{words[i]}/{pos[i]}\\\")\\n else:\\n result.append(words[i])\\n i += 1\\n else:\\n result.append(tag)\\n\\n return \\\" \\\".join(result)\",\n \"def process_tags(tags=list):\\n new_tag_list = list()\\n for tag in tags:\\n new_tag = tag.replace(\\\"<\\\", \\\" \\\")\\n new_tag = new_tag.replace(\\\">\\\", \\\" \\\")\\n new_tag = new_tag.split()\\n # sort elements by string length (this to avoid 'c' being checked before 'c++', etc)\\n new_tag.sort(key=len, reverse=True)\\n new_tag_list.append(new_tag)\\n return new_tag_list\",\n \"def get_empty_positions(self):\\n\\n empty_positions = []\\n\\n for i in range(self._dimension):\\n for j in range(self._dimension):\\n if self._board[i][j] == ' ':\\n empty_positions.append((i, j))\\n\\n return empty_positions\",\n \"def get_empty_cells(grid):\\n\\tempty = []\\n\\tfor j,row in enumerate(grid):\\n\\t\\tfor i,val in enumerate(row):\\n\\t\\t\\tif not val:\\n\\t\\t\\t\\tempty.append((j,i))\\n\\treturn empty\",\n \"def _postprocess(\\n self,\\n tags: List[str],\\n words: List[str],\\n pos: bool = False,\\n ):\\n result = list()\\n\\n i = 0\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n if pos:\\n result.append(f\\\"{words[i]}/{pos[i]}\\\")\\n else:\\n result.append(words[i])\\n i += 1\\n else:\\n result.append(tag)\\n\\n return \\\" \\\".join(result)\",\n \"def get_empty_cells(grid):\\n empty = []\\n for j,row in enumerate(grid):\\n for i,val in enumerate(row):\\n if not val:\\n empty.append((j,i))\\n return empty\",\n \"def normalized_pos_tags(self):\\n pos_list = []\\n for pos in self.pos_tags:\\n pos_list.extend([i for i in re.split('[:;]', pos) if i != ''])\\n return pos_list\",\n \"def mps_null_spaces(mpslist):\\n AL, C, AR = mpslist\\n d, chi, _ = AL.shape\\n NLshp = (d, chi, (d-1)*chi)\\n ALdag = fuse_left(AL).T.conj()\\n NLm = null_space(ALdag)\\n NL = NLm.reshape(NLshp)\\n\\n ARmat = fuse_right(AR)\\n NRm_dag = null_space(ARmat)\\n NRm = NRm_dag.conj()\\n NR = NRm.reshape((d, chi, (d-1)*chi))\\n NR = NR.transpose((0, 2, 1))\\n return (NL, NR)\",\n \"def _filter_empty(lst):\\n return [cell for cell in lst if cell is not Sudoku.EMPTY_CELL]\",\n \"def test_format_bad_tags(self):\\n tags = self.c._format_tags(None)\\n self.assertEqual(0, len(tags))\",\n \"def find_empty_space(board: list) -> tuple:\\n board_length = len(board)\\n for i in range(board_length):\\n for j in range(board_length):\\n if board[i][j] == 0:\\n return (i,j)\",\n \"def _py3_safe(parsed_list):\\n if len(parsed_list) < 2:\\n return parsed_list\\n else:\\n new_list = [parsed_list[0]]\\n nl_append = new_list.append\\n for before, after in py23_zip(islice(parsed_list, 0, len(parsed_list)-1),\\n islice(parsed_list, 1, None)):\\n if isinstance(before, Number) and isinstance(after, Number):\\n nl_append(\\\"\\\")\\n nl_append(after)\\n return tuple(new_list)\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def empty_cells(self) -> List[Cell]:\\n return list(ob.pos[0] for ob in self.new_obs())\",\n \"def splitTags(user_input):\\n \\n elements = []\\n if ',' in user_input:\\n elements = user_input.split(',')\\n elif ' ' in user_input:\\n elements = user_input.split(' ')\\n else:\\n elements.append(user_input)\\n\\n tags = []\\n for element in elements:\\n element = element.strip(' \\\\t\\\\n\\\\r').lower()\\n if(len(element) == 0): continue\\n if element not in tags:\\n tags.append(element)\\n return tags\",\n \"def expand_empty_tags(tokens, keep_minimized=None):\\n for token in tokens:\\n if isinstance(token, Empty):\\n if keep_minimized and token.name in keep_minimized:\\n yield token\\n else:\\n token.__class__ = Start\\n token.reserialize()\\n yield Start(token.xml.replace('/', ''))\\n yield End('</%s>' % token.name)\\n else:\\n yield token\",\n \"def next_empty(checker): # checker is dictionary\\n min_len = 100 # arbitrary large assignment\\n position = ' '\\n values = []\\n for element in checker:\\n if len(checker[element]) < min_len:\\n min_len = len(checker[element])\\n position = element\\n values = checker[element]\\n return position, values\",\n \"def get_empty_tiles(self) -> List[Point]:\\n\\t\\tempty_tiles = []\\n\\t\\tfor x in range(self.size):\\n\\t\\t\\tfor y in range(self.size):\\n\\t\\t\\t\\tif self.tiles[x][y] == 0:\\n\\t\\t\\t\\t\\tempty_tiles.append(Point(x,y))\\n\\t\\treturn empty_tiles\",\n \"def make_free_cell_list():\\r\\n for row in range(9):\\r\\n for col in range(9):\\r\\n if (application.ui.__getattribute__(f'cell{col+1}{row+1}')).text() == \\\"\\\":\\r\\n lst_free_cells.append(Point(row, col))\",\n \"def clean_recording_gaps(self, pos_xy: np.ndarray, pos_times: np.ndarray):\\n (\\n position_gap_inds_above_threshold\\n ) = self.check_for_position_gaps_above_threshold(pos_times)\\n cleaned_pos_xy = pos_xy[:]\\n for ind in position_gap_inds_above_threshold:\\n cleaned_pos_xy[ind - 5 : ind + 5] = np.nan\\n return (cleaned_pos_xy, position_gap_inds_above_threshold)\",\n \"def _genPosTags(self, tagged):\\n return [pos for (token, pos) in tagged]\",\n \"def tags(self):\\n return tuple([x.strip() for x in self._dict.get('tags').split(',')])\",\n \"def parser(self):\\n hold = [i for i, val in enumerate(self.board) if val != self.empty and val.colour == BLACK]\\n hold2 = [i for i, val in enumerate(self.board) if val != self.empty and val.colour == WHITE]\\n \\n #This is why dictionaries are better\\n black_coords = []\\n white_coords = []\\n \\n for i in hold:\\n black_coords.append(self.coords[i])\\n\\n for i in hold2:\\n white_coords.append(self.coords[i])\\n \\n return black_coords, white_coords\",\n \"def add_ignore_empty(x, y):\\n\\n def _ignore(t):\\n return t is None or (isinstance(t, tuple) and len(t) == 0)\\n\\n if _ignore(y):\\n return x\\n elif _ignore(x):\\n return y\\n else:\\n return x + y\",\n \"def _fix_treetags(self, tree):\\n for element in tree:\\n element.tag = element.tag.split('}')[1]\\n if len(element.getchildren()) > 0:\\n self._fix_treetags(element)\\n return tree\",\n \"def _transform_known_tags(self):\\n self.missing_known_tags = []\\n\\n for k, tf in self._known_tags.items():\\n v = self.tags.get(k, [])\\n if not v:\\n self.missing_known_tags.append(k)\\n continue\\n\\n if len(v) > 1:\\n raise Exception(f\\\"multiple instances of tag {k}\\\")\\n\\n setattr(self, k, v[0])\",\n \"def tags_list_should_have_no_duplicates(context):\\n assert context.tags\\n # converting a list to a set will remove all the duplicates\\n # then we need to:\\n # * convert it back to a list\\n # * sort both lists\\n # and finally compare both lists\\n unique_tags = list(set(context.tags))\\n assert sorted(context.tags) == sorted(unique_tags)\\n logging.debug(\\n 'Saved list of all tags does not contain duplicates:\\\\n%s',\\n pformat(sorted(context.tags)))\",\n \"def empty(self):\\n return [cell for cell in self.compact if not cell.peg]\",\n \"def get_empty_square(self) -> list:\\n empty_square = []\\n for line_index in range(len(self.grid)):\\n for col_index in range(len(self.grid[line_index])):\\n if self.grid[line_index][col_index].color is None:\\n empty_square.append((line_index, col_index))\\n\\n return empty_square\",\n \"def empty_cells(state):\\r\\n cells = []\\r\\n for x, row in enumerate(state):\\r\\n for y, cell in enumerate(row):\\r\\n if cell == 0:\\r\\n cells.append([x, y])\\r\\n\\r\\n return cells\",\n \"def get_empty_squares(self):\\n empty = []\\n for row in range(self._dim):\\n for col in range(self._dim):\\n if self._board[row][col] == EMPTY:\\n empty.append((row, col))\\n return empty\",\n \"def check_for_whitespace(data):\\n for keys, value in data.items():\\n if keys != 'tags':\\n if not value.strip():\\n abort(make_response(jsonify({\\n 'status': 400,\\n 'error':'{} field cannot be left blank'.format(keys)}), 400))\\n if keys == 'tags':\\n for tags in data['tags']:\\n if not tags.strip():\\n abort(make_response(jsonify({\\n 'status': 400,\\n 'error':'tags field cannot be left blank'}), 400))\\n return True\",\n \"def getEmpty(self):\\n emptyList = []\\n for spot in self.parkingSpots:\\n if spot.status == 'empty':\\n emptyList.append(spot)\\n return emptyList\",\n \"def find_empty(puzzle):\\r\\n empty_squares = []\\r\\n for y in range(len(puzzle.squares)):\\r\\n for x in range(len(puzzle.squares[0])):\\r\\n if puzzle.squares[y][x].is_editable() is True:\\r\\n empty_squares.append((x, y))\\r\\n return empty_squares\",\n \"def __wrap_with_tuple(self) -> tuple:\\r\\n l = list()\\r\\n length = len(self.data)\\r\\n while self.idx < length:\\r\\n l.append(self.__parse())\\r\\n return tuple(l)\",\n \"def discardBlanks (texts, scores):\\n\\tnew_texts = []\\n\\tnew_scores = []\\n\\tfor i,text in enumerate(texts):\\n\\t\\tif text != '' or text != ' ':\\n\\t\\t\\tnew_texts.append(text)\\n\\t\\t\\tnew_scores.append(scores[i])\\n\\treturn new_texts,new_scores\",\n \"def _canProcessTags(self, grammar, pos_tags):\\n badTags = []\\n for tag in pos_tags:\\n if tag not in grammar.tags:\\n badTags.append(tag)\\n logger.debug(\\\"Grammar can't handle tag:\\\" + tag)\\n if badTags:\\n return False\\n else:\\n return True\",\n \"def split_commaseparated_tags(cls, commaseparatedtags):\\n if commaseparatedtags.strip() == '':\\n return []\\n else:\\n return [\\n cls.normalize_tag(tagstring)\\n for tagstring in list([_f for _f in re.split(r'[,\\\\s]', commaseparatedtags) if _f])]\",\n \"def _clean_list(self, items):\\n itemlist = list(filter(None, items))\\n if len(itemlist) < 3:\\n itemlist.append(\\\"\\\")\\n return itemlist\\n\\n return itemlist\",\n \"def getNonEmptyCells(self):\\n nonemptys = []\\n for ri in range(self.nRow):\\n for ci in range(self.nCol):\\n val = self.vals[ri][ci]\\n if not self.isEmpty(val):\\n row = ri+1\\n col = ci+1\\n nonemptys.append(CellDesc(row=row, col=col, val=val))\\n return nonemptys\",\n \"def clean(self):\\n for i in range(len(self.asteroid_type) - 1, -1, -1):\\n x, y = self.get_coords(self.asteroid_type[i])\\n if x < -self.gap:\\n self.del_asteroid(i)\",\n \"def build_all(nodes=[]):\\n\\n if nodes:\\n nodes = [n for n in mc.ls(nodes) if mc.objExists(n+'.tagSpaces')]\\n else:\\n nodes = mc.ls('*.tagSpaces')\\n nodes = [n.replace('.tagSpaces','') for n in nodes if mc.getAttr(n)]\\n\\n for node in nodes:\\n space_obj = Space(node)\\n space_obj.build_space()\",\n \"def fill_in_empty_tags(prior, tags):\\n print \\\"filling in empty entries for tags\\\"\\n for key in tags:\\n if not key in prior:\\n prior[key] = {}\\n for key1 in tags:\\n for key2 in tags:\\n prior[key1].setdefault(key2, 0.0)\",\n \"def _fix_examples(examples):\\n if len(examples) > 0 and len(examples[0]) > 0 and len(examples[0][0]) > 2:\\n # Assumes all elements use the same format of tuple of length 3 (so we only check [0][0])\\n return [\\n [(tuple_ex[0], tuple_ex[1]) for tuple_ex in example]\\n for example in examples\\n ]\\n else:\\n return examples\",\n \"def filter_empty(word_list):\\n new_list = []\\n for x in word_list:\\n if(x):\\n new_list.append(x)\\n return new_list\",\n \"def _get_available_spaces(world):\\n spaces = []\\n for y, row in enumerate(world):\\n for x, column in enumerate(row):\\n if column == eg.NONE:\\n spaces.append((x, y))\\n\\n return spaces\",\n \"def test_merge_list_empty(short_ll, empty_ll):\\n assert ml(short_ll, empty_ll) == 8\\n assert len(short_ll) == 4\",\n \"def cleanup(self):\\n for element in self.root.iter():\\n element.tag = element.tag.partition('}')[-1]\",\n \"def pad_tuple_list(cls, tuple_list, pad_len):\\n\\n return [tuple(x)+('',)*(pad_len-len(x)) for x in tuple_list]\",\n \"def validate(self):\\n for search_tag_name in self.get_search_tag_names():\\n search_tag_obj = Tag(search_tag_name)\\n for search_tag_value in self.get_search_tag_values(search_tag_name):\\n for new_tag_name in self.get_new_tag_names(search_tag_name, search_tag_value):\\n new_tag_obj = Tag(new_tag_name)\\n new_tag_value = self.get_new_tag_value(search_tag_name, search_tag_value, new_tag_name)\\n if new_tag_obj.repeatable:\\n if not isinstance(new_tag_value, list):\\n raise KeyError('%s needs a list'%(new_tag_name))\\n else:\\n if isinstance(new_tag_value, list):\\n raise KeyError('%s needs a scalar value'%(new_tag_name))\",\n \"def __iter__(self):\\n for item in(self.data_):\\n if(item!= None):#We dont want to yield spaces that have not been filled yet \\n yield item\",\n \"def filtered_xyz(self) -> tuple[int, int, int]:\",\n \"def _align_tagged_sentence(self, ne_tagged_sentence):\\n omitted_tokens = self.task_config[\\\"OMITTED_TOKENS_FOR_ALIGNMENT\\\"]\\n\\n return [\\n (word, tag)\\n for word, tag in ne_tagged_sentence\\n if word not in omitted_tokens\\n ]\",\n \"def change_tags_format(page_tags):\\n\\treturn [tags.replace('\\\\n', ', ') if not tags == None else None for tags in page_tags]\",\n \"def process_dictionary(self, _list):\\n try:\\n del _list[_list.index('<unknown>')]\\n except ValueError:\\n pass\\n\\n try:\\n del _list[_list.index('<unk>')]\\n except ValueError:\\n pass\\n _list.insert(0, '<pad>')\\n _list.insert(0, '<unknown>')\\n\\n return _list\",\n \"def clean_tag(elmt_with_commas, max_lenght):\\r\\n elmt_list = elmt_with_commas.split(\\\",\\\")\\r\\n elmt_list = [e.strip() for e in elmt_list if len(e) < max_lenght]\\r\\n return elmt_list\",\n \"def remove_empty(ifiles, xvar, yvar):\\r\\n\\r\\n # Do nothing if keyword '_bbox' not in file name \\r\\n if '_bbox' not in ifiles[0]:\\r\\n return ifiles\\r\\n\\r\\n ifiles_ = []\\r\\n for ifile in ifiles:\\r\\n\\r\\n with h5py.File(ifile, 'r') as fi:\\r\\n lon = fi[xvar][:]\\r\\n lat = fi[yvar][:]\\r\\n\\r\\n bbox = get_bbox(ifile)\\r\\n proj = get_proj(ifile)\\r\\n\\r\\n xmin, xmax, ymin, ymax = bbox\\r\\n\\r\\n x, y = transform_coord('4326', proj, lon, lat)\\r\\n\\r\\n idx, = np.where( (x >= xmin) & (x <= xmax) & \\r\\n (y >= ymin) & (y <= ymax) )\\r\\n \\r\\n if len(idx) > 0:\\r\\n ifiles_.append(ifile)\\r\\n\\r\\n return ifiles_\",\n \"def _make_list_islot_otuples_from_nodelist(self):\\n if self.node_list is None:\\n raise ValueError(\\\"`node_list` attribute undefined\\\")\\n return [[('loc', 'scale')] for _ in self.node_list]\",\n \"def board_empty_positions(self, x, y):\\n board = self.boards[x][y]\\n coords = [(x, y, i, j) for (i, j) in board.empty_squares]\\n return self.coords_to_positions(coords)\",\n \"def find_empty(self):\\n min_num_choices = 10\\n ret_x, ret_y = (-1, -1)\\n\\n for x in range(0, 9):\\n for y in range(0, 9):\\n if self.field[x][y] != -1:\\n continue\\n\\n if (min_num_choices > len(self.choices[x][y])):\\n min_num_choices = len(self.choices[x][y])\\n ret_x = x\\n ret_y = y\\n\\n return (ret_x, ret_y)\",\n \"def test_parse_restricted_tags():\\n invalid_tags = {'*', '**', '***', 'a*', '*a', 'a*a*', '*a*a', '*aa*', 'a**a', '}'}\\n combined_tags = valid_tags | invalid_tags\\n\\n # Function under test\\n resultant_tags = searchtag.parse_restricted_tags(\\\" \\\".join(combined_tags))\\n\\n # Verify that we have the tags in the valid list\\n assert resultant_tags == valid_tags\",\n \"def get_empty_slots(self):\\n slots = np.reshape(range(0, self.size * self.size), (self.size, self.size))\\n\\n return slots[~self.tiles_taken]\",\n \"def pos_tag(self,sentence):\\n tagged = self.brill_tagger.tag(sentence.split())\\n tagged_sentence = \\\" \\\".join([nltk.tag.tuple2str(tok) for tok in tagged])\\n print tagged_sentence\\n\\n tag_list = [(each.split(\\\"/\\\")[0],each.split(\\\"/\\\")[1]) for each in tagged_sentence.split()]\\n return tag_list\",\n \"def is_tile_empty(self, y_pos, x_pos):\\n if 15 > y_pos >= 0 and 0 <= x_pos < 15:\\n return self.map[y_pos][x_pos] == ' '\\n return False\",\n \"def _convert_tags_to_wordpiece_tags(tags: List[str], offsets: List[int]) -> List[str]:\\n new_tags = []\\n j = 0\\n for i, offset in enumerate(offsets):\\n tag = tags[i]\\n is_o = tag == \\\"O\\\"\\n is_start = True\\n while j < offset:\\n if is_o:\\n new_tags.append(\\\"O\\\")\\n\\n elif tag.startswith(\\\"I\\\"):\\n new_tags.append(tag)\\n\\n elif is_start and tag.startswith(\\\"B\\\"):\\n new_tags.append(tag)\\n is_start = False\\n\\n elif tag.startswith(\\\"B\\\"):\\n _, label = tag.split(\\\"-\\\", 1)\\n new_tags.append(\\\"I-\\\" + label)\\n j += 1\\n\\n # Add O tags for cls and sep tokens.\\n return [\\\"O\\\"] + new_tags + [\\\"O\\\"]\",\n \"def nonull(inputlist):\\n return clean(inputlist, isnull, True)\",\n \"def phrase_list_filler():\\n return (Parse.word('we').possibly() + first_word('put write have know see') + \\n Parse.word('that').possibly()).nil()\",\n \"def check_end(self) -> Optional[List[Point]]:\\n\\t\\tfor x in range(self.size):\\n\\t\\t\\tfor y in range(self.size):\\n\\t\\t\\t\\tif not self.tiles[x][y] == 0:\\n\\t\\t\\t\\t\\tresult = self.check_around(x, y)\\n\\t\\t\\t\\t\\tif result is not None:\\n\\t\\t\\t\\t\\t\\treturn result\\n\\t\\tif len(self.get_empty_tiles()) == 0:\\n\\t\\t\\treturn []\\n\\t\\treturn None\",\n \"def empty_tuple():\\n empty = ()\\n print(type(empty)) # <type 'tuple'>\",\n \"def not_empty(entry):\\n gt_boxes = entry['boxes']\\n return gt_boxes.shape[0] > 0\",\n \"def _ConsolidateKnownOverlappingTags(self, typ_tags: FrozenSet[str]\\n ) -> FrozenSet[str]:\\n return typ_tags\",\n \"def _convert_tags_to_wordpiece_tags(tags: List[str], offsets: List[int]) -> List[str]:\\r\\n new_tags = []\\r\\n j = 0\\r\\n for i, offset in enumerate(offsets):\\r\\n tag = tags[i]\\r\\n is_o = tag == \\\"O\\\"\\r\\n is_start = True\\r\\n while j < offset:\\r\\n if is_o:\\r\\n new_tags.append(\\\"O\\\")\\r\\n\\r\\n elif tag.startswith(\\\"I\\\"):\\r\\n new_tags.append(tag)\\r\\n\\r\\n elif is_start and tag.startswith(\\\"B\\\"):\\r\\n new_tags.append(tag)\\r\\n is_start = False\\r\\n\\r\\n elif tag.startswith(\\\"B\\\"):\\r\\n _, label = tag.split(\\\"-\\\", 1)\\r\\n new_tags.append(\\\"I-\\\" + label)\\r\\n j += 1\\r\\n\\r\\n # Add O tags for cls and sep tokens.\\r\\n return [\\\"O\\\"] + new_tags + [\\\"O\\\"]\",\n \"def parse(m: tuple):\\n directions = ['across', 'down']\\n word = list() # Used to store the word we're working on\\n word_list = list() # Stores the growing list of words\\n\\n for direction in directions:\\n\\n for y in range(len(m)): # number of rows (size of outer tuple)\\n # word = list() # todo: can probably be deleted as word is reset at end of row already\\n\\n for x in range(len(m[0])): # number of columns (size of inner tuple)\\n\\n if direction == 'down': # flips so x is rows and y is columns if we are reading down\\n x, y = y, x\\n\\n square = matrix[y][x]\\n\\n if square != 0: # Encountered a letter\\n if len(word) == 0:\\n word.append((direction, y, x), ) # If start of a word, start with direction & coordinates\\n word.append(square) # First letter\\n\\n if direction == 'down': # flips x and y back before we reach the loop tests\\n x, y = y, x\\n\\n if square == 0 or x == 10: # Encountered a blank space\\n if len(word) > 3: # Then we collected a word and have come to the end of it\\n word_list.append(word) # Add it to the list of words\\n word = list() # Reset word\\n\\n word = list()\\n\\n return word_list\",\n \"def space_join(*items):\\n valid_items = []\\n for item in items:\\n if item is None:\\n continue\\n if isinstance(item, tuple):\\n if item[0] is None:\\n continue\\n stripped = strip_if_not_blank(item[0])\\n if not is_null(stripped):\\n if len(item) == 2:\\n if not is_null(item[1]):\\n valid_items.append(\\\"%s%s\\\" % (item[1], stripped))\\n else:\\n valid_items.append(stripped)\\n elif len(item) >= 3:\\n if not is_null(item[1]) and not is_null(item[2]):\\n valid_items.append(\\\"%s%s%s\\\" % (\\n item[1], stripped, item[2]))\\n elif not is_null(item[1]):\\n valid_items.append(\\\"%s%s\\\" % (item[1], stripped))\\n elif not is_null(item[2]):\\n valid_items.append(\\\"%s%s\\\" % (stripped, item[2]))\\n else:\\n stripped = strip_if_not_blank(item)\\n if stripped != \\\"\\\":\\n valid_items.append(stripped)\\n return \\\" \\\".join(valid_items)\",\n \"def store_empty_graphic_box(self):\\n for box in self.laby.empty_box():\\n x = box[0] * 40\\n y = box[1] * 40\\n self.store_emptyBox.append((y, x))\\n return self.store_emptyBox\",\n \"def wordoftuples_to_tupleofwords(wordoftuples):\\n if not equal(len(t) for t in wordoftuples):\\n raise ValueError(\\\"Not all entries of input have the same length.\\\")\\n def remove_empty_letters(word):\\n return [letter for letter in word if letter is not None]\\n return tuple(remove_empty_letters(word)\\n for word in zip(*wordoftuples))\",\n \"def find_free_ortho_spaces(self):\\r\\n for pos, ortho in ORTHOGONAL_POSITIONS.items():\\r\\n if self.board[pos[0]][pos[1]].color != 0:\\r\\n for p in ortho:\\r\\n if self.board[p[0]][p[1]].color == 0:\\r\\n if (pos[0], pos[1]) in self.free_pos.keys():\\r\\n self.free_pos[(pos[0], pos[1])].add(p)\\r\\n else:\\r\\n self.free_pos[(pos[0], pos[1])] = {p}\",\n \"def known_safes(self):\\n #if the bomb count is zero\\n if(self.count == 0):\\n #all spaces are safe, which returns all spots that are safe\\n return (self.cells)\\n else:\\n return set()\",\n \"def _set_list_tuple_only_structure(self, key):\\n ## Change to list and whatever it was\\n self.set_neighs([e[0] for e in key])\\n self.set_sp_rel_pos([e[1] for e in key])\",\n \"def clean_coordinates(coords, silent=False):\\n l1 = len(coords)\\n coords = coords[~N.isnan(coords).any(axis=1)] # remove NaN values\\n l2 = len(coords)\\n if not silent:\\n msg = \\\"{0} coordinates\\\".format(l2)\\n if l2 < l1:\\n msg += \\\" ({0} removed as invalid)\\\".format(l1-l2)\\n print(msg)\\n return coords\",\n \"def test_merge_list_empty_first(empty_ll, short_ll):\\n assert ml(empty_ll, short_ll) == 8\\n assert len(short_ll) == 4\",\n \"def test_insertion_for_each_element_in_iterable_tuple(empty_list):\\n b = (1, 2, 3)\\n bb = LinkedList([])\\n bb.insert(b)\\n assert len(bb) == 3\",\n \"def filled_positions(self):\\n return [x for x in assignable_positions if self.grid[x][0]]\",\n \"def cleanup(self):\\n for j in range(len(self.endTagList)):\\n self.result = self.result + self.endTagList[j]\",\n \"def _empty(self, w_beg, w_end):\\n\\n tmp = np.arange(w_beg + self.pre_pad,\\n w_end - self.post_pad + (1 / self.sampling_rate),\\n 1 / self.sampling_rate)\\n daten = [x.datetime for x in tmp]\\n\\n max_coa = max_coa_norm = np.full(len(daten), 0)\\n\\n coord = np.full((len(daten), 3), 0)\\n\\n return daten, max_coa, max_coa_norm, coord\",\n \"def get_empty_cells(board):\\n empty_cells = [idx for idx, e in enumerate(board) if e == ' ']\\n return empty_cells\",\n \"def non_empty_children(self) -> Tuple[CombinatorialClassType, ...]:\\n if self._non_empty_children is None:\\n self._non_empty_children = tuple(\\n child for child in self.children if not child.is_empty()\\n )\\n return self._non_empty_children\",\n \"def remove_empty(data):\\n out = []\\n for item in data:\\n if item == '':\\n continue\\n out.append(item)\\n return out\",\n \"def getSpaceTokenList(token, listSEs, jobCloud, analysisJob, fileListLength, si, alt=False):\\n\\n # check if there are any space tokens\\n if token == [''] and fileListLength > 1:\\n # correct length of empty list\\n token = token*fileListLength\\n tolog(\\\"Corrected length of empty space token list from 0 to %d\\\" % len(token))\\n\\n # no space tokens for tier 3s\\n if not si.isTier3():\\n token_list = getProperSpaceTokenList(token, listSEs, jobCloud, analysisJob, alt=alt)\\n else:\\n token_list = None\\n\\n return token_list\",\n \"def _normalize_together(self, together):\\n if not together:\\n return []\\n\\n if not isinstance(together[0], (tuple, list)):\\n together = (together,)\\n\\n return [\\n tuple(item)\\n for item in together\\n ]\",\n \"def checked_positions():\\n for base_position in chain([me.shipyard], me.get_dropoffs()):\\n x_shipyard = base_position.position.x\\n y_shipyard = base_position.position.y\\n for x in range(-search_range, search_range):\\n for y in range(-search_range, search_range):\\n yield hlt.Position(\\n x=x_shipyard + x,\\n y=y_shipyard + y)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56815004","0.5611002","0.54052174","0.5345678","0.53289914","0.5290784","0.5282728","0.52795637","0.52427185","0.5172312","0.5162299","0.5155179","0.5121523","0.5118857","0.5089582","0.50675386","0.5064925","0.506162","0.50472486","0.50319785","0.500313","0.500313","0.497172","0.49627206","0.4953047","0.49469945","0.4933877","0.49032608","0.48838368","0.48749062","0.4868899","0.48599032","0.4846124","0.48459074","0.48333606","0.4831453","0.4825286","0.4820901","0.48167613","0.48089156","0.48070067","0.4771244","0.47643313","0.47279108","0.47243467","0.4710081","0.47035053","0.47016597","0.46951473","0.46948758","0.46599168","0.46555376","0.464474","0.46415007","0.4632952","0.46191728","0.46078768","0.46016747","0.459861","0.45922744","0.45912266","0.4585627","0.45846522","0.45769024","0.45592186","0.45582262","0.45563775","0.4555945","0.45459464","0.45450783","0.4540103","0.4537493","0.45272538","0.4524175","0.45174208","0.45168287","0.45148328","0.45139414","0.4511324","0.45019054","0.4488261","0.44867676","0.44856355","0.4482457","0.44811693","0.44795462","0.44739535","0.4471961","0.44684732","0.44616327","0.4459563","0.4459326","0.44417885","0.44409052","0.4440033","0.44362068","0.44323975","0.44319114","0.44267783","0.4422543"],"string":"[\n \"0.56815004\",\n \"0.5611002\",\n \"0.54052174\",\n \"0.5345678\",\n \"0.53289914\",\n \"0.5290784\",\n \"0.5282728\",\n \"0.52795637\",\n \"0.52427185\",\n \"0.5172312\",\n \"0.5162299\",\n \"0.5155179\",\n \"0.5121523\",\n \"0.5118857\",\n \"0.5089582\",\n \"0.50675386\",\n \"0.5064925\",\n \"0.506162\",\n \"0.50472486\",\n \"0.50319785\",\n \"0.500313\",\n \"0.500313\",\n \"0.497172\",\n \"0.49627206\",\n \"0.4953047\",\n \"0.49469945\",\n \"0.4933877\",\n \"0.49032608\",\n \"0.48838368\",\n \"0.48749062\",\n \"0.4868899\",\n \"0.48599032\",\n \"0.4846124\",\n \"0.48459074\",\n \"0.48333606\",\n \"0.4831453\",\n \"0.4825286\",\n \"0.4820901\",\n \"0.48167613\",\n \"0.48089156\",\n \"0.48070067\",\n \"0.4771244\",\n \"0.47643313\",\n \"0.47279108\",\n \"0.47243467\",\n \"0.4710081\",\n \"0.47035053\",\n \"0.47016597\",\n \"0.46951473\",\n \"0.46948758\",\n \"0.46599168\",\n \"0.46555376\",\n \"0.464474\",\n \"0.46415007\",\n \"0.4632952\",\n \"0.46191728\",\n \"0.46078768\",\n \"0.46016747\",\n \"0.459861\",\n \"0.45922744\",\n \"0.45912266\",\n \"0.4585627\",\n \"0.45846522\",\n \"0.45769024\",\n \"0.45592186\",\n \"0.45582262\",\n \"0.45563775\",\n \"0.4555945\",\n \"0.45459464\",\n \"0.45450783\",\n \"0.4540103\",\n \"0.4537493\",\n \"0.45272538\",\n \"0.4524175\",\n \"0.45174208\",\n \"0.45168287\",\n \"0.45148328\",\n \"0.45139414\",\n \"0.4511324\",\n \"0.45019054\",\n \"0.4488261\",\n \"0.44867676\",\n \"0.44856355\",\n \"0.4482457\",\n \"0.44811693\",\n \"0.44795462\",\n \"0.44739535\",\n \"0.4471961\",\n \"0.44684732\",\n \"0.44616327\",\n \"0.4459563\",\n \"0.4459326\",\n \"0.44417885\",\n \"0.44409052\",\n \"0.4440033\",\n \"0.44362068\",\n \"0.44323975\",\n \"0.44319114\",\n \"0.44267783\",\n \"0.4422543\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56864506"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9293,"cells":{"query":{"kind":"string","value":"Function mashes together classes functionality and performs the AI's move. It recursively calls the minimax algorithm and after finding the best move it adds tag into the tags list."},"document":{"kind":"string","value":"def bot_handle_move(self) -> None:\r\n best_value = -INFINITY # default best value for maximizing player (bot in this app is a maximizing player)\r\n available_moves = self.check_for_moves() # for more info check the minimax algorithm theory\r\n depth = int(1.4*self.size - self.win_condition) # (depth) decides of how deep into recursion the algorithm will\r\n best_move = None # get. 1.4 seems to be the best consensus between time of\r\n # execution and accuracy of moves\r\n for move in available_moves:\r\n self.tags[move[0]][move[1]] = 'o'\r\n move_value = self.minimax(depth, -INFINITY, INFINITY, False)\r\n self.tags[move[0]][move[1]] = None\r\n if move_value > best_value:\r\n best_value = move_value\r\n best_move = move\r\n\r\n self.tags[best_move[0]][best_move[1]] = 'o'"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_move(self):\n\n # get relavent information\n affinity = self.get_affinity()\n sample_space = self.get_game_space()\n depth_limit = self.__search_depth\n\n # run a minimax search and get the best value\n bestval = MinimaxTree.alphabeta(self, sample_space, affinity, depth_limit, -10000, 10001, True)\n if bestval[0] is None: bestval = ((0,6),'x', 0)\n\n # print the number of nodes expanded \n print(self.nodes_expanded)\n\n # make the move found by the search \n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)","def action(self):\r\n\r\n\r\n #have we just started?\r\n if self.player_information[\"us\"][\"nTokens\"] == 0:\r\n move = generate_starting_move(self.player_information[\"us\"][\"player_side\"], self.board_array)\r\n return move\r\n\r\n #otherwise do minimax \r\n \r\n #start off with some shallow depth:\r\n if self.turn_no < 5:\r\n depth = 3\r\n else:\r\n depth = 2\r\n \r\n #set a constraint for search depth\r\n if self.total_tokens_on_board < 6:\r\n depth = 3\r\n elif self.total_tokens_on_board < 10:\r\n depth = 2\r\n else:\r\n depth = 1\r\n \r\n #have a time reference\r\n print(f'nthrows: {self.player_information[\"us\"][\"nThrowsRemaining\"]}')\r\n starting_time = int(round(time.time(), 0))\r\n #salvage result from minimax\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, depth, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, True, self.turn_no)\r\n\r\n #clean it up a bit \r\n print(self.board_dict)\r\n #tidy it up\r\n result = result[0]\r\n print(f'pre: {result}')\r\n #in case we get a bad move redo but make it very shallow\r\n if len(result) == 1 or result == (-5, -5):\r\n #force it to return a usable move\r\n counter = 0\r\n while (len(result) == 1) or (result == (-5, -5)):\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, 1, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, False, self.turn_no)\r\n result = result[0]\r\n counter += 1\r\n \r\n #if its taking too long\r\n if counter > 2: \r\n #generate one random possible move to use \r\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \"us\"]\r\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\r\n self.player_information, self.board_array, True, \"all\")\r\n \r\n \r\n #if there are no moves\r\n if len(move_list) == 0:\r\n if self.player_information['us']['nThrowsRemaining'] > 0:\r\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \"us\",\r\n self.player_information[\"us\"][\"player_side\"], self.board_array, \"all\" )\r\n result = random.choice(throws)\r\n \r\n else:\r\n result = random.choice(move_list)\r\n print(f'random: {result}')\r\n break\r\n\r\n print(f' inside: {result}')\r\n\r\n print(result)\r\n #otherwise clean it up\r\n if result[0] == 'throw':\r\n final_result = (result[0].upper(), result[1], result[2])\r\n else:\r\n final_result = (result[0].upper(), result[2], result[3])\r\n # return final result \r\n return final_result","def make_move(self):\n\n # get relavent information\n affinity = self.get_affinity()\n sample_space = self.get_game_space()\n depth_limit = self.__search_depth\n\n # run a minimax search and get the best value\n bestval = MinimaxTree.minimax(self, sample_space, affinity, depth_limit, True)\n if bestval[0] is None: bestval = ((0,6),'x', 0)\n\n # print the number of nodes expanded \n print(self.nodes_expanded)\n\n # make the move found by the search \n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n #Fetching legal moves for the active player at max level\n legal_moves = game.get_legal_moves()\n #Terminial condition - if there are no legal moves left will call the utility function\n if not legal_moves:\n return game.utility(self) #Returning utility function\n #Assigning default value to best move\n best_move = legal_moves[0]\n #Assigning default value to best score as -inf\n best_score = float('-inf')\n #for each future legal move of active player\n for move in legal_moves:\n #Fetching next state forecast moves\n next_state = game.forecast_move(move)\n #Calling min_value function for score - Return type of min_value function is score\n score = self.min_value(next_state, depth-1)\n if score > best_score:\n best_move = move\n best_score = score\n return best_move #Return best_move","def run_ai():\n print(\"Othello AI\") # First line is the name of this AI\n arguments = input().split(\",\")\n \n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \n limit = int(arguments[1]) #Depth limit\n minimax = int(arguments[2]) #Minimax or alpha beta\n caching = int(arguments[3]) #Caching \n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\n\n if (minimax == 1): eprint(\"Running MINIMAX\")\n else: eprint(\"Running ALPHA-BETA\")\n\n if (caching == 1): eprint(\"State Caching is ON\")\n else: eprint(\"State Caching is OFF\")\n\n if (ordering == 1): eprint(\"Node Ordering is ON\")\n else: eprint(\"Node Ordering is OFF\")\n\n if (limit == -1): eprint(\"Depth Limit is OFF\")\n else: eprint(\"Depth Limit is \", limit)\n\n if (minimax == 1 and ordering == 1): eprint(\"Node Ordering should have no impact on Minimax\")\n\n while True: # This is the main loop\n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input()\n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over.\n print\n else:\n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The\n # squares in each row are represented by\n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n\n # Select the move and send it to the manager\n if (minimax == 1): #run this if the minimax flag is given\n movei, movej = select_move_minimax(board, color, limit, caching)\n else: #else run alphabeta\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\n \n print(\"{} {}\".format(movei, movej))","def run_ai():\n print(\"Othello AI\") # First line is the name of this AI\n arguments = input().split(\",\")\n \n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \n limit = int(arguments[1]) #Depth limit\n minimax = int(arguments[2]) #Minimax or alpha beta\n caching = int(arguments[3]) #Caching \n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\n\n if (minimax == 1): eprint(\"Running MINIMAX\")\n else: eprint(\"Running ALPHA-BETA\")\n\n if (caching == 1): eprint(\"State Caching is ON\")\n else: eprint(\"State Caching is OFF\")\n\n if (ordering == 1): eprint(\"Node Ordering is ON\")\n else: eprint(\"Node Ordering is OFF\")\n\n if (limit == -1): eprint(\"Depth Limit is OFF\")\n else: eprint(\"Depth Limit is \", limit)\n\n if (minimax == 1 and ordering == 1): eprint(\"Node Ordering should have no impact on Minimax\")\n\n while True: # This is the main loop\n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input()\n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over.\n print\n else:\n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The\n # squares in each row are represented by\n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n\n # Select the move and send it to the manager\n if (minimax == 1): #run this if the minimax flag is given\n movei, movej = select_move_minimax(board, color, limit, caching)\n else: #else run alphabeta\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\n \n print(\"{} {}\".format(movei, movej))","def alphabeta_search(state):\r\n \r\n '''\r\n Terminates when game.actions is empty\r\n Class Game needs the following functions:\r\n - game.result(state, a) -- successor\r\n - game.actions(state) -- possible moves\r\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\r\n \r\n '''\r\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\r\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\r\n \r\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\r\n cutoff_test=None\r\n sort_fn = [vitalpoint, eyeHeur]\r\n eval_fn = survivalheur \r\n #randnumheuristics \r\n player = state.to_move()\r\n prune = 0\r\n pruned = {} #this will store the depth of the prune\r\n totaldepth = [0]\r\n visited = {}\r\n heuristicInd = 0\r\n \r\n def max_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = -infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #max wants decreasing\r\n #sorted(state.actions(), key = eval_sort, reverse = True)\r\n \r\n #sort by favorites first, returns a list of actions\r\n # for sorts in sort_fn:\r\n tempher = heuristicInd\r\n\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n ''''''\r\n for a in sortedactions:\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n \r\n onbranch += 1\r\n v = max(v, min_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\r\n if v >= beta: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n alpha = max(alpha, v)\r\n \r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n \r\n return v\r\n\r\n def min_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #min wants increasing\r\n #sorted(state.actions(), key = eval_sort)\r\n #Shayne\r\n tempher = heuristicInd\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state, 1)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n for a in sortedactions: #state.actions():\r\n onbranch += 1\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n v = min(v, max_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd))\r\n if v <= alpha: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n beta = min(beta, v)\r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n\r\n # Body of alphabeta_search starts here:\r\n #def cutoff_test and eval_fn \r\n cutoff_test = (cutoff_test or\r\n (lambda state,depth: depth>d or state.terminal_test()))\r\n eval_fn = eval_fn or (lambda state: state.utility(player))\r\n #by default, utility score is used\r\n \r\n \r\n #argmax goes through all the possible actions and \r\n # applies the alphabeta search onto all of them\r\n # and returns the move with the best score \r\n #print state.actions()\r\n heuristicInd = 0\r\n sorts = sort_fn[heuristicInd]\r\n sortedact, heuristicInd = sorts(state)\r\n abmove = argmax(sortedact,\r\n lambda a: min_value(state.result(a),\r\n -infinity, infinity, 0, heuristicInd))\r\n\r\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\r\n for i in range(1, len(visited)):\r\n if len(pruned) < i:\r\n pruned[i] = 0\r\n print i, \",\", len(visited[i]), \",\", pruned[i]\r\n \r\n return abmove","def run(self):\n\n # keep track of counter\n counter = 0\n\n while self.queue:\n\n # print depth of tree every 10000 steps\n if counter % 10000 == 0:\n print(len(self.queue[0]))\n\n # get first moves set from queue\n moves_set = self.get_moves_set()\n\n # move all moves from set\n self.try_moves(moves_set)\n\n # continue branch (add to queue) if layout is not in archive\n if self.not_in_archive():\n self.add_to_queue(moves_set)\n \n # check for win\n if self.won_game():\n\n # return winning set of moves\n return moves_set\n \n # reverse moves to original layout\n self.reverse_moves(moves_set)\n \n # add to counter\n counter += 1","def minimax(self, board: str):\n \"\"\" Your Code Here \"\"\"\n\n # ----------------------------BEGIN CODE----------------------------\n # disclaimer: I did only minimax (as said on the homework description https://drive.google.com/file/d/1JXBi_5JB8fwTWX34j0ZwN5YwjoIexh-Z/view)\n # my minimax does NOT try to prolong the game. It always goes for the best move!\n\n # initializing default values\n moveToMake = validMoves(board)[0]\n bestValue = -100\n\n # this will find the best move to go to, since value only returns the best score\n # util's setMove creates a copy, so we can use that as the successor\n for validmove in validMoves(board):\n currentValue = self.value(\n setMove(board, validmove, whoseMove(board)), 0)\n if currentValue > bestValue:\n bestValue = currentValue\n moveToMake = validmove\n\n # currently the val and game_length tuple is arbitrary because i have not implemented depth!\n return (moveToMake)","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n self.visited_states.append(self.currentState.state)\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n # If current state has no children, make children\n if not self.currentState.children:\n for movable_statement in movables:\n # Make the move\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n # print (\"new state \", new_state)\n\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\n if (new_state not in self.visited_states):\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.visited[new_gs] = True\n self.visited_states.append(new_state)\n self.gs_queue.append(new_gs)\n\n self.gm.reverseMove(movable_statement)\n\n # Return false if no more to explore\n if not self.gs_queue:\n return False\n\n # Revert to state at when current and next start to change\n root_curr = self.currentState\n self.currentState = self.gs_queue.popleft()\n root_new = self.currentState\n\n # Backtrack to when current node and new node start to diverge\n if root_new.depth == root_curr.depth:\n while root_curr.state != root_new.state:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n root_new = root_new.parent\n else:\n while root_curr.requiredMovable:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n\n # Return game master to state that we are exploring\n # Find path between root and current state\n path = []\n currNode = self.currentState\n while currNode != root_curr:\n path.append(currNode.requiredMovable)\n currNode = currNode.parent\n\n # Created backwards path, now make moves from root to current state\n path.reverse()\n for movable_statement in path:\n self.gm.makeMove(movable_statement)\n\n return False","def move(self):\n for agent in self.agents:\n if not agent.fidelity:\n options = agent.get_move_options(agent.hex, self.kernel_size, None, extend=True)\n target = random36.choices(population=options,weights=[x.quality**2 for x in options])\n agent.move(target[0])","def move(self, state):\n \n self.depth_limit=1\n self.best_utility=-2\n action=None\n while not self.is_time_up():\n self.terminal=True\n self.cache={}\n action=self.alpha_beta_search(state,0)\n if self.terminal==True:\n break\n self.depth_limit=self.depth_limit+1\n \n return action","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n # TODO: finish this function!\n # raise NotImplementedError\n\n legal_moves = game.get_legal_moves() # obtain legal moves available to the board\n best_move = (-1,-1) # initialisation of best move\n best_score = -math.inf # abstraction of infinity\n\n for m in legal_moves: # for each ACTION, create a new state for its outcome, RESULT\n new_state = game.forecast_move(m)\n score = self.min_value(new_state, depth - 1) # recursion to calculate the score of that state\n if score > best_score:\n best_move = m\n best_score = score\n return best_move","def itarate_the_recursion(battle_queue) -> List:\n\n score = None\n name = 1\n children = []\n m = [name, score, battle_queue, children]\n thing = Stack()\n thing.add(m)\n first_player = battle_queue.peek().get_name()\n\n\n while not thing.is_empty():\n\n x = thing.remove()\n\n\n if x[2].is_over():\n if x[2].get_winner():\n winner_hp = x[2].get_winner().get_hp()\n x[1] = winner_hp if x[2].get_winner().get_name() \\\n == first_player else winner_hp * -1\n else:\n x[1] = 0\n\n elif x[1] is None and x[3] != []:\n j = []\n for i in x[3]:\n j += [i[1]]\n x[1] = max(j)\n\n\n elif not x[2].is_over():\n thing.add(x)\n\n moves = x[2].peek().get_available_actions()\n\n for i in moves:\n name += 1\n\n clone = x[2].copy()\n next_char = clone.peek()\n\n mover(i, next_char)\n\n if not clone.is_empty():\n clone.remove()\n\n new_tree = [name, None, clone, []]\n\n x[3].append(new_tree)\n thing.add(new_tree)\n return m","def minimax(self, state, agent, parents_positions):\n if termialTest(state):\n return utility(state)\n return self.computeMinimaxScore(state, agent, parents_positions)","def minimax(board):\n #This function will return the best move. \n #If Ai is playing as X, I can reduce the processing time by creating a random first move. \n if (board == initial_state()):\n coord1 = randint(0,2)\n coord2 = randint(0,2)\n return ((coord1,coord2))\n #first I determine which player's turn it is\n player_to_move = player(board)\n best_action = None\n #If I am X\n if(player_to_move == \"X\"):\n current_max = float('-inf')\n #for every possible action I have right now, I'll call my \"future\" Min_Value since I will asume what will happen if I take this move.\n for action in actions(board):\n #peak on the future if I take that move\n curr_score = Min_Value(result(board,action))\n #if my future is favorable, I will store it as my current best option.\n if curr_score>= current_max:\n current_max = curr_score\n best_action = action\n else:\n #If I am O, I do something similar. \n current_max = float('inf')\n #for every action I peak on the future for favorable results\n for action in actions(board):\n #this time, however, it would be X's turn so I need to start with Max_Value\n curr_score = Max_Value(result(board,action))\n #if my future is favorable, I store it\n if curr_score<= current_max:\n current_max = curr_score\n best_action = action\n #I return the best move.\n return best_action","def player_loop(self):\n\n # Generate game tree object\n first_msg = self.receiver()\n # Initialize your minimax model\n model = self.initialize_model(initial_data=first_msg)\n\n while True:\n msg = self.receiver()\n\n # Create the root node of the game tree\n node = Node(message=msg, player=0)\n\n # Possible next moves: \"stay\", \"left\", \"right\", \"up\", \"down\"\n best_move = self.search_best_next_move(\n model=model, initial_tree_node=node)\n\n # Execute next action\n self.sender({\"action\": best_move, \"search_time\": None})","def minimax(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n legal_moves = game.get_legal_moves()\n\n best_move = (-1, -1)\n if maximizing_player:\n score = float(\"-inf\")\n else:\n score = float(\"inf\")\n\n #At bottom of minimax tree\n if depth == 1:\n for each_move in legal_moves:\n new_game = game.forecast_move(each_move)\n if maximizing_player and self.score(new_game, self) > score:\n score = self.score(new_game, self)\n best_move = each_move\n elif not maximizing_player and self.score(new_game, self) < score:\n score = self.score(new_game, self)\n best_move = each_move\n\n return score, best_move\n\n #Not at bottom of minimax tree\n for each_move in legal_moves:\n #Return each_move that gets the highest score\n new_game = game.forecast_move(each_move)\n new_score , new_move = self.minimax(new_game, depth-1, not maximizing_player)\n if maximizing_player and new_score > score:\n score = new_score\n best_move = each_move\n elif not maximizing_player and new_score < score:\n score = new_score\n best_move = each_move\n\n return score, best_move","def track(sprite, find_tags, pbad = 0.1) :\n\n enemies = []\n for t in find_tags:\n enemies.extend(get(t))\n\n distances = [distance(e.pos, sprite.pos) for e in enemies]\n\n enemy = enemies[distances.index(min(distances))]\n x, y = sprite.pos\n\n choices = [(x, y), (x, y-1), (x, y+1), (x+1, y), (x-1, y)]\n distances = [distance(p, enemy.pos) for p in choices]\n visibility = [visible(p) for p in choices]\n\n best = None\n min_dist = 999999\n for i in range(len(choices)):\n if is_wall(choices[i]) or not visibility[i]:\n continue\n\n #every now and then make a random \"bad\" move\n rnd = random.uniform(0, 1)\n if rnd <= pbad:\n best = choices[i]\n break\n elif distances[i] < min_dist:\n best = choices[i]\n min_dist = distances[i]\n if best is not None and best != (x,y):\n sprite.move((best[0] - x, best[1] - y))","def makeMove(self, movable_statement):\n ### Student code goes here\n tile = movable_statement.terms[0].term.element\n initialX = movable_statement.terms[1].term.element\n initialY = movable_statement.terms[2].term.element\n goalX = movable_statement.terms[3].term.element\n goalY = movable_statement.terms[4].term.element\n r1 = parse_input(\"fact: (on \" + tile + \" \" + initialX + \" \" + initialY + \")\")\n self.kb.kb_retract(r1)\n r2 = parse_input(\"fact: (on empty \" + goalX + \" \" + goalY + \")\")\n self.kb.kb_retract(r2)\n stat1 = parse_input(\"fact: (on \" + tile + \" \" + goalX + \" \" + goalY + \")\")\n self.kb.kb_assert(stat1)\n stat2 = parse_input(\"fact: (on empty \" + initialX + \" \" + initialY + \")\")\n self.kb.kb_assert(stat2)\n\n\n #for facts in self.kb.facts:\n # print(facts.statement)\n\n #print(\"\\n\\n\")\n ##Need to handle adjacentTo\n '''ask = parse_input(\"fact: (adjacentTo empty ?tile)\")\n answer = self.kb.kb_ask(ask)\n empty_adj = []\n if answer:\n for ans in answer.list_of_bindings:\n adjTile = ans[0].bindings[0].constant.element\n if adjTile != tile:\n rt = parse_input(\"fact: (adjacentTo empty \" + adjTile + \")\")\n self.kb.kb_retract(rt)\n #print(\"RMOVINGGGG\")\n #print(rt)\n rt1 = parse_input(\"fact: (adjacentTo \" + adjTile + \" empty)\")\n self.kb.kb_retract(rt1)\n empty_adj.append(adjTile) #All of empty's adjacent tiles'''\n\n #for facts in self.kb.facts:\n # print(facts.statement)\n\n #print(\"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\")\n '''ask1 = parse_input(\"fact: (adjacentTo \" + tile + \" ?tile)\")\n answer1 = self.kb.kb_ask(ask1)\n if answer1:\n for ans in answer1.list_of_bindings:\n adjTile = ans[0].bindings[0].constant.element\n if adjTile != \"empty\":\n stat = parse_input(\"fact: (adjacentTo empty \" + adjTile + \")\")\n self.kb.kb_assert(stat)\n radj1 = parse_input(\"fact: (adjacentTo \" + tile + \" \" + adjTile + \")\")\n self.kb.kb_retract(radj1)\n radj2 = parse_input(\"fact: (adjacentTo \" + adjTile + \" \" + tile + \")\")\n self.kb.kb_retract(radj2)\n for tiles in empty_adj:\n stat = parse_input(\"fact: (adjacentTo \" + tile + \" \" + tiles + \")\")\n self.kb.kb_assert(stat)'''","def minimax_helper(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n \n # Get all the available moves at the current state\n legal_moves = game.get_legal_moves()\n\n # Handle a terminal event/exhaustive search completion\n # at least in relation to depth sought\n if (not legal_moves) or (depth == 0):\n if maximizing_player:\n return (self.score(game, game.active_player), (-1, -1))\n else:\n return (self.score(game, game.inactive_player), (-1, -1))\n\n if maximizing_player: # the current player\n this_score = float(\"-inf\")\n for move in legal_moves:\n next_ply_state = game.forecast_move(move)\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\n depth-1, False)\n\n # Identify the maximum score branch for the current player.\n if next_ply_score >= this_score:\n this_move = move\n this_score = next_ply_score\n\n else: # the current player's opponent\n this_score = float(\"inf\")\n for move in legal_moves:\n next_ply_state = game.forecast_move(move)\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\n depth-1, True) \n\n # Identify the minimum score branch for the opponent\n if next_ply_score <= this_score:\n this_move = move\n this_score = next_ply_score\n\n return this_score, this_move","def getMove(self, grid):\n# global prune\n# prune = 0\n def Terminal(stateTup):\n \"\"\"\n Checks if the node is a terminal node\n Returns eval(state) if it is terminal\n \"\"\"\n state = stateTup[0]\n maxDepth = self.depthLimit\n if stateTup[1] == maxDepth:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n elif len(stateTup[0].getAvailableMoves()) == 0:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n\n def Eval(state):\n \"\"\"\n This is the eval function which combines many heuristics and assigns\n weights to each of them\n Returns a single value\n \"\"\"\n\n# H1 = htest2(state)\n# return H1\n H2 = h1(state)*monotonic(state)\n return H2\n\n\n def h1(state):\n Max = state.getMaxTile()\n left = len(state.getAvailableCells())/16\n if state.getCellValue([0,0]) == Max:\n v = 1\n else:\n v= 0.3\n Max = Max/1024\n return Max*left*v\n\n def mono(state):\n mon = 0\n# for i in range(4):\n# row = 0\n# for j in range(3):\n# if state.map[i][j] > state.map[i][j+1]:\n# row+=1\n# if row == 4:\n# mon += 1\n# for i in range(4):\n# column = 0\n# for j in range(3):\n# if state.map[j][i] > state.map[j+1][i]:\n# column +=1\n# if column == 4:\n# mon +=1\n#\n#\n# return mon/8\n for i in range(4):\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\n mon+=1\n\n return mon/8\n\n def monotonic(state):\n cellvals = {}\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n for i in Path1:\n cellvals[i] = state.getCellValue(i)\n mon = 0\n for i in range(4):\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\n mon +=1\n for j in range(4):\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\n mon+=1\n return mon/8\n\n\n\n def htest2(state):\n score1 = 0\n score2 = 0\n r = 0.5\n\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\n valDict = {}\n for n in range(16):\n valDict[Path1[n]] = state.getCellValue(Path1[n])\n for n in range(16):\n if n%3 == 0:\n self.emergency()\n cell1 = valDict.get(Path1[n])\n cell2 = valDict.get(Path2[n])\n score1 += (cell1) * (r**n)\n score2 += (cell2) * (r**n)\n return max(score1,score2)\n\n\n def Maximize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n maxChild , maxUtility = None,-999999999\n state = stateTup[0]\n Map = self.dict.get(str(state.map))\n if Map == None:\n children = []\n for M in range(4):\n g = state.clone()\n if g.move(M):\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Minimize(childTup,A,B)[1]\n if utility > maxUtility:\n maxChild , maxUtility = child , utility\n if maxUtility >= B:\n# global prune\n# prune +=1\n break\n if maxUtility > A:\n A = maxUtility\n\n return (maxChild,maxUtility)\n\n\n def Minimize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n minChild , minUtility = None,999999999\n state = stateTup[0]\n Map= self.dict.get(str(state.map))\n if Map == None:\n cells= state.getAvailableCells()\n children = []\n tiles = [2,4]\n for i in cells:\n for j in tiles:\n g = state.clone()\n g.insertTile(i,j)\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Maximize(childTup,A,B)[1]\n if utility < minUtility:\n minChild , minUtility = child , utility\n if minUtility <= A:\n# global prune\n# prune +=1\n break\n if minUtility < B:\n B = minUtility\n\n return (minChild,minUtility)\n\n\n\n def decision(grid):\n \"\"\"\n Decision function which returns the move which led to the state\n \"\"\"\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()\n\n self.dict = {}\n self.h = {}\n self.prevTime = time.clock()\n self.depthLimit = 1\n self.mL = []\n self.over = False\n while self.over == False:\n self.depthLimit +=1\n try :\n self.mL.append(decision(grid))\n\n except KeyError:\n# print(self.depthLimit)\n return self.mL[-1]\n except IndexError:\n return random.randint(0,3)\n self.Alarm(time.clock())\n return self.mL[-1]","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # For this problem we will be reusing the majority of our work from question 2, but we will be\n # implementing alpha-beta pruning on top of our existing minimax infrastructure\n actionList = gameState.getLegalActions(0)\n pacmanAgentIndex = 0\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\n count = util.Counter()\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\n\n def maximizer(curState, agentIndex, alpha, beta, depth):\n\n ghostActions = curState.getLegalActions(agentIndex)\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\n weight = -99999999 # Worst case starting value to be changed in the code\n if depth == maxDepth: # If we are at a leaf node\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\n # Otherwise, we progress the tree until the above condition is reached\n if len(ghostActions) != 0:\n for x in ghostActions:\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth):\n weight = weight\n else:\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth)\n if weight > beta:\n return weight\n if alpha < weight:\n alpha = weight\n return weight\n # if there are no legal actions left then evaluate at the last known state\n # Fall through into this return\n return self.evaluationFunction(curState)\n\n def minimizer(curState, agentIndex, alpha, beta, depth):\n ghostActions = curState.getLegalActions(agentIndex)\n weight = 999999999 # Worst case starting value to be changed in the code\n if len(ghostActions) != 0:\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\n for x in ghostActions: # For each legal action in the current position\n temp = maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, alpha, beta, depth+1)\n if weight < temp:\n weight = weight\n else:\n weight = temp\n if weight < alpha:\n return weight\n if beta > weight:\n beta = weight\n else: # Otherwise, we continue to minimize\n for x in ghostActions: # For each legal action in the current position\n temp = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth)\n if weight < temp:\n weight = weight\n else:\n weight = temp\n if weight < alpha:\n return weight\n if beta > weight:\n beta = weight\n return weight\n # if there are no legal actions left then evaluate at the last known state\n # Fall through into this return\n return self.evaluationFunction(curState)\n\n endWeight = -999999999\n alpha = -999999999\n beta = 999999999\n\n # Executing the minimizer for all possible actions\n for x in actionList:\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\n endWeight = minimizer(tempState, 1, alpha, beta, 0,)\n count[x] = endWeight\n if alpha < endWeight:\n alpha = endWeight\n # print('HELLO THERE')\n # print(count)\n return count.argMax()","def utility(state:State,maximizing_player):\n best_move_score = -1\n #######################[Goal]#########################\n is_current_player_stuck = is_stuck(state,state.player_type)\n other_player = RIVAL if state.player_type == PLAYER else PLAYER\n # Check if stuck\n if is_current_player_stuck:\n if state.player_type == PLAYER:\n state.players_score[state.player_type] -= state.penalty_score\n else:\n state.players_score[state.player_type] += state.penalty_score\n return state.players_score[state.player_type] - state.players_score[other_player] \n ######################################################\n # Else\n #--------------------------------------------------\n ################# Available Steps #################\n #--------------------------------------------------\n player_available_steps = availables(state.board, state.locations[PLAYER])\n h1 = 4-player_available_steps\n h4 = player_available_steps\n #--------------------------------------------------\n ################# Fruits Distance #################\n #--------------------------------------------------\n h2 = -1\n if state.fruits_ttl > 0 and len(state.fruits_dict) > 0:\n min_fruit_dist = float('inf')\n for fruit_loc in state.fruits_dict:\n curr_fruit_dist = Manhattan(state.locations[state.player_type], fruit_loc)\n # Check what is the closest fruit reachable\n if curr_fruit_dist < min_fruit_dist and curr_fruit_dist <= state.fruits_ttl:\n other_player_fruit_dist = Manhattan(state.locations[other_player], fruit_loc)\n if curr_fruit_dist < other_player_fruit_dist:\n min_fruit_dist = curr_fruit_dist\n max_dist = len(state.board)+len(state.board[0])\n h2 = (max_dist*10.0/min_fruit_dist)+1 if min_fruit_dist < float('inf') else -1\n #--------------------------------------------------\n ################# Reachable Squrs #################\n #--------------------------------------------------\n reachables_player = reachables(state.board,state.locations[PLAYER])\n reachables_rival = reachables(state.board,state.locations[RIVAL])\n h3 = reachables_player - reachables_rival # We want more for us\n #--------------------------------------------------\n ################# Combine it all. #################\n #--------------------------------------------------\n if not state.half_game():\n w = 0.8 if h2 > 0 else 1\n best_move_score = w*(h1-h3) + (1-w)*h2 \n else:\n w = 0.7 if h2 > 0 else 1\n best_move_score = w*(h4+h3) + (1-w)*h2 \n\n best_move_score += state.players_score[state.player_type]\n return best_move_score","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n\n \"\"\"\n From AIMA psuedocode:\n\n function MINIMAX-DECISION(state) returns an action\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\n \"\"\"\n\n best_move = (-1,-1)\n best_score = float(\"-inf\")\n actions = game.get_legal_moves()\n\n if not actions:\n return best_move\n else:\n best_move = actions[randint(0, len(actions) - 1)]\n\n try:\n # The try/except block will automatically catch the exception\n # raised when the timer is about to expire.\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\n for action in actions:\n score = self._min_value(game.forecast_move(action), 1)\n if score > best_score:\n best_score = score\n best_move = action\n\n except SearchTimeout:\n pass\n\n return best_move","def parse(self, words, gold_tree=None, beam_size=10):\n if gold_tree:\n word_order = self.get_word_order(gold_tree)\n tags = self.tagger.tag(words)\n possible_configs = [self.initial_config(words)]\n while any(config['next_move'] != None for config in possible_configs):\n old_possible_configs = possible_configs\n possible_configs = []\n for config in old_possible_configs:\n config = self.move(config)\n candidates = self.valid_moves(config)\n if candidates:\n feat = self.features(words, tags, config)\n scores = self.predict(feat, candidates)\n if gold_tree:\n gold_move = self.gold_move(config, gold_tree, \\\n word_order)\n if config['is_gold'] and gold_move not in scores:\n possible_configs = self.update_and_reset_config( \\\n config, feat, gold_move)\n break\n # add new configs for the possible moves\n for curr_move, curr_score in scores.items():\n # create a copy of the config and append it to the list\n new_config = deepcopy(config)\n if curr_score > 0:\n new_config['score'] += log(curr_score)\n else:\n new_config['score'] += float(\"-inf\")\n new_config['next_move'] = curr_move\n if gold_tree and gold_move != curr_move:\n new_config['is_gold'] = False\n possible_configs.append(new_config)\n else:\n config['next_move'] = None\n possible_configs.append(config)\n # delete the configs with the lowest scores\n while len(possible_configs) > beam_size:\n worst_conf_ind, worst_conf = \\\n min(enumerate(possible_configs), \n key = lambda t: t[1]['score'])\n if gold_tree and worst_conf['is_gold'] == True:\n feat = self.features(words, tags, worst_conf)\n possible_configs = self.update_and_reset_config( \\\n worst_conf, feat, worst_conf['next_move'])\n else:\n del possible_configs[worst_conf_ind]\n # return best tree\n best_config = max(possible_configs, key = lambda t: t['score'])\n return tags, best_config['pred_tree']","def search(start):\n\n '''\n Create a class named nodeClass which contains 4 elements: \n state: The puzzle object containing the puzzle board at the node \n misplaced: num of misplaced tiles\n depth: depth of the node in the tree \n prev: parent node\n '''\n nodeClass = namedtuple('nodeClass', 'state, misplaced, depth, prev')\n\n #instantiate object from class creating the root node\n node = nodeClass(start, 0, 0, None)\n\n #stores the nodes that are going to be explored. \n #the node with lower f-score is explored first\n frontier = q.PriorityQueue()\n frontier.put((0,node))\n\n # frontier_set keep track of the nodes in the frontier queue\n frontier_set = {node}\n #contains the board states already explored\n explored_states = set()\n for ite in range(1,max_iterations+2):#while True:\n #Retrieve the node in the frontier with lowest value\n node = frontier.get()[1]\n\n #get the puzzle board obj from the node object\n state = node.state\n\n #Check if the game has ben solved\n if state.solved or ite==max_iterations:\n Result = namedtuple('Result', 'board, depth, nodesExpanded, max_depth, isSolved')\n return Result(state, node.depth, ite, max(no.depth for no in frontier_set), state.solved)\n\n # expanded nodes are added to explored set\n explored_states.add(state)\n\n #EXPANDING\n for mov in state.possible_moves:\n new_state=state.move(mov)\n new_node = nodeClass(new_state, new_state.score,\n node.depth + 1, node)\n\n #compute f-score of the node\n f_score=new_state.score + new_node.depth\n\n if new_state not in explored_states and new_node not in frontier_set:\n frontier.put((f_score,new_node))\n frontier_set.add(new_node)","def run_ai():\n print(\"Minimax AI\") # First line is the name of this AI \n color = int(input()) # Then we read the color: 1 for dark (goes first), \n # 2 for light. \n\n while True: # This is the main loop \n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input() \n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n\n if status == \"FINAL\": # Game is over. \n print \n else: \n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The \n # squares in each row are represented by \n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n \n # Select the move and send it to the manager\n movei, movej = select_move_minimax(board, color)\n # movei, movej = select_move_alphabeta(board, color)\n print(\"{} {}\".format(movei, movej))","def action(self):\n\n self.start_timer()\n\n minimax_probability = self.norm.cdf(self.root.branching)\n use_minimax = boolean_from_probability(minimax_probability)\n if self.time_consumed > 53:\n # Time is starting to run low, use the faster option\n use_minimax=True\n\n if self.time_consumed < 59:\n if self.root.turn < 4:\n result = book_first_four_moves(self.root)\n elif use_minimax:\n result = minimax_paranoid_reduction(self.root)\n else:\n result = monte_carlo_tree_search(\n self.root,\n playout_amount=3,\n node_cutoff=4,\n outer_cutoff=4,\n num_iterations=1200,\n turn_time=0.75,\n exploration_constant=1.7,\n use_slow_culling=False,\n verbosity=0,\n use_prior=True,\n num_priors=4,\n use_fast_prune_eval=False,\n use_fast_rollout_eval=False,\n )\n else:\n result = greedy_choose(self.root)\n\n self.end_timer()\n\n return result","def step(self):\n if self.model.schedule.steps < self.model.residential_steps:\n residential_move = True\n else:\n residential_move = False\n\n\n if residential_move:\n # only step the agents if the number considered is not exhausted\n if self.model.total_considered < self.model.residential_moves_per_step:\n # move residential\n U_res = self.get_res_satisfaction(self.pos)\n self.model.res_satisfaction.append(U_res)\n\n # print(\"U_res\",U_res)\n if U_res < self.T:\n\n # todo: implement different move schemes, for now only random\n # find all empty places\n # rank them\n # take one with boltzmann probability.\n self.evaluate_move(U_res, school=False)\n\n else:\n self.model.res_happy += 1\n\n self.model.total_considered += 1\n #print(\"considered\",self.model.total_considered)\n\n\n else:\n if self.model.total_considered < self.model.school_moves_per_step:\n # school moves\n # satisfaction in current school\n U = self.get_school_satisfaction(self.school, self.dist_to_school)\n self.model.satisfaction.append(U)\n\n # If unhappy, compared to threshold move:\n if U < self.T:\n #print('unhappy')\n self.evaluate_move(U, school=True)\n\n else:\n self.model.happy += 1\n if self.model.total_considered>0:\n self.model.percent_happy = np.ma(self.model.happy/self.model.total_considered)","def minimax(board: list, player_turn: chr):\n if player_turn == 'b':\n enemy_turn = 'w'\n else:\n enemy_turn = 'b'\n player_moves, enemy_start_boards = Evaluator.generate_options(board, player_turn)\n\n player_scores = [x.get(\"final_score\") for x in player_moves]\n enemy_scores = []\n\n for enemy_start_board in enemy_start_boards:\n board_index = enemy_start_boards.index(enemy_start_board)\n player_score = player_scores[board_index]\n enemy_moves, player_start_boards = Evaluator.generate_options(enemy_start_board, enemy_turn)\n\n # Gets highest white score for first board.\n if enemy_start_boards.index(enemy_start_board) == 0:\n best_enemy_score = -10000000\n for move in enemy_moves:\n score = move.get(\"final_score\") - player_score\n if score > best_enemy_score:\n best_enemy_score = score\n enemy_scores.append(best_enemy_score)\n else:\n current_min = min(enemy_scores)\n best_enemy_score = -10000000\n break_flag = False\n\n # Checks moves where active player performs push, more likely to yield high score -> move ordering.\n push_moves = filter(Evaluator.filter_push, enemy_moves)\n for move in push_moves:\n score = move.get(\"final_score\") - player_score\n if score > current_min:\n enemy_scores.append(score)\n break_flag = True\n break\n if break_flag:\n continue\n\n for move in enemy_moves:\n if move.get(\"pushes\") > 0:\n continue\n score = move.get(\"final_score\") - player_score\n if score > current_min:\n enemy_scores.append(score)\n break_flag = True\n break\n if score > best_enemy_score:\n best_enemy_score = score\n if not break_flag:\n enemy_scores.append(best_enemy_score)\n # print(enemy_start_board)\n # [print(x) for x in enemy_moves]\n # print(\"======================\")\n\n # Gets the lowest score aka worst board state for the opponent which will be the best move for us.\n min_val = min(enemy_scores)\n check_scores = numpy.array(enemy_scores)\n min_index = numpy.where(check_scores == min_val)[0]\n\n best_index = 0\n best_score = -100000\n\n for i in min_index:\n if player_moves[i].get(\"final_score\") > best_score:\n best_score = player_moves[i].get(\"final_score\")\n best_index = i\n\n return player_moves[best_index]","def makeMove(self, movable_statement):\n ### Student code goes here\n disk = movable_statement.terms[0].term.element\n initial = movable_statement.terms[1].term.element\n goal = movable_statement.terms[2].term.element\n #### Add the disk to the new stack and remove the facts of it being on the old one\n r1 = parse_input(\"fact: (on \" + disk + \" \" + initial + \")\")\n self.kb.kb_retract(r1)\n r2 = parse_input(\"fact: (isTopofStack \" + disk + \" \" + initial + \")\")\n self.kb.kb_retract(r2)\n stat1 = parse_input(\"fact: (on \" + disk + \" \" + goal + \")\")\n self.kb.kb_assert(stat1)\n stat2 = parse_input(\"fact: (isTopofStack \" + disk + \" \" + goal + \")\")\n self.kb.kb_assert(stat2)\n\n ## Determine if any disks are on the initial peg\n ask1 = parse_input(\"fact: (on ?X \" + initial + \")\")\n answer = self.kb.kb_ask(ask1)\n if answer == False: #If no disks are on the initial peg\n empty_stat = parse_input(\"fact: (isempty \" + initial + \")\")\n self.kb.kb_assert(empty_stat)\n else:\n disks_on_initial = []\n for ans in answer.list_of_bindings:\n disks_on_initial.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\n ask_top = parse_input(\"fact: (isTopofStack ?X \" + initial + \")\")\n top_ans = self.kb.kb_ask(ask_top)\n disks_on_initial.sort()\n if top_ans:\n for ans in top_ans.list_of_bindings:\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_initial[0]:\n retract = parse_input(\"fact: (isTopofStack \" + ans[0].bindings[0].constant.element + \" \" + initial + \")\")\n self.kb.kb_retract(retract)\n assert1 = parse_input(\"fact: (isTopofStack disk\" + str(disks_on_initial[0]) + \" \" + initial + \")\")\n self.kb.kb_assert(assert1)\n\n goal_ask = parse_input(\"fact: (on ?X \" + goal + \")\")\n goal_answer = self.kb.kb_ask(goal_ask)\n disks_on_goal = []\n for ans in goal_answer.list_of_bindings:\n disks_on_goal.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\n ask_topg = parse_input(\"fact: (isTopofStack ?X \" + goal + \")\")\n top_ansg = self.kb.kb_ask(ask_topg)\n disks_on_goal.sort()\n if top_ansg:\n for ans in top_ansg.list_of_bindings:\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_goal[0]:\n retract = parse_input(\"fact: (isTopofStack \" + ans[0].bindings[0].constant.element + \" \" + goal + \")\")\n self.kb.kb_retract(retract)\n\n ask2 = parse_input(\"fact: (isempty \" + goal + \")\")\n answer2 = self.kb.kb_ask(ask2)\n if answer2:\n self.kb.kb_retract(ask2)","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n while to_move < len(movables):\n # Make the move\n movable_statement = movables[to_move]\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n\n # Find out if this state has already been explored\n visited = False\n for visited_state in self.visited.keys():\n if visited_state.state == new_state:\n visited = True\n\n # If the new state hasn't been visited then add it as a child then move down to this child\n if not visited:\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.currentState = new_gs\n break\n\n # Else skip this state and try going to the next movable statement\n else:\n # print(\"SKIP THIS STATE\")\n self.gm.reverseMove(movable_statement)\n to_move += 1\n\n # Went all the way down to a leaf, backtrack\n if (to_move >= len(movables)):\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n\n return False","def run(self):\n\n # init\n base_value = self._problem.evaluate()\n self._problem.set_as_best(base_value)\n\n # init iteration (used to count the amount of iterations)\n iteration = 0\n\n # add to data\n self._data_append(self.data, iteration, base_value, base_value)\n\n # init termination criterion\n self._termination_criterion.check_first_value(base_value)\n self._termination_criterion.start_timing()\n\n # main loop\n while self._termination_criterion.keep_running():\n\n # search the neighbourhood for the best move\n best_found_delta = self._best_found_delta_base_value\n best_found_move = None\n\n for move in self._problem.get_moves():\n\n # check quality move\n delta = self._problem.evaluate_move(move)\n\n # checks how the move alters the current state\n diff = self._diff(move)\n\n # if not in tabu list --> not similar to earlier performed\n # moves --> if delta better than old best move\n # --> becomes the best move\n\n if not self._tabu_list.contains(diff) and \\\n self._is_better(best_found_delta, delta):\n best_found_delta = delta\n best_found_move = move\n best_found_diff = diff\n\n # the best found move will be used as the next move\n # alter state problem\n base_value = base_value + best_found_delta\n\n # check if a move was found\n if best_found_move is not None:\n\n self._problem.move(best_found_move)\n\n # if better than best found --> new best_found\n if self._is_better(self._problem.best_order_value,\n base_value):\n self._problem.set_as_best(base_value)\n # log the better solution\n self._log_improvement(base_value)\n\n # add diff to tabu list\n self._tabu_list.add(best_found_diff)\n\n # add to data\n self._data_append(self.data, iteration,\n base_value, self._problem.best_order_value)\n\n self._termination_criterion.check_new_value(base_value)\n\n # functions _termination_criterion called\n self._termination_criterion.check_new_value(base_value)\n\n else:\n # no move found --> we're stuck --> break loop\n break\n\n iteration += 1\n self._termination_criterion.iteration_done()\n\n # last data point\n self._data_append(self.data, iteration, base_value,\n self._problem.best_order_value)\n\n # if we have data:\n # convert data to something easier to plot\n if self.data is not None:\n\n # convert to tuple of list\n data = convert_data(self.data)\n\n # make namedtuple\n DataAsLists = namedtuple(\n 'Data', ['time', 'iteration', 'value', 'best_value'])\n\n data = DataAsLists(data[0], data[1], data[2], data[3])\n\n else:\n data = None\n\n # return results\n\n Results = namedtuple('Results', ['best_order', 'best_value', 'data'])\n\n return Results(self._problem.best_order,\n self._problem.best_order_value,\n data)","def search_best_next_move(self, model, initial_tree_node):\n\n # EDIT THIS METHOD TO RETURN BEST NEXT POSSIBLE MODE FROM MINIMAX MODEL ###\n\n # NOTE: Don't forget to initialize the children of the current node\n # with its compute_and_get_children() method!\n\n alpha = float('-inf')\n beta = float('inf')\n depth = 4\n player = 0\n ##send root node and these parameters to minimax\n start_time = time()\n move = self.alpha_beta(initial_tree_node, player, alpha, beta, start_time)\n #random_move = random.randrange(5)\n return ACTION_TO_STR[move[1]]","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n print(\"\\t===========================================\")\n print(\"\\t Processing ... Please Wait for 11 seconds!\")\n print(\"\\t===========================================\")\n startState = problem.getStartState();\n fringe = util.PriorityQueue()\n costs = 0 \n visitedNodes = []\n actions = [] \n if ( problem.isGoalState(startState) == True):\n return actions\n else:\n newFringeItem = (startState , actions , costs)\n fringe.push(newFringeItem,costs)\n while(fringe.isEmpty() == False ):\n #f(x) = h(x) + g(x)\n currentState , actions , costs = fringe.pop()\n if ( problem.isGoalState(currentState) == True):\n #print(\"Final Actions : \" + str(actions)) \n \"\"\"\n If you want the Analyzer Class analizes the chosen path and heuristic , \n Uncomment these two lines of code otherwise leave it be commented cause it increases the run time by 2 seconds.\n \"\"\"\n \"\"\"Start : Analyzer Properties \"\"\"\n #analyzer = Analyzer(problem,actions)\n #analyzer.start()\n \"\"\"End : Analyzer Properties \"\"\"\n return actions\n else:\n if(not currentState in visitedNodes ):\n visitedNodes.append(currentState)\n currentNodeSuccessors = problem.getSuccessors(currentState)\n for node in currentNodeSuccessors :\n state , action , stateCost = node\n heuristicAmount = heuristic(state , problem)\n newFringeItem = state , actions + [action] , costs + stateCost\n priority = costs + heuristicAmount\n fringe.push( newFringeItem , priority )\n \n util.raiseNotDefined()","def run(self, max_depth):\n while len(self.stack) > 0:\n state = self.get_next_state()\n\n if state.is_solution():\n self.solutions.append(state.moves)\n\n if len(state.moves) < max_depth:\n self.create_children(state)\n\n self.archive[state.get_tuple()] = len(state.moves)\n\n # sort solutions best to worst\n self.solutions.sort(key=len)\n\n if self.solutions:\n return self.solutions[0]\n\n print(\"This depth is not sufficient.\")\n return []","def calculate_next_move(self, visit):\n self.depth += 1\n new_boards = []\n for vehicle_id in range(len(self.vehicles)):\n vehicle = self.vehicles[vehicle_id]\n state = self.get_board()\n if vehicle.orientation == 0: #horizontal\n if vehicle.x > 0: #left\n if state[vehicle.y][vehicle.x-1] == \"..\":\n self.vehicles[vehicle_id].x -=1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].x += 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].x += 1\n\n if vehicle.x + vehicle.length <= (len(state)-1): #right\n if state[vehicle.y][vehicle.x+vehicle.length] == \"..\":\n self.vehicles[vehicle_id].x += 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].x -= 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].x -= 1\n\n else: #vertical\n if vehicle.y - 1 >= 0: #up\n if state[vehicle.y-1][vehicle.x] == \"..\":\n self.vehicles[vehicle_id].y -= 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].y += 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].y += 1\n\n if vehicle.y + vehicle.length <= (len(state)-1):\n if state[vehicle.y + vehicle.length][vehicle.x] == \"..\":#down\n self.vehicles[vehicle_id].y += 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].y -= 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].y -= 1\n self.depth -= 1\n return new_boards","def minimax(self, game, depth):\n _, move = self.minimax_search(game, depth)\n return move","def ai_move():\n\tinitial_state = map(get_filled_edges, rects)\n\tpossible_moves = []\n\tfor index, filled_edges in enumerate(initial_state):\n\t\tif filled_edges == 0:\n\t\t\tpossible_moves.extend([(index, i) for i in 'ltrb'])\n\t\telif filled_edges == 1:\n\t\t\tpossible_moves.extend(one_filled_edge(index))\n\t\telif filled_edges == 2:\n\t\t\tpossible_moves.extend(two_filled_edge(index))\n\t\telif filled_edges == 3:\n\t\t\tpossible_moves.extend(three_filled_edge(index))\n\tprint possible_moves\n\tpossible_decisions = []\n\tfor move in possible_moves:\n\t\tfinal_state = apply_move(move)\n\t\tpossible_decisions.append(is_feasible(initial_state, final_state))\n\tprint possible_decisions\n\t# randomizing when some decisions have the same weight\n\tmax_weight = max(possible_decisions)\n\t# list of indices which have the same weight\n\tmax_indices = []\n\tfor index, weight in enumerate(possible_decisions):\n\t\tif weight == max_weight:\n\t\t\tmax_indices.append(index)\n\tx = choice(max_indices)\n\tprint x\n\treturn possible_moves[x]\n\t# return possible_moves[possible_decisions.index(max(possible_decisions))]","def __build_tree__(self, features, classes, depth=0):\n\n # TODO: finish this.\n root = None\n if (len(set(classes)) <= 1) and (len(classes) != 0) :\n return DecisionNode(None,None,None,classes[0])\n elif (len(classes) == 0):\n return DecisionNode(None,None,None,2)\n elif depth == self.depth_limit:\n return DecisionNode(None,None,None,max(set(classes), key=list(classes).count))\n else:\n# if depth == 0:\n features = np.array(features)\n classes = np.array(classes).reshape(-1,1)\n feat_shape = features.shape\n sample_list = range(feat_shape[0])\n gains = np.zeros((feat_shape[1]))\n indices = np.zeros((feat_shape[1]))\n for i in range(feat_shape[1]):\n attribute = features[:,i]\n for j in range(20):\n split_indx = int(np.random.choice(sample_list, replace=False))\n idx_above = np.where(attribute > attribute[split_indx])[0]\n idx_below = np.where(attribute < attribute[split_indx])[0]\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\n gain = gini_gain(list(classes.reshape(1,-1)[0]),[list(classes_below),list(classes_above)])\n if gain > gains[i]:\n gains[i] = gain\n indices[i] = split_indx\n indx = np.argmax(gains)\n split_indx = int(indices[indx])\n attribute = features[:,indx]\n idx_above = np.where(attribute > attribute[split_indx])[0]\n idx_below = np.where(attribute < attribute[split_indx])[0] \n features_below = features[idx_below,:]\n features_above = features[idx_above,:]\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\n if (len(classes_below) != 0) and (len(classes_above) != 0):\n root = DecisionNode(None,None,lambda feat:feat[indx] > features[split_indx,indx])\n root.left = self.__build_tree__(features_above, classes_above, depth+1)\n root.right = self.__build_tree__(features_below, classes_below, depth+1)\n return root\n elif (len(classes_below) == 0) and (len(classes_above) != 0):\n return DecisionNode(None,None,None,max(set(classes_above), key=list(classes_above).count))\n elif (len(classes_above) == 0) and (len(classes_below) !=0):\n return DecisionNode(None,None,None,max(set(classes_below), key=list(classes_below).count))\n else:\n return DecisionNode(None,None,None,2)","def _greedy(self, state):\n\n node = self.mcts_head\n if self.verbose > 1:\n logger.debug(f\"Starting greedy algorithm.\")\n\n while not node.terminal:\n # Parse current state\n this_state, total_reward, terminal = self._parse_path(state, node.path)\n node.set_terminal(terminal)\n if self.verbose > 1:\n logger.debug(f\" Analyzing node {node.path}\")\n\n # Expand\n if not node.terminal and not node.children:\n actions = self._find_legal_actions(this_state)\n step_rewards = [self._parse_action(action, from_which_env=\"sim\") for action in actions]\n if self.verbose > 1:\n logger.debug(f\" Expanding: {len(actions)} legal actions\")\n node.expand(actions, step_rewards=step_rewards)\n\n # If terminal, backup reward\n if node.terminal:\n if self.verbose > 1:\n logger.debug(f\" Node is terminal\")\n if self.verbose > 1:\n logger.debug(f\" Backing up total reward {total_reward}\")\n node.give_reward(self.episode_reward + total_reward, backup=True)\n\n # Debugging -- this should not happen\n if not node.terminal and not node.children:\n logger.warning(\n f\"Unexpected lack of children! Path: {node.path}, children: {node.children.keys()}, legal actions: {self._find_legal_actions(this_state)}, terminal: {node.terminal}\"\n )\n node.set_terminal(True)\n\n # Greedily select next action\n if not node.terminal:\n action = node.select_greedy()\n node = node.children[action]\n\n if self.verbose > 0:\n choice = self.mcts_head.select_best(mode=\"max\")\n self._report_decision(choice, state, \"Greedy\")","def moveManager(self):\r\n \r\n (nb1,nb2) = self._board.get_nb_pieces() \r\n val = 0\r\n alphaBeta_instance = AlphaBeta()\r\n \r\n # Early-Game: Check opening move in a custom bloom filter\r\n if(nb1+nb2 < MoveManager.__AI_OPENING_MOVE_VALUE__()): \r\n print(\"Check if \", Utils.HashingOperation.BoardToHashCode(self._board), \"is present\")\r\n move = self._openingMover.GetMove(self._board)\r\n \r\n if(move is None): #No Opening Move has been found, need to calculate the AB-pruning\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \r\n depth=3,\r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # End-Game: Special depth alpha-beta\r\n elif ((nb1+nb2) > MoveManager.__AI_ENDGAME_VALUE__(self._board)): \r\n# self._maxDepth = WIDTH*HEIGHT - (nb1+nb2)\r\n print(\"Special depth For Pruning: \", nb1+nb2)\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self,\r\n depth=self._board._boardsize * self._board._boardsize - (nb1+nb2), \r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # Mid-Game: Usual Case. Alpha Beta. Can use the parallelization, or chose to check a bloom filter if a good board has already been find \r\n else: \r\n #Alpha and Beta should be set directly on the AlphaBeta class\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \r\n depth=3,\r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # No move has been find, generate one with a simple heuristic\r\n if move is None: \r\n print(\"\")\r\n print(\"\")\r\n print(\"Default value. No move has been found\")\r\n val = -7578748789\r\n# time.sleep(1)\r\n (move, _) = MoveManager.MoveForGameBeginning(self, self._board.legal_moves()) \r\n \r\n print(\"\")\r\n print(\"\")\r\n print(\"\")\r\n print(\"Val is:\", val)\r\n# time.sleep(1)\r\n return move","def solveOneStep(self):\n ### Student code goes here\n if self.first_step == False:\n self.first_step = True\n if self.solveOneStep():\n return True\n if self.queue:\n self.gm_init()\n ele = self.queue.get()\n #print (len(ele))\n state = ele[0]\n premoves = ele[1]\n\n for m in premoves:\n self.gm.makeMove(m)\n if state.state == self.victoryCondition:\n return True\n self.visited[state] = True\n print(\"CURRENTSTATE:\")\n print(self.gm.getGameState())\n print(\"*******\")\n moves = self.gm.getMovables()\n for m in moves:\n self.gm.makeMove(m)\n if (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\n self.gm.reverseMove(m)\n continue\n self.visited[GameState(self.gm.getGameState(), 0, None)] = True\n new_pmv = [i for i in premoves]\n new_pmv.append(m)\n next_state = GameState(self.gm.getGameState(), state.depth+1, m)\n next_state.parent = state\n state.children.append(next_state)\n self.queue.put([next_state, new_pmv])\n self.gm.reverseMove(m)\n self.currentState = state\n\n #for i in range(len(premoves)-1, -1, -1):\n # mv = premoves[i]\n # self.gm.reverseMove(mv)\n return False","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\n # to serve the purpose of finding the expected value\n actionList = gameState.getLegalActions(0)\n pacmanAgentIndex = 0\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\n count = util.Counter()\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\n def maximizer(curState, agentIndex, depth):\n\n ghostActions = curState.getLegalActions(agentIndex)\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\n weight = -99999999 # Worst case starting value to be changed in the code\n if depth == maxDepth: # If we are at a leaf node\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\n # Otherwise, we progress the tree until the above condition is reached\n if len(ghostActions) != 0:\n for x in ghostActions:\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\n weight = weight\n else:\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n def minimizer(curState, agentIndex, depth):\n ghostActions = curState.getLegalActions(agentIndex)\n weight = 0 # Starting value of zero to be incremented below\n if len(ghostActions) != 0:\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\n weight = weight + temp\n else: # Otherwise, we continue to minimize\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\n weight = weight + temp\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n # Executing the minimizer for all possible actions\n for x in actionList:\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\n count[x] = minimizer(tempState,1,0)\n # print('HELLO THERE')\n # print(count)\n return count.argMax()","def make_move(self, time_limit, players_score):\n finish_time = time.time() + time_limit\n depth = 1\n best_move = (-np.inf, (-1, 0))\n while True:\n for direction in self.directions:\n initial_state = utils.State(self.board, direction, self.pos, self.current_turn,\n self.fruits_on_board_dict,\n finish_time)\n try:\n outcome = self.minimax_algo.search(initial_state, depth, True)\n if outcome[0] > best_move[0]:\n best_move = outcome\n except TimeoutError:\n self.board[self.pos[0]][self.pos[1]] = -1\n self.pos = (self.pos[0] + best_move[1][0], self.pos[1] + best_move[1][1])\n self.board[self.pos[0]][self.pos[1]] = 1\n\n return best_move[1]\n depth += 1\n # print('bigger_depth : {} '.format(depth))","def iterative_minimax_strategy(game: Any) -> Any:\n s = Stack()\n id0 = 0\n d = {0: Tree([id0, game, None])}\n s.add(0)\n\n while not s.is_empty():\n id1 = s.remove()\n item = [id1]\n if d[id1].children == []:\n for move in d[id1].value[1].current_state.get_possible_moves():\n game1 = copy.deepcopy(d[id1].value[1])\n game1.current_state = game1.current_state.make_move(move)\n id0 += 1\n d[id0] = Tree([id0, game1, None])\n d[id1].children.append(id0)\n item.append(id0)\n else:\n item.extend(d[id1].children)\n for num in item:\n if d[num].value[1].is_over(d[num].value[1].current_state):\n d[num].value[2] = -1\n elif d[num].children != [] and all(d[x].value[2] is not None\n for x in d[num].children):\n d[num].value[2] = max([(-1) * d[y].value[2]\n for y in d[num].children])\n else:\n s.add(num)\n i = 0\n for q in d[0].children:\n if d[q].value[2] == -1:\n i = d[0].children.index(q)\n return game.current_state.get_possible_moves()[i]","def minimax(self, state, is_max, depth = 0, alpha=float(\"-inf\"), beta=float(\"inf\")):\n # Terminate \n if self.terminate(depth, state):\n return None, Utility.utility_function(state) \n \n # Recursive\n possible_moves = state.current_player_possible_moves()\n return self.search(is_max, possible_moves, state, depth, alpha, beta)","def _alphabeta_search(self, depth, white, black, playing, move_sequence,\n alpha=float('-inf'), beta=float('inf'), max_depth=1000,\n time_left=1000):\n self.nodes_searched += 1 # keep track of nodes searched for displaying\n start_time = clock() # keep track of time to stop the thread\n action = None\n\n state = (tuple(sorted(white, key=lambda x: x[0] + 10 * x[1])),\n tuple(sorted(black, key=lambda x: x[0] + 10 * x[1])), playing)\n\n if state in move_sequence: return 0 # check if state was previously encountered in branch\n move_sequence.add(state)\n\n # check if node is database of stored nodes at the correct depth\n if state in self.nodes and self.nodes[state][2] >= depth and \\\n abs(self.nodes[state][0]) < 1000:\n move_sequence.remove(state)\n if depth == max_depth:\n return (self.nodes[state][0], self.nodes[state][1])\n else:\n return self.nodes[state][0]\n if playing == 1 and is_winning(white): # check that state is not terminal\n val = 100000 + depth\n elif playing == 0 and is_winning(black):\n val = -100000 - depth\n elif depth == 0: # if depth is zero return heuristic approximation\n val = self._heuristic(white, black, playing)\n else:\n if not self.big:\n xstart = 1\n ystart = 1\n n = 5\n m = 4\n else: # this whole set of statements is just to only consider the inner squares\n # of a big board for the first few moves.\n if self.turn > 5:\n xstart = 1\n ystart = 1\n n = 7\n m = 6\n else:\n xstart = 2\n ystart = 2\n n = 6\n m = 5\n\n if playing == 0: # maximizer\n val = float(\"-inf\")\n\n for a in get_actions(white, black, n, m, xstart, ystart):\n modified_cell = self._apply_action(a, white)\n v = self._alphabeta_search(depth - 1, white, black, 1, move_sequence, alpha, beta) # continue searching\n if v > val: # update value and action if a better path has been found\n val = v\n action = a\n self._undo_action(a, white, modified_cell)\n\n alpha = max(alpha, val) # alpha-beta prunning\n if beta < alpha: break\n if clock() - start_time > time_left: return # end search if out of time\n else: # minimizer\n val = float(\"inf\")\n\n for a in get_actions(black, white, n, m, xstart, ystart):\n modified_cell = self._apply_action(a, black)\n v = self._alphabeta_search(depth - 1, white, black, 0, move_sequence, alpha, beta)\n if v < val:# update value and action if a better path has been found\n val = v\n action = a\n\n self._undo_action(a, black, modified_cell)\n\n beta = min(beta, val) # alpha-beta prunning\n if beta < alpha: break\n if clock() - start_time > time_left: break # end search if out of time\n\n self.nodes[state] = (val, action, depth) # update state database\n move_sequence.remove(state)\n if max_depth == depth: # only return the action if at root node\n return (val, action)\n else:\n return val","def minimax(gamestate, depth, timeTotal, alpha, beta, maxEntity):\n\n bonus = 0\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\n # Basis Rekursif\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\n bonus = 10\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\n bonus = -10\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\n\n # Rekurens\n if (gamestate.currentPlayer.noPlayer == maxEntity):\n # Choose the maximum utility of the state\n # Iterate all pion and its possible moves\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n maxValue = -math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n # Iterate all possible moves of pion index\n for move in all_possible_moves:\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old max value\n if (utility > maxValue):\n maxValue = utility\n maxGameState = newGameState\n \n alpha = max(alpha, maxValue)\n if (beta <= alpha):\n return maxGameState, maxValue\n return maxGameState, maxValue\n\n else:\n # Choose the minimum utility of the state\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n minValue = math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n # Iterate all possible moves of pion index\n for move in all_possible_moves:\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old min value\n if (utility < minValue):\n minValue = utility\n minGameState = newGameState\n \n beta = min(beta, minValue)\n if (beta <= alpha):\n return minGameState, minValue\n \n return minGameState, minValue","def decision(grid):\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()","def train(n):\n\n ai = NimAI()\n\n print(f\"Play {n} training games\")\n for _ in range(n): \n game = Nim()\n\n # Keep track of last move made by either player\n last = {\n 0: {\"state\": None, \"action\": None},\n 1: {\"state\": None, \"action\": None}\n }\n\n # Game loop\n while True:\n\n # Keep track of current state and action\n state = game.piles.copy()\n action = ai.chooseAction(game.piles)\n\n # Keep track of last state and action\n last[game.player][\"state\"] = state\n last[game.player][\"action\"] = action\n\n # Make move and switch players\n game.move(action)\n new_state = game.piles.copy()\n\n # When game is over, update Q values with rewards\n if game.winner is not None:\n # The game is over when a player just made a move that lost him the game.\n # The move from the previous player was therefore game winning.\n # Both events are used to update the AI.\n # new_state is [0, 0, 0, 0] here and its used to update the AI, because\n # future rewards should not be considered in the Q-learning formula.\n ai.update(state, action, new_state, -1)\n ai.update(\n last[game.player][\"state\"],\n last[game.player][\"action\"],\n new_state,\n 1\n )\n break\n\n # If game is continuing, no rewards yet\n elif last[game.player][\"state\"] is not None:\n ai.update(\n last[game.player][\"state\"],\n last[game.player][\"action\"],\n new_state,\n 0\n )\n\n print(\"Done training\")\n\n # Return the trained AI\n return ai","def run_ai():\n print(\"Vivian\") # First line is the name of this AI \n color = int(input()) # Then we read the color: 1 for dark (goes first), \n # 2 for light. \n\n while True: # This is the main loop \n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input() \n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over. \n print \n else: \n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The \n # squares in each row are represented by \n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n \n # Select the move and send it to the manager \n# movei, movej = select_move_minimax(board, color)\n movei, movej = select_move_alphabeta(board, color)\n print(\"{} {}\".format(movei, movej))","def depthFirstSearch(problem):\n #print \"Start:\", problem.getStartState()\n #print \"Is the start a goal?\", problem.isGoalState(problem.getStartState())\n #print \"Start's successors:\", problem.getSuccessors(problem.getStartState())\n \n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n #created a frontier Stack for DFS\n #Here the stack acts as a LIFO stack\n neighbourNodes = util.Stack()\n #created a list of moves which will be returned in then end\n moves = []\n #pushed the start node and empty moves list, onto the frontier stack\n neighbourNodes.push((problem.getStartState(),moves))\n #this is a set of nodes which have been seen, to avoid adding nodes already visited \n seenNodes = set()\n #condition evaluated based on the existence of elements in the frontier stack\n while not neighbourNodes.isEmpty():\n #last node in the stack is popped and its state and action is stored\n poppedNodeState, poppedNodeAction = neighbourNodes.pop()\n #condition to check if the node is already been visited\n if(poppedNodeState in seenNodes):\n #if yes then it just skips the iteration using the continue statement\n continue\n #condition to check if the current node is the goal node\n if problem.isGoalState(poppedNodeState):\n #if yes then return the action or moves to be performed list\n return poppedNodeAction\n #if not visited before then node is added to the seenNodes set\n seenNodes.add(poppedNodeState)\n #loop to parse the successor nodes and check and add them to the frontier stack\n for state, action, cost in problem.getSuccessors(poppedNodeState):\n #checking if the successor node has already been visited before\n if(state in seenNodes):\n #if yes then it skips that node\n continue\n #else it adds that successor along with it action appeneded with the already existing actions\n neighbourNodes.push((state, poppedNodeAction+[action]))\n #the list of moves if finally returned\n return moves\n #util.raiseNotDefined()","def _optimize(self) -> None:\n\n for i, agent in enumerate(self.agents):\n states, actions, rewards, next_states, dones = self.memory.sample()\n\n actor_next_state = self._agent_states(i, next_states)\n next_actions = torch.cat(\n [a.actor_target(actor_next_state) for a in self.agents], 1\n )\n next_q = agent.critic_target(next_states, next_actions).detach()\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\n 1 - dones[:, i].view(-1, 1)\n )\n local_q = agent.critic_local(states, actions)\n\n value_loss = agent.loss_fn(local_q, target_q)\n agent.value_optimizer.zero_grad()\n value_loss.backward()\n agent.value_optimizer.step()\n\n local_actions = []\n for i, a in enumerate(self.agents):\n local_states = self._agent_states(i, states)\n local_actions.append(\n a.actor_local(local_states)\n if a == agent\n else a.actor_local(local_states).detach()\n )\n local_actions = torch.cat(local_actions, 1)\n policy_loss = -agent.critic_local(states, local_actions).mean()\n\n agent.policy_optimizer.zero_grad()\n policy_loss.backward()\n agent.policy_optimizer.step()\n\n self._update_target_model(agent.critic_local, agent.critic_target)\n self._update_target_model(agent.actor_local, agent.actor_target)","def minimax(board: bytearray,\n depth: int, # depth of current plies (0 = deepest)\n alpha: int, \n beta: int, \n max_player: bool, # is this maximzing player?\n at_top: bool=False, # are we the top call to this?\n ):\n \n # base cases:\n # - Player will win w/this board (since AI loses, return massive negative)\n # - AI will win w/this board (return massive positive)\n # - reached the depth of recursion (score this leaf for AI)\n # - board is full (no score for this leaf)\n\n won_by: int = 0\n for c1, c2, c3, c4 in _WINDOWS:\n if board[c1] and (board[c1] == board[c2] == board[c3] == board[c4]):\n won_by = board[c1]\n break\n \n if won_by == _PLAYER:\n # subtract depth so we delay loss as much as possible \n return -1000 - depth \n if won_by == _AI:\n # add depth so faster wins are more attractive\n return 1000 + depth \n if depth == 0:\n score = score_position(board, _AI) \n return score\n\n # (these are arranged _CENTER-out to help make a/b pruning most efficient)\n valid_locations: list[int] = [\n col % 7 for col in (38,37,39,36,40,35,41) if board[col] == _EMPTY]\n\n if not valid_locations:\n return 0\n \n # minimax strategy: alternate if AI is looking for best move (maximizing)\n # or the most harmful response from the player (minimizing).\n value: int\n new_col: int\n row: int\n \n if max_player:\n value = _MINUS_INFINITY\n new_col = random.choice(valid_locations)\n for col in valid_locations: \n for r in (0, 1, 2, 3, 4, 5):\n if board[7 * r + col] == 0:\n row = r\n break\n b_copy = bytearray(board)\n b_copy[row * 7 + col] = _AI\n new_score: int = minimax(b_copy, depth-1, alpha, beta, False)\n if new_score > value:\n value = new_score\n new_col = col\n alpha = max(alpha, value)\n if alpha >= beta:\n break\n\n else:\n value = _INFINITY\n for col in valid_locations:\n for r in (0, 1, 2, 3, 4, 5):\n if board[7 * r + col] == 0:\n row = r\n break\n b_copy = bytearray(board)\n b_copy[row * 7 + col] = _PLAYER\n new_score: int = minimax(b_copy, depth-1, alpha, beta, True)\n if new_score < value:\n value = new_score\n beta = min(beta, value)\n if alpha >= beta:\n break\n\n # For speed, return simple score except when exiting first recursive call,\n # and return the chosen column & the score in that case.\n if not at_top:\n return value\n else:\n return new_col % 7, value","def solve(self):\n while self.counter[-1] != len(self.sequences[-1]) + 1:\n basepair = self.generatebasepairs(self.counter) # Get the combination for the current coordination\n moves = self.generatemoves(basepair) # Get all possible ways to get to this current coordination\n\n maxscore = -100000000 # set the maxscore to a value which is always lower than possible scores\n bestmove = None\n\n # FOr each move calculate score\n for move in moves:\n coordinates = self.generatecoordinates(move, self.counter) # generate the origin coordinate for the current move\n score = self.retrievematrixelement(coordinates).score # Get the score at the origin coordinate\n pairs = self.getallpairs(move) # Get all pairs possible for the current move\n scores = [self.scorePair(u) for u in pairs] # Generate scores for all pairs\n newscore = score + sum(scores) # Add generated scores to origin score\n if newscore > maxscore:\n maxscore = newscore\n bestmove = coordinates\n\n self.enterelement(self.counter, Score(bestmove, maxscore))\n self.increase()","def registerInitialState(self, gameState):\n\n # stuff\n self.treeDepth = 4\n self.oldFood = []\n self.lastEatenFood = None\n self.i = 0\n\n\n\n #oldFood\n self.oldFood = self.getFoodYouAreDefending(gameState)\n\n\n self.red = gameState.isOnRedTeam(self.index)\n self.distancer = distanceCalculator.Distancer(gameState.data.layout)\n\n # comment this out to forgo maze distance computation and use manhattan distances\n self.distancer.getMazeDistances()\n\n\n\n \n\n \n # FIND PATROL POINTS\n\n\n\n x = gameState.data.layout.width/2-8\n #print \"WIDTH \", x+4\n\n y1 = gameState.data.layout.height-4\n y2 = 0+4\n\n\n\n point1 = (x,y2)\n point2 = (x,y1)\n topPoints = []\n botPoints = []\n for i in range(0,6):\n xv = x+i\n if not gameState.data.layout.walls[xv][y1]:\n\n newBP = (xv, y1)\n botPoints.append(newBP)\n else:\n newBP = (xv, y1)\n #print newBP, \" in wall\"\n\n if not gameState.data.layout.walls[xv][y2]:\n newTP = (xv, y2)\n topPoints.append(newTP)\n else:\n newTP = (xv, y2)\n #print newTP, \" in wall\"\n\n\n\n\n\n # FIND PATROL POINTS WITH THE SHORTEST PATH\n bestTP = topPoints[0]\n bestBP = botPoints[0]\n\n bestPath = self.getMazeDistance(bestTP,bestBP)\n for tp in topPoints:\n bp = min(botPoints, key=lambda p: self.getMazeDistance(tp, p))\n tempPath = self.getMazeDistance(tp, bp)\n if (tempPath < bestPath):\n bestTP = tp\n bestBP = bp\n bestPath = tempPath\n\n #print \"THE REAL BEST POINTS: \", bestBP, \" \", bestTP, \" \", bestPath\n\n self.patrolPoints = [bestTP,bestBP]\n\n\n\n\n\n\n import __main__\n if '_display' in dir(__main__):\n self.display = __main__._display","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n from game import Actions\n\n waiting_list = util.PriorityQueue()\n COSTS = {}\n start_state = problem.getStartState()\n COSTS[start_state] = 0\n waiting_list.push(start_state,0)\n parents = {}\n \n while not waiting_list.isEmpty():\n q_state = waiting_list.pop()\n if problem.isGoalState(q_state):\n target_state = q_state\n break\n for child in problem.getSuccessors(q_state):\n n_cost = COSTS[q_state] + child[2]\n \n if child[0] not in COSTS or n_cost < COSTS[q_state]:\n COSTS[child[0]] = n_cost\n prior = n_cost + heuristic(child[0], problem)\n waiting_list.push(child[0], prior)\n parents[child[0]] = q_state\n\n sequence = []\n prev_state = target_state\n while target_state in parents.keys():\n target_state = parents[target_state]\n direction = Actions.vectorToDirection([prev_state[0] - target_state[0], prev_state[1] - target_state[1]])\n prev_state = target_state\n sequence.append(direction)\n \n return sequence[::-1]","def minimax(self, game, depth):\n\n def min_value(game, traversed_depth=1):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n if traversed_depth==depth:\n return self.score(game,self)\n traversed_depth+=1\n v = float(\"inf\")\n for m in game.get_legal_moves():\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n v = min(v, max_value(game.forecast_move(m),traversed_depth))\n return v\n\n def max_value(game, traversed_depth=1):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n if traversed_depth==depth:\n return self.score(game,self)\n traversed_depth+=1\n v = float(\"-inf\")\n for m in game.get_legal_moves():\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n v = max(v, min_value(game.forecast_move(m),traversed_depth))\n return v\n \n return max(game.get_legal_moves(), key=lambda m: min_value(game.forecast_move(m)))","def run(cores):\n if not os.path.exists(\"Solutions\"):\n os.mkdir(\"Solutions\")\n\n #f = open(os.path.join(\"Solutions\",\"log.txt\"),'a') #a is for append, it also creates files if not available, the rest is self explanatory\n\n tg = globalTarget\n\n generation = 1 #counter for generation, for printing every 100 gens \n parent = Organism(tg.size,INITIAL_GENES) #calling Organism class, and passing the target size and initial gene pool size as params \n \n score=fitness(tg,parent.drawImage())\n\n p = multiprocessing.Pool(cores)\n\n while True:\n \n print \"Generation {} - Score {}\".format(generation,score)\n #f.write(\"Generation {} - Score {}\\n\".format(generation,score))\n \n if generation % GENERATIONS_PER_IMAGE == 0:\n parent.drawImage().save(os.path.join(\"Solutions\",\"{}.jpeg\".format(generation)))\n \n generation += 1\n \n \n \"\"\"\n This is where the genetic algo really starts.\n We will first start with making a children and a ss_scores array (idk why ss, it sounds cool)\n \"\"\"\n children=[]\n ss_score=[]\n\n \"\"\"\n Next, we will basically mutate and check fitness, then save to results, unless interrupted by the keyboard\n \"\"\"\n\n try:\n results = groupMutate(parent,POP_PER_GEN-1,p)\n except KeyboardInterrupt:\n print 'Sayonara!'\n p.close()\n return\n\n \"\"\"\n Now we will do 2 things to the children and the ss_scores arrays:\n save parents and score to those 2, incase the parents are better than the children\n \"\"\"\n children.append(parent)\n ss_score.append(score)\n \n \"\"\"\n Then we will put new children and new scores in those\n \"\"\"\n newScores,newChildren = zip(*results)\n\n children.extend(newChildren)\n ss_score.extend(newScores)\n\n \"\"\"\n Finally, we sort them, and pick the best to become the new parents (and log in the best in the scores too)\n \"\"\"\n \n \n winners = sorted(zip(children,ss_score),key=lambda x: x[1])\n #lambda here creates a memroy space in the area of calling, which makes the execution time \"blazingly fast\", quoting pranjal :)\n \n \n parent,score = winners[0]\n \n \n \"\"\"\n Now, these parents will go through mutation and give new children\n \"\"\"\n\n #this is becuase at one point, too many files are open, since we are opening a pool inside a loop, then not shutting it down","def play_game():\n \n \n def response(answer):\n \"\"\" Returns the user's response simplified\"\"\"\n if answer in ['YES', 'Yes', 'y', 'Y', 'yes']:\n return 'yes'\n elif answer in ['NO', 'no', 'N', 'n', 'No']:\n return 'no'\n else:\n raise ValueError('Invalid response')\n \n \n \"\"\" Load previous game or start new game \"\"\"\n new_game = input('Load previous game? ')\n mytree = None # Prime variable for current tree settings\n \n \n if response(new_game) == 'yes':\n new_game = input('Enter name of file: ') # Load a previously existing tree\n mytree = MyTree.load_tree(new_game)\n elif response(new_game) == 'no':\n mytree = MyTree() # Create a new tree\n \n \n def change_position(change):\n \"\"\" Changes current position in Tree : Change = Left or Right\"\"\"\n if response(change) == 'yes':\n mytree._position = mytree.left(mytree._position) # If answer is yes, move left\n return mytree._position\n elif response(change) == 'no':\n mytree._position = mytree.right(mytree._position) # If answer is no, move right\n return mytree._position\n else:\n raise NameError('Response not recognized') # If answer cannot be read in response(), NameError\n \n \n def at_end():\n \"\"\" Checks if position is at end of the tree \"\"\"\n return mytree.num_children(mytree._position)\n \n \"\"\" Start Game \"\"\"\n user_continue = 'yes'\n while response(user_continue) == 'yes':\n print('\\nThink of an animal, and I will guess it.') # Print first computer's statement\n while at_end() != 0: # Check if current position has leaves\n temp_answer = input(mytree._position.element() + ' ') # Print question and ask for a yes or no\n change_position(response(temp_answer)) # Move position\n\n \n temp_answer = input('Is it a %s ' %(mytree._position.element() + '?')) # Make a guess\n if response(temp_answer) == 'yes':\n user_continue = input('I win! Continue? ') # Condition if final guess is right\n \n elif response(temp_answer) == 'no':\n new_animal = input('I give up. What is it? ') # Condition if final guess is wrong\n new_question = input('Please type a question whose answer is yes for %s and no for %s.\\n' % (new_animal, mytree._position.element()))\n wrong_guess = mytree._position.element()\n mytree._replace(mytree._position, new_question) # Replace wrong guess with question\n mytree._add_left(mytree._position, new_animal) # Add input animal to 'yes' leaf\n mytree._add_right(mytree._position, wrong_guess) # Add old animal to 'no' leaf\n user_continue = input('Continue? ') # Ask to play again\n \n mytree._position = mytree.root() # Reset position to top (root)\n \n if response(user_continue) == 'no':\n save = input('Would you like to save your tree? ') # Ask to save build tree\n if response(save) == 'yes':\n filename = input('Enter file saveas: ') \n mytree.save_tree(filename) # Save file to user filename\n \n print('\\nGood-bye')","def minimax(self, game, depth, maximizing_player=True, tab='\\t'):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n legal_moves = game.get_legal_moves(game.active_player)\n if legal_moves is not None and len(legal_moves)>0:\n if depth>0: # Recursive case:\n if maximizing_player: # MAXIMIZING ply\n score, move = None, None\n for i,m in enumerate(legal_moves):\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\t')\n if score is None or newscore > score:\n score, move = newscore, m\n else: # MINIMIZING ply\n score, move = None, None\n for i,m in enumerate(legal_moves):\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\t')\n if score is None or newscore < score:\n score, move = newscore, m\n else: # Base case (depth==0)\n score, move = self.score(game, self), None\n else: # We are at a DEAD-END here\n score, move = self.score(game, self), (-1, -1)\n\n return score, move","def classify_treeInsert(self, query_name, cluster_naming_function):\n classes = Set(self.class_map.values())\n\n full_dist_matrix = self.orig_dist_matrix.drop(query_name)\n full_dist_matrix = full_dist_matrix.drop(query_name, axis=1)\n\n if PROGRESS: print '\\nStarting treeInsert!'\n \n #1] Build a tree for each class\n class_trees = {}\n all_elements = full_dist_matrix.columns.values.tolist()\n classes_done = 0\n num_of_classes = len(classes)\n for c in classes:\n\n #1a. Construct a mini distance matrix for the current class\n nonclass_members = [i for i in all_elements if self.class_map[i] != c]\n class_dist_matrix = full_dist_matrix.drop(nonclass_members)\n class_dist_matrix = class_dist_matrix.drop(nonclass_members, axis=1)\n\n #1b. Build class tree\n if PROGRESS: print 'Building class tree for ' + c\n\n class_njt = NJTree()\n class_njt.build(class_dist_matrix, self.class_map, myClusterNaming)\n class_trees[c] = class_njt\n classes_done = classes_done + 1\n\n if PROGRESS:\n print str(classes_done) + \" classes down, \" + str(num_of_classes - classes_done) \n + \" to go...\"\n\n #2] Determine the insertion cost of each tree\n class_insert_costs = {}\n for c,class_tree in class_trees.iteritems():\n\n #2a. Find insertion cost of each leaf in the tree\n leaves = [i for i in class_tree.tree.nodes() if class_tree.isLeaf(i)] \n leaf_insert_costs = {}\n for leaf_i in leaves:\n\n parent_i = class_tree.tree.neighbors(leaf_i)[0] \n cons = ({'type': 'eq',\n 'fun': lambda x: x[0] + x[1] - nx.shortest_path_length(class_tree.tree, \n source=parent_i, target=leaf_i, weight='length')})\n optimum_leaf_insert_cost = optimize.minimize(_leaf_insertion_cost, [0,0,0], \n args=(class_tree.orig_dist_matrix, leaf_i, leaves, query_name, self), method='SLSQP', \n constraints=cons)\n\n if DEBUG:\n print \"Optimum cost for \", leaf_i, \" : \", optimum_leaf_insert_cost.x[0]\n\n leaf_insert_costs[leaf_i] = optimum_leaf_insert_cost.x[0]\n \n class_insert_costs[c] = min(list(leaf_insert_costs.values()))\n\n #3] Output the class name of tree with minimum insertion cost\n min_insert_cost = min(list(class_insert_costs.values()))\n for c,cost in class_insert_costs.iteritems():\n if cost==min_insert_cost:\n return c\n break","def solveOneStep(self):\n ### Student code goes here\n\n if self.currentState.state == self.victoryCondition:\n return True\n\n current_depth = self.currentState.depth\n found_move = False\n while self.currentState.parent:\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n count = self.currentState.nextChildToVisit\n if len(self.currentState.children) > count:\n found_move = True\n break\n if not found_move:\n for all_visited in self.visited.keys():\n all_visited.nextChildToVisit = 0\n current_depth += 1\n if len(self.visited) == 1:\n all_possible_moves = self.gm.getMovables()\n for every_move in all_possible_moves:\n self.gm.makeMove(every_move)\n new_game_state = GameState(self.gm.getGameState(), current_depth, every_move)\n new_game_state.parent = self.currentState\n self.visited[new_game_state] = False\n self.currentState.children.append(new_game_state)\n self.gm.reverseMove(every_move)\n while current_depth != self.currentState.depth:\n count = self.currentState.nextChildToVisit\n self.currentState.nextChildToVisit += 1\n if len(self.currentState.children) > count:\n self.currentState = self.currentState.children[count]\n next_move = self.currentState.requiredMovable\n self.gm.makeMove(next_move)\n else:\n found_move = False\n while self.currentState.parent:\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n if len(self.currentState.children) > self.currentState.nextChildToVisit:\n found_move = True\n break\n if not found_move:\n return False\n\n if self.currentState.state != self.victoryCondition:\n self.visited[self.currentState] = True\n all_possible_moves = self.gm.getMovables()\n next_depth = current_depth + 1\n for every_move in all_possible_moves:\n self.gm.makeMove(every_move)\n new_game_state = GameState(self.gm.getGameState(), next_depth, every_move)\n if new_game_state not in self.visited:\n self.visited[new_game_state] = False\n new_game_state.parent = self.currentState\n self.currentState.children.append(new_game_state)\n self.gm.reverseMove(every_move)\n return False\n else:\n return True","def get_move(self, board, score, turns_alive, turns_to_starve, direction, head_position, body_parts):\n #find coordinates of food(s)\n snakeHead = (head_position[0], head_position[1])\n\n foods = []\n distance = []\n temp = 1000\n choiceFood = [\"nothing\"]\n for x in range(self.width):\n for y in range(self.length):\n if board[x][y] == GameObject.FOOD:\n foods.append((x,y))\n distance.append(abs(x-snakeHead[0]) + abs(y-snakeHead[1]))\n\n for index, item in enumerate(distance):\n if item < temp:\n temp = item\n choiceFood[0] = foods[index]\n\n\n rootNode = Agent(None, snakeHead, direction)\n foodNode = Agent(None, choiceFood[0], None)\n\n openList = []\n closedList = []\n #add root node to the openList\n openList.append(rootNode)\n\n #implements time\n program_start = time.time()\n\n sum = 0\n while len(openList) > 0:\n sum += 1\n #print(sum)\n now = time.time()\n currentNode = openList[0]\n currentIndex = 0\n\n #once body is created calculate how many body in up, down, left, right\n snakeBodyRight = 0\n snakeBodyLeft = 0\n snakeBodyUp = 0\n snakeBodyDown = 0\n areaLeftClean = snakeHead[0]*self.width\n areaRightClean = (self.width - snakeHead[0])*self.width \n areaDownClean = (self.width - snakeHead[1])*self.width\n areaUpClean = snakeHead[1]*self.width\n for a in body_parts:\n if a[0] > snakeHead[0]: #body on the right\n snakeBodyRight += 1\n elif a[0] < snakeHead[0]: #body on the left\n snakeBodyLeft += 1\n\n for a in body_parts: \n if a[1] > snakeHead[1]: #body snake below head\n snakeBodyDown += 1\n elif a[1] < snakeHead[1]: #body snake above head\n snakeBodyUp += 1\n\n # areaLeftClean = areaLeftClean - snakeBodyLeft\n # areaRightClean = areaRightClean - snakeBodyRight\n # areaDownClean = areaDownClean - snakeBodyDown\n # areaUpClean = areaUpClean - snakeBodyUp\n areaLeftClean = (areaLeftClean - snakeBodyLeft)/(areaLeftClean + 1)\n areaRightClean = (areaRightClean - snakeBodyRight)/(areaRightClean+1)\n areaDownClean = (areaDownClean - snakeBodyDown)/(areaDownClean+1)\n areaUpClean = (areaUpClean - snakeBodyUp)/(areaUpClean+1)\n #print(\"up\", areaUpClean, \"down\", areaDownClean, \"left\", areaLeftClean, \"right\", areaRightClean)\n\n \n if now - program_start > 0.01 :\n\n move = None\n if snakeHead[1] - 1 < 0 or snakeHead[1] + 1 >= self.width or snakeHead[0] - 1 < 0 or snakeHead[0] + 1 >= self.width: # at the edges\n if direction == Direction.NORTH:\n if areaLeftClean > areaRightClean and snakeBodyLeft < snakeBodyRight:\n move = Move.LEFT\n\n if snakeHead[0] - 1 < 0: #if the snake besides the left edges\n move = Move.RIGHT\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL: #left edges and obstacles on the right\n move = Move.STRAIGHT\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 <self.width:\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL:# if left is obstacles while on upper edge\n move = Move.RIGHT\n elif snakeHead[0] + 1 >= self.width:\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\n move = Move.STRAIGHT\n\n else: \n move = Move.RIGHT\n\n if snakeHead[0] - 1 < 0 and (board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL): #if the snake besides the left edgesa and right is obstacle\n move = Move.STRAIGHT\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 < self.width:\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL:# if right is obstacles while on upper edge\n move = Move.LEFT\n elif snakeHead[0] + 1 >= self.width:\n move = Move.LEFT\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\n move = Move.STRAIGHT\n\n elif direction == Direction.SOUTH:\n if areaLeftClean > areaRightClean and snakeBodyLeft < snakeBodyRight:\n move = Move.RIGHT #go to left\n \n if snakeHead[0] - 1 < 0: #if the snake besides the left edges\n move = Move.LEFT\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL: #left edges and obstacles on the right\n move = Move.STRAIGHT\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 <self.width:\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL:# if left is obstacles while on upper edge\n move = Move.LEFT\n elif snakeHead[0] + 1 >= self.width:\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\n move = Move.STRAIGHT\n else: \n move = Move.LEFT\n \n if snakeHead[0] - 1 < 0 and (board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL): #if the snake besides the left edgesa and right is obstacle\n move = Move.STRAIGHT\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 < self.width:\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL:# if right is obstacles while on upper edge\n move = Move.RIGHT\n elif snakeHead[0] + 1 >= self.width:\n move = Move.RIGHT\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\n move = Move.STRAIGHT\n\n elif direction == Direction.EAST:\n if areaDownClean > areaUpClean and snakeBodyDown < snakeBodyUp:\n move = Move.RIGHT\n if snakeHead[1] - 1 < 0 and (board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL): # if snake besides upper edgees and below is obstacle\n move = Move.STRAIGHT\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on right edge\n move = Move.LEFT\n elif snakeHead[1] + 1 >= self.width:\n move = Move.LEFT\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\n move = Move.STRAIGHT\n\n else:\n move = Move.LEFT\n\n if snakeHead[1] - 1 < 0: # if snake besides upper edgees\n move = Move.RIGHT\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL: #if below is obstacle\n move = Move.STRAIGHT\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on right edge\n move = Move.RIGHT\n elif snakeHead[1] + 1 >= self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\n move = Move.STRAIGHT\n\n else: #west\n if areaDownClean > areaUpClean and snakeBodyDown < snakeBodyUp:\n move = Move.LEFT\n \n if snakeHead[1] - 1 < 0 and (board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL): # if snake besides upper edgees and below is obstacle\n move = Move.STRAIGHT\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on left edge\n move = Move.RIGHT\n elif snakeHead[1] + 1 >= self.width:\n move = Move.RIGHT\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\n move = Move.STRAIGHT \n else:\n move = Move.RIGHT\n \n if snakeHead[1] - 1 < 0: # if snake besides upper edgees\n move = Move.LEFT\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL: #if below is obstacle\n move = Move.STRAIGHT\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if up is obstacle while on left edge\n move = Move.LEFT\n elif snakeHead[1] + 1 >= self.width:\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\n move = Move.STRAIGHT\n\n else: \n if direction == Direction.NORTH:\n move = Move.STRAIGHT\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY: #check if above obstacles\n if areaRightClean > areaLeftClean and snakeBodyRight < snakeBodyLeft: #lots of body parts on left\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.EMPTY:\n move = Move.RIGHT\n else:\n move = Move.LEFT\n else: #if body parts on left is smaller than right\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.EMPTY:\n move = Move.LEFT\n else:\n move = Move.RIGHT\n \n elif direction == Direction.SOUTH:\n move = Move.STRAIGHT\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY: #check if belo obstacles\n if areaRightClean > areaLeftClean and snakeBodyRight < snakeBodyLeft: #lots of body parts on left\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.EMPTY:\n move = Move.LEFT\n else:\n move = Move.RIGHT\n else: #if body parts on left is smaller than right\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.EMPTY:\n move = Move.RIGHT\n else:\n move = Move.LEFT\n\n elif direction == Direction.EAST:\n move = Move.STRAIGHT\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY: #check if right obstacles\n if areaUpClean > areaDownClean and snakeBodyUp < snakeBodyDown: #lots of body parts on below\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.EMPTY:\n move = Move.LEFT\n else:\n move = Move.RIGHT\n else: #if body parts on below is lower than upper\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.EMPTY:\n move = Move.RIGHT\n else:\n move = Move.LEFT\n\n else: #west\n move = Move.STRAIGHT\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL or board[snakeHead[0]-1][snakeHead[1]] == GameObject.SNAKE_BODY: #check if left obstacles\n if areaUpClean > areaDownClean and snakeBodyUp < snakeBodyDown: #lots of body parts on below\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.EMPTY:\n move = Move.RIGHT\n else:\n move = Move.LEFT\n else: #if body parts on below is lower than upper\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.EMPTY:\n move = Move.LEFT\n else:\n move = Move.RIGHT\n\n return move\n\n \n\n for index, item in enumerate(openList):\n if item.f < currentNode.f or (item.f == currentNode.f and item.g < currentNode.g):\n currentIndex = index\n currentNode = item\n \n openList.pop(currentIndex)#remove current node that is calculated\n closedList.append(currentNode)#removed node in openList is moved to closedList\n\n\n if (currentNode.Pos == foodNode.Pos):\n path = []\n current = currentNode\n while current is not None:\n path.append(current.Pos)\n current = current.parent\n #print(path[::-1])\n move = None\n path = path[::-1]\n xAxis = path[1][0] - path[0][0]\n yAxis = path[1][1] - path[0][1]\n\n if(direction == Direction.NORTH):\n if xAxis < 0 and yAxis == 0: #left\n move = Move.LEFT \n elif xAxis > 0 and yAxis == 0: #right\n move = Move.RIGHT\n else: #yAxis < 0 #up\n move = Move.STRAIGHT\n\n elif(direction == Direction.SOUTH):\n if xAxis < 0 and yAxis == 0: #left\n move = Move.RIGHT \n elif yAxis > 0 and xAxis == 0: #down\n move = Move.STRAIGHT\n else: #right\n move = Move.LEFT\n\n\n elif(direction == Direction.EAST):\n if yAxis > 0 and xAxis == 0: #down\n move = Move.RIGHT \n elif xAxis > 0 and yAxis == 0: #right\n move = Move.STRAIGHT\n else: #yAxis < 0 #up\n move = Move.LEFT\n\n else: #west\n if xAxis < 0 and yAxis == 0: #left\n move = Move.STRAIGHT \n elif yAxis > 0 and xAxis == 0: #down\n move = Move.LEFT \n else: #yAxis < 0 #up\n move = Move.RIGHT\n \n return move\n\n\n branches = []\n north = [(1,0), (-1, 0), (0,-1)] #right, left, up\n south = [(1,0), (-1, 0), (0, 1)] #rightm, left, down\n east = [(1,0), (0, 1), (0,-1)] #right, up, down\n west = [(0,1), (-1, 0), (0,-1)] #down, left, up\n\n if currentNode.directions == Direction.NORTH:\n for adjacent in north:\n curDirection = None \n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\n \n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\n continue\n\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\n continue\n\n #check the direction of the neighbor\n if neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.WEST\n elif neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.EAST\n else: \n curDirection = Direction.NORTH\n\n \n\n newBranch = Agent(currentNode, neighbor, curDirection)\n branches.append(newBranch)\n\n elif currentNode.directions == Direction.SOUTH:\n for adjacent in south:\n curDirection = None\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\n \n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\n continue\n\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\n continue\n\n #check the direction of the neighbor\n if neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.WEST\n elif neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.EAST\n else: \n curDirection = Direction.SOUTH\n\n newBranch = Agent(currentNode, neighbor, curDirection)\n branches.append(newBranch)\n\n elif currentNode.directions == Direction.EAST:\n for adjacent in east:\n curDirection = None\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\n \n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\n continue\n\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\n continue\n\n #check the direction of the neighbor\n if neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.EAST\n elif neighbor[1] > currentNode.Pos[1] and neighbor[0] == currentNode.Pos[0]:\n curDirection = Direction.SOUTH\n else: \n curDirection = Direction.NORTH\n newBranch = Agent(currentNode, neighbor, curDirection)\n branches.append(newBranch)\n\n else: #west\n for adjacent in west:\n curDirection = None\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\n \n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\n continue\n\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\n continue\n\n #check the direction of the neighbor\n if neighbor[1] > currentNode.Pos[1] and neighbor[0] == currentNode.Pos[0]:\n curDirection = Direction.SOUTH\n elif neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\n curDirection = Direction.WEST\n else: \n curDirection = Direction.NORTH\n\n newBranch = Agent(currentNode, neighbor, curDirection)\n branches.append(newBranch)\n\n\n #get all of the child in the current branches and calculate the f/g/h\n \n for child in branches:\n\n child.g = currentNode.g + 1\n child.h = ((child.Pos[0] - foodNode.Pos[0]) ** 2) + ((child.Pos[1] - foodNode.Pos[1]) ** 2)\n child.f = child.g + child.h\n \n openList.append(child)","def get_move(self, rootstate, itermax, verbose = True, **kwargs):\n\n # print(rootstate.playerHands[rootstate.playerToMove])\n\n assert len(rootstate.playerHands[rootstate.playerToMove]) == 2\n\n move, victim, guess = get_move(rootstate, ismcts=True)\n\n if move:\n return move, victim, guess\n\n rootnode = Node()\n counter = 0\n for i in range(itermax):\n node = rootnode\n # determinize\n state = rootstate.clone_and_randomize(vanilla=kwargs.get('vanilla', True))\n node = self.select(state, node)\n node = self.expand(state, node)\n self.simulate(state)\n self.backpropagate(state, node)\n\n # Output some information about the tree - can be omitted\n if verbose:\n print(rootnode.children_to_string())\n\n return self.select_final_move(rootnode, rootstate)","def search(self, is_max, possible_moves, state, depth, alpha, beta):\n temp_state = state.deepcopy()\n best_move = None\n best_move_val = float('-inf') if is_max else float('inf')\n \n for move in possible_moves:\n for to in move['to']:\n \n if time() > self.thinking_time:\n return best_move, best_move_val\n \n temp_state.board.move_pawn(move['from'], to)\n temp_state.next_turn()\n _, val = self.minimax(temp_state, not(is_max), depth+1, alpha, beta)\n \n temp_state.board.move_pawn(to, move['from'])\n temp_state.undo_turn()\n \n if is_max and val > best_move_val:\n alpha = max(val, alpha)\n best_move_val = val\n best_move = (move['from'], to)\n \n if not(is_max) and val < best_move_val:\n beta = min(val, beta)\n best_move_val = val\n best_move = (move['from'], to)\n \n if beta <= alpha: #pruning\n return best_move, best_move_val\n \n return best_move, best_move_val","def test_prioritize():\n tiles = Tiles(800, 100)\n board = Board(800, 100, tiles)\n player = Player('Alfred', board, 'black')\n ai = AI(board, player)\n board.add_tile(board.count//2 - 1, 0, 'white')\n for i in range(1, board.count - 1):\n if board.tiles_list[board.count//2 - 1][i] is None:\n board.add_tile(board.count//2 - 1, i, 'black')\n else:\n board.tiles_list[board.count//2 - 1][i].color = 'black'\n assert ai.prioritize()[0] == (board.count//2 - 1, board.count - 1)\n assert len(ai.prioritize()[1]) == board.count - 2\n for i in range(board.count//2 + 1, board.count - 1):\n board.add_tile(i, i, 'black')\n assert ai.occupy_corner()[0] == (board.count - 1, board.count - 1)\n assert len(ai.occupy_corner()[1]) == board.count//2 - 2","def classes(self):\n #print \"making classes again!\"\n l = []\n for p in self.marks:\n l.append(psi_class(self,p))\n for d in range(1, self.dimension + 1):\n l.append(kappa_class(self,d))\n for i in range(1, self.genus+1):\n l.append(chern_char(self, 2*i-1))\n if True:#self.genus != 0:\n l.append(irreducible_boundary(self))\n marks = set(self.marks)\n reducible_boundaries = []\n if self.n != 0:\n first_mark_list = [marks.pop()] \n for g1 in range(0, self.genus + 1):\n for p in subsets(marks):\n r_marks = set(first_mark_list + p)\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\n \n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\n \n else: #self.n == 0\n for g1 in range(1, floor(self.genus/2.0)+1):\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \n \n \n l += reducible_boundaries \n \n for i in range(1,self.genus+1):\n l.append(lambda_class(self,i))\n return l","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def agentCounter(gameState, index, depth):\n \"\"\"When index is out of bounds return pacmans index and\n reduce depth by 1\"\"\"\n if index == gameState.getNumAgents():\n return [depth-1, 0]\n else:\n return [depth, index]\n\n def minimax(self, gameState, depth, index):\n \"\"\"Implement minimax function for pacman game. \n return an array with score and best move\"\"\"\n ultimateMove = None # The best move the agent can use\n if depth == 0 or gameState.isWin() or gameState.isLose():\n # if leaf node return value.\n return [self.evaluationFunction(gameState), ultimateMove]\n else:\n if index == 0: # if pacman => agent is max agent\n value = -math.inf\n maxValue = value\n # iterates through max agent w/index=0 moves\n for action in gameState.getLegalActions(0):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action) # generates the next state when move is done\n value = max(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\n if maxValue != value: # If value has changed update values\n ultimateMove = action\n maxValue = value\n return [value, ultimateMove]\n else: # is ghost => agent is min agent\n value = math.inf\n minValue = value\n # Iterate through the moves of a min agent w/index not 0\n for action in gameState.getLegalActions(index):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action)\n value = min(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\n if minValue != value: # If value has changed update values\n ultimateMove = action\n minValue = value\n return [value, ultimateMove]\n\n best = minimax(self, gameState, self.depth, self.index)\n #print(\"Move: \", best[1], \" | Score: \", best[0])\n return best[1]","def _avoid_tag(self, id=0, ignore=Obstacle.IS_SONAR):\n sorted_detections = self._sort_tags_left_to_right(\n self.swarmie.get_latest_targets().detections,\n id=id\n )\n\n # if count == 3: # last resort\n # self.current_state = Planner.STATE_DRIVE\n # angle = self._get_angle_to_face(point)\n # self.swarmie.turn(\n # angle,\n # ignore=Obstacle.TAG_TARGET,\n # throw=False\n # )\n # self.result = self.swarmie.drive(\n # .75,\n # ignore=Obstacle.TAG_TARGET,\n # throw=False\n # )\n\n if len(sorted_detections) == 0:\n # no tags in view anymore\n print(\"I can't see anymore tags, I'll try creeping\",\n \"and clearing.\")\n self.prev_state = self.current_state\n self.current_state = Planner.STATE_DRIVE\n self.swarmie.drive(\n 0.1,\n ignore=Obstacle.SONAR_BLOCK,\n throw=False\n )\n drive_result = self.clear(math.pi / 8, ignore=ignore)\n\n else:\n left_angle, left_dist = \\\n self._get_angle_and_dist_to_avoid(\n sorted_detections[0],\n direction='left'\n )\n right_angle, right_dist = \\\n self._get_angle_and_dist_to_avoid(\n sorted_detections[-1],\n direction='right'\n )\n angle = left_angle\n dist = left_dist\n\n if (self.current_state == Planner.STATE_AVOID_LEFT or\n self.prev_state == Planner.STATE_AVOID_LEFT):\n # Keep going left. Should help avoid bouncing back\n # and forth between tags just out of view.\n print(\"I was turning left last time, so I'll keep\",\n \"it that way.\")\n self.prev_state = self.current_state\n self.current_state = Planner.STATE_AVOID_LEFT\n angle = left_angle\n dist = left_dist\n\n elif (self.current_state == Planner.STATE_AVOID_RIGHT or\n self.prev_state == Planner.STATE_AVOID_RIGHT):\n # Keep going right\n print(\"I was turning right last time, so I'll\",\n \"keep it that way.\")\n self.prev_state = self.current_state\n self.current_state = Planner.STATE_AVOID_RIGHT\n angle = right_angle\n dist = right_dist\n\n else:\n # pick whichever angle is shortest\n if abs(right_angle) < abs(left_angle):\n print('Right looks most clear, turning right.')\n # print('Right turn makes most sense, turning right.')\n self.prev_state = self.current_state\n self.current_state = Planner.STATE_AVOID_RIGHT\n angle = right_angle\n dist = right_dist\n else:\n print('Left looks most clear, turning left.')\n # print('Left turn makes most sense, turning left')\n self.prev_state = self.current_state\n self.current_state = Planner.STATE_AVOID_LEFT\n\n _turn_result, drive_result = self._go_around(\n angle,\n dist\n )\n\n return drive_result","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n self.NumAgents = gameState.getNumAgents()\n self.root = gameState\n # alpha-beta-search\n # one call of Max_Value is enough to iterate the whole tree and keep the optimal move\n self.Max_Value(gameState, -10000, 10000, self.index, self.depth)\n return self.move\n util.raiseNotDefined()","def find_best_move(state: GameState) -> None:","def improve(self):\n tour = Tour(self.heuristic_path)\n\n # Find all valid 2-opt moves and try them\n for t1 in self.heuristic_path:\n around = tour.around(t1)\n\n for t2 in around:\n broken = set([makePair(t1, t2)])\n # Initial savings\n gain = TSP.dist(t1, t2)\n\n close = self.closest(t2, tour, gain, broken, set())\n\n # Number of neighbours to try\n tries = 5\n\n for t3, (_, Gi) in close:\n # Make sure that the new node is none of t_1's neighbours\n # so it does not belong to the tour.\n if t3 in around:\n continue\n\n joined = set([makePair(t2, t3)])\n\n # The positive Gi is taken care of by `closest()`\n Log.debug(\"Start: X: {} - Y: {} = {}\".format((t1, t2),\n (t2, t3), Gi))\n\n if self.chooseX(tour, t1, t3, Gi, broken, joined):\n # Return to Step 2, that is the initial loop\n return True\n # Else try the other options\n\n tries -= 1\n # Explored enough nodes, change t_2\n if tries == 0:\n break\n\n return False","def a_star_gs(self):\n print('Performing A*GS\\n')\n\n frontier = PriorityFrontier()\n\n initial_node = SearchNode(self.initial_state)\n initial_heuristic = self.get_heuristic(self.initial_state) + initial_node.path_cost\n frontier.insert(initial_node, initial_heuristic)\n\n visited_nodes = set()\n \n num_expanded_nodes = 0\n \n while True:\n if frontier.is_empty():\n # Search failure\n print('Empty frontier.')\n return AStarResult(failure=True)\n \n # Get the next leaf node from the frontier\n leaf_node = frontier.pop()\n \n if not leaf_node:\n # Search failure\n print('Popped all the frontier nodes.')\n return AStarResult(failure=True)\n \n # Check for the goal state\n if self.check_goal_state(leaf_node.state):\n # Search success\n # Return final state and list of actions along path to the goal\n # as part of the AStarResult class solution member\n action_path = self.get_action_path(leaf_node)\n return AStarResult(solution=Solution(final_state=leaf_node.state, actions=action_path), \n num_expanded_nodes=num_expanded_nodes, max_depth=len(action_path) - 1)\n\n # Add this node to the visited nodes set\n visited_nodes.add(leaf_node)\n \n # Generate all possible actions for the given state\n actions = self.get_actions(leaf_node.state)\n \n # Create search nodes from the generated actions\n for action in actions:\n # Generate a new state from the given action\n new_state = self.get_result(leaf_node.state, action)\n \n # Create a new search node with the created state\n new_node = SearchNode(new_state, leaf_node, action, path_cost=leaf_node.path_cost + 1)\n \n num_expanded_nodes += 1\n\n # If this node has already been visited, ignore it\n if new_node in visited_nodes:\n continue\n\n # Get the new node's heuristic\n new_heuristic = self.get_heuristic(new_state) + new_node.path_cost\n \n # Check for any nodes with the same state as new_state and with better heuristic values that \n # have yet to be visited in the frontier before adding new_node\n if new_node in frontier:\n frontier_node = frontier.peek_node(new_node)\n frontier_heuristic = frontier.peek_heuristic(new_node)\n\n if frontier_heuristic <= new_heuristic:\n # The original heuristic was less than or equal to the new node\n # Disregard the new node\n continue\n \n else:\n # The new node's heuristic is larger\n # Remove the original node from the frontier\n frontier.remove_node(frontier_node)\n\n # Add the new node to the frontier\n frontier.insert(new_node, new_heuristic)","def solveOneStep(self):\n ### Student code goes here\n if (self.currentState.state == self.victoryCondition) or (self.currentState not in self.visited):\n self.visited[self.currentState] = True\n win_or_not = self.currentState.state == self.victoryCondition\n return win_or_not\n\n if not self.currentState.nextChildToVisit: \n its = 0\n for movable in self.gm.getMovables():\n its += 1\n # time test\n # too long \n if its == \"too long\":\n return \"too long\"\n #make every move in movable\n self.gm.makeMove(movable)\n new = self.gm.getGameState()\n new_gs = GameState(new, self.currentState.depth+1, movable)\n \n if new_gs not in self.visited:\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.gm.reverseMove(movable) \n \n num_children = len(self.currentState.children)\n if self.currentState.nextChildToVisit < num_children:\n new = self.currentState.children[self.currentState.nextChildToVisit]\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\n self.gm.makeMove(new.requiredMovable)\n self.currentState = new\n #recurse\n return self.solveOneStep()\n else:\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n #recurse\n return self.solveOneStep()","def run_UCT(self, game, actions_taken):\n \n # If current tree is null, create one using game\n if self.root == None:\n self.root = Node(game.clone())\n # If it's not, check if there are actions from actions_taken to update\n # the tree from this player.\n # If the list is not empty, update the root accordingly.\n # If the list is empty, that means this player hasn't passed the turn,\n # therefore the root is already updated.\n elif len(actions_taken) != 0:\n for i in range(len(actions_taken)):\n # Check if action from history is in current root.children.\n if actions_taken[i][0] in self.root.children:\n # Check if the actions are made from the same player\n child_node = self.root.children[actions_taken[i][0]]\n if child_node.state.player_turn == actions_taken[i][1] \\\n and set(self.root.state.available_moves()) \\\n == set(game.available_moves()):\n self.root = child_node\n else:\n self.root = None\n self.root = Node(actions_taken[i][2].clone())\n else:\n self.root = None\n self.root = Node(actions_taken[i][2].clone())\n # This means the player is still playing (i.e.: didn't choose 'n').\n else:\n # Therefore, check if current root has the same children as \"game\"\n # offers. If not, reset the tree.\n if set(self.root.children) != set(game.available_moves()):\n self.root = None\n self.root = Node(game.clone())\n\n #Expand the children of the root if it is not expanded already\n if not self.root.is_expanded():\n self.expand_children(self.root)\n\n root_state = self.root.state.clone()\n\n for _ in range(self.n_simulations):\n node = self.root\n node.state = root_state.clone()\n search_path = [node]\n while node.is_expanded():\n action, new_node = self.select_child(node)\n node.action_taken = action\n search_path.append(new_node)\n node = new_node\n # At this point, a leaf was reached.\n # If it was not visited yet, then perform the rollout and\n # backpropagates the reward returned from the simulation.\n # If it has been visited, then expand its children, choose the one\n # with the highest ucb score and do a rollout from there.\n if node.n_visits == 0:\n rollout_value = self.rollout(node)\n self.backpropagate(search_path, rollout_value)\n else:\n _, terminal_state = node.state.is_finished()\n # Special case: if \"node\" is actually a leaf of the game (not \n # a leaf from the current tree), then only rollout should be \n # applied since it does not make sense to expand the children\n # of a leaf.\n if terminal_state:\n rollout_value = self.rollout(node)\n self.backpropagate(search_path, rollout_value)\n else:\n self.expand_children(node)\n action, new_node = self.select_child(node)\n node.action_taken = action\n search_path.append(new_node)\n node = new_node\n rollout_value = self.rollout(node)\n self.backpropagate(search_path, rollout_value)\n \n dist_probability = self.distribution_probability(game)\n action = self.select_action(game, self.root, dist_probability)\n q_a_root = self.root.q_a\n self.root = self.root.children[action]\n # Remove the statistics of the chosen action from the chosen child\n if self.root.n_a:\n self.root.n_a.pop(action)\n if self.root.q_a:\n self.root.q_a.pop(action)\n return action, dist_probability, q_a_root","def solveOneStep(self):\n ### Student code goes here\n state = self.currentState\n #print (type(state))\n self.visited[state] = True\n #print (type(self.gm.getGameState()))\n moves = self.gm.getMovables()\n print (\"CURRENTSTATE\" + str(self.currentState.state))\n print (\"MOVABLES:\")\n if moves:\n for m in moves:\n print (str(m))\n print (\"CHILDINDEX:\")\n print (state.nextChildToVisit)\n print (\"*********\")\n if state.state == self.victoryCondition:\n return True\n #if no child to expand then go back\n if not moves or state.nextChildToVisit >= len(moves):\n self.currentState = state.parent\n if state.requiredMovable is not None:\n self.gm.reverseMove(state.requiredMovable)\n # expand\n else:\n\n next_move = moves[state.nextChildToVisit]\n self.gm.makeMove(next_move)\n state.nextChildToVisit += 1\n\n #if to parent or if visited then skip\n while (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\n print (\"PARENT FOUND!\")\n self.gm.reverseMove(next_move)\n if state.nextChildToVisit >= len(moves):\n self.currentState = state.parent\n return False\n else:\n next_move = moves[state.nextChildToVisit]\n self.gm.makeMove(next_move)\n state.nextChildToVisit += 1\n\n next_state = GameState(self.gm.getGameState(), state.depth + 1, next_move)\n next_state.parent = state\n #next_state.requiredMovable = next_move\n state.children.append(next_state)\n self.currentState = next_state\n print (state.nextChildToVisit)\n return False","def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\n # assigning cost of changing from one leg to another based on the distance to the desired pose\n cost_ChangeLeg = 1\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\n if dz_final < 1:\n cost_ChangeLeg = 10\n elif dz_final < 2:\n cost_ChangeLeg = 20\n else:\n cost_ChangeLeg = 10\n\n # assigning weight for cost of predicted repositioning and cost of robot motion\n w_cost_reposition = 40\n w_cost_motion = 10\n\n # finding object's leg cordinates\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\n\n # initialization (initializeing cost to infinity)\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\n cost_legchange = [0, 0, 0, 0]\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\n cost_manipulation = [0, 0, 0, 0]\n cost_motion = [0, 0, 0, 0]\n force = [0, 0, 0, 0]\n path = [[[], []], [[], []], [[], []], [[], []]]\n planned_path_w = [[],[],[],[]]\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\n command = [[], [], [], []]\n des = [[], [], [], [], []]\n PAM_goal = state()\n\n # find the nominal trajectory for manipulation\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\n\n # itterate through each leg to find the leg with minimum cost\n for leg in range(4):\n phi_linear = theta\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\n \t# find the cost and required force for manipulation for the leg\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\n \t# adding cost of changing leg\n if leg != current_leg:\n cost_legchange[leg] = cost_ChangeLeg\n # adding cost of PAM motion to PAM goal pose\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\n if cost_PAM[leg][push_pull]!= float(\"inf\"):\n PAM_s_sim = copy.deepcopy(PAM_s)\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n # adding cost of predicted re-positionings\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\n # print(n_transition)\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\n else:\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\n\n if min(cost) < float(\"inf\"):\n \t[min_index, min_value] = [np.argmin(cost), min(cost)]\n \t# Finding the grasping goal pose based on the selected plan\n \tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\n \tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\n \tPAM_goal = state()\n \tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\n \tobject_path_planned = Path()\n \tobject_path_planned.header.frame_id = 'frame_0'\n \tfor i in range(len(planned_path_w[min_index])):\n \t\tpose = PoseStamped()\n \t\tpose.pose.position.x = planned_path_w[min_index][i][0]\n \t\tpose.pose.position.y = planned_path_w[min_index][i][1]\n \t\tpose.pose.position.z = 0\n \t\tobject_path_planned.poses.append(pose)\n\n \tPAM_path_planned = Path()\n \tPAM_path_planned.header.frame_id = 'frame_0'\n \tif min_index != current_leg:\n \t\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\n \t\t\tpose = PoseStamped()\n \t\t\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\n \t\t\tPAM_path_planned.poses.append(pose)\n else:\n \tmin_index = 5\n \tmin_value = float(\"inf\")\n if 0 < min_index and min_index <= 4:\n force_d = force[min_index][0]\n else:\n force_d = [0,0,0]\n\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned","def get_greedy_ai_move(self, gamestate):\n multiplier = 1 if gamestate.ai_colour else -1\n best_moves = []\n best_score = self.BLACK_CHECKMATE\n for move in gamestate.get_valid_moves():\n # Execute the move\n (current_row, current_column), (new_row, new_column) = move\n current_piece = gamestate.board.board[current_row][current_column]\n piece_at_new_square = gamestate.board.board[new_row][new_column]\n\n gamestate.board.board[current_row][current_column] = None\n gamestate.board.board[new_row][new_column] = current_piece\n\n if piece_at_new_square:\n if piece_at_new_square.colour:\n gamestate.board.white_pieces.remove(piece_at_new_square)\n else:\n gamestate.board.black_pieces.remove(piece_at_new_square)\n\n # Evaluate the new board state\n score = (\n self.evaluate_board(\n gamestate.board,\n gamestate.white_checkmate,\n gamestate.black_checkmate,\n gamestate.stalemate,\n )\n * multiplier\n )\n\n # Undo the move\n gamestate.board.board[current_row][current_column] = current_piece\n gamestate.board.board[new_row][new_column] = piece_at_new_square\n\n if piece_at_new_square:\n if piece_at_new_square.colour:\n gamestate.board.white_pieces.append(piece_at_new_square)\n else:\n gamestate.board.black_pieces.append(piece_at_new_square)\n\n # Check if best move\n if score > best_score:\n best_score = score\n best_moves = [move]\n elif score == best_score:\n best_moves.append(move)\n\n # If there are no best moves, return a random move.\n if best_moves:\n return self.get_random_move(best_moves)\n return self.get_random_move(gamestate.get_valid_moves())","def minimaxTest(yourAgent, minimax_fn):\n\n # create dummy 5x5 board\n print(\"Now running the Minimax test.\")\n print()\n try:\n def time_left(): # For these testing purposes, let's ignore timeouts\n return 10000\n\n player = yourAgent() #using as a dummy player to create a board\n sample_board = Board(player, RandomPlayer())\n # setting up the board as though we've been playing\n board_state = [\n [\"Q1\", \" \", \" \", \" \", \" \", \"X\", \" \"],\n [\" \", \" \", \" \", \" \", \" \", \" \", \" \"],\n [\"X\", \" \", \" \", \" \", \" \", \" \", \" \"],\n [\" \", \" \", \"X\", \"Q2\", \"X\", \" \", \" \"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \" \", \" \"],\n [\" \", \" \", \"X\", \" \", \"X\", \" \", \" \"],\n [\" \", \" \", \"X\", \" \", \"X\", \" \", \" \"]\n ]\n sample_board.set_state(board_state, True)\n\n test_pass = True\n\n expected_depth_scores = [(1, 4), (2, -2), (3, 4), (4, -2), (5, 2)]\n\n for depth, exp_score in expected_depth_scores:\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\n if exp_score != score:\n print(\"Minimax failed for depth: \", depth)\n test_pass = False\n\n if test_pass:\n player = yourAgent()\n sample_board = Board(player, RandomPlayer())\n # setting up the board as though we've been playing\n board_state = [\n [\" \", \" \", \" \", \" \", \"X\", \" \", \"X\"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \"Q2\", \" \"],\n [\" \", \"X\", \"X\", \" \", \"X\", \" \", \" \"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \"X\", \" \"],\n [\"X\", \" \", \"Q1\", \" \", \"X\", \" \", \"X\"],\n [\"X\", \" \", \" \", \" \", \"X\", \"X\", \" \"],\n [\"X\", \" \", \" \", \" \", \"X\", \" \", \" \"]\n ]\n sample_board.set_state(board_state, True)\n\n test_pass = True\n\n expected_depth_scores = [(1, 5), (2, 5), (3, 5), (4, 6), (5, 6)]\n\n for depth, exp_score in expected_depth_scores:\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\n if exp_score != score:\n print(\"Minimax failed for depth: \", depth)\n test_pass = False\n\n if test_pass:\n print(\"Minimax Test: Runs Successfully!\")\n\n except NotImplementedError:\n print('Minimax Test: Not implemented')\n except:\n print('Minimax Test: ERROR OCCURRED')\n print(traceback.format_exc())","def job_tree(self):\n\n # 1. Enforce depth of 1 for steps\n def depth_one(steps):\n depth_one = []\n for step in steps:\n if type(step) is list:\n if type(step[0]) is list:\n depth_one.append(step[0])\n else:\n depth_one.append(step)\n else:\n depth_one.append([step])\n return depth_one\n\n # 2. Convert steps to list of node objects (0,1,2,3...)\n def assign_nodes(steps):\n nodes = [i for i in range(len(steps))]\n objects = list(\n set([elem for sublist in steps for elem in sublist]))\n\n # checks for multiple src and dst objects -- added when looking for\n # mutiples\n split_objects = []\n for obj in objects:\n if len(obj) > 1:\n new_objs = obj.split(\", \")\n split_objects.extend(new_objs)\n else:\n split_objects.append(obj)\n objects = split_objects\n del(split_objects)\n\n # populate with leafless trees (Node objects, no edges)\n for node in nodes:\n nodes[node] = Node(str(node))\n\n # search for leafy trees\n for obj in objects:\n\n # accounts for multiple drc/dst objects\n leaves = []\n for i, sublist in enumerate(steps):\n for string in sublist:\n if string.count(',') > 0:\n if obj in string:\n leaves.append(i)\n else:\n if obj in sublist:\n leaves.append(i)\n leaves = sorted(list(set(leaves)))\n\n if len(leaves) > 1:\n viable_edges = []\n\n # compute cross-product\n for leaf1 in leaves:\n for leaf2 in leaves:\n if str(leaf1) != str(leaf2) and sorted((leaf1, leaf2)) not in viable_edges:\n viable_edges.append(sorted((leaf1, leaf2)))\n\n # form edge networks\n for edge in viable_edges:\n n1, n2 = nodes[edge[0]], nodes[edge[1]]\n n1.add_edge(n2)\n n2.add_edge(n1)\n nodes[int(n1.name)], nodes[int(n2.name)] = n1, n2\n return nodes\n\n # 3. Determine number of trees and regroup by connected nodes\n def connected_nodes(nodes):\n proto_trees = []\n nodes = set(nodes)\n\n while nodes:\n n = nodes.pop()\n group = {n}\n queue = [n]\n while queue:\n n = queue.pop(0)\n neighbors = n.edges\n neighbors.difference_update(group)\n nodes.difference_update(neighbors)\n group.update(neighbors)\n queue.extend(neighbors)\n proto_trees.append(group)\n return proto_trees\n\n # 4. Convert nodes to nested dictionary of parent-children relations\n # i.e. adding depth -- also deals with tree-node sorting and path\n # optimization\n def build_tree_dict(trees, steps):\n # node sorting in trees\n sorted_trees = []\n for tree in trees:\n sorted_trees.append(\n sorted(tree, key=lambda x: int(x.name)))\n\n # retrieve values of the nodes (the protocol's containers)\n # for each tree ... may want to use dictionary eventually\n all_values = []\n for tree in sorted_trees:\n values = [steps[int(node.name)] for node in tree]\n all_values.append(values)\n\n # create relational tuples:\n all_digs = []\n singles = []\n dst_potentials = []\n for tree_idx in range(len(sorted_trees)):\n edge_flag = False\n tree_digs = []\n for node_idx in range(len(sorted_trees[tree_idx])):\n\n # digs: directed graph vectors\n digs = []\n dst_nodes = []\n node_values = all_values[tree_idx][node_idx]\n src_node = str(sorted_trees[tree_idx][node_idx].name)\n\n # ACTION ON MULTIPLE OBJECTS (E.G. TRANSFER FROM SRC -> DST\n # WELLS)\n # Outcome space: {1-1, 1-many, many-1, many-many}\n if len(node_values) == 2:\n # single destination (x-1)\n if node_values[1].count(\",\") == 0:\n dst_nodes = [i for i, sublist in enumerate(\n steps) if node_values[1] == sublist[0]]\n # multiple destinations (x-many)\n elif node_values[1].count(\",\") > 0:\n dst_nodes = []\n for dst in node_values[1].replace(\", \", \"\"):\n for i, sublist in enumerate(steps):\n if i not in dst_nodes and dst == sublist[0]:\n dst_nodes.append(i)\n\n # ACTION ON A SINGLE OBJECT\n elif len(node_values) == 1:\n dst_nodes = [i for i, sublist in enumerate(\n steps) if node_values[0] == sublist[0]]\n\n # Constructing tuples in (child, parent) format\n for dst_node in dst_nodes:\n dig = (int(dst_node), int(src_node))\n digs.append(dig)\n\n # else: an edge-case for dictionaries constructed with no edges\n # initiates tree separation via flag\n if digs != []:\n edge_flag = False\n tree_digs.append(digs)\n else:\n edge_flag = True\n digs = [(int(src_node), int(src_node))]\n tree_digs.append(digs)\n\n # digraph cycle detection: avoids cycles by overlooking set\n # repeats\n true_tree_digs = []\n for digs in tree_digs:\n for dig in digs:\n if tuple(sorted(dig, reverse=True)) not in true_tree_digs:\n true_tree_digs.append(\n tuple(sorted(dig, reverse=True)))\n\n # edge-case for dictionaries constructed with no edges\n if true_tree_digs != [] and edge_flag == False:\n all_digs.append(true_tree_digs)\n elif edge_flag == True:\n all_digs.extend(tree_digs)\n\n # Enforces forest ordering\n all_digs = sorted(all_digs, key=lambda x: x[0])\n\n # job tree traversal to find all paths:\n forest = []\n for digs_set in all_digs:\n\n # pass 1: initialize nodes dictionary\n nodes = OrderedDict()\n for tup in digs_set:\n id, parent_id = tup\n # ensure all nodes accounted for\n nodes[id] = OrderedDict({'id': id})\n nodes[parent_id] = OrderedDict({'id': parent_id})\n\n # pass 2: create trees and parent-child relations\n for tup in digs_set:\n id, parent_id = tup\n node = nodes[id]\n # links node to its parent\n if id != parent_id:\n # add new_node as child to parent\n parent = nodes[parent_id]\n if not 'children' in parent:\n # ensure parent has a 'children' field\n parent['children'] = []\n children = parent['children']\n children.append(node)\n\n desired_tree_idx = sorted(list(nodes.keys()))[0]\n forest.append(nodes[desired_tree_idx])\n return forest\n\n # 5. Convert dictionary-stored nodes to unflattened, nested list of\n # parent-children relations\n def dict_to_list(forest):\n forest_list = []\n for tree in forest:\n tString = str(json.dumps(tree))\n tString = tString.replace('\"id\": ', \"\").replace('\"children\": ', \"\").replace(\n '[{', \"[\").replace('}]', \"]\").replace('{', \"[\").replace('}', \"]\")\n\n # find largest repeated branch (if applicable)\n # maybe think about using prefix trees or SIMD extensions for better\n # efficiency\n x, y, length, match = 0, 0, 0, ''\n for y in range(len(tString)):\n for x in range(len(tString)):\n substring = tString[y:x]\n if len(list(re.finditer(re.escape(substring), tString))) > 1 and len(substring) > length:\n match = substring\n length = len(substring)\n\n # checking for legitimate branch repeat\n if \"[\" in match and \"]\" in match:\n hits = []\n index = 0\n if len(tString) > 3:\n while index < len(tString):\n index = tString.find(str(match), index)\n if index == -1:\n break\n hits.append(index)\n index += len(match)\n\n # find all locations of repeated branch and remove\n if len(hits) > 1:\n for start_loc in hits[1:]:\n tString = tString[:start_loc] + \\\n tString[start_loc:].replace(match, \"]\", 1)\n\n # increment all numbers in string to match the protocol\n newString = \"\"\n numString = \"\"\n for el in tString:\n if el.isdigit(): # build number\n numString += el\n else:\n if numString != \"\": # convert it to int and reinstantaite numString\n numString = str(int(numString) + 1)\n newString += numString\n newString += el\n numString = \"\"\n tString = newString\n del newString\n\n forest_list.append(ast.literal_eval(tString))\n return forest_list\n\n # 6. Print job tree(s)\n def print_tree(lst, level=0):\n print(' ' * (level - 1) + '+---' * (level > 0) + str(lst[0]))\n for l in lst[1:]:\n if type(l) is list:\n print_tree(l, level + 1)\n else:\n print(' ' * level + '+---' + l)\n\n # 1\n steps = depth_one(self.object_list)\n # 2\n nodes = assign_nodes(steps)\n # 3\n proto_forest = connected_nodes(nodes)\n # 4\n forest = build_tree_dict(proto_forest, steps)\n # 5\n self.forest_list = dict_to_list(forest)\n # 6\n print(\"\\n\" + \"A suggested Job Tree based on container dependency: \\n\")\n for tree_list in self.forest_list:\n print_tree(tree_list)","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n # Initialize data structures\n parent_node = {}\n path_to_node = {}\n priority_queue = util.PriorityQueue()\n\n p_c = 0.5\n h_c = 1 - p_c\n\n # Get the start node\n start_node = problem.getStartState()\n parent_node[start_node] = None\n path_to_node[start_node] = []\n priority_queue.update(start_node, 0)\n\n #goal_found = False\n\n while not priority_queue.isEmpty():\n # Get the next node\n node_to_expand = priority_queue.pop()\n # Check if goal state is reached\n if problem.isGoalState(node_to_expand):\n break\n next_nodes = problem.getSuccessors(node_to_expand)\n path_to_parent = path_to_node[node_to_expand]\n\n for one_node in next_nodes:\n point, move, cost = one_node\n curr_path = path_to_node[node_to_expand] + [move]\n curr_cost = problem.getCostOfActions(curr_path)\n heuristic_cost = heuristic(point, problem)\n # Check if current node already exists in the previously visited nodes\n if point in path_to_node:\n prev_cost = problem.getCostOfActions(path_to_node[point])\n if prev_cost > curr_cost:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n else:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\n\n print(node_to_expand) \n return path_to_node[node_to_expand]\n \n# nodes_to_expand = set()\n# # get max value node in the fringe node\n# min_val = float(\"inf\")\n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost < min_val:\n# min_val = total_cost\n# \n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost == min_val:\n# nodes_to_expand.add(one_node)\n# fringe_node.remove(one_node)\n#\n# # Expand the fringe node \n# for one_node in nodes_to_expand:\n# path_to_parent = path_to_point[one_node]\n# for nxt_node in problem.getSuccessors(one_node):\n# pos = nxt_node[0]\n# mv = nxt_node[1]\n# # check if point already present in path to point\n# prev_cost = float(\"inf\")\n# if pos in cost_to_point:\n# prev_cost = cost_to_point[pos]\n# new_path = path_to_parent + [mv]\n# if prev_cost > problem.getCostOfActions(new_path):\n# path_to_point[pos] = new_path\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\n# fringe_node.append(pos)\n#\n# # Check if destination is reached in the fringe node\n# for one_node in fringe_node:\n# if problem.isGoalState(one_node):\n# final_node = one_node\n# goal_found = True\n# break\n# \n# #print(len(fringe_node))\n# print(final_node)\n# print(path_to_point[final_node])\n# return path_to_point[final_node] \n\n util.raiseNotDefined()","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n #here again we are making use of the priority queue for storing the frontier nodes\n #created a priority queue for Astarsearch\n neighbourNodes = util.PriorityQueue()\n moves = []\n neighbourNodes.push((problem.getStartState(),moves,0),0)\n seenNodes = set()\n\n while not neighbourNodes.isEmpty():\n currentState, currentActions, currentCost = neighbourNodes.pop()\n if(currentState in seenNodes):\n continue\n if problem.isGoalState(currentState):\n return currentActions\n seenNodes.add(currentState)\n for state, action, cost in problem.getSuccessors(currentState):\n if(state in seenNodes):\n continue\n #here we calculate the hueristic value of visting each nodes\n hvalue = heuristic(state, problem)\n #and while pushing onto the queue we not only have the cost to visit the node\n #but also the heuristic value of that node.\n neighbourNodes.push((state, currentActions+[action], currentCost+cost),currentCost+cost+hvalue)\n return moves","def optimized_work_tree(obj, **kwargs):\n exclusions = kwargs.get('exclusions', {\"groups\": [], \"classes\": [], \"params\": []})\n groups_done = {}\n classes = {\"depths\": {}, \"content\": {}}\n params = {\"depths\": {}, \"content\": {}}\n if hasattr(obj, 'hostname') and not hasattr(obj, 'name'):\n obj.name = obj.hostname\n to_index = [(obj, 1)]\n\n index_pop = to_index.pop\n index_extend = to_index.extend\n while to_index:\n (obj, depth) = index_pop()\n objname = obj.name\n if objname in groups_done and groups_done[objname] <= depth:\n continue\n\n objclasses = obj.classes.exclude(classname__in=exclusions['classes'])\n updated_classes = optimized_update_values(objclasses, \"classname\", \"classparams\", depth=depth, results=classes)\n\n objparams = obj.parameters.exclude(paramkey__in=exclusions['params'])\n updated_params = optimized_update_values(objparams, \"paramkey\", \"paramvalue\", depth=depth, results=params)\n\n if not updated_classes or not updated_params:\n return (\"Fail\", \"Fail\")\n\n groups_done[objname] = depth\n depth += 1\n children = ((group, depth) for group in obj.groups.exclude(name__in=exclusions['groups']))\n index_extend(children)\n\n params['content']['done_count'] = len(groups_done)\n return (classes[\"content\"], params[\"content\"])","def minimax(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n if game.get_legal_moves():\n scores = [(self.minvalue(game.forecast_move(move), depth), move) for move in game.get_legal_moves()]\n else:\n return (self.score(game, self), (-1,-1)) \n\n return max(scores)","def move_mcts(self, board, exploration_obj, evaluation_fn):\n tree = mcts.MCTS(board, exploration_obj, evaluation_fn)\n start = time.process_time()\n tree.search(Parameters.uct_sims, Parameters.tree_sims)\n total = time.process_time()-start\n recommendation = tree.get_best_action()\n return recommendation, total","def move_buildings(self):","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n actionList = gameState.getLegalActions(0)\n pacmanAgentIndex = 0\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\n count = util.Counter()\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\n\n def maximizer(curState, agentIndex, depth):\n\n ghostActions = curState.getLegalActions(agentIndex)\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\n weight = -99999999 # Worst case starting value to be changed in the code\n if depth == maxDepth: # If we are at a leaf node\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\n # Otherwise, we progress the tree until the above condition is reached\n if len(ghostActions) != 0:\n for x in ghostActions:\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth):\n weight = weight\n else:\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n def minimizer(curState, agentIndex, depth):\n ghostActions = curState.getLegalActions(agentIndex)\n weight = 999999999 # Worst case starting value to be changed in the code\n if len(ghostActions) != 0:\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\n for x in ghostActions: # For each legal action in the current position\n temp = maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\n if weight < temp:\n weight = weight\n else:\n weight = temp\n else: # Otherwise, we continue to minimize\n for x in ghostActions: # For each legal action in the current position\n temp = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\n if weight < temp:\n weight = weight\n else:\n weight = temp\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n\n # Executing the minimizer for all possible actions\n for x in actionList:\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\n count[x] = minimizer(tempState,1,0)\n # print('HELLO THERE')\n # print(count)\n return count.argMax()","def move(self, board):\r\n self.start_time = time.time()\r\n disk_total = self.get_disk_count(self.my_color, board) + self.get_disk_count(self.opponent_color, board)\r\n\r\n if disk_total < 15:\r\n # In early-game, we can allow a deeper minimax search since there's not too many possible moves.\r\n self.minimax_max_depth = 7\r\n\r\n elif disk_total < 45:\r\n # In mid-game, minimax tree has the most branches. Therefore, we must give it space to breathe.\r\n self.minimax_max_depth = 5\r\n else:\r\n # In the very end-game, minimax tree has the least branches, so we can allow a full search.\r\n self.minimax_max_depth = 8\r\n\r\n possible_moves = self.find_possible_moves(board, self.my_color)\r\n\r\n # If there's only one move available, return it\r\n if len(possible_moves) == 1:\r\n return possible_moves[0]\r\n\r\n # If we can take a corner, take it and don't consider any other options.\r\n # This rarely backfires and allows to save a tiny bit of time\r\n corners = [(0,0), (0,7), (7,0), (7,7)]\r\n for corner in corners:\r\n if corner in possible_moves:\r\n return corner\r\n\r\n # Grow a minimax tree to find the best available move\r\n alpha_init = -10000000\r\n beta_init = 10000000\r\n\r\n available_moves = self.minimax(board, 0, self.my_color, alpha_init, beta_init)\r\n print(available_moves)\r\n if available_moves != 0:\r\n best_value = max(available_moves.values())\r\n for move in available_moves:\r\n if available_moves[move] == best_value:\r\n return move\r\n\r\n return None","def step(self):\n try:\n self.agents.sort(key=lambda x: x.dist)\n except Exception as e:\n print(e)\n\n for agent in self.agents:\n try:\n agent.step()\n except Exception as e:\n print(e)\n\n\n # Removes agents if they reach exit\n for exit in self.model.exits:\n x, y = exit.pos[0] * 6 + 1, exit.pos[1] * 6 + 1\n if agent.node == (x, y):\n try:\n agent.saved()\n except Exception as e:\n print(e)","def agent(obs_dict, config_dict):\n global last_move\n observation = Observation(obs_dict)\n configuration = Configuration(config_dict)\n player_index = observation.index\n player_goose = observation.geese[player_index]\n player_head = player_goose[0]\n player_row, player_column = row_col(player_head, configuration.columns)\n possible_moves = [Action.SOUTH.name, Action.NORTH.name, Action.WEST.name, Action.EAST.name]\n possible_move = None\n oldFoodDistanceToMe = 9999\n \n def getFoodsIndex(): \n foods = []\n for i in range(len(observation.food)):\n food = observation.food[i]\n foods.append(row_col(food, configuration.columns))\n return foods\n\n def getGoose(index):\n goose = []\n for i in range(len(observation.geese[index])):\n goose.append(row_col(observation.geese[index][i], configuration.columns))\n return goose\n\n def getGeesesIndex():\n geeses = []\n for geese in observation.geese:\n geeses.append(row_col(geese[0], configuration.columns))\n return geeses\n\n def randomMove(moves):\n if len(moves) > 1:\n return moves[randint(0, len(moves) - 1)]\n return moves[0]\n\n def countMoves(x1, y1, x2, y2):\n return abs((x1-x2)+(y1-y2)) \n\n def willCollide(x, y, action):\n #print(f'Goose[{player_index} in player_row: {player_row}, player_column: {player_column} move to {action} and can collide with x: {x}, y: {y}')\n if action == Action.WEST.name:\n if player_column - 1 == y and x == player_row:\n return True \n if player_column == 0 and y == 10 and x == player_row:\n return True\n if action == Action.EAST.name:\n if player_column + 1 == y and x == player_row:\n return True\n if player_column == 10 and y == 0 and x == player_row:\n return True\n if action == Action.SOUTH.name:\n if player_row + 1 == x and y == player_column:\n return True\n if player_row == 6 and x == 0 and y == player_column:\n return True\n if action == Action.NORTH.name:\n if player_row - 1 == x and y == player_column:\n return True\n if player_row == 0 and x == 6 and y == player_column:\n return True\n return False\n\n def opposite(action):\n if action == Action.NORTH.name:\n return Action.SOUTH.name\n if action == Action.SOUTH.name:\n return Action.NORTH.name\n if action == Action.EAST.name:\n return Action.WEST.name\n if action == Action.WEST.name:\n return Action.EAST.name\n\n possible_moves = [Action.SOUTH.name, Action.NORTH.name, Action.WEST.name, Action.EAST.name]\n\n if last_move[player_index] is not None:\n print(f'Geese {player_index} removes opposite last move: {opposite(last_move[player_index])}')\n possible_moves.remove(opposite(last_move[player_index]))\n\n for geese_row, geese_column in getGeesesIndex():\n for food_row, food_column in getFoodsIndex():\n foodDistanceToMe = countMoves(food_row, food_column, player_row, player_column)\n if oldFoodDistanceToMe > foodDistanceToMe:\n oldFoodDistanceToMe = foodDistanceToMe\n else:\n continue\n \n geeseDistanceToFood = countMoves(geese_row, geese_column, food_row, food_column)\n if foodDistanceToMe < geeseDistanceToFood:\n if food_row > player_row:\n possible_move = Action.SOUTH.name\n\n if food_row < player_row:\n possible_move = Action.NORTH.name\n\n if food_column > player_column:\n possible_move = Action.EAST.name\n\n if food_column < player_column:\n possible_move = Action.WEST.name\n \n print(f'Geese {player_index} based by food, possible move: {possible_move}')\n if possible_move not in possible_moves:\n print(f'Geese {player_index}, possible move: {possible_move} is banned.')\n possible_move = randomMove(possible_moves)\n\n for i in range(len(observation.geese)):\n geese_index = getGoose(i)\n j = 0\n while j < len(geese_index):\n collision = False\n x, y = geese_index[j]\n if i != player_index:\n print(f'geese {player_index} -> geese {i} part {j}')\n #print(f'goose[{player_index}] in {getGoose(player_index)[0]} with possible move: {possible_move} can colide with goose[{i}] in x: {x} and y: {y}')\n while willCollide(x, y, possible_move):\n collision = True\n print(f'goose[{player_index}] in {getGoose(player_index)[0]} with possible move: {possible_move} will colide with goose[{i}] in x: {x} and y: {y}')\n possible_moves.remove(possible_move)\n possible_move = randomMove(possible_moves)\n print(f'now goose[{player_index}] will to {possible_move}')\n j = 0\n if not collision:\n j += 1\n\n for x, y in getGoose(player_index):\n while willCollide(x, y, possible_move):\n print(f'BODY HIT!!!')\n possible_moves.remove(possible_move)\n possible_move = randomMove(possible_moves)\n\n if len(possible_moves) == 1:\n print(f'Geese {player_index} just remain this move: {possible_moves[0]}')\n possible_move = possible_moves[0]\n\n last_move[player_index] = possible_move\n\n print(f'Geese {player_index}: {getGoose(player_index)} move to {possible_move}')\n return possible_move","def perform_split_brain_actions(self):\n proximity = self.grid.proximity_to_apple()\n inputs = [\n torch.tensor([\n [\n proximity,\n self.grid.safe_cells_up_global(),\n self.grid.safe_cells_up(),\n self.grid.apple_is_up_safe(0.5)\n ]\n ]),\n torch.tensor([\n [\n proximity,\n self.grid.safe_cells_down_global(),\n self.grid.safe_cells_down(),\n self.grid.apple_is_down_safe(0.5)\n ]\n ]),\n torch.tensor([\n [\n proximity,\n self.grid.safe_cells_left_global(),\n self.grid.safe_cells_left(),\n self.grid.apple_is_left_safe(0.5)\n ]\n ]),\n torch.tensor([\n [\n proximity,\n self.grid.safe_cells_right_global(),\n self.grid.safe_cells_right(),\n self.grid.apple_is_right_safe(0.5)\n ]\n ])\n ]\n\n new_direction = self.split_brain_network.eval(inputs)\n self.grid.change_direction(new_direction)\n got_apple = self.grid.next_frame()\n new_proximity = self.grid.proximity_to_apple()\n\n if self.is_training:\n reward = torch.tensor([-0.5])\n\n if self.grid.snake_died():\n reward = torch.tensor([-1.0])\n elif got_apple:\n reward = torch.tensor([1.0])\n elif new_proximity > proximity:\n reward = torch.tensor([0.8])\n\n self.split_brain_network.update(reward)","def solve1(cheese, model, original=0, helper1=1, helper2=2, destination=3):\n\n # solve the model if there is only 1 cheese\n # if model only has 1 cheese then move it from stool 0 to stool 3\n if cheese == 1:\n model.move(original, destination)\n print(model)\n time.sleep(delay_between_moves)\n # solve the mdoel with a set of steps when there are 2 cheeses\n elif cheese == 2:\n model.move(original, helper1)\n print(model)\n time.sleep(delay_between_moves)\n model.move(original, destination)\n print(model)\n time.sleep(delay_between_moves)\n model.move(helper1, destination)\n print(model)\n time.sleep(delay_between_moves)\n # solve the model if there is more than 2 cheeses\n # 1. first move all but 2 cheeses to stool 2 using stool 1 and stool 3\n # as helper tools\n # 2. Then use predefined steps to move the 2 cheeses from stool 0 to stool 3\n # 3. Then move all the cheeses that were left on stool 2 from step 1 to\n # stool 3 using stool 0 and stool 1 as helper stools\n else:\n solve1(cheese - 2, model, original, helper1, destination, helper2)\n model.move(original, helper1)\n print(model)\n time.sleep(delay_between_moves)\n model.move(original, destination)\n print(model)\n time.sleep(delay_between_moves)\n model.move(helper1, destination)\n print(model)\n time.sleep(delay_between_moves)\n solve1(cheese - 2, model, helper2, original, helper1, destination)","def action(self):\n # TODO: Decide what action to take, and return it\n\n # Minimax: For each white tokens on the board, there are 4 different directions to move to.\n colour = \"blacks\" if self.colour == \"white\" else \"whites\"\n eval, action = minimax(self.layout, 6, -13, 13, True, colour, self.colour + \"s\")\n return action","def ai_move(board, player_id):\n\n global boards\n\n move = -1\n root = Node(board, player_id, -1)\n start = time.time()\n turn_length = 15\n while time.time() < start + turn_length:\n mcts(root)\n\n best_score = -inf\n print(f\"length of children: {len(root.children)}\")\n for child in root.children:\n if child.wins / child.games > best_score:\n move = child.move\n best_score = child.wins / child.games\n\n if move == -1:\n print(\"Random move\")\n move = randint(0, 24)\n\n board[move] = player_id\n print(f\"Calls to mcts: {boards}\")","def actions_turn(positions, player1, player2, creatures):\n\n attacking = []\n moving = []\n\n # Split the orders within attacks and movements\n for character in positions:\n if character in creatures:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n elif character in player1:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n\n else:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n\n # Execute the attacks\n for character in attacking:\n # First attacking : the creatures\n if character in creatures:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n # Then the heroes of the first player\n elif character in player1:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n # Finally the ones of the second player\n else:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n\n for character in moving:\n print(character, moving)\n # First moving : the creatures\n if character in creatures:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n # Then the heroes of the first player\n elif character in player1:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n # Finally the ones of the second player\n else:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n return player1, player2, positions, creatures","def move_to_new_class(self, elements_to_move):\n for element in elements_to_move:\n place = self._place[element]\n place.delete()\n self.add_class(elements_to_move)","def next_move(\r\n self,\r\n state: TwoPlayerGameState,\r\n gui: bool = False,\r\n ) -> TwoPlayerGameState:\r\n\r\n successors = self.generate_successors(state)\r\n\r\n minimax_value = -np.inf\r\n\r\n for successor in successors:\r\n if self.verbose > 1:\r\n print('{}: {}'.format(state.board, minimax_value))\r\n\r\n successor_minimax_value = self._min_value(\r\n successor,\r\n self.max_depth_minimax,\r\n )\r\n\r\n if (successor_minimax_value > minimax_value):\r\n minimax_value = successor_minimax_value\r\n next_state = successor\r\n\r\n if self.verbose > 0:\r\n if self.verbose > 1:\r\n print('\\nGame state before move:\\n')\r\n print(state.board)\r\n print()\r\n print('Minimax value = {:.2g}'.format(minimax_value))\r\n\r\n return next_state"],"string":"[\n \"def make_move(self):\\n\\n # get relavent information\\n affinity = self.get_affinity()\\n sample_space = self.get_game_space()\\n depth_limit = self.__search_depth\\n\\n # run a minimax search and get the best value\\n bestval = MinimaxTree.alphabeta(self, sample_space, affinity, depth_limit, -10000, 10001, True)\\n if bestval[0] is None: bestval = ((0,6),'x', 0)\\n\\n # print the number of nodes expanded \\n print(self.nodes_expanded)\\n\\n # make the move found by the search \\n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)\",\n \"def action(self):\\r\\n\\r\\n\\r\\n #have we just started?\\r\\n if self.player_information[\\\"us\\\"][\\\"nTokens\\\"] == 0:\\r\\n move = generate_starting_move(self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array)\\r\\n return move\\r\\n\\r\\n #otherwise do minimax \\r\\n \\r\\n #start off with some shallow depth:\\r\\n if self.turn_no < 5:\\r\\n depth = 3\\r\\n else:\\r\\n depth = 2\\r\\n \\r\\n #set a constraint for search depth\\r\\n if self.total_tokens_on_board < 6:\\r\\n depth = 3\\r\\n elif self.total_tokens_on_board < 10:\\r\\n depth = 2\\r\\n else:\\r\\n depth = 1\\r\\n \\r\\n #have a time reference\\r\\n print(f'nthrows: {self.player_information[\\\"us\\\"][\\\"nThrowsRemaining\\\"]}')\\r\\n starting_time = int(round(time.time(), 0))\\r\\n #salvage result from minimax\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, depth, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, True, self.turn_no)\\r\\n\\r\\n #clean it up a bit \\r\\n print(self.board_dict)\\r\\n #tidy it up\\r\\n result = result[0]\\r\\n print(f'pre: {result}')\\r\\n #in case we get a bad move redo but make it very shallow\\r\\n if len(result) == 1 or result == (-5, -5):\\r\\n #force it to return a usable move\\r\\n counter = 0\\r\\n while (len(result) == 1) or (result == (-5, -5)):\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, 1, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, False, self.turn_no)\\r\\n result = result[0]\\r\\n counter += 1\\r\\n \\r\\n #if its taking too long\\r\\n if counter > 2: \\r\\n #generate one random possible move to use \\r\\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \\\"us\\\"]\\r\\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\\r\\n self.player_information, self.board_array, True, \\\"all\\\")\\r\\n \\r\\n \\r\\n #if there are no moves\\r\\n if len(move_list) == 0:\\r\\n if self.player_information['us']['nThrowsRemaining'] > 0:\\r\\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \\\"us\\\",\\r\\n self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array, \\\"all\\\" )\\r\\n result = random.choice(throws)\\r\\n \\r\\n else:\\r\\n result = random.choice(move_list)\\r\\n print(f'random: {result}')\\r\\n break\\r\\n\\r\\n print(f' inside: {result}')\\r\\n\\r\\n print(result)\\r\\n #otherwise clean it up\\r\\n if result[0] == 'throw':\\r\\n final_result = (result[0].upper(), result[1], result[2])\\r\\n else:\\r\\n final_result = (result[0].upper(), result[2], result[3])\\r\\n # return final result \\r\\n return final_result\",\n \"def make_move(self):\\n\\n # get relavent information\\n affinity = self.get_affinity()\\n sample_space = self.get_game_space()\\n depth_limit = self.__search_depth\\n\\n # run a minimax search and get the best value\\n bestval = MinimaxTree.minimax(self, sample_space, affinity, depth_limit, True)\\n if bestval[0] is None: bestval = ((0,6),'x', 0)\\n\\n # print the number of nodes expanded \\n print(self.nodes_expanded)\\n\\n # make the move found by the search \\n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n #Fetching legal moves for the active player at max level\\n legal_moves = game.get_legal_moves()\\n #Terminial condition - if there are no legal moves left will call the utility function\\n if not legal_moves:\\n return game.utility(self) #Returning utility function\\n #Assigning default value to best move\\n best_move = legal_moves[0]\\n #Assigning default value to best score as -inf\\n best_score = float('-inf')\\n #for each future legal move of active player\\n for move in legal_moves:\\n #Fetching next state forecast moves\\n next_state = game.forecast_move(move)\\n #Calling min_value function for score - Return type of min_value function is score\\n score = self.min_value(next_state, depth-1)\\n if score > best_score:\\n best_move = move\\n best_score = score\\n return best_move #Return best_move\",\n \"def run_ai():\\n print(\\\"Othello AI\\\") # First line is the name of this AI\\n arguments = input().split(\\\",\\\")\\n \\n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \\n limit = int(arguments[1]) #Depth limit\\n minimax = int(arguments[2]) #Minimax or alpha beta\\n caching = int(arguments[3]) #Caching \\n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\\n\\n if (minimax == 1): eprint(\\\"Running MINIMAX\\\")\\n else: eprint(\\\"Running ALPHA-BETA\\\")\\n\\n if (caching == 1): eprint(\\\"State Caching is ON\\\")\\n else: eprint(\\\"State Caching is OFF\\\")\\n\\n if (ordering == 1): eprint(\\\"Node Ordering is ON\\\")\\n else: eprint(\\\"Node Ordering is OFF\\\")\\n\\n if (limit == -1): eprint(\\\"Depth Limit is OFF\\\")\\n else: eprint(\\\"Depth Limit is \\\", limit)\\n\\n if (minimax == 1 and ordering == 1): eprint(\\\"Node Ordering should have no impact on Minimax\\\")\\n\\n while True: # This is the main loop\\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input()\\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over.\\n print\\n else:\\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The\\n # squares in each row are represented by\\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n\\n # Select the move and send it to the manager\\n if (minimax == 1): #run this if the minimax flag is given\\n movei, movej = select_move_minimax(board, color, limit, caching)\\n else: #else run alphabeta\\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\\n \\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def run_ai():\\n print(\\\"Othello AI\\\") # First line is the name of this AI\\n arguments = input().split(\\\",\\\")\\n \\n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \\n limit = int(arguments[1]) #Depth limit\\n minimax = int(arguments[2]) #Minimax or alpha beta\\n caching = int(arguments[3]) #Caching \\n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\\n\\n if (minimax == 1): eprint(\\\"Running MINIMAX\\\")\\n else: eprint(\\\"Running ALPHA-BETA\\\")\\n\\n if (caching == 1): eprint(\\\"State Caching is ON\\\")\\n else: eprint(\\\"State Caching is OFF\\\")\\n\\n if (ordering == 1): eprint(\\\"Node Ordering is ON\\\")\\n else: eprint(\\\"Node Ordering is OFF\\\")\\n\\n if (limit == -1): eprint(\\\"Depth Limit is OFF\\\")\\n else: eprint(\\\"Depth Limit is \\\", limit)\\n\\n if (minimax == 1 and ordering == 1): eprint(\\\"Node Ordering should have no impact on Minimax\\\")\\n\\n while True: # This is the main loop\\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input()\\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over.\\n print\\n else:\\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The\\n # squares in each row are represented by\\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n\\n # Select the move and send it to the manager\\n if (minimax == 1): #run this if the minimax flag is given\\n movei, movej = select_move_minimax(board, color, limit, caching)\\n else: #else run alphabeta\\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\\n \\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def alphabeta_search(state):\\r\\n \\r\\n '''\\r\\n Terminates when game.actions is empty\\r\\n Class Game needs the following functions:\\r\\n - game.result(state, a) -- successor\\r\\n - game.actions(state) -- possible moves\\r\\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\\r\\n \\r\\n '''\\r\\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\\r\\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\\r\\n \\r\\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\\r\\n cutoff_test=None\\r\\n sort_fn = [vitalpoint, eyeHeur]\\r\\n eval_fn = survivalheur \\r\\n #randnumheuristics \\r\\n player = state.to_move()\\r\\n prune = 0\\r\\n pruned = {} #this will store the depth of the prune\\r\\n totaldepth = [0]\\r\\n visited = {}\\r\\n heuristicInd = 0\\r\\n \\r\\n def max_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = -infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #max wants decreasing\\r\\n #sorted(state.actions(), key = eval_sort, reverse = True)\\r\\n \\r\\n #sort by favorites first, returns a list of actions\\r\\n # for sorts in sort_fn:\\r\\n tempher = heuristicInd\\r\\n\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n ''''''\\r\\n for a in sortedactions:\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n \\r\\n onbranch += 1\\r\\n v = max(v, min_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\\r\\n if v >= beta: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n alpha = max(alpha, v)\\r\\n \\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n \\r\\n return v\\r\\n\\r\\n def min_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #min wants increasing\\r\\n #sorted(state.actions(), key = eval_sort)\\r\\n #Shayne\\r\\n tempher = heuristicInd\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state, 1)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n for a in sortedactions: #state.actions():\\r\\n onbranch += 1\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n v = min(v, max_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd))\\r\\n if v <= alpha: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n beta = min(beta, v)\\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n\\r\\n # Body of alphabeta_search starts here:\\r\\n #def cutoff_test and eval_fn \\r\\n cutoff_test = (cutoff_test or\\r\\n (lambda state,depth: depth>d or state.terminal_test()))\\r\\n eval_fn = eval_fn or (lambda state: state.utility(player))\\r\\n #by default, utility score is used\\r\\n \\r\\n \\r\\n #argmax goes through all the possible actions and \\r\\n # applies the alphabeta search onto all of them\\r\\n # and returns the move with the best score \\r\\n #print state.actions()\\r\\n heuristicInd = 0\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedact, heuristicInd = sorts(state)\\r\\n abmove = argmax(sortedact,\\r\\n lambda a: min_value(state.result(a),\\r\\n -infinity, infinity, 0, heuristicInd))\\r\\n\\r\\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\\r\\n for i in range(1, len(visited)):\\r\\n if len(pruned) < i:\\r\\n pruned[i] = 0\\r\\n print i, \\\",\\\", len(visited[i]), \\\",\\\", pruned[i]\\r\\n \\r\\n return abmove\",\n \"def run(self):\\n\\n # keep track of counter\\n counter = 0\\n\\n while self.queue:\\n\\n # print depth of tree every 10000 steps\\n if counter % 10000 == 0:\\n print(len(self.queue[0]))\\n\\n # get first moves set from queue\\n moves_set = self.get_moves_set()\\n\\n # move all moves from set\\n self.try_moves(moves_set)\\n\\n # continue branch (add to queue) if layout is not in archive\\n if self.not_in_archive():\\n self.add_to_queue(moves_set)\\n \\n # check for win\\n if self.won_game():\\n\\n # return winning set of moves\\n return moves_set\\n \\n # reverse moves to original layout\\n self.reverse_moves(moves_set)\\n \\n # add to counter\\n counter += 1\",\n \"def minimax(self, board: str):\\n \\\"\\\"\\\" Your Code Here \\\"\\\"\\\"\\n\\n # ----------------------------BEGIN CODE----------------------------\\n # disclaimer: I did only minimax (as said on the homework description https://drive.google.com/file/d/1JXBi_5JB8fwTWX34j0ZwN5YwjoIexh-Z/view)\\n # my minimax does NOT try to prolong the game. It always goes for the best move!\\n\\n # initializing default values\\n moveToMake = validMoves(board)[0]\\n bestValue = -100\\n\\n # this will find the best move to go to, since value only returns the best score\\n # util's setMove creates a copy, so we can use that as the successor\\n for validmove in validMoves(board):\\n currentValue = self.value(\\n setMove(board, validmove, whoseMove(board)), 0)\\n if currentValue > bestValue:\\n bestValue = currentValue\\n moveToMake = validmove\\n\\n # currently the val and game_length tuple is arbitrary because i have not implemented depth!\\n return (moveToMake)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n self.visited_states.append(self.currentState.state)\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n # If current state has no children, make children\\n if not self.currentState.children:\\n for movable_statement in movables:\\n # Make the move\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n # print (\\\"new state \\\", new_state)\\n\\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\\n if (new_state not in self.visited_states):\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.visited[new_gs] = True\\n self.visited_states.append(new_state)\\n self.gs_queue.append(new_gs)\\n\\n self.gm.reverseMove(movable_statement)\\n\\n # Return false if no more to explore\\n if not self.gs_queue:\\n return False\\n\\n # Revert to state at when current and next start to change\\n root_curr = self.currentState\\n self.currentState = self.gs_queue.popleft()\\n root_new = self.currentState\\n\\n # Backtrack to when current node and new node start to diverge\\n if root_new.depth == root_curr.depth:\\n while root_curr.state != root_new.state:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n root_new = root_new.parent\\n else:\\n while root_curr.requiredMovable:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n\\n # Return game master to state that we are exploring\\n # Find path between root and current state\\n path = []\\n currNode = self.currentState\\n while currNode != root_curr:\\n path.append(currNode.requiredMovable)\\n currNode = currNode.parent\\n\\n # Created backwards path, now make moves from root to current state\\n path.reverse()\\n for movable_statement in path:\\n self.gm.makeMove(movable_statement)\\n\\n return False\",\n \"def move(self):\\n for agent in self.agents:\\n if not agent.fidelity:\\n options = agent.get_move_options(agent.hex, self.kernel_size, None, extend=True)\\n target = random36.choices(population=options,weights=[x.quality**2 for x in options])\\n agent.move(target[0])\",\n \"def move(self, state):\\n \\n self.depth_limit=1\\n self.best_utility=-2\\n action=None\\n while not self.is_time_up():\\n self.terminal=True\\n self.cache={}\\n action=self.alpha_beta_search(state,0)\\n if self.terminal==True:\\n break\\n self.depth_limit=self.depth_limit+1\\n \\n return action\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n # TODO: finish this function!\\n # raise NotImplementedError\\n\\n legal_moves = game.get_legal_moves() # obtain legal moves available to the board\\n best_move = (-1,-1) # initialisation of best move\\n best_score = -math.inf # abstraction of infinity\\n\\n for m in legal_moves: # for each ACTION, create a new state for its outcome, RESULT\\n new_state = game.forecast_move(m)\\n score = self.min_value(new_state, depth - 1) # recursion to calculate the score of that state\\n if score > best_score:\\n best_move = m\\n best_score = score\\n return best_move\",\n \"def itarate_the_recursion(battle_queue) -> List:\\n\\n score = None\\n name = 1\\n children = []\\n m = [name, score, battle_queue, children]\\n thing = Stack()\\n thing.add(m)\\n first_player = battle_queue.peek().get_name()\\n\\n\\n while not thing.is_empty():\\n\\n x = thing.remove()\\n\\n\\n if x[2].is_over():\\n if x[2].get_winner():\\n winner_hp = x[2].get_winner().get_hp()\\n x[1] = winner_hp if x[2].get_winner().get_name() \\\\\\n == first_player else winner_hp * -1\\n else:\\n x[1] = 0\\n\\n elif x[1] is None and x[3] != []:\\n j = []\\n for i in x[3]:\\n j += [i[1]]\\n x[1] = max(j)\\n\\n\\n elif not x[2].is_over():\\n thing.add(x)\\n\\n moves = x[2].peek().get_available_actions()\\n\\n for i in moves:\\n name += 1\\n\\n clone = x[2].copy()\\n next_char = clone.peek()\\n\\n mover(i, next_char)\\n\\n if not clone.is_empty():\\n clone.remove()\\n\\n new_tree = [name, None, clone, []]\\n\\n x[3].append(new_tree)\\n thing.add(new_tree)\\n return m\",\n \"def minimax(self, state, agent, parents_positions):\\n if termialTest(state):\\n return utility(state)\\n return self.computeMinimaxScore(state, agent, parents_positions)\",\n \"def minimax(board):\\n #This function will return the best move. \\n #If Ai is playing as X, I can reduce the processing time by creating a random first move. \\n if (board == initial_state()):\\n coord1 = randint(0,2)\\n coord2 = randint(0,2)\\n return ((coord1,coord2))\\n #first I determine which player's turn it is\\n player_to_move = player(board)\\n best_action = None\\n #If I am X\\n if(player_to_move == \\\"X\\\"):\\n current_max = float('-inf')\\n #for every possible action I have right now, I'll call my \\\"future\\\" Min_Value since I will asume what will happen if I take this move.\\n for action in actions(board):\\n #peak on the future if I take that move\\n curr_score = Min_Value(result(board,action))\\n #if my future is favorable, I will store it as my current best option.\\n if curr_score>= current_max:\\n current_max = curr_score\\n best_action = action\\n else:\\n #If I am O, I do something similar. \\n current_max = float('inf')\\n #for every action I peak on the future for favorable results\\n for action in actions(board):\\n #this time, however, it would be X's turn so I need to start with Max_Value\\n curr_score = Max_Value(result(board,action))\\n #if my future is favorable, I store it\\n if curr_score<= current_max:\\n current_max = curr_score\\n best_action = action\\n #I return the best move.\\n return best_action\",\n \"def player_loop(self):\\n\\n # Generate game tree object\\n first_msg = self.receiver()\\n # Initialize your minimax model\\n model = self.initialize_model(initial_data=first_msg)\\n\\n while True:\\n msg = self.receiver()\\n\\n # Create the root node of the game tree\\n node = Node(message=msg, player=0)\\n\\n # Possible next moves: \\\"stay\\\", \\\"left\\\", \\\"right\\\", \\\"up\\\", \\\"down\\\"\\n best_move = self.search_best_next_move(\\n model=model, initial_tree_node=node)\\n\\n # Execute next action\\n self.sender({\\\"action\\\": best_move, \\\"search_time\\\": None})\",\n \"def minimax(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n legal_moves = game.get_legal_moves()\\n\\n best_move = (-1, -1)\\n if maximizing_player:\\n score = float(\\\"-inf\\\")\\n else:\\n score = float(\\\"inf\\\")\\n\\n #At bottom of minimax tree\\n if depth == 1:\\n for each_move in legal_moves:\\n new_game = game.forecast_move(each_move)\\n if maximizing_player and self.score(new_game, self) > score:\\n score = self.score(new_game, self)\\n best_move = each_move\\n elif not maximizing_player and self.score(new_game, self) < score:\\n score = self.score(new_game, self)\\n best_move = each_move\\n\\n return score, best_move\\n\\n #Not at bottom of minimax tree\\n for each_move in legal_moves:\\n #Return each_move that gets the highest score\\n new_game = game.forecast_move(each_move)\\n new_score , new_move = self.minimax(new_game, depth-1, not maximizing_player)\\n if maximizing_player and new_score > score:\\n score = new_score\\n best_move = each_move\\n elif not maximizing_player and new_score < score:\\n score = new_score\\n best_move = each_move\\n\\n return score, best_move\",\n \"def track(sprite, find_tags, pbad = 0.1) :\\n\\n enemies = []\\n for t in find_tags:\\n enemies.extend(get(t))\\n\\n distances = [distance(e.pos, sprite.pos) for e in enemies]\\n\\n enemy = enemies[distances.index(min(distances))]\\n x, y = sprite.pos\\n\\n choices = [(x, y), (x, y-1), (x, y+1), (x+1, y), (x-1, y)]\\n distances = [distance(p, enemy.pos) for p in choices]\\n visibility = [visible(p) for p in choices]\\n\\n best = None\\n min_dist = 999999\\n for i in range(len(choices)):\\n if is_wall(choices[i]) or not visibility[i]:\\n continue\\n\\n #every now and then make a random \\\"bad\\\" move\\n rnd = random.uniform(0, 1)\\n if rnd <= pbad:\\n best = choices[i]\\n break\\n elif distances[i] < min_dist:\\n best = choices[i]\\n min_dist = distances[i]\\n if best is not None and best != (x,y):\\n sprite.move((best[0] - x, best[1] - y))\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n tile = movable_statement.terms[0].term.element\\n initialX = movable_statement.terms[1].term.element\\n initialY = movable_statement.terms[2].term.element\\n goalX = movable_statement.terms[3].term.element\\n goalY = movable_statement.terms[4].term.element\\n r1 = parse_input(\\\"fact: (on \\\" + tile + \\\" \\\" + initialX + \\\" \\\" + initialY + \\\")\\\")\\n self.kb.kb_retract(r1)\\n r2 = parse_input(\\\"fact: (on empty \\\" + goalX + \\\" \\\" + goalY + \\\")\\\")\\n self.kb.kb_retract(r2)\\n stat1 = parse_input(\\\"fact: (on \\\" + tile + \\\" \\\" + goalX + \\\" \\\" + goalY + \\\")\\\")\\n self.kb.kb_assert(stat1)\\n stat2 = parse_input(\\\"fact: (on empty \\\" + initialX + \\\" \\\" + initialY + \\\")\\\")\\n self.kb.kb_assert(stat2)\\n\\n\\n #for facts in self.kb.facts:\\n # print(facts.statement)\\n\\n #print(\\\"\\\\n\\\\n\\\")\\n ##Need to handle adjacentTo\\n '''ask = parse_input(\\\"fact: (adjacentTo empty ?tile)\\\")\\n answer = self.kb.kb_ask(ask)\\n empty_adj = []\\n if answer:\\n for ans in answer.list_of_bindings:\\n adjTile = ans[0].bindings[0].constant.element\\n if adjTile != tile:\\n rt = parse_input(\\\"fact: (adjacentTo empty \\\" + adjTile + \\\")\\\")\\n self.kb.kb_retract(rt)\\n #print(\\\"RMOVINGGGG\\\")\\n #print(rt)\\n rt1 = parse_input(\\\"fact: (adjacentTo \\\" + adjTile + \\\" empty)\\\")\\n self.kb.kb_retract(rt1)\\n empty_adj.append(adjTile) #All of empty's adjacent tiles'''\\n\\n #for facts in self.kb.facts:\\n # print(facts.statement)\\n\\n #print(\\\"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\\\")\\n '''ask1 = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" ?tile)\\\")\\n answer1 = self.kb.kb_ask(ask1)\\n if answer1:\\n for ans in answer1.list_of_bindings:\\n adjTile = ans[0].bindings[0].constant.element\\n if adjTile != \\\"empty\\\":\\n stat = parse_input(\\\"fact: (adjacentTo empty \\\" + adjTile + \\\")\\\")\\n self.kb.kb_assert(stat)\\n radj1 = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" \\\" + adjTile + \\\")\\\")\\n self.kb.kb_retract(radj1)\\n radj2 = parse_input(\\\"fact: (adjacentTo \\\" + adjTile + \\\" \\\" + tile + \\\")\\\")\\n self.kb.kb_retract(radj2)\\n for tiles in empty_adj:\\n stat = parse_input(\\\"fact: (adjacentTo \\\" + tile + \\\" \\\" + tiles + \\\")\\\")\\n self.kb.kb_assert(stat)'''\",\n \"def minimax_helper(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n \\n # Get all the available moves at the current state\\n legal_moves = game.get_legal_moves()\\n\\n # Handle a terminal event/exhaustive search completion\\n # at least in relation to depth sought\\n if (not legal_moves) or (depth == 0):\\n if maximizing_player:\\n return (self.score(game, game.active_player), (-1, -1))\\n else:\\n return (self.score(game, game.inactive_player), (-1, -1))\\n\\n if maximizing_player: # the current player\\n this_score = float(\\\"-inf\\\")\\n for move in legal_moves:\\n next_ply_state = game.forecast_move(move)\\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\\n depth-1, False)\\n\\n # Identify the maximum score branch for the current player.\\n if next_ply_score >= this_score:\\n this_move = move\\n this_score = next_ply_score\\n\\n else: # the current player's opponent\\n this_score = float(\\\"inf\\\")\\n for move in legal_moves:\\n next_ply_state = game.forecast_move(move)\\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\\n depth-1, True) \\n\\n # Identify the minimum score branch for the opponent\\n if next_ply_score <= this_score:\\n this_move = move\\n this_score = next_ply_score\\n\\n return this_score, this_move\",\n \"def getMove(self, grid):\\n# global prune\\n# prune = 0\\n def Terminal(stateTup):\\n \\\"\\\"\\\"\\n Checks if the node is a terminal node\\n Returns eval(state) if it is terminal\\n \\\"\\\"\\\"\\n state = stateTup[0]\\n maxDepth = self.depthLimit\\n if stateTup[1] == maxDepth:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n elif len(stateTup[0].getAvailableMoves()) == 0:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n\\n def Eval(state):\\n \\\"\\\"\\\"\\n This is the eval function which combines many heuristics and assigns\\n weights to each of them\\n Returns a single value\\n \\\"\\\"\\\"\\n\\n# H1 = htest2(state)\\n# return H1\\n H2 = h1(state)*monotonic(state)\\n return H2\\n\\n\\n def h1(state):\\n Max = state.getMaxTile()\\n left = len(state.getAvailableCells())/16\\n if state.getCellValue([0,0]) == Max:\\n v = 1\\n else:\\n v= 0.3\\n Max = Max/1024\\n return Max*left*v\\n\\n def mono(state):\\n mon = 0\\n# for i in range(4):\\n# row = 0\\n# for j in range(3):\\n# if state.map[i][j] > state.map[i][j+1]:\\n# row+=1\\n# if row == 4:\\n# mon += 1\\n# for i in range(4):\\n# column = 0\\n# for j in range(3):\\n# if state.map[j][i] > state.map[j+1][i]:\\n# column +=1\\n# if column == 4:\\n# mon +=1\\n#\\n#\\n# return mon/8\\n for i in range(4):\\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\\n mon+=1\\n\\n return mon/8\\n\\n def monotonic(state):\\n cellvals = {}\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n for i in Path1:\\n cellvals[i] = state.getCellValue(i)\\n mon = 0\\n for i in range(4):\\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\\n mon +=1\\n for j in range(4):\\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\\n mon+=1\\n return mon/8\\n\\n\\n\\n def htest2(state):\\n score1 = 0\\n score2 = 0\\n r = 0.5\\n\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\\n valDict = {}\\n for n in range(16):\\n valDict[Path1[n]] = state.getCellValue(Path1[n])\\n for n in range(16):\\n if n%3 == 0:\\n self.emergency()\\n cell1 = valDict.get(Path1[n])\\n cell2 = valDict.get(Path2[n])\\n score1 += (cell1) * (r**n)\\n score2 += (cell2) * (r**n)\\n return max(score1,score2)\\n\\n\\n def Maximize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n maxChild , maxUtility = None,-999999999\\n state = stateTup[0]\\n Map = self.dict.get(str(state.map))\\n if Map == None:\\n children = []\\n for M in range(4):\\n g = state.clone()\\n if g.move(M):\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Minimize(childTup,A,B)[1]\\n if utility > maxUtility:\\n maxChild , maxUtility = child , utility\\n if maxUtility >= B:\\n# global prune\\n# prune +=1\\n break\\n if maxUtility > A:\\n A = maxUtility\\n\\n return (maxChild,maxUtility)\\n\\n\\n def Minimize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n minChild , minUtility = None,999999999\\n state = stateTup[0]\\n Map= self.dict.get(str(state.map))\\n if Map == None:\\n cells= state.getAvailableCells()\\n children = []\\n tiles = [2,4]\\n for i in cells:\\n for j in tiles:\\n g = state.clone()\\n g.insertTile(i,j)\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Maximize(childTup,A,B)[1]\\n if utility < minUtility:\\n minChild , minUtility = child , utility\\n if minUtility <= A:\\n# global prune\\n# prune +=1\\n break\\n if minUtility < B:\\n B = minUtility\\n\\n return (minChild,minUtility)\\n\\n\\n\\n def decision(grid):\\n \\\"\\\"\\\"\\n Decision function which returns the move which led to the state\\n \\\"\\\"\\\"\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\\n\\n self.dict = {}\\n self.h = {}\\n self.prevTime = time.clock()\\n self.depthLimit = 1\\n self.mL = []\\n self.over = False\\n while self.over == False:\\n self.depthLimit +=1\\n try :\\n self.mL.append(decision(grid))\\n\\n except KeyError:\\n# print(self.depthLimit)\\n return self.mL[-1]\\n except IndexError:\\n return random.randint(0,3)\\n self.Alarm(time.clock())\\n return self.mL[-1]\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # For this problem we will be reusing the majority of our work from question 2, but we will be\\n # implementing alpha-beta pruning on top of our existing minimax infrastructure\\n actionList = gameState.getLegalActions(0)\\n pacmanAgentIndex = 0\\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\\n count = util.Counter()\\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\\n\\n def maximizer(curState, agentIndex, alpha, beta, depth):\\n\\n ghostActions = curState.getLegalActions(agentIndex)\\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\\n weight = -99999999 # Worst case starting value to be changed in the code\\n if depth == maxDepth: # If we are at a leaf node\\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\\n # Otherwise, we progress the tree until the above condition is reached\\n if len(ghostActions) != 0:\\n for x in ghostActions:\\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth):\\n weight = weight\\n else:\\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth)\\n if weight > beta:\\n return weight\\n if alpha < weight:\\n alpha = weight\\n return weight\\n # if there are no legal actions left then evaluate at the last known state\\n # Fall through into this return\\n return self.evaluationFunction(curState)\\n\\n def minimizer(curState, agentIndex, alpha, beta, depth):\\n ghostActions = curState.getLegalActions(agentIndex)\\n weight = 999999999 # Worst case starting value to be changed in the code\\n if len(ghostActions) != 0:\\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\\n for x in ghostActions: # For each legal action in the current position\\n temp = maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, alpha, beta, depth+1)\\n if weight < temp:\\n weight = weight\\n else:\\n weight = temp\\n if weight < alpha:\\n return weight\\n if beta > weight:\\n beta = weight\\n else: # Otherwise, we continue to minimize\\n for x in ghostActions: # For each legal action in the current position\\n temp = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, alpha, beta, depth)\\n if weight < temp:\\n weight = weight\\n else:\\n weight = temp\\n if weight < alpha:\\n return weight\\n if beta > weight:\\n beta = weight\\n return weight\\n # if there are no legal actions left then evaluate at the last known state\\n # Fall through into this return\\n return self.evaluationFunction(curState)\\n\\n endWeight = -999999999\\n alpha = -999999999\\n beta = 999999999\\n\\n # Executing the minimizer for all possible actions\\n for x in actionList:\\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\\n endWeight = minimizer(tempState, 1, alpha, beta, 0,)\\n count[x] = endWeight\\n if alpha < endWeight:\\n alpha = endWeight\\n # print('HELLO THERE')\\n # print(count)\\n return count.argMax()\",\n \"def utility(state:State,maximizing_player):\\n best_move_score = -1\\n #######################[Goal]#########################\\n is_current_player_stuck = is_stuck(state,state.player_type)\\n other_player = RIVAL if state.player_type == PLAYER else PLAYER\\n # Check if stuck\\n if is_current_player_stuck:\\n if state.player_type == PLAYER:\\n state.players_score[state.player_type] -= state.penalty_score\\n else:\\n state.players_score[state.player_type] += state.penalty_score\\n return state.players_score[state.player_type] - state.players_score[other_player] \\n ######################################################\\n # Else\\n #--------------------------------------------------\\n ################# Available Steps #################\\n #--------------------------------------------------\\n player_available_steps = availables(state.board, state.locations[PLAYER])\\n h1 = 4-player_available_steps\\n h4 = player_available_steps\\n #--------------------------------------------------\\n ################# Fruits Distance #################\\n #--------------------------------------------------\\n h2 = -1\\n if state.fruits_ttl > 0 and len(state.fruits_dict) > 0:\\n min_fruit_dist = float('inf')\\n for fruit_loc in state.fruits_dict:\\n curr_fruit_dist = Manhattan(state.locations[state.player_type], fruit_loc)\\n # Check what is the closest fruit reachable\\n if curr_fruit_dist < min_fruit_dist and curr_fruit_dist <= state.fruits_ttl:\\n other_player_fruit_dist = Manhattan(state.locations[other_player], fruit_loc)\\n if curr_fruit_dist < other_player_fruit_dist:\\n min_fruit_dist = curr_fruit_dist\\n max_dist = len(state.board)+len(state.board[0])\\n h2 = (max_dist*10.0/min_fruit_dist)+1 if min_fruit_dist < float('inf') else -1\\n #--------------------------------------------------\\n ################# Reachable Squrs #################\\n #--------------------------------------------------\\n reachables_player = reachables(state.board,state.locations[PLAYER])\\n reachables_rival = reachables(state.board,state.locations[RIVAL])\\n h3 = reachables_player - reachables_rival # We want more for us\\n #--------------------------------------------------\\n ################# Combine it all. #################\\n #--------------------------------------------------\\n if not state.half_game():\\n w = 0.8 if h2 > 0 else 1\\n best_move_score = w*(h1-h3) + (1-w)*h2 \\n else:\\n w = 0.7 if h2 > 0 else 1\\n best_move_score = w*(h4+h3) + (1-w)*h2 \\n\\n best_move_score += state.players_score[state.player_type]\\n return best_move_score\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n\\n \\\"\\\"\\\"\\n From AIMA psuedocode:\\n\\n function MINIMAX-DECISION(state) returns an action\\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\\n \\\"\\\"\\\"\\n\\n best_move = (-1,-1)\\n best_score = float(\\\"-inf\\\")\\n actions = game.get_legal_moves()\\n\\n if not actions:\\n return best_move\\n else:\\n best_move = actions[randint(0, len(actions) - 1)]\\n\\n try:\\n # The try/except block will automatically catch the exception\\n # raised when the timer is about to expire.\\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\\n for action in actions:\\n score = self._min_value(game.forecast_move(action), 1)\\n if score > best_score:\\n best_score = score\\n best_move = action\\n\\n except SearchTimeout:\\n pass\\n\\n return best_move\",\n \"def parse(self, words, gold_tree=None, beam_size=10):\\n if gold_tree:\\n word_order = self.get_word_order(gold_tree)\\n tags = self.tagger.tag(words)\\n possible_configs = [self.initial_config(words)]\\n while any(config['next_move'] != None for config in possible_configs):\\n old_possible_configs = possible_configs\\n possible_configs = []\\n for config in old_possible_configs:\\n config = self.move(config)\\n candidates = self.valid_moves(config)\\n if candidates:\\n feat = self.features(words, tags, config)\\n scores = self.predict(feat, candidates)\\n if gold_tree:\\n gold_move = self.gold_move(config, gold_tree, \\\\\\n word_order)\\n if config['is_gold'] and gold_move not in scores:\\n possible_configs = self.update_and_reset_config( \\\\\\n config, feat, gold_move)\\n break\\n # add new configs for the possible moves\\n for curr_move, curr_score in scores.items():\\n # create a copy of the config and append it to the list\\n new_config = deepcopy(config)\\n if curr_score > 0:\\n new_config['score'] += log(curr_score)\\n else:\\n new_config['score'] += float(\\\"-inf\\\")\\n new_config['next_move'] = curr_move\\n if gold_tree and gold_move != curr_move:\\n new_config['is_gold'] = False\\n possible_configs.append(new_config)\\n else:\\n config['next_move'] = None\\n possible_configs.append(config)\\n # delete the configs with the lowest scores\\n while len(possible_configs) > beam_size:\\n worst_conf_ind, worst_conf = \\\\\\n min(enumerate(possible_configs), \\n key = lambda t: t[1]['score'])\\n if gold_tree and worst_conf['is_gold'] == True:\\n feat = self.features(words, tags, worst_conf)\\n possible_configs = self.update_and_reset_config( \\\\\\n worst_conf, feat, worst_conf['next_move'])\\n else:\\n del possible_configs[worst_conf_ind]\\n # return best tree\\n best_config = max(possible_configs, key = lambda t: t['score'])\\n return tags, best_config['pred_tree']\",\n \"def search(start):\\n\\n '''\\n Create a class named nodeClass which contains 4 elements: \\n state: The puzzle object containing the puzzle board at the node \\n misplaced: num of misplaced tiles\\n depth: depth of the node in the tree \\n prev: parent node\\n '''\\n nodeClass = namedtuple('nodeClass', 'state, misplaced, depth, prev')\\n\\n #instantiate object from class creating the root node\\n node = nodeClass(start, 0, 0, None)\\n\\n #stores the nodes that are going to be explored. \\n #the node with lower f-score is explored first\\n frontier = q.PriorityQueue()\\n frontier.put((0,node))\\n\\n # frontier_set keep track of the nodes in the frontier queue\\n frontier_set = {node}\\n #contains the board states already explored\\n explored_states = set()\\n for ite in range(1,max_iterations+2):#while True:\\n #Retrieve the node in the frontier with lowest value\\n node = frontier.get()[1]\\n\\n #get the puzzle board obj from the node object\\n state = node.state\\n\\n #Check if the game has ben solved\\n if state.solved or ite==max_iterations:\\n Result = namedtuple('Result', 'board, depth, nodesExpanded, max_depth, isSolved')\\n return Result(state, node.depth, ite, max(no.depth for no in frontier_set), state.solved)\\n\\n # expanded nodes are added to explored set\\n explored_states.add(state)\\n\\n #EXPANDING\\n for mov in state.possible_moves:\\n new_state=state.move(mov)\\n new_node = nodeClass(new_state, new_state.score,\\n node.depth + 1, node)\\n\\n #compute f-score of the node\\n f_score=new_state.score + new_node.depth\\n\\n if new_state not in explored_states and new_node not in frontier_set:\\n frontier.put((f_score,new_node))\\n frontier_set.add(new_node)\",\n \"def run_ai():\\n print(\\\"Minimax AI\\\") # First line is the name of this AI \\n color = int(input()) # Then we read the color: 1 for dark (goes first), \\n # 2 for light. \\n\\n while True: # This is the main loop \\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input() \\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n\\n if status == \\\"FINAL\\\": # Game is over. \\n print \\n else: \\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The \\n # squares in each row are represented by \\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n \\n # Select the move and send it to the manager\\n movei, movej = select_move_minimax(board, color)\\n # movei, movej = select_move_alphabeta(board, color)\\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def action(self):\\n\\n self.start_timer()\\n\\n minimax_probability = self.norm.cdf(self.root.branching)\\n use_minimax = boolean_from_probability(minimax_probability)\\n if self.time_consumed > 53:\\n # Time is starting to run low, use the faster option\\n use_minimax=True\\n\\n if self.time_consumed < 59:\\n if self.root.turn < 4:\\n result = book_first_four_moves(self.root)\\n elif use_minimax:\\n result = minimax_paranoid_reduction(self.root)\\n else:\\n result = monte_carlo_tree_search(\\n self.root,\\n playout_amount=3,\\n node_cutoff=4,\\n outer_cutoff=4,\\n num_iterations=1200,\\n turn_time=0.75,\\n exploration_constant=1.7,\\n use_slow_culling=False,\\n verbosity=0,\\n use_prior=True,\\n num_priors=4,\\n use_fast_prune_eval=False,\\n use_fast_rollout_eval=False,\\n )\\n else:\\n result = greedy_choose(self.root)\\n\\n self.end_timer()\\n\\n return result\",\n \"def step(self):\\n if self.model.schedule.steps < self.model.residential_steps:\\n residential_move = True\\n else:\\n residential_move = False\\n\\n\\n if residential_move:\\n # only step the agents if the number considered is not exhausted\\n if self.model.total_considered < self.model.residential_moves_per_step:\\n # move residential\\n U_res = self.get_res_satisfaction(self.pos)\\n self.model.res_satisfaction.append(U_res)\\n\\n # print(\\\"U_res\\\",U_res)\\n if U_res < self.T:\\n\\n # todo: implement different move schemes, for now only random\\n # find all empty places\\n # rank them\\n # take one with boltzmann probability.\\n self.evaluate_move(U_res, school=False)\\n\\n else:\\n self.model.res_happy += 1\\n\\n self.model.total_considered += 1\\n #print(\\\"considered\\\",self.model.total_considered)\\n\\n\\n else:\\n if self.model.total_considered < self.model.school_moves_per_step:\\n # school moves\\n # satisfaction in current school\\n U = self.get_school_satisfaction(self.school, self.dist_to_school)\\n self.model.satisfaction.append(U)\\n\\n # If unhappy, compared to threshold move:\\n if U < self.T:\\n #print('unhappy')\\n self.evaluate_move(U, school=True)\\n\\n else:\\n self.model.happy += 1\\n if self.model.total_considered>0:\\n self.model.percent_happy = np.ma(self.model.happy/self.model.total_considered)\",\n \"def minimax(board: list, player_turn: chr):\\n if player_turn == 'b':\\n enemy_turn = 'w'\\n else:\\n enemy_turn = 'b'\\n player_moves, enemy_start_boards = Evaluator.generate_options(board, player_turn)\\n\\n player_scores = [x.get(\\\"final_score\\\") for x in player_moves]\\n enemy_scores = []\\n\\n for enemy_start_board in enemy_start_boards:\\n board_index = enemy_start_boards.index(enemy_start_board)\\n player_score = player_scores[board_index]\\n enemy_moves, player_start_boards = Evaluator.generate_options(enemy_start_board, enemy_turn)\\n\\n # Gets highest white score for first board.\\n if enemy_start_boards.index(enemy_start_board) == 0:\\n best_enemy_score = -10000000\\n for move in enemy_moves:\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > best_enemy_score:\\n best_enemy_score = score\\n enemy_scores.append(best_enemy_score)\\n else:\\n current_min = min(enemy_scores)\\n best_enemy_score = -10000000\\n break_flag = False\\n\\n # Checks moves where active player performs push, more likely to yield high score -> move ordering.\\n push_moves = filter(Evaluator.filter_push, enemy_moves)\\n for move in push_moves:\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > current_min:\\n enemy_scores.append(score)\\n break_flag = True\\n break\\n if break_flag:\\n continue\\n\\n for move in enemy_moves:\\n if move.get(\\\"pushes\\\") > 0:\\n continue\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > current_min:\\n enemy_scores.append(score)\\n break_flag = True\\n break\\n if score > best_enemy_score:\\n best_enemy_score = score\\n if not break_flag:\\n enemy_scores.append(best_enemy_score)\\n # print(enemy_start_board)\\n # [print(x) for x in enemy_moves]\\n # print(\\\"======================\\\")\\n\\n # Gets the lowest score aka worst board state for the opponent which will be the best move for us.\\n min_val = min(enemy_scores)\\n check_scores = numpy.array(enemy_scores)\\n min_index = numpy.where(check_scores == min_val)[0]\\n\\n best_index = 0\\n best_score = -100000\\n\\n for i in min_index:\\n if player_moves[i].get(\\\"final_score\\\") > best_score:\\n best_score = player_moves[i].get(\\\"final_score\\\")\\n best_index = i\\n\\n return player_moves[best_index]\",\n \"def makeMove(self, movable_statement):\\n ### Student code goes here\\n disk = movable_statement.terms[0].term.element\\n initial = movable_statement.terms[1].term.element\\n goal = movable_statement.terms[2].term.element\\n #### Add the disk to the new stack and remove the facts of it being on the old one\\n r1 = parse_input(\\\"fact: (on \\\" + disk + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(r1)\\n r2 = parse_input(\\\"fact: (isTopofStack \\\" + disk + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(r2)\\n stat1 = parse_input(\\\"fact: (on \\\" + disk + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_assert(stat1)\\n stat2 = parse_input(\\\"fact: (isTopofStack \\\" + disk + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_assert(stat2)\\n\\n ## Determine if any disks are on the initial peg\\n ask1 = parse_input(\\\"fact: (on ?X \\\" + initial + \\\")\\\")\\n answer = self.kb.kb_ask(ask1)\\n if answer == False: #If no disks are on the initial peg\\n empty_stat = parse_input(\\\"fact: (isempty \\\" + initial + \\\")\\\")\\n self.kb.kb_assert(empty_stat)\\n else:\\n disks_on_initial = []\\n for ans in answer.list_of_bindings:\\n disks_on_initial.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\\n ask_top = parse_input(\\\"fact: (isTopofStack ?X \\\" + initial + \\\")\\\")\\n top_ans = self.kb.kb_ask(ask_top)\\n disks_on_initial.sort()\\n if top_ans:\\n for ans in top_ans.list_of_bindings:\\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_initial[0]:\\n retract = parse_input(\\\"fact: (isTopofStack \\\" + ans[0].bindings[0].constant.element + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_retract(retract)\\n assert1 = parse_input(\\\"fact: (isTopofStack disk\\\" + str(disks_on_initial[0]) + \\\" \\\" + initial + \\\")\\\")\\n self.kb.kb_assert(assert1)\\n\\n goal_ask = parse_input(\\\"fact: (on ?X \\\" + goal + \\\")\\\")\\n goal_answer = self.kb.kb_ask(goal_ask)\\n disks_on_goal = []\\n for ans in goal_answer.list_of_bindings:\\n disks_on_goal.append(int(ans[0].bindings[0].constant.element.split('disk',1)[1]))\\n ask_topg = parse_input(\\\"fact: (isTopofStack ?X \\\" + goal + \\\")\\\")\\n top_ansg = self.kb.kb_ask(ask_topg)\\n disks_on_goal.sort()\\n if top_ansg:\\n for ans in top_ansg.list_of_bindings:\\n if int(ans[0].bindings[0].constant.element.split('disk',1)[1]) != disks_on_goal[0]:\\n retract = parse_input(\\\"fact: (isTopofStack \\\" + ans[0].bindings[0].constant.element + \\\" \\\" + goal + \\\")\\\")\\n self.kb.kb_retract(retract)\\n\\n ask2 = parse_input(\\\"fact: (isempty \\\" + goal + \\\")\\\")\\n answer2 = self.kb.kb_ask(ask2)\\n if answer2:\\n self.kb.kb_retract(ask2)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n while to_move < len(movables):\\n # Make the move\\n movable_statement = movables[to_move]\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n\\n # Find out if this state has already been explored\\n visited = False\\n for visited_state in self.visited.keys():\\n if visited_state.state == new_state:\\n visited = True\\n\\n # If the new state hasn't been visited then add it as a child then move down to this child\\n if not visited:\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.currentState = new_gs\\n break\\n\\n # Else skip this state and try going to the next movable statement\\n else:\\n # print(\\\"SKIP THIS STATE\\\")\\n self.gm.reverseMove(movable_statement)\\n to_move += 1\\n\\n # Went all the way down to a leaf, backtrack\\n if (to_move >= len(movables)):\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n\\n return False\",\n \"def run(self):\\n\\n # init\\n base_value = self._problem.evaluate()\\n self._problem.set_as_best(base_value)\\n\\n # init iteration (used to count the amount of iterations)\\n iteration = 0\\n\\n # add to data\\n self._data_append(self.data, iteration, base_value, base_value)\\n\\n # init termination criterion\\n self._termination_criterion.check_first_value(base_value)\\n self._termination_criterion.start_timing()\\n\\n # main loop\\n while self._termination_criterion.keep_running():\\n\\n # search the neighbourhood for the best move\\n best_found_delta = self._best_found_delta_base_value\\n best_found_move = None\\n\\n for move in self._problem.get_moves():\\n\\n # check quality move\\n delta = self._problem.evaluate_move(move)\\n\\n # checks how the move alters the current state\\n diff = self._diff(move)\\n\\n # if not in tabu list --> not similar to earlier performed\\n # moves --> if delta better than old best move\\n # --> becomes the best move\\n\\n if not self._tabu_list.contains(diff) and \\\\\\n self._is_better(best_found_delta, delta):\\n best_found_delta = delta\\n best_found_move = move\\n best_found_diff = diff\\n\\n # the best found move will be used as the next move\\n # alter state problem\\n base_value = base_value + best_found_delta\\n\\n # check if a move was found\\n if best_found_move is not None:\\n\\n self._problem.move(best_found_move)\\n\\n # if better than best found --> new best_found\\n if self._is_better(self._problem.best_order_value,\\n base_value):\\n self._problem.set_as_best(base_value)\\n # log the better solution\\n self._log_improvement(base_value)\\n\\n # add diff to tabu list\\n self._tabu_list.add(best_found_diff)\\n\\n # add to data\\n self._data_append(self.data, iteration,\\n base_value, self._problem.best_order_value)\\n\\n self._termination_criterion.check_new_value(base_value)\\n\\n # functions _termination_criterion called\\n self._termination_criterion.check_new_value(base_value)\\n\\n else:\\n # no move found --> we're stuck --> break loop\\n break\\n\\n iteration += 1\\n self._termination_criterion.iteration_done()\\n\\n # last data point\\n self._data_append(self.data, iteration, base_value,\\n self._problem.best_order_value)\\n\\n # if we have data:\\n # convert data to something easier to plot\\n if self.data is not None:\\n\\n # convert to tuple of list\\n data = convert_data(self.data)\\n\\n # make namedtuple\\n DataAsLists = namedtuple(\\n 'Data', ['time', 'iteration', 'value', 'best_value'])\\n\\n data = DataAsLists(data[0], data[1], data[2], data[3])\\n\\n else:\\n data = None\\n\\n # return results\\n\\n Results = namedtuple('Results', ['best_order', 'best_value', 'data'])\\n\\n return Results(self._problem.best_order,\\n self._problem.best_order_value,\\n data)\",\n \"def search_best_next_move(self, model, initial_tree_node):\\n\\n # EDIT THIS METHOD TO RETURN BEST NEXT POSSIBLE MODE FROM MINIMAX MODEL ###\\n\\n # NOTE: Don't forget to initialize the children of the current node\\n # with its compute_and_get_children() method!\\n\\n alpha = float('-inf')\\n beta = float('inf')\\n depth = 4\\n player = 0\\n ##send root node and these parameters to minimax\\n start_time = time()\\n move = self.alpha_beta(initial_tree_node, player, alpha, beta, start_time)\\n #random_move = random.randrange(5)\\n return ACTION_TO_STR[move[1]]\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n print(\\\"\\\\t===========================================\\\")\\n print(\\\"\\\\t Processing ... Please Wait for 11 seconds!\\\")\\n print(\\\"\\\\t===========================================\\\")\\n startState = problem.getStartState();\\n fringe = util.PriorityQueue()\\n costs = 0 \\n visitedNodes = []\\n actions = [] \\n if ( problem.isGoalState(startState) == True):\\n return actions\\n else:\\n newFringeItem = (startState , actions , costs)\\n fringe.push(newFringeItem,costs)\\n while(fringe.isEmpty() == False ):\\n #f(x) = h(x) + g(x)\\n currentState , actions , costs = fringe.pop()\\n if ( problem.isGoalState(currentState) == True):\\n #print(\\\"Final Actions : \\\" + str(actions)) \\n \\\"\\\"\\\"\\n If you want the Analyzer Class analizes the chosen path and heuristic , \\n Uncomment these two lines of code otherwise leave it be commented cause it increases the run time by 2 seconds.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"Start : Analyzer Properties \\\"\\\"\\\"\\n #analyzer = Analyzer(problem,actions)\\n #analyzer.start()\\n \\\"\\\"\\\"End : Analyzer Properties \\\"\\\"\\\"\\n return actions\\n else:\\n if(not currentState in visitedNodes ):\\n visitedNodes.append(currentState)\\n currentNodeSuccessors = problem.getSuccessors(currentState)\\n for node in currentNodeSuccessors :\\n state , action , stateCost = node\\n heuristicAmount = heuristic(state , problem)\\n newFringeItem = state , actions + [action] , costs + stateCost\\n priority = costs + heuristicAmount\\n fringe.push( newFringeItem , priority )\\n \\n util.raiseNotDefined()\",\n \"def run(self, max_depth):\\n while len(self.stack) > 0:\\n state = self.get_next_state()\\n\\n if state.is_solution():\\n self.solutions.append(state.moves)\\n\\n if len(state.moves) < max_depth:\\n self.create_children(state)\\n\\n self.archive[state.get_tuple()] = len(state.moves)\\n\\n # sort solutions best to worst\\n self.solutions.sort(key=len)\\n\\n if self.solutions:\\n return self.solutions[0]\\n\\n print(\\\"This depth is not sufficient.\\\")\\n return []\",\n \"def calculate_next_move(self, visit):\\n self.depth += 1\\n new_boards = []\\n for vehicle_id in range(len(self.vehicles)):\\n vehicle = self.vehicles[vehicle_id]\\n state = self.get_board()\\n if vehicle.orientation == 0: #horizontal\\n if vehicle.x > 0: #left\\n if state[vehicle.y][vehicle.x-1] == \\\"..\\\":\\n self.vehicles[vehicle_id].x -=1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].x += 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].x += 1\\n\\n if vehicle.x + vehicle.length <= (len(state)-1): #right\\n if state[vehicle.y][vehicle.x+vehicle.length] == \\\"..\\\":\\n self.vehicles[vehicle_id].x += 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].x -= 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].x -= 1\\n\\n else: #vertical\\n if vehicle.y - 1 >= 0: #up\\n if state[vehicle.y-1][vehicle.x] == \\\"..\\\":\\n self.vehicles[vehicle_id].y -= 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].y += 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].y += 1\\n\\n if vehicle.y + vehicle.length <= (len(state)-1):\\n if state[vehicle.y + vehicle.length][vehicle.x] == \\\"..\\\":#down\\n self.vehicles[vehicle_id].y += 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].y -= 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].y -= 1\\n self.depth -= 1\\n return new_boards\",\n \"def minimax(self, game, depth):\\n _, move = self.minimax_search(game, depth)\\n return move\",\n \"def ai_move():\\n\\tinitial_state = map(get_filled_edges, rects)\\n\\tpossible_moves = []\\n\\tfor index, filled_edges in enumerate(initial_state):\\n\\t\\tif filled_edges == 0:\\n\\t\\t\\tpossible_moves.extend([(index, i) for i in 'ltrb'])\\n\\t\\telif filled_edges == 1:\\n\\t\\t\\tpossible_moves.extend(one_filled_edge(index))\\n\\t\\telif filled_edges == 2:\\n\\t\\t\\tpossible_moves.extend(two_filled_edge(index))\\n\\t\\telif filled_edges == 3:\\n\\t\\t\\tpossible_moves.extend(three_filled_edge(index))\\n\\tprint possible_moves\\n\\tpossible_decisions = []\\n\\tfor move in possible_moves:\\n\\t\\tfinal_state = apply_move(move)\\n\\t\\tpossible_decisions.append(is_feasible(initial_state, final_state))\\n\\tprint possible_decisions\\n\\t# randomizing when some decisions have the same weight\\n\\tmax_weight = max(possible_decisions)\\n\\t# list of indices which have the same weight\\n\\tmax_indices = []\\n\\tfor index, weight in enumerate(possible_decisions):\\n\\t\\tif weight == max_weight:\\n\\t\\t\\tmax_indices.append(index)\\n\\tx = choice(max_indices)\\n\\tprint x\\n\\treturn possible_moves[x]\\n\\t# return possible_moves[possible_decisions.index(max(possible_decisions))]\",\n \"def __build_tree__(self, features, classes, depth=0):\\n\\n # TODO: finish this.\\n root = None\\n if (len(set(classes)) <= 1) and (len(classes) != 0) :\\n return DecisionNode(None,None,None,classes[0])\\n elif (len(classes) == 0):\\n return DecisionNode(None,None,None,2)\\n elif depth == self.depth_limit:\\n return DecisionNode(None,None,None,max(set(classes), key=list(classes).count))\\n else:\\n# if depth == 0:\\n features = np.array(features)\\n classes = np.array(classes).reshape(-1,1)\\n feat_shape = features.shape\\n sample_list = range(feat_shape[0])\\n gains = np.zeros((feat_shape[1]))\\n indices = np.zeros((feat_shape[1]))\\n for i in range(feat_shape[1]):\\n attribute = features[:,i]\\n for j in range(20):\\n split_indx = int(np.random.choice(sample_list, replace=False))\\n idx_above = np.where(attribute > attribute[split_indx])[0]\\n idx_below = np.where(attribute < attribute[split_indx])[0]\\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\\n gain = gini_gain(list(classes.reshape(1,-1)[0]),[list(classes_below),list(classes_above)])\\n if gain > gains[i]:\\n gains[i] = gain\\n indices[i] = split_indx\\n indx = np.argmax(gains)\\n split_indx = int(indices[indx])\\n attribute = features[:,indx]\\n idx_above = np.where(attribute > attribute[split_indx])[0]\\n idx_below = np.where(attribute < attribute[split_indx])[0] \\n features_below = features[idx_below,:]\\n features_above = features[idx_above,:]\\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\\n if (len(classes_below) != 0) and (len(classes_above) != 0):\\n root = DecisionNode(None,None,lambda feat:feat[indx] > features[split_indx,indx])\\n root.left = self.__build_tree__(features_above, classes_above, depth+1)\\n root.right = self.__build_tree__(features_below, classes_below, depth+1)\\n return root\\n elif (len(classes_below) == 0) and (len(classes_above) != 0):\\n return DecisionNode(None,None,None,max(set(classes_above), key=list(classes_above).count))\\n elif (len(classes_above) == 0) and (len(classes_below) !=0):\\n return DecisionNode(None,None,None,max(set(classes_below), key=list(classes_below).count))\\n else:\\n return DecisionNode(None,None,None,2)\",\n \"def _greedy(self, state):\\n\\n node = self.mcts_head\\n if self.verbose > 1:\\n logger.debug(f\\\"Starting greedy algorithm.\\\")\\n\\n while not node.terminal:\\n # Parse current state\\n this_state, total_reward, terminal = self._parse_path(state, node.path)\\n node.set_terminal(terminal)\\n if self.verbose > 1:\\n logger.debug(f\\\" Analyzing node {node.path}\\\")\\n\\n # Expand\\n if not node.terminal and not node.children:\\n actions = self._find_legal_actions(this_state)\\n step_rewards = [self._parse_action(action, from_which_env=\\\"sim\\\") for action in actions]\\n if self.verbose > 1:\\n logger.debug(f\\\" Expanding: {len(actions)} legal actions\\\")\\n node.expand(actions, step_rewards=step_rewards)\\n\\n # If terminal, backup reward\\n if node.terminal:\\n if self.verbose > 1:\\n logger.debug(f\\\" Node is terminal\\\")\\n if self.verbose > 1:\\n logger.debug(f\\\" Backing up total reward {total_reward}\\\")\\n node.give_reward(self.episode_reward + total_reward, backup=True)\\n\\n # Debugging -- this should not happen\\n if not node.terminal and not node.children:\\n logger.warning(\\n f\\\"Unexpected lack of children! Path: {node.path}, children: {node.children.keys()}, legal actions: {self._find_legal_actions(this_state)}, terminal: {node.terminal}\\\"\\n )\\n node.set_terminal(True)\\n\\n # Greedily select next action\\n if not node.terminal:\\n action = node.select_greedy()\\n node = node.children[action]\\n\\n if self.verbose > 0:\\n choice = self.mcts_head.select_best(mode=\\\"max\\\")\\n self._report_decision(choice, state, \\\"Greedy\\\")\",\n \"def moveManager(self):\\r\\n \\r\\n (nb1,nb2) = self._board.get_nb_pieces() \\r\\n val = 0\\r\\n alphaBeta_instance = AlphaBeta()\\r\\n \\r\\n # Early-Game: Check opening move in a custom bloom filter\\r\\n if(nb1+nb2 < MoveManager.__AI_OPENING_MOVE_VALUE__()): \\r\\n print(\\\"Check if \\\", Utils.HashingOperation.BoardToHashCode(self._board), \\\"is present\\\")\\r\\n move = self._openingMover.GetMove(self._board)\\r\\n \\r\\n if(move is None): #No Opening Move has been found, need to calculate the AB-pruning\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \\r\\n depth=3,\\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # End-Game: Special depth alpha-beta\\r\\n elif ((nb1+nb2) > MoveManager.__AI_ENDGAME_VALUE__(self._board)): \\r\\n# self._maxDepth = WIDTH*HEIGHT - (nb1+nb2)\\r\\n print(\\\"Special depth For Pruning: \\\", nb1+nb2)\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self,\\r\\n depth=self._board._boardsize * self._board._boardsize - (nb1+nb2), \\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # Mid-Game: Usual Case. Alpha Beta. Can use the parallelization, or chose to check a bloom filter if a good board has already been find \\r\\n else: \\r\\n #Alpha and Beta should be set directly on the AlphaBeta class\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \\r\\n depth=3,\\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # No move has been find, generate one with a simple heuristic\\r\\n if move is None: \\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"Default value. No move has been found\\\")\\r\\n val = -7578748789\\r\\n# time.sleep(1)\\r\\n (move, _) = MoveManager.MoveForGameBeginning(self, self._board.legal_moves()) \\r\\n \\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"Val is:\\\", val)\\r\\n# time.sleep(1)\\r\\n return move\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n if self.first_step == False:\\n self.first_step = True\\n if self.solveOneStep():\\n return True\\n if self.queue:\\n self.gm_init()\\n ele = self.queue.get()\\n #print (len(ele))\\n state = ele[0]\\n premoves = ele[1]\\n\\n for m in premoves:\\n self.gm.makeMove(m)\\n if state.state == self.victoryCondition:\\n return True\\n self.visited[state] = True\\n print(\\\"CURRENTSTATE:\\\")\\n print(self.gm.getGameState())\\n print(\\\"*******\\\")\\n moves = self.gm.getMovables()\\n for m in moves:\\n self.gm.makeMove(m)\\n if (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\\n self.gm.reverseMove(m)\\n continue\\n self.visited[GameState(self.gm.getGameState(), 0, None)] = True\\n new_pmv = [i for i in premoves]\\n new_pmv.append(m)\\n next_state = GameState(self.gm.getGameState(), state.depth+1, m)\\n next_state.parent = state\\n state.children.append(next_state)\\n self.queue.put([next_state, new_pmv])\\n self.gm.reverseMove(m)\\n self.currentState = state\\n\\n #for i in range(len(premoves)-1, -1, -1):\\n # mv = premoves[i]\\n # self.gm.reverseMove(mv)\\n return False\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\\n # to serve the purpose of finding the expected value\\n actionList = gameState.getLegalActions(0)\\n pacmanAgentIndex = 0\\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\\n count = util.Counter()\\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\\n def maximizer(curState, agentIndex, depth):\\n\\n ghostActions = curState.getLegalActions(agentIndex)\\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\\n weight = -99999999 # Worst case starting value to be changed in the code\\n if depth == maxDepth: # If we are at a leaf node\\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\\n # Otherwise, we progress the tree until the above condition is reached\\n if len(ghostActions) != 0:\\n for x in ghostActions:\\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\\n weight = weight\\n else:\\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n def minimizer(curState, agentIndex, depth):\\n ghostActions = curState.getLegalActions(agentIndex)\\n weight = 0 # Starting value of zero to be incremented below\\n if len(ghostActions) != 0:\\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\\n weight = weight + temp\\n else: # Otherwise, we continue to minimize\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\\n weight = weight + temp\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n # Executing the minimizer for all possible actions\\n for x in actionList:\\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\\n count[x] = minimizer(tempState,1,0)\\n # print('HELLO THERE')\\n # print(count)\\n return count.argMax()\",\n \"def make_move(self, time_limit, players_score):\\n finish_time = time.time() + time_limit\\n depth = 1\\n best_move = (-np.inf, (-1, 0))\\n while True:\\n for direction in self.directions:\\n initial_state = utils.State(self.board, direction, self.pos, self.current_turn,\\n self.fruits_on_board_dict,\\n finish_time)\\n try:\\n outcome = self.minimax_algo.search(initial_state, depth, True)\\n if outcome[0] > best_move[0]:\\n best_move = outcome\\n except TimeoutError:\\n self.board[self.pos[0]][self.pos[1]] = -1\\n self.pos = (self.pos[0] + best_move[1][0], self.pos[1] + best_move[1][1])\\n self.board[self.pos[0]][self.pos[1]] = 1\\n\\n return best_move[1]\\n depth += 1\\n # print('bigger_depth : {} '.format(depth))\",\n \"def iterative_minimax_strategy(game: Any) -> Any:\\n s = Stack()\\n id0 = 0\\n d = {0: Tree([id0, game, None])}\\n s.add(0)\\n\\n while not s.is_empty():\\n id1 = s.remove()\\n item = [id1]\\n if d[id1].children == []:\\n for move in d[id1].value[1].current_state.get_possible_moves():\\n game1 = copy.deepcopy(d[id1].value[1])\\n game1.current_state = game1.current_state.make_move(move)\\n id0 += 1\\n d[id0] = Tree([id0, game1, None])\\n d[id1].children.append(id0)\\n item.append(id0)\\n else:\\n item.extend(d[id1].children)\\n for num in item:\\n if d[num].value[1].is_over(d[num].value[1].current_state):\\n d[num].value[2] = -1\\n elif d[num].children != [] and all(d[x].value[2] is not None\\n for x in d[num].children):\\n d[num].value[2] = max([(-1) * d[y].value[2]\\n for y in d[num].children])\\n else:\\n s.add(num)\\n i = 0\\n for q in d[0].children:\\n if d[q].value[2] == -1:\\n i = d[0].children.index(q)\\n return game.current_state.get_possible_moves()[i]\",\n \"def minimax(self, state, is_max, depth = 0, alpha=float(\\\"-inf\\\"), beta=float(\\\"inf\\\")):\\n # Terminate \\n if self.terminate(depth, state):\\n return None, Utility.utility_function(state) \\n \\n # Recursive\\n possible_moves = state.current_player_possible_moves()\\n return self.search(is_max, possible_moves, state, depth, alpha, beta)\",\n \"def _alphabeta_search(self, depth, white, black, playing, move_sequence,\\n alpha=float('-inf'), beta=float('inf'), max_depth=1000,\\n time_left=1000):\\n self.nodes_searched += 1 # keep track of nodes searched for displaying\\n start_time = clock() # keep track of time to stop the thread\\n action = None\\n\\n state = (tuple(sorted(white, key=lambda x: x[0] + 10 * x[1])),\\n tuple(sorted(black, key=lambda x: x[0] + 10 * x[1])), playing)\\n\\n if state in move_sequence: return 0 # check if state was previously encountered in branch\\n move_sequence.add(state)\\n\\n # check if node is database of stored nodes at the correct depth\\n if state in self.nodes and self.nodes[state][2] >= depth and \\\\\\n abs(self.nodes[state][0]) < 1000:\\n move_sequence.remove(state)\\n if depth == max_depth:\\n return (self.nodes[state][0], self.nodes[state][1])\\n else:\\n return self.nodes[state][0]\\n if playing == 1 and is_winning(white): # check that state is not terminal\\n val = 100000 + depth\\n elif playing == 0 and is_winning(black):\\n val = -100000 - depth\\n elif depth == 0: # if depth is zero return heuristic approximation\\n val = self._heuristic(white, black, playing)\\n else:\\n if not self.big:\\n xstart = 1\\n ystart = 1\\n n = 5\\n m = 4\\n else: # this whole set of statements is just to only consider the inner squares\\n # of a big board for the first few moves.\\n if self.turn > 5:\\n xstart = 1\\n ystart = 1\\n n = 7\\n m = 6\\n else:\\n xstart = 2\\n ystart = 2\\n n = 6\\n m = 5\\n\\n if playing == 0: # maximizer\\n val = float(\\\"-inf\\\")\\n\\n for a in get_actions(white, black, n, m, xstart, ystart):\\n modified_cell = self._apply_action(a, white)\\n v = self._alphabeta_search(depth - 1, white, black, 1, move_sequence, alpha, beta) # continue searching\\n if v > val: # update value and action if a better path has been found\\n val = v\\n action = a\\n self._undo_action(a, white, modified_cell)\\n\\n alpha = max(alpha, val) # alpha-beta prunning\\n if beta < alpha: break\\n if clock() - start_time > time_left: return # end search if out of time\\n else: # minimizer\\n val = float(\\\"inf\\\")\\n\\n for a in get_actions(black, white, n, m, xstart, ystart):\\n modified_cell = self._apply_action(a, black)\\n v = self._alphabeta_search(depth - 1, white, black, 0, move_sequence, alpha, beta)\\n if v < val:# update value and action if a better path has been found\\n val = v\\n action = a\\n\\n self._undo_action(a, black, modified_cell)\\n\\n beta = min(beta, val) # alpha-beta prunning\\n if beta < alpha: break\\n if clock() - start_time > time_left: break # end search if out of time\\n\\n self.nodes[state] = (val, action, depth) # update state database\\n move_sequence.remove(state)\\n if max_depth == depth: # only return the action if at root node\\n return (val, action)\\n else:\\n return val\",\n \"def minimax(gamestate, depth, timeTotal, alpha, beta, maxEntity):\\n\\n bonus = 0\\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\\n # Basis Rekursif\\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\\n bonus = 10\\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\\n bonus = -10\\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\\n\\n # Rekurens\\n if (gamestate.currentPlayer.noPlayer == maxEntity):\\n # Choose the maximum utility of the state\\n # Iterate all pion and its possible moves\\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n maxValue = -math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n # Iterate all possible moves of pion index\\n for move in all_possible_moves:\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n\\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old max value\\n if (utility > maxValue):\\n maxValue = utility\\n maxGameState = newGameState\\n \\n alpha = max(alpha, maxValue)\\n if (beta <= alpha):\\n return maxGameState, maxValue\\n return maxGameState, maxValue\\n\\n else:\\n # Choose the minimum utility of the state\\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n minValue = math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n # Iterate all possible moves of pion index\\n for move in all_possible_moves:\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n\\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old min value\\n if (utility < minValue):\\n minValue = utility\\n minGameState = newGameState\\n \\n beta = min(beta, minValue)\\n if (beta <= alpha):\\n return minGameState, minValue\\n \\n return minGameState, minValue\",\n \"def decision(grid):\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\",\n \"def train(n):\\n\\n ai = NimAI()\\n\\n print(f\\\"Play {n} training games\\\")\\n for _ in range(n): \\n game = Nim()\\n\\n # Keep track of last move made by either player\\n last = {\\n 0: {\\\"state\\\": None, \\\"action\\\": None},\\n 1: {\\\"state\\\": None, \\\"action\\\": None}\\n }\\n\\n # Game loop\\n while True:\\n\\n # Keep track of current state and action\\n state = game.piles.copy()\\n action = ai.chooseAction(game.piles)\\n\\n # Keep track of last state and action\\n last[game.player][\\\"state\\\"] = state\\n last[game.player][\\\"action\\\"] = action\\n\\n # Make move and switch players\\n game.move(action)\\n new_state = game.piles.copy()\\n\\n # When game is over, update Q values with rewards\\n if game.winner is not None:\\n # The game is over when a player just made a move that lost him the game.\\n # The move from the previous player was therefore game winning.\\n # Both events are used to update the AI.\\n # new_state is [0, 0, 0, 0] here and its used to update the AI, because\\n # future rewards should not be considered in the Q-learning formula.\\n ai.update(state, action, new_state, -1)\\n ai.update(\\n last[game.player][\\\"state\\\"],\\n last[game.player][\\\"action\\\"],\\n new_state,\\n 1\\n )\\n break\\n\\n # If game is continuing, no rewards yet\\n elif last[game.player][\\\"state\\\"] is not None:\\n ai.update(\\n last[game.player][\\\"state\\\"],\\n last[game.player][\\\"action\\\"],\\n new_state,\\n 0\\n )\\n\\n print(\\\"Done training\\\")\\n\\n # Return the trained AI\\n return ai\",\n \"def run_ai():\\n print(\\\"Vivian\\\") # First line is the name of this AI \\n color = int(input()) # Then we read the color: 1 for dark (goes first), \\n # 2 for light. \\n\\n while True: # This is the main loop \\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input() \\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over. \\n print \\n else: \\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The \\n # squares in each row are represented by \\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n \\n # Select the move and send it to the manager \\n# movei, movej = select_move_minimax(board, color)\\n movei, movej = select_move_alphabeta(board, color)\\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def depthFirstSearch(problem):\\n #print \\\"Start:\\\", problem.getStartState()\\n #print \\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState())\\n #print \\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState())\\n \\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n #created a frontier Stack for DFS\\n #Here the stack acts as a LIFO stack\\n neighbourNodes = util.Stack()\\n #created a list of moves which will be returned in then end\\n moves = []\\n #pushed the start node and empty moves list, onto the frontier stack\\n neighbourNodes.push((problem.getStartState(),moves))\\n #this is a set of nodes which have been seen, to avoid adding nodes already visited \\n seenNodes = set()\\n #condition evaluated based on the existence of elements in the frontier stack\\n while not neighbourNodes.isEmpty():\\n #last node in the stack is popped and its state and action is stored\\n poppedNodeState, poppedNodeAction = neighbourNodes.pop()\\n #condition to check if the node is already been visited\\n if(poppedNodeState in seenNodes):\\n #if yes then it just skips the iteration using the continue statement\\n continue\\n #condition to check if the current node is the goal node\\n if problem.isGoalState(poppedNodeState):\\n #if yes then return the action or moves to be performed list\\n return poppedNodeAction\\n #if not visited before then node is added to the seenNodes set\\n seenNodes.add(poppedNodeState)\\n #loop to parse the successor nodes and check and add them to the frontier stack\\n for state, action, cost in problem.getSuccessors(poppedNodeState):\\n #checking if the successor node has already been visited before\\n if(state in seenNodes):\\n #if yes then it skips that node\\n continue\\n #else it adds that successor along with it action appeneded with the already existing actions\\n neighbourNodes.push((state, poppedNodeAction+[action]))\\n #the list of moves if finally returned\\n return moves\\n #util.raiseNotDefined()\",\n \"def _optimize(self) -> None:\\n\\n for i, agent in enumerate(self.agents):\\n states, actions, rewards, next_states, dones = self.memory.sample()\\n\\n actor_next_state = self._agent_states(i, next_states)\\n next_actions = torch.cat(\\n [a.actor_target(actor_next_state) for a in self.agents], 1\\n )\\n next_q = agent.critic_target(next_states, next_actions).detach()\\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\\n 1 - dones[:, i].view(-1, 1)\\n )\\n local_q = agent.critic_local(states, actions)\\n\\n value_loss = agent.loss_fn(local_q, target_q)\\n agent.value_optimizer.zero_grad()\\n value_loss.backward()\\n agent.value_optimizer.step()\\n\\n local_actions = []\\n for i, a in enumerate(self.agents):\\n local_states = self._agent_states(i, states)\\n local_actions.append(\\n a.actor_local(local_states)\\n if a == agent\\n else a.actor_local(local_states).detach()\\n )\\n local_actions = torch.cat(local_actions, 1)\\n policy_loss = -agent.critic_local(states, local_actions).mean()\\n\\n agent.policy_optimizer.zero_grad()\\n policy_loss.backward()\\n agent.policy_optimizer.step()\\n\\n self._update_target_model(agent.critic_local, agent.critic_target)\\n self._update_target_model(agent.actor_local, agent.actor_target)\",\n \"def minimax(board: bytearray,\\n depth: int, # depth of current plies (0 = deepest)\\n alpha: int, \\n beta: int, \\n max_player: bool, # is this maximzing player?\\n at_top: bool=False, # are we the top call to this?\\n ):\\n \\n # base cases:\\n # - Player will win w/this board (since AI loses, return massive negative)\\n # - AI will win w/this board (return massive positive)\\n # - reached the depth of recursion (score this leaf for AI)\\n # - board is full (no score for this leaf)\\n\\n won_by: int = 0\\n for c1, c2, c3, c4 in _WINDOWS:\\n if board[c1] and (board[c1] == board[c2] == board[c3] == board[c4]):\\n won_by = board[c1]\\n break\\n \\n if won_by == _PLAYER:\\n # subtract depth so we delay loss as much as possible \\n return -1000 - depth \\n if won_by == _AI:\\n # add depth so faster wins are more attractive\\n return 1000 + depth \\n if depth == 0:\\n score = score_position(board, _AI) \\n return score\\n\\n # (these are arranged _CENTER-out to help make a/b pruning most efficient)\\n valid_locations: list[int] = [\\n col % 7 for col in (38,37,39,36,40,35,41) if board[col] == _EMPTY]\\n\\n if not valid_locations:\\n return 0\\n \\n # minimax strategy: alternate if AI is looking for best move (maximizing)\\n # or the most harmful response from the player (minimizing).\\n value: int\\n new_col: int\\n row: int\\n \\n if max_player:\\n value = _MINUS_INFINITY\\n new_col = random.choice(valid_locations)\\n for col in valid_locations: \\n for r in (0, 1, 2, 3, 4, 5):\\n if board[7 * r + col] == 0:\\n row = r\\n break\\n b_copy = bytearray(board)\\n b_copy[row * 7 + col] = _AI\\n new_score: int = minimax(b_copy, depth-1, alpha, beta, False)\\n if new_score > value:\\n value = new_score\\n new_col = col\\n alpha = max(alpha, value)\\n if alpha >= beta:\\n break\\n\\n else:\\n value = _INFINITY\\n for col in valid_locations:\\n for r in (0, 1, 2, 3, 4, 5):\\n if board[7 * r + col] == 0:\\n row = r\\n break\\n b_copy = bytearray(board)\\n b_copy[row * 7 + col] = _PLAYER\\n new_score: int = minimax(b_copy, depth-1, alpha, beta, True)\\n if new_score < value:\\n value = new_score\\n beta = min(beta, value)\\n if alpha >= beta:\\n break\\n\\n # For speed, return simple score except when exiting first recursive call,\\n # and return the chosen column & the score in that case.\\n if not at_top:\\n return value\\n else:\\n return new_col % 7, value\",\n \"def solve(self):\\n while self.counter[-1] != len(self.sequences[-1]) + 1:\\n basepair = self.generatebasepairs(self.counter) # Get the combination for the current coordination\\n moves = self.generatemoves(basepair) # Get all possible ways to get to this current coordination\\n\\n maxscore = -100000000 # set the maxscore to a value which is always lower than possible scores\\n bestmove = None\\n\\n # FOr each move calculate score\\n for move in moves:\\n coordinates = self.generatecoordinates(move, self.counter) # generate the origin coordinate for the current move\\n score = self.retrievematrixelement(coordinates).score # Get the score at the origin coordinate\\n pairs = self.getallpairs(move) # Get all pairs possible for the current move\\n scores = [self.scorePair(u) for u in pairs] # Generate scores for all pairs\\n newscore = score + sum(scores) # Add generated scores to origin score\\n if newscore > maxscore:\\n maxscore = newscore\\n bestmove = coordinates\\n\\n self.enterelement(self.counter, Score(bestmove, maxscore))\\n self.increase()\",\n \"def registerInitialState(self, gameState):\\n\\n # stuff\\n self.treeDepth = 4\\n self.oldFood = []\\n self.lastEatenFood = None\\n self.i = 0\\n\\n\\n\\n #oldFood\\n self.oldFood = self.getFoodYouAreDefending(gameState)\\n\\n\\n self.red = gameState.isOnRedTeam(self.index)\\n self.distancer = distanceCalculator.Distancer(gameState.data.layout)\\n\\n # comment this out to forgo maze distance computation and use manhattan distances\\n self.distancer.getMazeDistances()\\n\\n\\n\\n \\n\\n \\n # FIND PATROL POINTS\\n\\n\\n\\n x = gameState.data.layout.width/2-8\\n #print \\\"WIDTH \\\", x+4\\n\\n y1 = gameState.data.layout.height-4\\n y2 = 0+4\\n\\n\\n\\n point1 = (x,y2)\\n point2 = (x,y1)\\n topPoints = []\\n botPoints = []\\n for i in range(0,6):\\n xv = x+i\\n if not gameState.data.layout.walls[xv][y1]:\\n\\n newBP = (xv, y1)\\n botPoints.append(newBP)\\n else:\\n newBP = (xv, y1)\\n #print newBP, \\\" in wall\\\"\\n\\n if not gameState.data.layout.walls[xv][y2]:\\n newTP = (xv, y2)\\n topPoints.append(newTP)\\n else:\\n newTP = (xv, y2)\\n #print newTP, \\\" in wall\\\"\\n\\n\\n\\n\\n\\n # FIND PATROL POINTS WITH THE SHORTEST PATH\\n bestTP = topPoints[0]\\n bestBP = botPoints[0]\\n\\n bestPath = self.getMazeDistance(bestTP,bestBP)\\n for tp in topPoints:\\n bp = min(botPoints, key=lambda p: self.getMazeDistance(tp, p))\\n tempPath = self.getMazeDistance(tp, bp)\\n if (tempPath < bestPath):\\n bestTP = tp\\n bestBP = bp\\n bestPath = tempPath\\n\\n #print \\\"THE REAL BEST POINTS: \\\", bestBP, \\\" \\\", bestTP, \\\" \\\", bestPath\\n\\n self.patrolPoints = [bestTP,bestBP]\\n\\n\\n\\n\\n\\n\\n import __main__\\n if '_display' in dir(__main__):\\n self.display = __main__._display\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Actions\\n\\n waiting_list = util.PriorityQueue()\\n COSTS = {}\\n start_state = problem.getStartState()\\n COSTS[start_state] = 0\\n waiting_list.push(start_state,0)\\n parents = {}\\n \\n while not waiting_list.isEmpty():\\n q_state = waiting_list.pop()\\n if problem.isGoalState(q_state):\\n target_state = q_state\\n break\\n for child in problem.getSuccessors(q_state):\\n n_cost = COSTS[q_state] + child[2]\\n \\n if child[0] not in COSTS or n_cost < COSTS[q_state]:\\n COSTS[child[0]] = n_cost\\n prior = n_cost + heuristic(child[0], problem)\\n waiting_list.push(child[0], prior)\\n parents[child[0]] = q_state\\n\\n sequence = []\\n prev_state = target_state\\n while target_state in parents.keys():\\n target_state = parents[target_state]\\n direction = Actions.vectorToDirection([prev_state[0] - target_state[0], prev_state[1] - target_state[1]])\\n prev_state = target_state\\n sequence.append(direction)\\n \\n return sequence[::-1]\",\n \"def minimax(self, game, depth):\\n\\n def min_value(game, traversed_depth=1):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n if traversed_depth==depth:\\n return self.score(game,self)\\n traversed_depth+=1\\n v = float(\\\"inf\\\")\\n for m in game.get_legal_moves():\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n v = min(v, max_value(game.forecast_move(m),traversed_depth))\\n return v\\n\\n def max_value(game, traversed_depth=1):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n if traversed_depth==depth:\\n return self.score(game,self)\\n traversed_depth+=1\\n v = float(\\\"-inf\\\")\\n for m in game.get_legal_moves():\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n v = max(v, min_value(game.forecast_move(m),traversed_depth))\\n return v\\n \\n return max(game.get_legal_moves(), key=lambda m: min_value(game.forecast_move(m)))\",\n \"def run(cores):\\n if not os.path.exists(\\\"Solutions\\\"):\\n os.mkdir(\\\"Solutions\\\")\\n\\n #f = open(os.path.join(\\\"Solutions\\\",\\\"log.txt\\\"),'a') #a is for append, it also creates files if not available, the rest is self explanatory\\n\\n tg = globalTarget\\n\\n generation = 1 #counter for generation, for printing every 100 gens \\n parent = Organism(tg.size,INITIAL_GENES) #calling Organism class, and passing the target size and initial gene pool size as params \\n \\n score=fitness(tg,parent.drawImage())\\n\\n p = multiprocessing.Pool(cores)\\n\\n while True:\\n \\n print \\\"Generation {} - Score {}\\\".format(generation,score)\\n #f.write(\\\"Generation {} - Score {}\\\\n\\\".format(generation,score))\\n \\n if generation % GENERATIONS_PER_IMAGE == 0:\\n parent.drawImage().save(os.path.join(\\\"Solutions\\\",\\\"{}.jpeg\\\".format(generation)))\\n \\n generation += 1\\n \\n \\n \\\"\\\"\\\"\\n This is where the genetic algo really starts.\\n We will first start with making a children and a ss_scores array (idk why ss, it sounds cool)\\n \\\"\\\"\\\"\\n children=[]\\n ss_score=[]\\n\\n \\\"\\\"\\\"\\n Next, we will basically mutate and check fitness, then save to results, unless interrupted by the keyboard\\n \\\"\\\"\\\"\\n\\n try:\\n results = groupMutate(parent,POP_PER_GEN-1,p)\\n except KeyboardInterrupt:\\n print 'Sayonara!'\\n p.close()\\n return\\n\\n \\\"\\\"\\\"\\n Now we will do 2 things to the children and the ss_scores arrays:\\n save parents and score to those 2, incase the parents are better than the children\\n \\\"\\\"\\\"\\n children.append(parent)\\n ss_score.append(score)\\n \\n \\\"\\\"\\\"\\n Then we will put new children and new scores in those\\n \\\"\\\"\\\"\\n newScores,newChildren = zip(*results)\\n\\n children.extend(newChildren)\\n ss_score.extend(newScores)\\n\\n \\\"\\\"\\\"\\n Finally, we sort them, and pick the best to become the new parents (and log in the best in the scores too)\\n \\\"\\\"\\\"\\n \\n \\n winners = sorted(zip(children,ss_score),key=lambda x: x[1])\\n #lambda here creates a memroy space in the area of calling, which makes the execution time \\\"blazingly fast\\\", quoting pranjal :)\\n \\n \\n parent,score = winners[0]\\n \\n \\n \\\"\\\"\\\"\\n Now, these parents will go through mutation and give new children\\n \\\"\\\"\\\"\\n\\n #this is becuase at one point, too many files are open, since we are opening a pool inside a loop, then not shutting it down\",\n \"def play_game():\\n \\n \\n def response(answer):\\n \\\"\\\"\\\" Returns the user's response simplified\\\"\\\"\\\"\\n if answer in ['YES', 'Yes', 'y', 'Y', 'yes']:\\n return 'yes'\\n elif answer in ['NO', 'no', 'N', 'n', 'No']:\\n return 'no'\\n else:\\n raise ValueError('Invalid response')\\n \\n \\n \\\"\\\"\\\" Load previous game or start new game \\\"\\\"\\\"\\n new_game = input('Load previous game? ')\\n mytree = None # Prime variable for current tree settings\\n \\n \\n if response(new_game) == 'yes':\\n new_game = input('Enter name of file: ') # Load a previously existing tree\\n mytree = MyTree.load_tree(new_game)\\n elif response(new_game) == 'no':\\n mytree = MyTree() # Create a new tree\\n \\n \\n def change_position(change):\\n \\\"\\\"\\\" Changes current position in Tree : Change = Left or Right\\\"\\\"\\\"\\n if response(change) == 'yes':\\n mytree._position = mytree.left(mytree._position) # If answer is yes, move left\\n return mytree._position\\n elif response(change) == 'no':\\n mytree._position = mytree.right(mytree._position) # If answer is no, move right\\n return mytree._position\\n else:\\n raise NameError('Response not recognized') # If answer cannot be read in response(), NameError\\n \\n \\n def at_end():\\n \\\"\\\"\\\" Checks if position is at end of the tree \\\"\\\"\\\"\\n return mytree.num_children(mytree._position)\\n \\n \\\"\\\"\\\" Start Game \\\"\\\"\\\"\\n user_continue = 'yes'\\n while response(user_continue) == 'yes':\\n print('\\\\nThink of an animal, and I will guess it.') # Print first computer's statement\\n while at_end() != 0: # Check if current position has leaves\\n temp_answer = input(mytree._position.element() + ' ') # Print question and ask for a yes or no\\n change_position(response(temp_answer)) # Move position\\n\\n \\n temp_answer = input('Is it a %s ' %(mytree._position.element() + '?')) # Make a guess\\n if response(temp_answer) == 'yes':\\n user_continue = input('I win! Continue? ') # Condition if final guess is right\\n \\n elif response(temp_answer) == 'no':\\n new_animal = input('I give up. What is it? ') # Condition if final guess is wrong\\n new_question = input('Please type a question whose answer is yes for %s and no for %s.\\\\n' % (new_animal, mytree._position.element()))\\n wrong_guess = mytree._position.element()\\n mytree._replace(mytree._position, new_question) # Replace wrong guess with question\\n mytree._add_left(mytree._position, new_animal) # Add input animal to 'yes' leaf\\n mytree._add_right(mytree._position, wrong_guess) # Add old animal to 'no' leaf\\n user_continue = input('Continue? ') # Ask to play again\\n \\n mytree._position = mytree.root() # Reset position to top (root)\\n \\n if response(user_continue) == 'no':\\n save = input('Would you like to save your tree? ') # Ask to save build tree\\n if response(save) == 'yes':\\n filename = input('Enter file saveas: ') \\n mytree.save_tree(filename) # Save file to user filename\\n \\n print('\\\\nGood-bye')\",\n \"def minimax(self, game, depth, maximizing_player=True, tab='\\\\t'):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n legal_moves = game.get_legal_moves(game.active_player)\\n if legal_moves is not None and len(legal_moves)>0:\\n if depth>0: # Recursive case:\\n if maximizing_player: # MAXIMIZING ply\\n score, move = None, None\\n for i,m in enumerate(legal_moves):\\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\\\t')\\n if score is None or newscore > score:\\n score, move = newscore, m\\n else: # MINIMIZING ply\\n score, move = None, None\\n for i,m in enumerate(legal_moves):\\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\\\t')\\n if score is None or newscore < score:\\n score, move = newscore, m\\n else: # Base case (depth==0)\\n score, move = self.score(game, self), None\\n else: # We are at a DEAD-END here\\n score, move = self.score(game, self), (-1, -1)\\n\\n return score, move\",\n \"def classify_treeInsert(self, query_name, cluster_naming_function):\\n classes = Set(self.class_map.values())\\n\\n full_dist_matrix = self.orig_dist_matrix.drop(query_name)\\n full_dist_matrix = full_dist_matrix.drop(query_name, axis=1)\\n\\n if PROGRESS: print '\\\\nStarting treeInsert!'\\n \\n #1] Build a tree for each class\\n class_trees = {}\\n all_elements = full_dist_matrix.columns.values.tolist()\\n classes_done = 0\\n num_of_classes = len(classes)\\n for c in classes:\\n\\n #1a. Construct a mini distance matrix for the current class\\n nonclass_members = [i for i in all_elements if self.class_map[i] != c]\\n class_dist_matrix = full_dist_matrix.drop(nonclass_members)\\n class_dist_matrix = class_dist_matrix.drop(nonclass_members, axis=1)\\n\\n #1b. Build class tree\\n if PROGRESS: print 'Building class tree for ' + c\\n\\n class_njt = NJTree()\\n class_njt.build(class_dist_matrix, self.class_map, myClusterNaming)\\n class_trees[c] = class_njt\\n classes_done = classes_done + 1\\n\\n if PROGRESS:\\n print str(classes_done) + \\\" classes down, \\\" + str(num_of_classes - classes_done) \\n + \\\" to go...\\\"\\n\\n #2] Determine the insertion cost of each tree\\n class_insert_costs = {}\\n for c,class_tree in class_trees.iteritems():\\n\\n #2a. Find insertion cost of each leaf in the tree\\n leaves = [i for i in class_tree.tree.nodes() if class_tree.isLeaf(i)] \\n leaf_insert_costs = {}\\n for leaf_i in leaves:\\n\\n parent_i = class_tree.tree.neighbors(leaf_i)[0] \\n cons = ({'type': 'eq',\\n 'fun': lambda x: x[0] + x[1] - nx.shortest_path_length(class_tree.tree, \\n source=parent_i, target=leaf_i, weight='length')})\\n optimum_leaf_insert_cost = optimize.minimize(_leaf_insertion_cost, [0,0,0], \\n args=(class_tree.orig_dist_matrix, leaf_i, leaves, query_name, self), method='SLSQP', \\n constraints=cons)\\n\\n if DEBUG:\\n print \\\"Optimum cost for \\\", leaf_i, \\\" : \\\", optimum_leaf_insert_cost.x[0]\\n\\n leaf_insert_costs[leaf_i] = optimum_leaf_insert_cost.x[0]\\n \\n class_insert_costs[c] = min(list(leaf_insert_costs.values()))\\n\\n #3] Output the class name of tree with minimum insertion cost\\n min_insert_cost = min(list(class_insert_costs.values()))\\n for c,cost in class_insert_costs.iteritems():\\n if cost==min_insert_cost:\\n return c\\n break\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n\\n if self.currentState.state == self.victoryCondition:\\n return True\\n\\n current_depth = self.currentState.depth\\n found_move = False\\n while self.currentState.parent:\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n count = self.currentState.nextChildToVisit\\n if len(self.currentState.children) > count:\\n found_move = True\\n break\\n if not found_move:\\n for all_visited in self.visited.keys():\\n all_visited.nextChildToVisit = 0\\n current_depth += 1\\n if len(self.visited) == 1:\\n all_possible_moves = self.gm.getMovables()\\n for every_move in all_possible_moves:\\n self.gm.makeMove(every_move)\\n new_game_state = GameState(self.gm.getGameState(), current_depth, every_move)\\n new_game_state.parent = self.currentState\\n self.visited[new_game_state] = False\\n self.currentState.children.append(new_game_state)\\n self.gm.reverseMove(every_move)\\n while current_depth != self.currentState.depth:\\n count = self.currentState.nextChildToVisit\\n self.currentState.nextChildToVisit += 1\\n if len(self.currentState.children) > count:\\n self.currentState = self.currentState.children[count]\\n next_move = self.currentState.requiredMovable\\n self.gm.makeMove(next_move)\\n else:\\n found_move = False\\n while self.currentState.parent:\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n if len(self.currentState.children) > self.currentState.nextChildToVisit:\\n found_move = True\\n break\\n if not found_move:\\n return False\\n\\n if self.currentState.state != self.victoryCondition:\\n self.visited[self.currentState] = True\\n all_possible_moves = self.gm.getMovables()\\n next_depth = current_depth + 1\\n for every_move in all_possible_moves:\\n self.gm.makeMove(every_move)\\n new_game_state = GameState(self.gm.getGameState(), next_depth, every_move)\\n if new_game_state not in self.visited:\\n self.visited[new_game_state] = False\\n new_game_state.parent = self.currentState\\n self.currentState.children.append(new_game_state)\\n self.gm.reverseMove(every_move)\\n return False\\n else:\\n return True\",\n \"def get_move(self, board, score, turns_alive, turns_to_starve, direction, head_position, body_parts):\\n #find coordinates of food(s)\\n snakeHead = (head_position[0], head_position[1])\\n\\n foods = []\\n distance = []\\n temp = 1000\\n choiceFood = [\\\"nothing\\\"]\\n for x in range(self.width):\\n for y in range(self.length):\\n if board[x][y] == GameObject.FOOD:\\n foods.append((x,y))\\n distance.append(abs(x-snakeHead[0]) + abs(y-snakeHead[1]))\\n\\n for index, item in enumerate(distance):\\n if item < temp:\\n temp = item\\n choiceFood[0] = foods[index]\\n\\n\\n rootNode = Agent(None, snakeHead, direction)\\n foodNode = Agent(None, choiceFood[0], None)\\n\\n openList = []\\n closedList = []\\n #add root node to the openList\\n openList.append(rootNode)\\n\\n #implements time\\n program_start = time.time()\\n\\n sum = 0\\n while len(openList) > 0:\\n sum += 1\\n #print(sum)\\n now = time.time()\\n currentNode = openList[0]\\n currentIndex = 0\\n\\n #once body is created calculate how many body in up, down, left, right\\n snakeBodyRight = 0\\n snakeBodyLeft = 0\\n snakeBodyUp = 0\\n snakeBodyDown = 0\\n areaLeftClean = snakeHead[0]*self.width\\n areaRightClean = (self.width - snakeHead[0])*self.width \\n areaDownClean = (self.width - snakeHead[1])*self.width\\n areaUpClean = snakeHead[1]*self.width\\n for a in body_parts:\\n if a[0] > snakeHead[0]: #body on the right\\n snakeBodyRight += 1\\n elif a[0] < snakeHead[0]: #body on the left\\n snakeBodyLeft += 1\\n\\n for a in body_parts: \\n if a[1] > snakeHead[1]: #body snake below head\\n snakeBodyDown += 1\\n elif a[1] < snakeHead[1]: #body snake above head\\n snakeBodyUp += 1\\n\\n # areaLeftClean = areaLeftClean - snakeBodyLeft\\n # areaRightClean = areaRightClean - snakeBodyRight\\n # areaDownClean = areaDownClean - snakeBodyDown\\n # areaUpClean = areaUpClean - snakeBodyUp\\n areaLeftClean = (areaLeftClean - snakeBodyLeft)/(areaLeftClean + 1)\\n areaRightClean = (areaRightClean - snakeBodyRight)/(areaRightClean+1)\\n areaDownClean = (areaDownClean - snakeBodyDown)/(areaDownClean+1)\\n areaUpClean = (areaUpClean - snakeBodyUp)/(areaUpClean+1)\\n #print(\\\"up\\\", areaUpClean, \\\"down\\\", areaDownClean, \\\"left\\\", areaLeftClean, \\\"right\\\", areaRightClean)\\n\\n \\n if now - program_start > 0.01 :\\n\\n move = None\\n if snakeHead[1] - 1 < 0 or snakeHead[1] + 1 >= self.width or snakeHead[0] - 1 < 0 or snakeHead[0] + 1 >= self.width: # at the edges\\n if direction == Direction.NORTH:\\n if areaLeftClean > areaRightClean and snakeBodyLeft < snakeBodyRight:\\n move = Move.LEFT\\n\\n if snakeHead[0] - 1 < 0: #if the snake besides the left edges\\n move = Move.RIGHT\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL: #left edges and obstacles on the right\\n move = Move.STRAIGHT\\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 <self.width:\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL:# if left is obstacles while on upper edge\\n move = Move.RIGHT\\n elif snakeHead[0] + 1 >= self.width:\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\\n move = Move.STRAIGHT\\n\\n else: \\n move = Move.RIGHT\\n\\n if snakeHead[0] - 1 < 0 and (board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL): #if the snake besides the left edgesa and right is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 < self.width:\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL:# if right is obstacles while on upper edge\\n move = Move.LEFT\\n elif snakeHead[0] + 1 >= self.width:\\n move = Move.LEFT\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\\n move = Move.STRAIGHT\\n\\n elif direction == Direction.SOUTH:\\n if areaLeftClean > areaRightClean and snakeBodyLeft < snakeBodyRight:\\n move = Move.RIGHT #go to left\\n \\n if snakeHead[0] - 1 < 0: #if the snake besides the left edges\\n move = Move.LEFT\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL: #left edges and obstacles on the right\\n move = Move.STRAIGHT\\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 <self.width:\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL:# if left is obstacles while on upper edge\\n move = Move.LEFT\\n elif snakeHead[0] + 1 >= self.width:\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\\n move = Move.STRAIGHT\\n else: \\n move = Move.LEFT\\n \\n if snakeHead[0] - 1 < 0 and (board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL): #if the snake besides the left edgesa and right is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[0] - 1 >= 0 and snakeHead[0] + 1 < self.width:\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL:# if right is obstacles while on upper edge\\n move = Move.RIGHT\\n elif snakeHead[0] + 1 >= self.width:\\n move = Move.RIGHT\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.SNAKE_BODY or board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL: #right edges and obstacles on the left\\n move = Move.STRAIGHT\\n\\n elif direction == Direction.EAST:\\n if areaDownClean > areaUpClean and snakeBodyDown < snakeBodyUp:\\n move = Move.RIGHT\\n if snakeHead[1] - 1 < 0 and (board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL): # if snake besides upper edgees and below is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on right edge\\n move = Move.LEFT\\n elif snakeHead[1] + 1 >= self.width:\\n move = Move.LEFT\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\\n move = Move.STRAIGHT\\n\\n else:\\n move = Move.LEFT\\n\\n if snakeHead[1] - 1 < 0: # if snake besides upper edgees\\n move = Move.RIGHT\\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL: #if below is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on right edge\\n move = Move.RIGHT\\n elif snakeHead[1] + 1 >= self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\\n move = Move.STRAIGHT\\n\\n else: #west\\n if areaDownClean > areaUpClean and snakeBodyDown < snakeBodyUp:\\n move = Move.LEFT\\n \\n if snakeHead[1] - 1 < 0 and (board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL): # if snake besides upper edgees and below is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if down is obstacle while on left edge\\n move = Move.RIGHT\\n elif snakeHead[1] + 1 >= self.width:\\n move = Move.RIGHT\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\\n move = Move.STRAIGHT \\n else:\\n move = Move.RIGHT\\n \\n if snakeHead[1] - 1 < 0: # if snake besides upper edgees\\n move = Move.LEFT\\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL: #if below is obstacle\\n move = Move.STRAIGHT\\n elif snakeHead[1] - 1 >= 0 and snakeHead[1] + 1 < self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL:# if up is obstacle while on left edge\\n move = Move.LEFT\\n elif snakeHead[1] + 1 >= self.width:\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL: #down edges and obstacles on up\\n move = Move.STRAIGHT\\n\\n else: \\n if direction == Direction.NORTH:\\n move = Move.STRAIGHT\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.WALL or board[snakeHead[0]][snakeHead[1] - 1] == GameObject.SNAKE_BODY: #check if above obstacles\\n if areaRightClean > areaLeftClean and snakeBodyRight < snakeBodyLeft: #lots of body parts on left\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.EMPTY:\\n move = Move.RIGHT\\n else:\\n move = Move.LEFT\\n else: #if body parts on left is smaller than right\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.EMPTY:\\n move = Move.LEFT\\n else:\\n move = Move.RIGHT\\n \\n elif direction == Direction.SOUTH:\\n move = Move.STRAIGHT\\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.WALL or board[snakeHead[0]][snakeHead[1] + 1] == GameObject.SNAKE_BODY: #check if belo obstacles\\n if areaRightClean > areaLeftClean and snakeBodyRight < snakeBodyLeft: #lots of body parts on left\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.EMPTY:\\n move = Move.LEFT\\n else:\\n move = Move.RIGHT\\n else: #if body parts on left is smaller than right\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.EMPTY:\\n move = Move.RIGHT\\n else:\\n move = Move.LEFT\\n\\n elif direction == Direction.EAST:\\n move = Move.STRAIGHT\\n if board[snakeHead[0] + 1][snakeHead[1]] == GameObject.WALL or board[snakeHead[0] + 1][snakeHead[1]] == GameObject.SNAKE_BODY: #check if right obstacles\\n if areaUpClean > areaDownClean and snakeBodyUp < snakeBodyDown: #lots of body parts on below\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.EMPTY:\\n move = Move.LEFT\\n else:\\n move = Move.RIGHT\\n else: #if body parts on below is lower than upper\\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.EMPTY:\\n move = Move.RIGHT\\n else:\\n move = Move.LEFT\\n\\n else: #west\\n move = Move.STRAIGHT\\n if board[snakeHead[0] - 1][snakeHead[1]] == GameObject.WALL or board[snakeHead[0]-1][snakeHead[1]] == GameObject.SNAKE_BODY: #check if left obstacles\\n if areaUpClean > areaDownClean and snakeBodyUp < snakeBodyDown: #lots of body parts on below\\n if board[snakeHead[0]][snakeHead[1] - 1] == GameObject.EMPTY:\\n move = Move.RIGHT\\n else:\\n move = Move.LEFT\\n else: #if body parts on below is lower than upper\\n if board[snakeHead[0]][snakeHead[1] + 1] == GameObject.EMPTY:\\n move = Move.LEFT\\n else:\\n move = Move.RIGHT\\n\\n return move\\n\\n \\n\\n for index, item in enumerate(openList):\\n if item.f < currentNode.f or (item.f == currentNode.f and item.g < currentNode.g):\\n currentIndex = index\\n currentNode = item\\n \\n openList.pop(currentIndex)#remove current node that is calculated\\n closedList.append(currentNode)#removed node in openList is moved to closedList\\n\\n\\n if (currentNode.Pos == foodNode.Pos):\\n path = []\\n current = currentNode\\n while current is not None:\\n path.append(current.Pos)\\n current = current.parent\\n #print(path[::-1])\\n move = None\\n path = path[::-1]\\n xAxis = path[1][0] - path[0][0]\\n yAxis = path[1][1] - path[0][1]\\n\\n if(direction == Direction.NORTH):\\n if xAxis < 0 and yAxis == 0: #left\\n move = Move.LEFT \\n elif xAxis > 0 and yAxis == 0: #right\\n move = Move.RIGHT\\n else: #yAxis < 0 #up\\n move = Move.STRAIGHT\\n\\n elif(direction == Direction.SOUTH):\\n if xAxis < 0 and yAxis == 0: #left\\n move = Move.RIGHT \\n elif yAxis > 0 and xAxis == 0: #down\\n move = Move.STRAIGHT\\n else: #right\\n move = Move.LEFT\\n\\n\\n elif(direction == Direction.EAST):\\n if yAxis > 0 and xAxis == 0: #down\\n move = Move.RIGHT \\n elif xAxis > 0 and yAxis == 0: #right\\n move = Move.STRAIGHT\\n else: #yAxis < 0 #up\\n move = Move.LEFT\\n\\n else: #west\\n if xAxis < 0 and yAxis == 0: #left\\n move = Move.STRAIGHT \\n elif yAxis > 0 and xAxis == 0: #down\\n move = Move.LEFT \\n else: #yAxis < 0 #up\\n move = Move.RIGHT\\n \\n return move\\n\\n\\n branches = []\\n north = [(1,0), (-1, 0), (0,-1)] #right, left, up\\n south = [(1,0), (-1, 0), (0, 1)] #rightm, left, down\\n east = [(1,0), (0, 1), (0,-1)] #right, up, down\\n west = [(0,1), (-1, 0), (0,-1)] #down, left, up\\n\\n if currentNode.directions == Direction.NORTH:\\n for adjacent in north:\\n curDirection = None \\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\\n \\n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\\n continue\\n\\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\\n continue\\n\\n #check the direction of the neighbor\\n if neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.WEST\\n elif neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.EAST\\n else: \\n curDirection = Direction.NORTH\\n\\n \\n\\n newBranch = Agent(currentNode, neighbor, curDirection)\\n branches.append(newBranch)\\n\\n elif currentNode.directions == Direction.SOUTH:\\n for adjacent in south:\\n curDirection = None\\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\\n \\n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\\n continue\\n\\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\\n continue\\n\\n #check the direction of the neighbor\\n if neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.WEST\\n elif neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.EAST\\n else: \\n curDirection = Direction.SOUTH\\n\\n newBranch = Agent(currentNode, neighbor, curDirection)\\n branches.append(newBranch)\\n\\n elif currentNode.directions == Direction.EAST:\\n for adjacent in east:\\n curDirection = None\\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\\n \\n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\\n continue\\n\\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\\n continue\\n\\n #check the direction of the neighbor\\n if neighbor[0] > currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.EAST\\n elif neighbor[1] > currentNode.Pos[1] and neighbor[0] == currentNode.Pos[0]:\\n curDirection = Direction.SOUTH\\n else: \\n curDirection = Direction.NORTH\\n newBranch = Agent(currentNode, neighbor, curDirection)\\n branches.append(newBranch)\\n\\n else: #west\\n for adjacent in west:\\n curDirection = None\\n neighbor = (currentNode.Pos[0] + adjacent[0], currentNode.Pos[1] + adjacent[1])\\n \\n if neighbor[0] < 0 or neighbor[0] > (self.length - 1) or neighbor[1] < 0 or neighbor[1] > (self.length -1):\\n continue\\n\\n if board[neighbor[0]][neighbor[1]] == GameObject.SNAKE_BODY or board[neighbor[0]][neighbor[1]] == GameObject.WALL:\\n continue\\n\\n #check the direction of the neighbor\\n if neighbor[1] > currentNode.Pos[1] and neighbor[0] == currentNode.Pos[0]:\\n curDirection = Direction.SOUTH\\n elif neighbor[0] < currentNode.Pos[0] and neighbor[1] == currentNode.Pos[1]:\\n curDirection = Direction.WEST\\n else: \\n curDirection = Direction.NORTH\\n\\n newBranch = Agent(currentNode, neighbor, curDirection)\\n branches.append(newBranch)\\n\\n\\n #get all of the child in the current branches and calculate the f/g/h\\n \\n for child in branches:\\n\\n child.g = currentNode.g + 1\\n child.h = ((child.Pos[0] - foodNode.Pos[0]) ** 2) + ((child.Pos[1] - foodNode.Pos[1]) ** 2)\\n child.f = child.g + child.h\\n \\n openList.append(child)\",\n \"def get_move(self, rootstate, itermax, verbose = True, **kwargs):\\n\\n # print(rootstate.playerHands[rootstate.playerToMove])\\n\\n assert len(rootstate.playerHands[rootstate.playerToMove]) == 2\\n\\n move, victim, guess = get_move(rootstate, ismcts=True)\\n\\n if move:\\n return move, victim, guess\\n\\n rootnode = Node()\\n counter = 0\\n for i in range(itermax):\\n node = rootnode\\n # determinize\\n state = rootstate.clone_and_randomize(vanilla=kwargs.get('vanilla', True))\\n node = self.select(state, node)\\n node = self.expand(state, node)\\n self.simulate(state)\\n self.backpropagate(state, node)\\n\\n # Output some information about the tree - can be omitted\\n if verbose:\\n print(rootnode.children_to_string())\\n\\n return self.select_final_move(rootnode, rootstate)\",\n \"def search(self, is_max, possible_moves, state, depth, alpha, beta):\\n temp_state = state.deepcopy()\\n best_move = None\\n best_move_val = float('-inf') if is_max else float('inf')\\n \\n for move in possible_moves:\\n for to in move['to']:\\n \\n if time() > self.thinking_time:\\n return best_move, best_move_val\\n \\n temp_state.board.move_pawn(move['from'], to)\\n temp_state.next_turn()\\n _, val = self.minimax(temp_state, not(is_max), depth+1, alpha, beta)\\n \\n temp_state.board.move_pawn(to, move['from'])\\n temp_state.undo_turn()\\n \\n if is_max and val > best_move_val:\\n alpha = max(val, alpha)\\n best_move_val = val\\n best_move = (move['from'], to)\\n \\n if not(is_max) and val < best_move_val:\\n beta = min(val, beta)\\n best_move_val = val\\n best_move = (move['from'], to)\\n \\n if beta <= alpha: #pruning\\n return best_move, best_move_val\\n \\n return best_move, best_move_val\",\n \"def test_prioritize():\\n tiles = Tiles(800, 100)\\n board = Board(800, 100, tiles)\\n player = Player('Alfred', board, 'black')\\n ai = AI(board, player)\\n board.add_tile(board.count//2 - 1, 0, 'white')\\n for i in range(1, board.count - 1):\\n if board.tiles_list[board.count//2 - 1][i] is None:\\n board.add_tile(board.count//2 - 1, i, 'black')\\n else:\\n board.tiles_list[board.count//2 - 1][i].color = 'black'\\n assert ai.prioritize()[0] == (board.count//2 - 1, board.count - 1)\\n assert len(ai.prioritize()[1]) == board.count - 2\\n for i in range(board.count//2 + 1, board.count - 1):\\n board.add_tile(i, i, 'black')\\n assert ai.occupy_corner()[0] == (board.count - 1, board.count - 1)\\n assert len(ai.occupy_corner()[1]) == board.count//2 - 2\",\n \"def classes(self):\\n #print \\\"making classes again!\\\"\\n l = []\\n for p in self.marks:\\n l.append(psi_class(self,p))\\n for d in range(1, self.dimension + 1):\\n l.append(kappa_class(self,d))\\n for i in range(1, self.genus+1):\\n l.append(chern_char(self, 2*i-1))\\n if True:#self.genus != 0:\\n l.append(irreducible_boundary(self))\\n marks = set(self.marks)\\n reducible_boundaries = []\\n if self.n != 0:\\n first_mark_list = [marks.pop()] \\n for g1 in range(0, self.genus + 1):\\n for p in subsets(marks):\\n r_marks = set(first_mark_list + p)\\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\\n \\n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\\n \\n else: #self.n == 0\\n for g1 in range(1, floor(self.genus/2.0)+1):\\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \\n \\n \\n l += reducible_boundaries \\n \\n for i in range(1,self.genus+1):\\n l.append(lambda_class(self,i))\\n return l\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def agentCounter(gameState, index, depth):\\n \\\"\\\"\\\"When index is out of bounds return pacmans index and\\n reduce depth by 1\\\"\\\"\\\"\\n if index == gameState.getNumAgents():\\n return [depth-1, 0]\\n else:\\n return [depth, index]\\n\\n def minimax(self, gameState, depth, index):\\n \\\"\\\"\\\"Implement minimax function for pacman game. \\n return an array with score and best move\\\"\\\"\\\"\\n ultimateMove = None # The best move the agent can use\\n if depth == 0 or gameState.isWin() or gameState.isLose():\\n # if leaf node return value.\\n return [self.evaluationFunction(gameState), ultimateMove]\\n else:\\n if index == 0: # if pacman => agent is max agent\\n value = -math.inf\\n maxValue = value\\n # iterates through max agent w/index=0 moves\\n for action in gameState.getLegalActions(0):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action) # generates the next state when move is done\\n value = max(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\\n if maxValue != value: # If value has changed update values\\n ultimateMove = action\\n maxValue = value\\n return [value, ultimateMove]\\n else: # is ghost => agent is min agent\\n value = math.inf\\n minValue = value\\n # Iterate through the moves of a min agent w/index not 0\\n for action in gameState.getLegalActions(index):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action)\\n value = min(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\\n if minValue != value: # If value has changed update values\\n ultimateMove = action\\n minValue = value\\n return [value, ultimateMove]\\n\\n best = minimax(self, gameState, self.depth, self.index)\\n #print(\\\"Move: \\\", best[1], \\\" | Score: \\\", best[0])\\n return best[1]\",\n \"def _avoid_tag(self, id=0, ignore=Obstacle.IS_SONAR):\\n sorted_detections = self._sort_tags_left_to_right(\\n self.swarmie.get_latest_targets().detections,\\n id=id\\n )\\n\\n # if count == 3: # last resort\\n # self.current_state = Planner.STATE_DRIVE\\n # angle = self._get_angle_to_face(point)\\n # self.swarmie.turn(\\n # angle,\\n # ignore=Obstacle.TAG_TARGET,\\n # throw=False\\n # )\\n # self.result = self.swarmie.drive(\\n # .75,\\n # ignore=Obstacle.TAG_TARGET,\\n # throw=False\\n # )\\n\\n if len(sorted_detections) == 0:\\n # no tags in view anymore\\n print(\\\"I can't see anymore tags, I'll try creeping\\\",\\n \\\"and clearing.\\\")\\n self.prev_state = self.current_state\\n self.current_state = Planner.STATE_DRIVE\\n self.swarmie.drive(\\n 0.1,\\n ignore=Obstacle.SONAR_BLOCK,\\n throw=False\\n )\\n drive_result = self.clear(math.pi / 8, ignore=ignore)\\n\\n else:\\n left_angle, left_dist = \\\\\\n self._get_angle_and_dist_to_avoid(\\n sorted_detections[0],\\n direction='left'\\n )\\n right_angle, right_dist = \\\\\\n self._get_angle_and_dist_to_avoid(\\n sorted_detections[-1],\\n direction='right'\\n )\\n angle = left_angle\\n dist = left_dist\\n\\n if (self.current_state == Planner.STATE_AVOID_LEFT or\\n self.prev_state == Planner.STATE_AVOID_LEFT):\\n # Keep going left. Should help avoid bouncing back\\n # and forth between tags just out of view.\\n print(\\\"I was turning left last time, so I'll keep\\\",\\n \\\"it that way.\\\")\\n self.prev_state = self.current_state\\n self.current_state = Planner.STATE_AVOID_LEFT\\n angle = left_angle\\n dist = left_dist\\n\\n elif (self.current_state == Planner.STATE_AVOID_RIGHT or\\n self.prev_state == Planner.STATE_AVOID_RIGHT):\\n # Keep going right\\n print(\\\"I was turning right last time, so I'll\\\",\\n \\\"keep it that way.\\\")\\n self.prev_state = self.current_state\\n self.current_state = Planner.STATE_AVOID_RIGHT\\n angle = right_angle\\n dist = right_dist\\n\\n else:\\n # pick whichever angle is shortest\\n if abs(right_angle) < abs(left_angle):\\n print('Right looks most clear, turning right.')\\n # print('Right turn makes most sense, turning right.')\\n self.prev_state = self.current_state\\n self.current_state = Planner.STATE_AVOID_RIGHT\\n angle = right_angle\\n dist = right_dist\\n else:\\n print('Left looks most clear, turning left.')\\n # print('Left turn makes most sense, turning left')\\n self.prev_state = self.current_state\\n self.current_state = Planner.STATE_AVOID_LEFT\\n\\n _turn_result, drive_result = self._go_around(\\n angle,\\n dist\\n )\\n\\n return drive_result\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.NumAgents = gameState.getNumAgents()\\n self.root = gameState\\n # alpha-beta-search\\n # one call of Max_Value is enough to iterate the whole tree and keep the optimal move\\n self.Max_Value(gameState, -10000, 10000, self.index, self.depth)\\n return self.move\\n util.raiseNotDefined()\",\n \"def find_best_move(state: GameState) -> None:\",\n \"def improve(self):\\n tour = Tour(self.heuristic_path)\\n\\n # Find all valid 2-opt moves and try them\\n for t1 in self.heuristic_path:\\n around = tour.around(t1)\\n\\n for t2 in around:\\n broken = set([makePair(t1, t2)])\\n # Initial savings\\n gain = TSP.dist(t1, t2)\\n\\n close = self.closest(t2, tour, gain, broken, set())\\n\\n # Number of neighbours to try\\n tries = 5\\n\\n for t3, (_, Gi) in close:\\n # Make sure that the new node is none of t_1's neighbours\\n # so it does not belong to the tour.\\n if t3 in around:\\n continue\\n\\n joined = set([makePair(t2, t3)])\\n\\n # The positive Gi is taken care of by `closest()`\\n Log.debug(\\\"Start: X: {} - Y: {} = {}\\\".format((t1, t2),\\n (t2, t3), Gi))\\n\\n if self.chooseX(tour, t1, t3, Gi, broken, joined):\\n # Return to Step 2, that is the initial loop\\n return True\\n # Else try the other options\\n\\n tries -= 1\\n # Explored enough nodes, change t_2\\n if tries == 0:\\n break\\n\\n return False\",\n \"def a_star_gs(self):\\n print('Performing A*GS\\\\n')\\n\\n frontier = PriorityFrontier()\\n\\n initial_node = SearchNode(self.initial_state)\\n initial_heuristic = self.get_heuristic(self.initial_state) + initial_node.path_cost\\n frontier.insert(initial_node, initial_heuristic)\\n\\n visited_nodes = set()\\n \\n num_expanded_nodes = 0\\n \\n while True:\\n if frontier.is_empty():\\n # Search failure\\n print('Empty frontier.')\\n return AStarResult(failure=True)\\n \\n # Get the next leaf node from the frontier\\n leaf_node = frontier.pop()\\n \\n if not leaf_node:\\n # Search failure\\n print('Popped all the frontier nodes.')\\n return AStarResult(failure=True)\\n \\n # Check for the goal state\\n if self.check_goal_state(leaf_node.state):\\n # Search success\\n # Return final state and list of actions along path to the goal\\n # as part of the AStarResult class solution member\\n action_path = self.get_action_path(leaf_node)\\n return AStarResult(solution=Solution(final_state=leaf_node.state, actions=action_path), \\n num_expanded_nodes=num_expanded_nodes, max_depth=len(action_path) - 1)\\n\\n # Add this node to the visited nodes set\\n visited_nodes.add(leaf_node)\\n \\n # Generate all possible actions for the given state\\n actions = self.get_actions(leaf_node.state)\\n \\n # Create search nodes from the generated actions\\n for action in actions:\\n # Generate a new state from the given action\\n new_state = self.get_result(leaf_node.state, action)\\n \\n # Create a new search node with the created state\\n new_node = SearchNode(new_state, leaf_node, action, path_cost=leaf_node.path_cost + 1)\\n \\n num_expanded_nodes += 1\\n\\n # If this node has already been visited, ignore it\\n if new_node in visited_nodes:\\n continue\\n\\n # Get the new node's heuristic\\n new_heuristic = self.get_heuristic(new_state) + new_node.path_cost\\n \\n # Check for any nodes with the same state as new_state and with better heuristic values that \\n # have yet to be visited in the frontier before adding new_node\\n if new_node in frontier:\\n frontier_node = frontier.peek_node(new_node)\\n frontier_heuristic = frontier.peek_heuristic(new_node)\\n\\n if frontier_heuristic <= new_heuristic:\\n # The original heuristic was less than or equal to the new node\\n # Disregard the new node\\n continue\\n \\n else:\\n # The new node's heuristic is larger\\n # Remove the original node from the frontier\\n frontier.remove_node(frontier_node)\\n\\n # Add the new node to the frontier\\n frontier.insert(new_node, new_heuristic)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n if (self.currentState.state == self.victoryCondition) or (self.currentState not in self.visited):\\n self.visited[self.currentState] = True\\n win_or_not = self.currentState.state == self.victoryCondition\\n return win_or_not\\n\\n if not self.currentState.nextChildToVisit: \\n its = 0\\n for movable in self.gm.getMovables():\\n its += 1\\n # time test\\n # too long \\n if its == \\\"too long\\\":\\n return \\\"too long\\\"\\n #make every move in movable\\n self.gm.makeMove(movable)\\n new = self.gm.getGameState()\\n new_gs = GameState(new, self.currentState.depth+1, movable)\\n \\n if new_gs not in self.visited:\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.gm.reverseMove(movable) \\n \\n num_children = len(self.currentState.children)\\n if self.currentState.nextChildToVisit < num_children:\\n new = self.currentState.children[self.currentState.nextChildToVisit]\\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\\n self.gm.makeMove(new.requiredMovable)\\n self.currentState = new\\n #recurse\\n return self.solveOneStep()\\n else:\\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n #recurse\\n return self.solveOneStep()\",\n \"def run_UCT(self, game, actions_taken):\\n \\n # If current tree is null, create one using game\\n if self.root == None:\\n self.root = Node(game.clone())\\n # If it's not, check if there are actions from actions_taken to update\\n # the tree from this player.\\n # If the list is not empty, update the root accordingly.\\n # If the list is empty, that means this player hasn't passed the turn,\\n # therefore the root is already updated.\\n elif len(actions_taken) != 0:\\n for i in range(len(actions_taken)):\\n # Check if action from history is in current root.children.\\n if actions_taken[i][0] in self.root.children:\\n # Check if the actions are made from the same player\\n child_node = self.root.children[actions_taken[i][0]]\\n if child_node.state.player_turn == actions_taken[i][1] \\\\\\n and set(self.root.state.available_moves()) \\\\\\n == set(game.available_moves()):\\n self.root = child_node\\n else:\\n self.root = None\\n self.root = Node(actions_taken[i][2].clone())\\n else:\\n self.root = None\\n self.root = Node(actions_taken[i][2].clone())\\n # This means the player is still playing (i.e.: didn't choose 'n').\\n else:\\n # Therefore, check if current root has the same children as \\\"game\\\"\\n # offers. If not, reset the tree.\\n if set(self.root.children) != set(game.available_moves()):\\n self.root = None\\n self.root = Node(game.clone())\\n\\n #Expand the children of the root if it is not expanded already\\n if not self.root.is_expanded():\\n self.expand_children(self.root)\\n\\n root_state = self.root.state.clone()\\n\\n for _ in range(self.n_simulations):\\n node = self.root\\n node.state = root_state.clone()\\n search_path = [node]\\n while node.is_expanded():\\n action, new_node = self.select_child(node)\\n node.action_taken = action\\n search_path.append(new_node)\\n node = new_node\\n # At this point, a leaf was reached.\\n # If it was not visited yet, then perform the rollout and\\n # backpropagates the reward returned from the simulation.\\n # If it has been visited, then expand its children, choose the one\\n # with the highest ucb score and do a rollout from there.\\n if node.n_visits == 0:\\n rollout_value = self.rollout(node)\\n self.backpropagate(search_path, rollout_value)\\n else:\\n _, terminal_state = node.state.is_finished()\\n # Special case: if \\\"node\\\" is actually a leaf of the game (not \\n # a leaf from the current tree), then only rollout should be \\n # applied since it does not make sense to expand the children\\n # of a leaf.\\n if terminal_state:\\n rollout_value = self.rollout(node)\\n self.backpropagate(search_path, rollout_value)\\n else:\\n self.expand_children(node)\\n action, new_node = self.select_child(node)\\n node.action_taken = action\\n search_path.append(new_node)\\n node = new_node\\n rollout_value = self.rollout(node)\\n self.backpropagate(search_path, rollout_value)\\n \\n dist_probability = self.distribution_probability(game)\\n action = self.select_action(game, self.root, dist_probability)\\n q_a_root = self.root.q_a\\n self.root = self.root.children[action]\\n # Remove the statistics of the chosen action from the chosen child\\n if self.root.n_a:\\n self.root.n_a.pop(action)\\n if self.root.q_a:\\n self.root.q_a.pop(action)\\n return action, dist_probability, q_a_root\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n state = self.currentState\\n #print (type(state))\\n self.visited[state] = True\\n #print (type(self.gm.getGameState()))\\n moves = self.gm.getMovables()\\n print (\\\"CURRENTSTATE\\\" + str(self.currentState.state))\\n print (\\\"MOVABLES:\\\")\\n if moves:\\n for m in moves:\\n print (str(m))\\n print (\\\"CHILDINDEX:\\\")\\n print (state.nextChildToVisit)\\n print (\\\"*********\\\")\\n if state.state == self.victoryCondition:\\n return True\\n #if no child to expand then go back\\n if not moves or state.nextChildToVisit >= len(moves):\\n self.currentState = state.parent\\n if state.requiredMovable is not None:\\n self.gm.reverseMove(state.requiredMovable)\\n # expand\\n else:\\n\\n next_move = moves[state.nextChildToVisit]\\n self.gm.makeMove(next_move)\\n state.nextChildToVisit += 1\\n\\n #if to parent or if visited then skip\\n while (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\\n print (\\\"PARENT FOUND!\\\")\\n self.gm.reverseMove(next_move)\\n if state.nextChildToVisit >= len(moves):\\n self.currentState = state.parent\\n return False\\n else:\\n next_move = moves[state.nextChildToVisit]\\n self.gm.makeMove(next_move)\\n state.nextChildToVisit += 1\\n\\n next_state = GameState(self.gm.getGameState(), state.depth + 1, next_move)\\n next_state.parent = state\\n #next_state.requiredMovable = next_move\\n state.children.append(next_state)\\n self.currentState = next_state\\n print (state.nextChildToVisit)\\n return False\",\n \"def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\\n # assigning cost of changing from one leg to another based on the distance to the desired pose\\n cost_ChangeLeg = 1\\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\\n if dz_final < 1:\\n cost_ChangeLeg = 10\\n elif dz_final < 2:\\n cost_ChangeLeg = 20\\n else:\\n cost_ChangeLeg = 10\\n\\n # assigning weight for cost of predicted repositioning and cost of robot motion\\n w_cost_reposition = 40\\n w_cost_motion = 10\\n\\n # finding object's leg cordinates\\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\\n\\n # initialization (initializeing cost to infinity)\\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\\n cost_legchange = [0, 0, 0, 0]\\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\\n cost_manipulation = [0, 0, 0, 0]\\n cost_motion = [0, 0, 0, 0]\\n force = [0, 0, 0, 0]\\n path = [[[], []], [[], []], [[], []], [[], []]]\\n planned_path_w = [[],[],[],[]]\\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\\n command = [[], [], [], []]\\n des = [[], [], [], [], []]\\n PAM_goal = state()\\n\\n # find the nominal trajectory for manipulation\\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\\n\\n # itterate through each leg to find the leg with minimum cost\\n for leg in range(4):\\n phi_linear = theta\\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\\n \\t# find the cost and required force for manipulation for the leg\\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\\n \\t# adding cost of changing leg\\n if leg != current_leg:\\n cost_legchange[leg] = cost_ChangeLeg\\n # adding cost of PAM motion to PAM goal pose\\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\\n if cost_PAM[leg][push_pull]!= float(\\\"inf\\\"):\\n PAM_s_sim = copy.deepcopy(PAM_s)\\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n # adding cost of predicted re-positionings\\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\\n # print(n_transition)\\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\\n else:\\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\\n\\n if min(cost) < float(\\\"inf\\\"):\\n \\t[min_index, min_value] = [np.argmin(cost), min(cost)]\\n \\t# Finding the grasping goal pose based on the selected plan\\n \\tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\\n \\tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\\n \\tPAM_goal = state()\\n \\tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\\n \\tobject_path_planned = Path()\\n \\tobject_path_planned.header.frame_id = 'frame_0'\\n \\tfor i in range(len(planned_path_w[min_index])):\\n \\t\\tpose = PoseStamped()\\n \\t\\tpose.pose.position.x = planned_path_w[min_index][i][0]\\n \\t\\tpose.pose.position.y = planned_path_w[min_index][i][1]\\n \\t\\tpose.pose.position.z = 0\\n \\t\\tobject_path_planned.poses.append(pose)\\n\\n \\tPAM_path_planned = Path()\\n \\tPAM_path_planned.header.frame_id = 'frame_0'\\n \\tif min_index != current_leg:\\n \\t\\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\\n \\t\\t\\tpose = PoseStamped()\\n \\t\\t\\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\\n \\t\\t\\tPAM_path_planned.poses.append(pose)\\n else:\\n \\tmin_index = 5\\n \\tmin_value = float(\\\"inf\\\")\\n if 0 < min_index and min_index <= 4:\\n force_d = force[min_index][0]\\n else:\\n force_d = [0,0,0]\\n\\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\",\n \"def get_greedy_ai_move(self, gamestate):\\n multiplier = 1 if gamestate.ai_colour else -1\\n best_moves = []\\n best_score = self.BLACK_CHECKMATE\\n for move in gamestate.get_valid_moves():\\n # Execute the move\\n (current_row, current_column), (new_row, new_column) = move\\n current_piece = gamestate.board.board[current_row][current_column]\\n piece_at_new_square = gamestate.board.board[new_row][new_column]\\n\\n gamestate.board.board[current_row][current_column] = None\\n gamestate.board.board[new_row][new_column] = current_piece\\n\\n if piece_at_new_square:\\n if piece_at_new_square.colour:\\n gamestate.board.white_pieces.remove(piece_at_new_square)\\n else:\\n gamestate.board.black_pieces.remove(piece_at_new_square)\\n\\n # Evaluate the new board state\\n score = (\\n self.evaluate_board(\\n gamestate.board,\\n gamestate.white_checkmate,\\n gamestate.black_checkmate,\\n gamestate.stalemate,\\n )\\n * multiplier\\n )\\n\\n # Undo the move\\n gamestate.board.board[current_row][current_column] = current_piece\\n gamestate.board.board[new_row][new_column] = piece_at_new_square\\n\\n if piece_at_new_square:\\n if piece_at_new_square.colour:\\n gamestate.board.white_pieces.append(piece_at_new_square)\\n else:\\n gamestate.board.black_pieces.append(piece_at_new_square)\\n\\n # Check if best move\\n if score > best_score:\\n best_score = score\\n best_moves = [move]\\n elif score == best_score:\\n best_moves.append(move)\\n\\n # If there are no best moves, return a random move.\\n if best_moves:\\n return self.get_random_move(best_moves)\\n return self.get_random_move(gamestate.get_valid_moves())\",\n \"def minimaxTest(yourAgent, minimax_fn):\\n\\n # create dummy 5x5 board\\n print(\\\"Now running the Minimax test.\\\")\\n print()\\n try:\\n def time_left(): # For these testing purposes, let's ignore timeouts\\n return 10000\\n\\n player = yourAgent() #using as a dummy player to create a board\\n sample_board = Board(player, RandomPlayer())\\n # setting up the board as though we've been playing\\n board_state = [\\n [\\\"Q1\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\"Q2\\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"]\\n ]\\n sample_board.set_state(board_state, True)\\n\\n test_pass = True\\n\\n expected_depth_scores = [(1, 4), (2, -2), (3, 4), (4, -2), (5, 2)]\\n\\n for depth, exp_score in expected_depth_scores:\\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\\n if exp_score != score:\\n print(\\\"Minimax failed for depth: \\\", depth)\\n test_pass = False\\n\\n if test_pass:\\n player = yourAgent()\\n sample_board = Board(player, RandomPlayer())\\n # setting up the board as though we've been playing\\n board_state = [\\n [\\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\"Q2\\\", \\\" \\\"],\\n [\\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\"Q1\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"]\\n ]\\n sample_board.set_state(board_state, True)\\n\\n test_pass = True\\n\\n expected_depth_scores = [(1, 5), (2, 5), (3, 5), (4, 6), (5, 6)]\\n\\n for depth, exp_score in expected_depth_scores:\\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\\n if exp_score != score:\\n print(\\\"Minimax failed for depth: \\\", depth)\\n test_pass = False\\n\\n if test_pass:\\n print(\\\"Minimax Test: Runs Successfully!\\\")\\n\\n except NotImplementedError:\\n print('Minimax Test: Not implemented')\\n except:\\n print('Minimax Test: ERROR OCCURRED')\\n print(traceback.format_exc())\",\n \"def job_tree(self):\\n\\n # 1. Enforce depth of 1 for steps\\n def depth_one(steps):\\n depth_one = []\\n for step in steps:\\n if type(step) is list:\\n if type(step[0]) is list:\\n depth_one.append(step[0])\\n else:\\n depth_one.append(step)\\n else:\\n depth_one.append([step])\\n return depth_one\\n\\n # 2. Convert steps to list of node objects (0,1,2,3...)\\n def assign_nodes(steps):\\n nodes = [i for i in range(len(steps))]\\n objects = list(\\n set([elem for sublist in steps for elem in sublist]))\\n\\n # checks for multiple src and dst objects -- added when looking for\\n # mutiples\\n split_objects = []\\n for obj in objects:\\n if len(obj) > 1:\\n new_objs = obj.split(\\\", \\\")\\n split_objects.extend(new_objs)\\n else:\\n split_objects.append(obj)\\n objects = split_objects\\n del(split_objects)\\n\\n # populate with leafless trees (Node objects, no edges)\\n for node in nodes:\\n nodes[node] = Node(str(node))\\n\\n # search for leafy trees\\n for obj in objects:\\n\\n # accounts for multiple drc/dst objects\\n leaves = []\\n for i, sublist in enumerate(steps):\\n for string in sublist:\\n if string.count(',') > 0:\\n if obj in string:\\n leaves.append(i)\\n else:\\n if obj in sublist:\\n leaves.append(i)\\n leaves = sorted(list(set(leaves)))\\n\\n if len(leaves) > 1:\\n viable_edges = []\\n\\n # compute cross-product\\n for leaf1 in leaves:\\n for leaf2 in leaves:\\n if str(leaf1) != str(leaf2) and sorted((leaf1, leaf2)) not in viable_edges:\\n viable_edges.append(sorted((leaf1, leaf2)))\\n\\n # form edge networks\\n for edge in viable_edges:\\n n1, n2 = nodes[edge[0]], nodes[edge[1]]\\n n1.add_edge(n2)\\n n2.add_edge(n1)\\n nodes[int(n1.name)], nodes[int(n2.name)] = n1, n2\\n return nodes\\n\\n # 3. Determine number of trees and regroup by connected nodes\\n def connected_nodes(nodes):\\n proto_trees = []\\n nodes = set(nodes)\\n\\n while nodes:\\n n = nodes.pop()\\n group = {n}\\n queue = [n]\\n while queue:\\n n = queue.pop(0)\\n neighbors = n.edges\\n neighbors.difference_update(group)\\n nodes.difference_update(neighbors)\\n group.update(neighbors)\\n queue.extend(neighbors)\\n proto_trees.append(group)\\n return proto_trees\\n\\n # 4. Convert nodes to nested dictionary of parent-children relations\\n # i.e. adding depth -- also deals with tree-node sorting and path\\n # optimization\\n def build_tree_dict(trees, steps):\\n # node sorting in trees\\n sorted_trees = []\\n for tree in trees:\\n sorted_trees.append(\\n sorted(tree, key=lambda x: int(x.name)))\\n\\n # retrieve values of the nodes (the protocol's containers)\\n # for each tree ... may want to use dictionary eventually\\n all_values = []\\n for tree in sorted_trees:\\n values = [steps[int(node.name)] for node in tree]\\n all_values.append(values)\\n\\n # create relational tuples:\\n all_digs = []\\n singles = []\\n dst_potentials = []\\n for tree_idx in range(len(sorted_trees)):\\n edge_flag = False\\n tree_digs = []\\n for node_idx in range(len(sorted_trees[tree_idx])):\\n\\n # digs: directed graph vectors\\n digs = []\\n dst_nodes = []\\n node_values = all_values[tree_idx][node_idx]\\n src_node = str(sorted_trees[tree_idx][node_idx].name)\\n\\n # ACTION ON MULTIPLE OBJECTS (E.G. TRANSFER FROM SRC -> DST\\n # WELLS)\\n # Outcome space: {1-1, 1-many, many-1, many-many}\\n if len(node_values) == 2:\\n # single destination (x-1)\\n if node_values[1].count(\\\",\\\") == 0:\\n dst_nodes = [i for i, sublist in enumerate(\\n steps) if node_values[1] == sublist[0]]\\n # multiple destinations (x-many)\\n elif node_values[1].count(\\\",\\\") > 0:\\n dst_nodes = []\\n for dst in node_values[1].replace(\\\", \\\", \\\"\\\"):\\n for i, sublist in enumerate(steps):\\n if i not in dst_nodes and dst == sublist[0]:\\n dst_nodes.append(i)\\n\\n # ACTION ON A SINGLE OBJECT\\n elif len(node_values) == 1:\\n dst_nodes = [i for i, sublist in enumerate(\\n steps) if node_values[0] == sublist[0]]\\n\\n # Constructing tuples in (child, parent) format\\n for dst_node in dst_nodes:\\n dig = (int(dst_node), int(src_node))\\n digs.append(dig)\\n\\n # else: an edge-case for dictionaries constructed with no edges\\n # initiates tree separation via flag\\n if digs != []:\\n edge_flag = False\\n tree_digs.append(digs)\\n else:\\n edge_flag = True\\n digs = [(int(src_node), int(src_node))]\\n tree_digs.append(digs)\\n\\n # digraph cycle detection: avoids cycles by overlooking set\\n # repeats\\n true_tree_digs = []\\n for digs in tree_digs:\\n for dig in digs:\\n if tuple(sorted(dig, reverse=True)) not in true_tree_digs:\\n true_tree_digs.append(\\n tuple(sorted(dig, reverse=True)))\\n\\n # edge-case for dictionaries constructed with no edges\\n if true_tree_digs != [] and edge_flag == False:\\n all_digs.append(true_tree_digs)\\n elif edge_flag == True:\\n all_digs.extend(tree_digs)\\n\\n # Enforces forest ordering\\n all_digs = sorted(all_digs, key=lambda x: x[0])\\n\\n # job tree traversal to find all paths:\\n forest = []\\n for digs_set in all_digs:\\n\\n # pass 1: initialize nodes dictionary\\n nodes = OrderedDict()\\n for tup in digs_set:\\n id, parent_id = tup\\n # ensure all nodes accounted for\\n nodes[id] = OrderedDict({'id': id})\\n nodes[parent_id] = OrderedDict({'id': parent_id})\\n\\n # pass 2: create trees and parent-child relations\\n for tup in digs_set:\\n id, parent_id = tup\\n node = nodes[id]\\n # links node to its parent\\n if id != parent_id:\\n # add new_node as child to parent\\n parent = nodes[parent_id]\\n if not 'children' in parent:\\n # ensure parent has a 'children' field\\n parent['children'] = []\\n children = parent['children']\\n children.append(node)\\n\\n desired_tree_idx = sorted(list(nodes.keys()))[0]\\n forest.append(nodes[desired_tree_idx])\\n return forest\\n\\n # 5. Convert dictionary-stored nodes to unflattened, nested list of\\n # parent-children relations\\n def dict_to_list(forest):\\n forest_list = []\\n for tree in forest:\\n tString = str(json.dumps(tree))\\n tString = tString.replace('\\\"id\\\": ', \\\"\\\").replace('\\\"children\\\": ', \\\"\\\").replace(\\n '[{', \\\"[\\\").replace('}]', \\\"]\\\").replace('{', \\\"[\\\").replace('}', \\\"]\\\")\\n\\n # find largest repeated branch (if applicable)\\n # maybe think about using prefix trees or SIMD extensions for better\\n # efficiency\\n x, y, length, match = 0, 0, 0, ''\\n for y in range(len(tString)):\\n for x in range(len(tString)):\\n substring = tString[y:x]\\n if len(list(re.finditer(re.escape(substring), tString))) > 1 and len(substring) > length:\\n match = substring\\n length = len(substring)\\n\\n # checking for legitimate branch repeat\\n if \\\"[\\\" in match and \\\"]\\\" in match:\\n hits = []\\n index = 0\\n if len(tString) > 3:\\n while index < len(tString):\\n index = tString.find(str(match), index)\\n if index == -1:\\n break\\n hits.append(index)\\n index += len(match)\\n\\n # find all locations of repeated branch and remove\\n if len(hits) > 1:\\n for start_loc in hits[1:]:\\n tString = tString[:start_loc] + \\\\\\n tString[start_loc:].replace(match, \\\"]\\\", 1)\\n\\n # increment all numbers in string to match the protocol\\n newString = \\\"\\\"\\n numString = \\\"\\\"\\n for el in tString:\\n if el.isdigit(): # build number\\n numString += el\\n else:\\n if numString != \\\"\\\": # convert it to int and reinstantaite numString\\n numString = str(int(numString) + 1)\\n newString += numString\\n newString += el\\n numString = \\\"\\\"\\n tString = newString\\n del newString\\n\\n forest_list.append(ast.literal_eval(tString))\\n return forest_list\\n\\n # 6. Print job tree(s)\\n def print_tree(lst, level=0):\\n print(' ' * (level - 1) + '+---' * (level > 0) + str(lst[0]))\\n for l in lst[1:]:\\n if type(l) is list:\\n print_tree(l, level + 1)\\n else:\\n print(' ' * level + '+---' + l)\\n\\n # 1\\n steps = depth_one(self.object_list)\\n # 2\\n nodes = assign_nodes(steps)\\n # 3\\n proto_forest = connected_nodes(nodes)\\n # 4\\n forest = build_tree_dict(proto_forest, steps)\\n # 5\\n self.forest_list = dict_to_list(forest)\\n # 6\\n print(\\\"\\\\n\\\" + \\\"A suggested Job Tree based on container dependency: \\\\n\\\")\\n for tree_list in self.forest_list:\\n print_tree(tree_list)\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Initialize data structures\\n parent_node = {}\\n path_to_node = {}\\n priority_queue = util.PriorityQueue()\\n\\n p_c = 0.5\\n h_c = 1 - p_c\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n parent_node[start_node] = None\\n path_to_node[start_node] = []\\n priority_queue.update(start_node, 0)\\n\\n #goal_found = False\\n\\n while not priority_queue.isEmpty():\\n # Get the next node\\n node_to_expand = priority_queue.pop()\\n # Check if goal state is reached\\n if problem.isGoalState(node_to_expand):\\n break\\n next_nodes = problem.getSuccessors(node_to_expand)\\n path_to_parent = path_to_node[node_to_expand]\\n\\n for one_node in next_nodes:\\n point, move, cost = one_node\\n curr_path = path_to_node[node_to_expand] + [move]\\n curr_cost = problem.getCostOfActions(curr_path)\\n heuristic_cost = heuristic(point, problem)\\n # Check if current node already exists in the previously visited nodes\\n if point in path_to_node:\\n prev_cost = problem.getCostOfActions(path_to_node[point])\\n if prev_cost > curr_cost:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n else:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\\n\\n print(node_to_expand) \\n return path_to_node[node_to_expand]\\n \\n# nodes_to_expand = set()\\n# # get max value node in the fringe node\\n# min_val = float(\\\"inf\\\")\\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost < min_val:\\n# min_val = total_cost\\n# \\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost == min_val:\\n# nodes_to_expand.add(one_node)\\n# fringe_node.remove(one_node)\\n#\\n# # Expand the fringe node \\n# for one_node in nodes_to_expand:\\n# path_to_parent = path_to_point[one_node]\\n# for nxt_node in problem.getSuccessors(one_node):\\n# pos = nxt_node[0]\\n# mv = nxt_node[1]\\n# # check if point already present in path to point\\n# prev_cost = float(\\\"inf\\\")\\n# if pos in cost_to_point:\\n# prev_cost = cost_to_point[pos]\\n# new_path = path_to_parent + [mv]\\n# if prev_cost > problem.getCostOfActions(new_path):\\n# path_to_point[pos] = new_path\\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\\n# fringe_node.append(pos)\\n#\\n# # Check if destination is reached in the fringe node\\n# for one_node in fringe_node:\\n# if problem.isGoalState(one_node):\\n# final_node = one_node\\n# goal_found = True\\n# break\\n# \\n# #print(len(fringe_node))\\n# print(final_node)\\n# print(path_to_point[final_node])\\n# return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n #here again we are making use of the priority queue for storing the frontier nodes\\n #created a priority queue for Astarsearch\\n neighbourNodes = util.PriorityQueue()\\n moves = []\\n neighbourNodes.push((problem.getStartState(),moves,0),0)\\n seenNodes = set()\\n\\n while not neighbourNodes.isEmpty():\\n currentState, currentActions, currentCost = neighbourNodes.pop()\\n if(currentState in seenNodes):\\n continue\\n if problem.isGoalState(currentState):\\n return currentActions\\n seenNodes.add(currentState)\\n for state, action, cost in problem.getSuccessors(currentState):\\n if(state in seenNodes):\\n continue\\n #here we calculate the hueristic value of visting each nodes\\n hvalue = heuristic(state, problem)\\n #and while pushing onto the queue we not only have the cost to visit the node\\n #but also the heuristic value of that node.\\n neighbourNodes.push((state, currentActions+[action], currentCost+cost),currentCost+cost+hvalue)\\n return moves\",\n \"def optimized_work_tree(obj, **kwargs):\\n exclusions = kwargs.get('exclusions', {\\\"groups\\\": [], \\\"classes\\\": [], \\\"params\\\": []})\\n groups_done = {}\\n classes = {\\\"depths\\\": {}, \\\"content\\\": {}}\\n params = {\\\"depths\\\": {}, \\\"content\\\": {}}\\n if hasattr(obj, 'hostname') and not hasattr(obj, 'name'):\\n obj.name = obj.hostname\\n to_index = [(obj, 1)]\\n\\n index_pop = to_index.pop\\n index_extend = to_index.extend\\n while to_index:\\n (obj, depth) = index_pop()\\n objname = obj.name\\n if objname in groups_done and groups_done[objname] <= depth:\\n continue\\n\\n objclasses = obj.classes.exclude(classname__in=exclusions['classes'])\\n updated_classes = optimized_update_values(objclasses, \\\"classname\\\", \\\"classparams\\\", depth=depth, results=classes)\\n\\n objparams = obj.parameters.exclude(paramkey__in=exclusions['params'])\\n updated_params = optimized_update_values(objparams, \\\"paramkey\\\", \\\"paramvalue\\\", depth=depth, results=params)\\n\\n if not updated_classes or not updated_params:\\n return (\\\"Fail\\\", \\\"Fail\\\")\\n\\n groups_done[objname] = depth\\n depth += 1\\n children = ((group, depth) for group in obj.groups.exclude(name__in=exclusions['groups']))\\n index_extend(children)\\n\\n params['content']['done_count'] = len(groups_done)\\n return (classes[\\\"content\\\"], params[\\\"content\\\"])\",\n \"def minimax(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n if game.get_legal_moves():\\n scores = [(self.minvalue(game.forecast_move(move), depth), move) for move in game.get_legal_moves()]\\n else:\\n return (self.score(game, self), (-1,-1)) \\n\\n return max(scores)\",\n \"def move_mcts(self, board, exploration_obj, evaluation_fn):\\n tree = mcts.MCTS(board, exploration_obj, evaluation_fn)\\n start = time.process_time()\\n tree.search(Parameters.uct_sims, Parameters.tree_sims)\\n total = time.process_time()-start\\n recommendation = tree.get_best_action()\\n return recommendation, total\",\n \"def move_buildings(self):\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n actionList = gameState.getLegalActions(0)\\n pacmanAgentIndex = 0\\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\\n count = util.Counter()\\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\\n\\n def maximizer(curState, agentIndex, depth):\\n\\n ghostActions = curState.getLegalActions(agentIndex)\\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\\n weight = -99999999 # Worst case starting value to be changed in the code\\n if depth == maxDepth: # If we are at a leaf node\\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\\n # Otherwise, we progress the tree until the above condition is reached\\n if len(ghostActions) != 0:\\n for x in ghostActions:\\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth):\\n weight = weight\\n else:\\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n def minimizer(curState, agentIndex, depth):\\n ghostActions = curState.getLegalActions(agentIndex)\\n weight = 999999999 # Worst case starting value to be changed in the code\\n if len(ghostActions) != 0:\\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\\n for x in ghostActions: # For each legal action in the current position\\n temp = maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\\n if weight < temp:\\n weight = weight\\n else:\\n weight = temp\\n else: # Otherwise, we continue to minimize\\n for x in ghostActions: # For each legal action in the current position\\n temp = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\\n if weight < temp:\\n weight = weight\\n else:\\n weight = temp\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n\\n # Executing the minimizer for all possible actions\\n for x in actionList:\\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\\n count[x] = minimizer(tempState,1,0)\\n # print('HELLO THERE')\\n # print(count)\\n return count.argMax()\",\n \"def move(self, board):\\r\\n self.start_time = time.time()\\r\\n disk_total = self.get_disk_count(self.my_color, board) + self.get_disk_count(self.opponent_color, board)\\r\\n\\r\\n if disk_total < 15:\\r\\n # In early-game, we can allow a deeper minimax search since there's not too many possible moves.\\r\\n self.minimax_max_depth = 7\\r\\n\\r\\n elif disk_total < 45:\\r\\n # In mid-game, minimax tree has the most branches. Therefore, we must give it space to breathe.\\r\\n self.minimax_max_depth = 5\\r\\n else:\\r\\n # In the very end-game, minimax tree has the least branches, so we can allow a full search.\\r\\n self.minimax_max_depth = 8\\r\\n\\r\\n possible_moves = self.find_possible_moves(board, self.my_color)\\r\\n\\r\\n # If there's only one move available, return it\\r\\n if len(possible_moves) == 1:\\r\\n return possible_moves[0]\\r\\n\\r\\n # If we can take a corner, take it and don't consider any other options.\\r\\n # This rarely backfires and allows to save a tiny bit of time\\r\\n corners = [(0,0), (0,7), (7,0), (7,7)]\\r\\n for corner in corners:\\r\\n if corner in possible_moves:\\r\\n return corner\\r\\n\\r\\n # Grow a minimax tree to find the best available move\\r\\n alpha_init = -10000000\\r\\n beta_init = 10000000\\r\\n\\r\\n available_moves = self.minimax(board, 0, self.my_color, alpha_init, beta_init)\\r\\n print(available_moves)\\r\\n if available_moves != 0:\\r\\n best_value = max(available_moves.values())\\r\\n for move in available_moves:\\r\\n if available_moves[move] == best_value:\\r\\n return move\\r\\n\\r\\n return None\",\n \"def step(self):\\n try:\\n self.agents.sort(key=lambda x: x.dist)\\n except Exception as e:\\n print(e)\\n\\n for agent in self.agents:\\n try:\\n agent.step()\\n except Exception as e:\\n print(e)\\n\\n\\n # Removes agents if they reach exit\\n for exit in self.model.exits:\\n x, y = exit.pos[0] * 6 + 1, exit.pos[1] * 6 + 1\\n if agent.node == (x, y):\\n try:\\n agent.saved()\\n except Exception as e:\\n print(e)\",\n \"def agent(obs_dict, config_dict):\\n global last_move\\n observation = Observation(obs_dict)\\n configuration = Configuration(config_dict)\\n player_index = observation.index\\n player_goose = observation.geese[player_index]\\n player_head = player_goose[0]\\n player_row, player_column = row_col(player_head, configuration.columns)\\n possible_moves = [Action.SOUTH.name, Action.NORTH.name, Action.WEST.name, Action.EAST.name]\\n possible_move = None\\n oldFoodDistanceToMe = 9999\\n \\n def getFoodsIndex(): \\n foods = []\\n for i in range(len(observation.food)):\\n food = observation.food[i]\\n foods.append(row_col(food, configuration.columns))\\n return foods\\n\\n def getGoose(index):\\n goose = []\\n for i in range(len(observation.geese[index])):\\n goose.append(row_col(observation.geese[index][i], configuration.columns))\\n return goose\\n\\n def getGeesesIndex():\\n geeses = []\\n for geese in observation.geese:\\n geeses.append(row_col(geese[0], configuration.columns))\\n return geeses\\n\\n def randomMove(moves):\\n if len(moves) > 1:\\n return moves[randint(0, len(moves) - 1)]\\n return moves[0]\\n\\n def countMoves(x1, y1, x2, y2):\\n return abs((x1-x2)+(y1-y2)) \\n\\n def willCollide(x, y, action):\\n #print(f'Goose[{player_index} in player_row: {player_row}, player_column: {player_column} move to {action} and can collide with x: {x}, y: {y}')\\n if action == Action.WEST.name:\\n if player_column - 1 == y and x == player_row:\\n return True \\n if player_column == 0 and y == 10 and x == player_row:\\n return True\\n if action == Action.EAST.name:\\n if player_column + 1 == y and x == player_row:\\n return True\\n if player_column == 10 and y == 0 and x == player_row:\\n return True\\n if action == Action.SOUTH.name:\\n if player_row + 1 == x and y == player_column:\\n return True\\n if player_row == 6 and x == 0 and y == player_column:\\n return True\\n if action == Action.NORTH.name:\\n if player_row - 1 == x and y == player_column:\\n return True\\n if player_row == 0 and x == 6 and y == player_column:\\n return True\\n return False\\n\\n def opposite(action):\\n if action == Action.NORTH.name:\\n return Action.SOUTH.name\\n if action == Action.SOUTH.name:\\n return Action.NORTH.name\\n if action == Action.EAST.name:\\n return Action.WEST.name\\n if action == Action.WEST.name:\\n return Action.EAST.name\\n\\n possible_moves = [Action.SOUTH.name, Action.NORTH.name, Action.WEST.name, Action.EAST.name]\\n\\n if last_move[player_index] is not None:\\n print(f'Geese {player_index} removes opposite last move: {opposite(last_move[player_index])}')\\n possible_moves.remove(opposite(last_move[player_index]))\\n\\n for geese_row, geese_column in getGeesesIndex():\\n for food_row, food_column in getFoodsIndex():\\n foodDistanceToMe = countMoves(food_row, food_column, player_row, player_column)\\n if oldFoodDistanceToMe > foodDistanceToMe:\\n oldFoodDistanceToMe = foodDistanceToMe\\n else:\\n continue\\n \\n geeseDistanceToFood = countMoves(geese_row, geese_column, food_row, food_column)\\n if foodDistanceToMe < geeseDistanceToFood:\\n if food_row > player_row:\\n possible_move = Action.SOUTH.name\\n\\n if food_row < player_row:\\n possible_move = Action.NORTH.name\\n\\n if food_column > player_column:\\n possible_move = Action.EAST.name\\n\\n if food_column < player_column:\\n possible_move = Action.WEST.name\\n \\n print(f'Geese {player_index} based by food, possible move: {possible_move}')\\n if possible_move not in possible_moves:\\n print(f'Geese {player_index}, possible move: {possible_move} is banned.')\\n possible_move = randomMove(possible_moves)\\n\\n for i in range(len(observation.geese)):\\n geese_index = getGoose(i)\\n j = 0\\n while j < len(geese_index):\\n collision = False\\n x, y = geese_index[j]\\n if i != player_index:\\n print(f'geese {player_index} -> geese {i} part {j}')\\n #print(f'goose[{player_index}] in {getGoose(player_index)[0]} with possible move: {possible_move} can colide with goose[{i}] in x: {x} and y: {y}')\\n while willCollide(x, y, possible_move):\\n collision = True\\n print(f'goose[{player_index}] in {getGoose(player_index)[0]} with possible move: {possible_move} will colide with goose[{i}] in x: {x} and y: {y}')\\n possible_moves.remove(possible_move)\\n possible_move = randomMove(possible_moves)\\n print(f'now goose[{player_index}] will to {possible_move}')\\n j = 0\\n if not collision:\\n j += 1\\n\\n for x, y in getGoose(player_index):\\n while willCollide(x, y, possible_move):\\n print(f'BODY HIT!!!')\\n possible_moves.remove(possible_move)\\n possible_move = randomMove(possible_moves)\\n\\n if len(possible_moves) == 1:\\n print(f'Geese {player_index} just remain this move: {possible_moves[0]}')\\n possible_move = possible_moves[0]\\n\\n last_move[player_index] = possible_move\\n\\n print(f'Geese {player_index}: {getGoose(player_index)} move to {possible_move}')\\n return possible_move\",\n \"def perform_split_brain_actions(self):\\n proximity = self.grid.proximity_to_apple()\\n inputs = [\\n torch.tensor([\\n [\\n proximity,\\n self.grid.safe_cells_up_global(),\\n self.grid.safe_cells_up(),\\n self.grid.apple_is_up_safe(0.5)\\n ]\\n ]),\\n torch.tensor([\\n [\\n proximity,\\n self.grid.safe_cells_down_global(),\\n self.grid.safe_cells_down(),\\n self.grid.apple_is_down_safe(0.5)\\n ]\\n ]),\\n torch.tensor([\\n [\\n proximity,\\n self.grid.safe_cells_left_global(),\\n self.grid.safe_cells_left(),\\n self.grid.apple_is_left_safe(0.5)\\n ]\\n ]),\\n torch.tensor([\\n [\\n proximity,\\n self.grid.safe_cells_right_global(),\\n self.grid.safe_cells_right(),\\n self.grid.apple_is_right_safe(0.5)\\n ]\\n ])\\n ]\\n\\n new_direction = self.split_brain_network.eval(inputs)\\n self.grid.change_direction(new_direction)\\n got_apple = self.grid.next_frame()\\n new_proximity = self.grid.proximity_to_apple()\\n\\n if self.is_training:\\n reward = torch.tensor([-0.5])\\n\\n if self.grid.snake_died():\\n reward = torch.tensor([-1.0])\\n elif got_apple:\\n reward = torch.tensor([1.0])\\n elif new_proximity > proximity:\\n reward = torch.tensor([0.8])\\n\\n self.split_brain_network.update(reward)\",\n \"def solve1(cheese, model, original=0, helper1=1, helper2=2, destination=3):\\n\\n # solve the model if there is only 1 cheese\\n # if model only has 1 cheese then move it from stool 0 to stool 3\\n if cheese == 1:\\n model.move(original, destination)\\n print(model)\\n time.sleep(delay_between_moves)\\n # solve the mdoel with a set of steps when there are 2 cheeses\\n elif cheese == 2:\\n model.move(original, helper1)\\n print(model)\\n time.sleep(delay_between_moves)\\n model.move(original, destination)\\n print(model)\\n time.sleep(delay_between_moves)\\n model.move(helper1, destination)\\n print(model)\\n time.sleep(delay_between_moves)\\n # solve the model if there is more than 2 cheeses\\n # 1. first move all but 2 cheeses to stool 2 using stool 1 and stool 3\\n # as helper tools\\n # 2. Then use predefined steps to move the 2 cheeses from stool 0 to stool 3\\n # 3. Then move all the cheeses that were left on stool 2 from step 1 to\\n # stool 3 using stool 0 and stool 1 as helper stools\\n else:\\n solve1(cheese - 2, model, original, helper1, destination, helper2)\\n model.move(original, helper1)\\n print(model)\\n time.sleep(delay_between_moves)\\n model.move(original, destination)\\n print(model)\\n time.sleep(delay_between_moves)\\n model.move(helper1, destination)\\n print(model)\\n time.sleep(delay_between_moves)\\n solve1(cheese - 2, model, helper2, original, helper1, destination)\",\n \"def action(self):\\n # TODO: Decide what action to take, and return it\\n\\n # Minimax: For each white tokens on the board, there are 4 different directions to move to.\\n colour = \\\"blacks\\\" if self.colour == \\\"white\\\" else \\\"whites\\\"\\n eval, action = minimax(self.layout, 6, -13, 13, True, colour, self.colour + \\\"s\\\")\\n return action\",\n \"def ai_move(board, player_id):\\n\\n global boards\\n\\n move = -1\\n root = Node(board, player_id, -1)\\n start = time.time()\\n turn_length = 15\\n while time.time() < start + turn_length:\\n mcts(root)\\n\\n best_score = -inf\\n print(f\\\"length of children: {len(root.children)}\\\")\\n for child in root.children:\\n if child.wins / child.games > best_score:\\n move = child.move\\n best_score = child.wins / child.games\\n\\n if move == -1:\\n print(\\\"Random move\\\")\\n move = randint(0, 24)\\n\\n board[move] = player_id\\n print(f\\\"Calls to mcts: {boards}\\\")\",\n \"def actions_turn(positions, player1, player2, creatures):\\n\\n attacking = []\\n moving = []\\n\\n # Split the orders within attacks and movements\\n for character in positions:\\n if character in creatures:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n elif character in player1:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n\\n else:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n\\n # Execute the attacks\\n for character in attacking:\\n # First attacking : the creatures\\n if character in creatures:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n # Then the heroes of the first player\\n elif character in player1:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n # Finally the ones of the second player\\n else:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n\\n for character in moving:\\n print(character, moving)\\n # First moving : the creatures\\n if character in creatures:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n # Then the heroes of the first player\\n elif character in player1:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n # Finally the ones of the second player\\n else:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n return player1, player2, positions, creatures\",\n \"def move_to_new_class(self, elements_to_move):\\n for element in elements_to_move:\\n place = self._place[element]\\n place.delete()\\n self.add_class(elements_to_move)\",\n \"def next_move(\\r\\n self,\\r\\n state: TwoPlayerGameState,\\r\\n gui: bool = False,\\r\\n ) -> TwoPlayerGameState:\\r\\n\\r\\n successors = self.generate_successors(state)\\r\\n\\r\\n minimax_value = -np.inf\\r\\n\\r\\n for successor in successors:\\r\\n if self.verbose > 1:\\r\\n print('{}: {}'.format(state.board, minimax_value))\\r\\n\\r\\n successor_minimax_value = self._min_value(\\r\\n successor,\\r\\n self.max_depth_minimax,\\r\\n )\\r\\n\\r\\n if (successor_minimax_value > minimax_value):\\r\\n minimax_value = successor_minimax_value\\r\\n next_state = successor\\r\\n\\r\\n if self.verbose > 0:\\r\\n if self.verbose > 1:\\r\\n print('\\\\nGame state before move:\\\\n')\\r\\n print(state.board)\\r\\n print()\\r\\n print('Minimax value = {:.2g}'.format(minimax_value))\\r\\n\\r\\n return next_state\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55172825","0.53830636","0.537255","0.53636533","0.53437847","0.53437847","0.52932066","0.5251569","0.5240633","0.5203933","0.51793545","0.5154717","0.50856817","0.5070792","0.50352716","0.50260264","0.4998866","0.49944788","0.4988436","0.4984612","0.49742377","0.4970498","0.49661568","0.49660122","0.4960328","0.492652","0.4911554","0.49102223","0.4905687","0.48831335","0.4880997","0.48693684","0.4857612","0.48461404","0.48423287","0.48092985","0.48068282","0.48047835","0.48047823","0.48006567","0.47951502","0.4791588","0.47904977","0.4790272","0.4786646","0.47786754","0.47646356","0.47562185","0.47499287","0.47499236","0.4741125","0.47382867","0.4731133","0.47295827","0.47246557","0.47219515","0.47179624","0.47090858","0.46887386","0.46851224","0.46734285","0.467059","0.46699423","0.46656463","0.46589664","0.465537","0.465292","0.46518847","0.46317306","0.4630525","0.46301287","0.4620352","0.46195197","0.4618455","0.4615412","0.46127322","0.4608321","0.4606463","0.4593909","0.4591924","0.45906138","0.45895636","0.45893207","0.45878613","0.45851478","0.45847684","0.45792702","0.45780417","0.4572896","0.4565424","0.4561059","0.45593074","0.4558899","0.4557107","0.4556616","0.45475033","0.45458734","0.45415556","0.45399526","0.45378587"],"string":"[\n \"0.55172825\",\n \"0.53830636\",\n \"0.537255\",\n \"0.53636533\",\n \"0.53437847\",\n \"0.53437847\",\n \"0.52932066\",\n \"0.5251569\",\n \"0.5240633\",\n \"0.5203933\",\n \"0.51793545\",\n \"0.5154717\",\n \"0.50856817\",\n \"0.5070792\",\n \"0.50352716\",\n \"0.50260264\",\n \"0.4998866\",\n \"0.49944788\",\n \"0.4988436\",\n \"0.4984612\",\n \"0.49742377\",\n \"0.4970498\",\n \"0.49661568\",\n \"0.49660122\",\n \"0.4960328\",\n \"0.492652\",\n \"0.4911554\",\n \"0.49102223\",\n \"0.4905687\",\n \"0.48831335\",\n \"0.4880997\",\n \"0.48693684\",\n \"0.4857612\",\n \"0.48461404\",\n \"0.48423287\",\n \"0.48092985\",\n \"0.48068282\",\n \"0.48047835\",\n \"0.48047823\",\n \"0.48006567\",\n \"0.47951502\",\n \"0.4791588\",\n \"0.47904977\",\n \"0.4790272\",\n \"0.4786646\",\n \"0.47786754\",\n \"0.47646356\",\n \"0.47562185\",\n \"0.47499287\",\n \"0.47499236\",\n \"0.4741125\",\n \"0.47382867\",\n \"0.4731133\",\n \"0.47295827\",\n \"0.47246557\",\n \"0.47219515\",\n \"0.47179624\",\n \"0.47090858\",\n \"0.46887386\",\n \"0.46851224\",\n \"0.46734285\",\n \"0.467059\",\n \"0.46699423\",\n \"0.46656463\",\n \"0.46589664\",\n \"0.465537\",\n \"0.465292\",\n \"0.46518847\",\n \"0.46317306\",\n \"0.4630525\",\n \"0.46301287\",\n \"0.4620352\",\n \"0.46195197\",\n \"0.4618455\",\n \"0.4615412\",\n \"0.46127322\",\n \"0.4608321\",\n \"0.4606463\",\n \"0.4593909\",\n \"0.4591924\",\n \"0.45906138\",\n \"0.45895636\",\n \"0.45893207\",\n \"0.45878613\",\n \"0.45851478\",\n \"0.45847684\",\n \"0.45792702\",\n \"0.45780417\",\n \"0.4572896\",\n \"0.4565424\",\n \"0.4561059\",\n \"0.45593074\",\n \"0.4558899\",\n \"0.4557107\",\n \"0.4556616\",\n \"0.45475033\",\n \"0.45458734\",\n \"0.45415556\",\n \"0.45399526\",\n \"0.45378587\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62191063"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9294,"cells":{"query":{"kind":"string","value":"Minimax algorithm equipped in prunning functionality and wrapped into Ticktactoe game environment."},"document":{"kind":"string","value":"def minimax(self, depth: int, alpha: float, beta: float, maximizing_player: bool) -> float:\r\n if self.check_if_win('x' if maximizing_player is True else 'o'):\r\n return -10 if maximizing_player else 10\r\n if self.full_board():\r\n return 1\r\n if depth == 0:\r\n return 0\r\n\r\n available_moves = self.check_for_moves()\r\n\r\n if maximizing_player:\r\n max_eval = -INFINITY\r\n for move in available_moves:\r\n self.tags[move[0]][move[1]] = 'o'\r\n evaluation = self.minimax(depth - 1, alpha, beta, False)\r\n self.tags[move[0]][move[1]] = None\r\n max_eval = max(max_eval, evaluation)\r\n alpha = max(alpha, evaluation)\r\n if beta <= alpha:\r\n break\r\n return max_eval\r\n\r\n else:\r\n min_eval = INFINITY\r\n for move in available_moves:\r\n self.tags[move[0]][move[1]] = 'x'\r\n evaluation = self.minimax(depth - 1, alpha, beta, True)\r\n self.tags[move[0]][move[1]] = None\r\n min_eval = min(min_eval, evaluation)\r\n beta = min(beta, evaluation)\r\n if beta <= alpha:\r\n break\r\n return min_eval"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iterative_minimax_strategy(game: Any) -> Any:\n s = Stack()\n id0 = 0\n d = {0: Tree([id0, game, None])}\n s.add(0)\n\n while not s.is_empty():\n id1 = s.remove()\n item = [id1]\n if d[id1].children == []:\n for move in d[id1].value[1].current_state.get_possible_moves():\n game1 = copy.deepcopy(d[id1].value[1])\n game1.current_state = game1.current_state.make_move(move)\n id0 += 1\n d[id0] = Tree([id0, game1, None])\n d[id1].children.append(id0)\n item.append(id0)\n else:\n item.extend(d[id1].children)\n for num in item:\n if d[num].value[1].is_over(d[num].value[1].current_state):\n d[num].value[2] = -1\n elif d[num].children != [] and all(d[x].value[2] is not None\n for x in d[num].children):\n d[num].value[2] = max([(-1) * d[y].value[2]\n for y in d[num].children])\n else:\n s.add(num)\n i = 0\n for q in d[0].children:\n if d[q].value[2] == -1:\n i = d[0].children.index(q)\n return game.current_state.get_possible_moves()[i]","def minimax(board):\n\n current_player = player(board)","def get_ai_move_minimax(self, gamestate, depth, current_player):\n multiplier = 1 if current_player else -1\n # Base case\n if depth == 0:\n return (\n self.evaluate_board(\n gamestate.board,\n gamestate.white_checkmate,\n gamestate.black_checkmate,\n gamestate.stalemate,\n )\n * multiplier\n )\n\n best_score = self.BLACK_CHECKMATE\n for move in gamestate.get_valid_moves():\n # Execute the move\n (current_row, current_column), (new_row, new_column) = move\n current_piece = gamestate.board.board[current_row][current_column]\n piece_at_new_square = gamestate.board.board[new_row][new_column]\n\n gamestate.board.board[current_row][current_column] = None\n gamestate.board.board[new_row][new_column] = current_piece\n\n # Update King's location\n if isinstance(current_piece, King):\n if current_player:\n gamestate.white_king_location = (new_row, new_column)\n else:\n gamestate.black_king_location = (new_row, new_column)\n\n # Execute pawn promotion\n elif isinstance(current_piece, Pawn):\n if current_piece.colour and new_row == 0:\n new_piece = Queen(new_row, new_column, True)\n gamestate.board.white_pieces.remove(current_piece)\n gamestate.board.white_pieces.append(new_piece)\n gamestate.board.board[new_row][new_column] = new_piece\n\n elif not current_piece.colour and new_row == 7:\n new_piece = Queen(new_row, new_column, False)\n gamestate.board.black_pieces.remove(current_piece)\n gamestate.board.black_pieces.append(new_piece)\n gamestate.board.board[new_row][new_column] = new_piece\n\n # Switch player\n gamestate.current_player_colour = not gamestate.current_player_colour\n\n if current_piece is None:\n return self.BLACK_CHECKMATE\n\n current_piece.row = new_row\n current_piece.column = new_column\n\n if piece_at_new_square:\n if piece_at_new_square.colour:\n gamestate.board.white_pieces.remove(piece_at_new_square)\n else:\n gamestate.board.black_pieces.remove(piece_at_new_square)\n\n gamestate.is_checkmate_or_stalemate()\n gamestate.check_draw()\n\n # Evaluate score for gamestate recursively\n score = -1 * self.get_ai_move_minimax(\n gamestate, depth - 1, not current_player\n )\n\n # Undo the move\n gamestate.board.board[current_row][current_column] = current_piece\n gamestate.board.board[new_row][new_column] = piece_at_new_square\n\n if isinstance(current_piece, King):\n if current_player:\n gamestate.white_king_location = (current_row, current_column)\n else:\n gamestate.black_king_location = (current_row, current_column)\n\n # Undo pawn promotion\n elif isinstance(current_piece, Pawn):\n if current_piece.colour and new_row == 0:\n gamestate.board.white_pieces.append(current_piece)\n gamestate.board.white_pieces.remove(new_piece)\n elif not current_piece.colour and new_row == 7:\n gamestate.board.black_pieces.append(current_piece)\n gamestate.board.black_pieces.remove(new_piece)\n\n # Switch player back\n gamestate.current_player_colour = not gamestate.current_player_colour\n\n current_piece.row = current_row\n current_piece.column = current_column\n\n if piece_at_new_square:\n if piece_at_new_square.colour:\n gamestate.board.white_pieces.append(piece_at_new_square)\n else:\n gamestate.board.black_pieces.append(piece_at_new_square)\n\n gamestate.white_checkmate = False\n gamestate.black_checkmate = False\n gamestate.stalemate = False\n\n # Check if best score and update list of best moves\n if score > best_score:\n best_score = score\n if depth == self.DEPTH:\n self.minimax_best_moves = [move]\n\n elif score == best_score and depth == self.DEPTH:\n self.minimax_best_moves.append(move)\n\n return best_score","def test_minimax_interface(self):\n h, w = 7, 7 # board size\n test_depth = 1\n starting_location = (5, 3)\n adversary_location = (0, 0) # top left corner\n iterative_search = False\n search_method = \"minimax\"\n heuristic = lambda g, p: 0. # return 0 everywhere\n\n # create a player agent & a game board\n agentUT = game_agent.CustomPlayer(\n test_depth, heuristic, iterative_search, search_method)\n agentUT.time_left = lambda: 99 # ignore timeout for fixed-depth search\n board = isolation.Board(agentUT, 'null_agent', w, h)\n\n # place two \"players\" on the board at arbitrary (but fixed) locations\n board.apply_move(starting_location)\n board.apply_move(adversary_location)\n\n for move in board.get_legal_moves():\n next_state = board.forecast_move(move)\n v, _ = agentUT.minimax(next_state, test_depth)\n\n self.assertTrue(type(v) == float,\n (\"Minimax function should return a floating \" +\n \"point value approximating the score for the \" +\n \"branch being searched.\"))","def play_against_minimax():\n global FIRST_MOVE\n global done\n done = False\n g = Game()\n turn = np.random.randint(2)\n # if turn == RED:\n # FIRST_MOVE = False\n transitions_agent = []\n agent.epsilon = agent.eps_min\n while done == False:\n g.printBoard()\n # print(g.board)\n if turn == PLAYER:\n row = input('{}\\'s turn:'.format('Red'))\n g.insert(int(row), PLAYER_PIECE)\n else:\n observation = []\n obs = np.zeros((6, 7))\n for row, sublist in enumerate(g.board):\n for col, i in enumerate(sublist):\n observation.append(i)\n obs[col, row] = i\n\n observation = np.asarray(observation)\n action, _ = minimax(np.flipud(obs), 5, -math.inf, math.inf, True)\n if g.check_if_action_valid(action):\n print('{}\\'s turn: %d'.format('Yellow') % action)\n g.insert(action, AI_PIECE)\n else:\n while g.check_if_action_valid(action) == False:\n agent.store_transition(observation, action, -100, observation, done)\n action = np.random.randint(7)\n print('{}\\'s turn: %d'.format('Yellow') % action)\n g.insert(action, AI_PIECE)\n observation_ = []\n for sublist in g.board:\n for i in sublist:\n observation_.append(i)\n observation_ = np.asarray(observation_)\n transitions_agent += [(observation, action, observation_, done)]\n turn = (turn + 1) % 2\n return","def minimax(board):\n #This function will return the best move. \n #If Ai is playing as X, I can reduce the processing time by creating a random first move. \n if (board == initial_state()):\n coord1 = randint(0,2)\n coord2 = randint(0,2)\n return ((coord1,coord2))\n #first I determine which player's turn it is\n player_to_move = player(board)\n best_action = None\n #If I am X\n if(player_to_move == \"X\"):\n current_max = float('-inf')\n #for every possible action I have right now, I'll call my \"future\" Min_Value since I will asume what will happen if I take this move.\n for action in actions(board):\n #peak on the future if I take that move\n curr_score = Min_Value(result(board,action))\n #if my future is favorable, I will store it as my current best option.\n if curr_score>= current_max:\n current_max = curr_score\n best_action = action\n else:\n #If I am O, I do something similar. \n current_max = float('inf')\n #for every action I peak on the future for favorable results\n for action in actions(board):\n #this time, however, it would be X's turn so I need to start with Max_Value\n curr_score = Max_Value(result(board,action))\n #if my future is favorable, I store it\n if curr_score<= current_max:\n current_max = curr_score\n best_action = action\n #I return the best move.\n return best_action","def minimax(gamestate, depth, timeTotal, alpha, beta, maxEntity):\n\n bonus = 0\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\n # Basis Rekursif\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\n bonus = 10\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\n bonus = -10\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\n\n # Rekurens\n if (gamestate.currentPlayer.noPlayer == maxEntity):\n # Choose the maximum utility of the state\n # Iterate all pion and its possible moves\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n maxValue = -math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n # Iterate all possible moves of pion index\n for move in all_possible_moves:\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old max value\n if (utility > maxValue):\n maxValue = utility\n maxGameState = newGameState\n \n alpha = max(alpha, maxValue)\n if (beta <= alpha):\n return maxGameState, maxValue\n return maxGameState, maxValue\n\n else:\n # Choose the minimum utility of the state\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n minValue = math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n # Iterate all possible moves of pion index\n for move in all_possible_moves:\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old min value\n if (utility < minValue):\n minValue = utility\n minGameState = newGameState\n \n beta = min(beta, minValue)\n if (beta <= alpha):\n return minGameState, minValue\n \n return minGameState, minValue","def run_ai():\n print(\"Minimax AI\") # First line is the name of this AI \n color = int(input()) # Then we read the color: 1 for dark (goes first), \n # 2 for light. \n\n while True: # This is the main loop \n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input() \n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n\n if status == \"FINAL\": # Game is over. \n print \n else: \n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The \n # squares in each row are represented by \n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n \n # Select the move and send it to the manager\n movei, movej = select_move_minimax(board, color)\n # movei, movej = select_move_alphabeta(board, color)\n print(\"{} {}\".format(movei, movej))","def recursive_minimax_strategy(game: Any) -> Any:\n lista = []\n if game.current_state.p1_turn:\n for i in game.current_state.get_possible_moves():\n game2 = copy.deepcopy(game)\n new_state = game2.current_state.make_move(i)\n game2.current_state = new_state\n lista.append(recursive1(game2, []))\n\n else:\n for i in game.current_state.get_possible_moves():\n game2 = copy.deepcopy(game)\n new_state = game2.current_state.make_move(i)\n game2.current_state = new_state\n lista.append(recursive2(game2, []))\n\n if 1 in lista:\n return game.current_state.get_possible_moves()[lista.index(1)]\n return game.current_state.get_possible_moves()[0]","def action(self):\r\n\r\n\r\n #have we just started?\r\n if self.player_information[\"us\"][\"nTokens\"] == 0:\r\n move = generate_starting_move(self.player_information[\"us\"][\"player_side\"], self.board_array)\r\n return move\r\n\r\n #otherwise do minimax \r\n \r\n #start off with some shallow depth:\r\n if self.turn_no < 5:\r\n depth = 3\r\n else:\r\n depth = 2\r\n \r\n #set a constraint for search depth\r\n if self.total_tokens_on_board < 6:\r\n depth = 3\r\n elif self.total_tokens_on_board < 10:\r\n depth = 2\r\n else:\r\n depth = 1\r\n \r\n #have a time reference\r\n print(f'nthrows: {self.player_information[\"us\"][\"nThrowsRemaining\"]}')\r\n starting_time = int(round(time.time(), 0))\r\n #salvage result from minimax\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, depth, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, True, self.turn_no)\r\n\r\n #clean it up a bit \r\n print(self.board_dict)\r\n #tidy it up\r\n result = result[0]\r\n print(f'pre: {result}')\r\n #in case we get a bad move redo but make it very shallow\r\n if len(result) == 1 or result == (-5, -5):\r\n #force it to return a usable move\r\n counter = 0\r\n while (len(result) == 1) or (result == (-5, -5)):\r\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\r\n None, None, None, 1, True, -math.inf, math.inf,\r\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \r\n starting_time, False, self.turn_no)\r\n result = result[0]\r\n counter += 1\r\n \r\n #if its taking too long\r\n if counter > 2: \r\n #generate one random possible move to use \r\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \"us\"]\r\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\r\n self.player_information, self.board_array, True, \"all\")\r\n \r\n \r\n #if there are no moves\r\n if len(move_list) == 0:\r\n if self.player_information['us']['nThrowsRemaining'] > 0:\r\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \"us\",\r\n self.player_information[\"us\"][\"player_side\"], self.board_array, \"all\" )\r\n result = random.choice(throws)\r\n \r\n else:\r\n result = random.choice(move_list)\r\n print(f'random: {result}')\r\n break\r\n\r\n print(f' inside: {result}')\r\n\r\n print(result)\r\n #otherwise clean it up\r\n if result[0] == 'throw':\r\n final_result = (result[0].upper(), result[1], result[2])\r\n else:\r\n final_result = (result[0].upper(), result[2], result[3])\r\n # return final result \r\n return final_result","def minimaxTest(yourAgent, minimax_fn):\n\n # create dummy 5x5 board\n print(\"Now running the Minimax test.\")\n print()\n try:\n def time_left(): # For these testing purposes, let's ignore timeouts\n return 10000\n\n player = yourAgent() #using as a dummy player to create a board\n sample_board = Board(player, RandomPlayer())\n # setting up the board as though we've been playing\n board_state = [\n [\"Q1\", \" \", \" \", \" \", \" \", \"X\", \" \"],\n [\" \", \" \", \" \", \" \", \" \", \" \", \" \"],\n [\"X\", \" \", \" \", \" \", \" \", \" \", \" \"],\n [\" \", \" \", \"X\", \"Q2\", \"X\", \" \", \" \"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \" \", \" \"],\n [\" \", \" \", \"X\", \" \", \"X\", \" \", \" \"],\n [\" \", \" \", \"X\", \" \", \"X\", \" \", \" \"]\n ]\n sample_board.set_state(board_state, True)\n\n test_pass = True\n\n expected_depth_scores = [(1, 4), (2, -2), (3, 4), (4, -2), (5, 2)]\n\n for depth, exp_score in expected_depth_scores:\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\n if exp_score != score:\n print(\"Minimax failed for depth: \", depth)\n test_pass = False\n\n if test_pass:\n player = yourAgent()\n sample_board = Board(player, RandomPlayer())\n # setting up the board as though we've been playing\n board_state = [\n [\" \", \" \", \" \", \" \", \"X\", \" \", \"X\"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \"Q2\", \" \"],\n [\" \", \"X\", \"X\", \" \", \"X\", \" \", \" \"],\n [\"X\", \"X\", \"X\", \" \", \"X\", \"X\", \" \"],\n [\"X\", \" \", \"Q1\", \" \", \"X\", \" \", \"X\"],\n [\"X\", \" \", \" \", \" \", \"X\", \"X\", \" \"],\n [\"X\", \" \", \" \", \" \", \"X\", \" \", \" \"]\n ]\n sample_board.set_state(board_state, True)\n\n test_pass = True\n\n expected_depth_scores = [(1, 5), (2, 5), (3, 5), (4, 6), (5, 6)]\n\n for depth, exp_score in expected_depth_scores:\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\n if exp_score != score:\n print(\"Minimax failed for depth: \", depth)\n test_pass = False\n\n if test_pass:\n print(\"Minimax Test: Runs Successfully!\")\n\n except NotImplementedError:\n print('Minimax Test: Not implemented')\n except:\n print('Minimax Test: ERROR OCCURRED')\n print(traceback.format_exc())","def minimax(board: list, player_turn: chr):\n if player_turn == 'b':\n enemy_turn = 'w'\n else:\n enemy_turn = 'b'\n player_moves, enemy_start_boards = Evaluator.generate_options(board, player_turn)\n\n player_scores = [x.get(\"final_score\") for x in player_moves]\n enemy_scores = []\n\n for enemy_start_board in enemy_start_boards:\n board_index = enemy_start_boards.index(enemy_start_board)\n player_score = player_scores[board_index]\n enemy_moves, player_start_boards = Evaluator.generate_options(enemy_start_board, enemy_turn)\n\n # Gets highest white score for first board.\n if enemy_start_boards.index(enemy_start_board) == 0:\n best_enemy_score = -10000000\n for move in enemy_moves:\n score = move.get(\"final_score\") - player_score\n if score > best_enemy_score:\n best_enemy_score = score\n enemy_scores.append(best_enemy_score)\n else:\n current_min = min(enemy_scores)\n best_enemy_score = -10000000\n break_flag = False\n\n # Checks moves where active player performs push, more likely to yield high score -> move ordering.\n push_moves = filter(Evaluator.filter_push, enemy_moves)\n for move in push_moves:\n score = move.get(\"final_score\") - player_score\n if score > current_min:\n enemy_scores.append(score)\n break_flag = True\n break\n if break_flag:\n continue\n\n for move in enemy_moves:\n if move.get(\"pushes\") > 0:\n continue\n score = move.get(\"final_score\") - player_score\n if score > current_min:\n enemy_scores.append(score)\n break_flag = True\n break\n if score > best_enemy_score:\n best_enemy_score = score\n if not break_flag:\n enemy_scores.append(best_enemy_score)\n # print(enemy_start_board)\n # [print(x) for x in enemy_moves]\n # print(\"======================\")\n\n # Gets the lowest score aka worst board state for the opponent which will be the best move for us.\n min_val = min(enemy_scores)\n check_scores = numpy.array(enemy_scores)\n min_index = numpy.where(check_scores == min_val)[0]\n\n best_index = 0\n best_score = -100000\n\n for i in min_index:\n if player_moves[i].get(\"final_score\") > best_score:\n best_score = player_moves[i].get(\"final_score\")\n best_index = i\n\n return player_moves[best_index]","def run_ai():\n print(\"Othello AI\") # First line is the name of this AI\n arguments = input().split(\",\")\n \n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \n limit = int(arguments[1]) #Depth limit\n minimax = int(arguments[2]) #Minimax or alpha beta\n caching = int(arguments[3]) #Caching \n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\n\n if (minimax == 1): eprint(\"Running MINIMAX\")\n else: eprint(\"Running ALPHA-BETA\")\n\n if (caching == 1): eprint(\"State Caching is ON\")\n else: eprint(\"State Caching is OFF\")\n\n if (ordering == 1): eprint(\"Node Ordering is ON\")\n else: eprint(\"Node Ordering is OFF\")\n\n if (limit == -1): eprint(\"Depth Limit is OFF\")\n else: eprint(\"Depth Limit is \", limit)\n\n if (minimax == 1 and ordering == 1): eprint(\"Node Ordering should have no impact on Minimax\")\n\n while True: # This is the main loop\n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input()\n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over.\n print\n else:\n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The\n # squares in each row are represented by\n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n\n # Select the move and send it to the manager\n if (minimax == 1): #run this if the minimax flag is given\n movei, movej = select_move_minimax(board, color, limit, caching)\n else: #else run alphabeta\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\n \n print(\"{} {}\".format(movei, movej))","def run_ai():\n print(\"Othello AI\") # First line is the name of this AI\n arguments = input().split(\",\")\n \n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \n limit = int(arguments[1]) #Depth limit\n minimax = int(arguments[2]) #Minimax or alpha beta\n caching = int(arguments[3]) #Caching \n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\n\n if (minimax == 1): eprint(\"Running MINIMAX\")\n else: eprint(\"Running ALPHA-BETA\")\n\n if (caching == 1): eprint(\"State Caching is ON\")\n else: eprint(\"State Caching is OFF\")\n\n if (ordering == 1): eprint(\"Node Ordering is ON\")\n else: eprint(\"Node Ordering is OFF\")\n\n if (limit == -1): eprint(\"Depth Limit is OFF\")\n else: eprint(\"Depth Limit is \", limit)\n\n if (minimax == 1 and ordering == 1): eprint(\"Node Ordering should have no impact on Minimax\")\n\n while True: # This is the main loop\n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input()\n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over.\n print\n else:\n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The\n # squares in each row are represented by\n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n\n # Select the move and send it to the manager\n if (minimax == 1): #run this if the minimax flag is given\n movei, movej = select_move_minimax(board, color, limit, caching)\n else: #else run alphabeta\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\n \n print(\"{} {}\".format(movei, movej))","def play_minimax(minimax_dep):\n global win_cntr\n global lose_cntr\n global done\n global vertical_win\n vertical_win = False\n g = Game()\n turn = np.random.randint(2)\n done = False\n transitions_agent = []\n transitions_agent2 = []\n while done == False:\n #g.printBoard()\n\n # Player 1 dqn agent\n if turn == PLAYER:\n observation = []\n for row, sublist in enumerate(g.board):\n for col, obs in enumerate(sublist):\n observation.append(obs)\n\n observation = np.asarray(observation)\n action = agent.choose_action(observation)\n if g.check_if_action_valid(action):\n g.insert(action, PLAYER_PIECE)\n else:\n while g.check_if_action_valid(action) == False:\n agent.store_transition(observation, action, -100, observation, done)\n action = np.random.randint(7)\n g.insert(action, PLAYER_PIECE)\n observation_ = []\n for sublist in g.board:\n for obs in sublist:\n observation_.append(obs)\n observation_ = np.asarray(observation_)\n transitions_agent2 += [(observation, action, observation_, done)]\n\n # Player 2 Minimax\n else:\n observation = []\n obs = np.zeros((6, 7))\n for row, sublist in enumerate(g.board):\n for col, sub in enumerate(sublist):\n observation.append(sub)\n obs[col, row] = sub\n\n observation = np.asarray(observation)\n\n if minimax_dep > 0: #and np.random.rand(1) > 0.05\n action, _ = minimax(np.flipud(obs), minimax_dep, -math.inf, math.inf, True)\n else:\n action = np.random.randint(7)\n\n if g.check_if_action_valid(action):\n g.insert(action, AI_PIECE)\n else:\n while not g.check_if_action_valid(action):\n agent.store_transition(observation, action, -100, observation, done)\n action = np.random.randint(7)\n\n g.insert(action, AI_PIECE)\n\n observation_ = []\n for sublist in g.board:\n for sub in sublist:\n observation_.append(sub)\n observation_ = np.asarray(observation_)\n transitions_agent += [(observation, action, observation_, done)]\n turn = (turn + 1) % 2\n\n if g.getWinner() == Tie:\n #reward_minimax = -1\n reward_nn = -1\n else:\n winner = AI if turn == PLAYER else PLAYER\n\n if winner == AI:\n lose_cntr += 1\n #reward_minimax = 20\n reward_nn = -20\n else:\n win_cntr += 1\n #reward_minimax = -20\n reward_nn = 20\n\n '''for obs in range(len(transitions_agent)):\n agent.store_transition(transitions_agent[obs][0], transitions_agent[obs][1], reward_minimax,\n transitions_agent[obs][2], transitions_agent[obs][3])'''\n for i in range(len(transitions_agent2)):\n agent.store_transition(transitions_agent2[i][0], transitions_agent2[i][1], reward_nn, transitions_agent2[i][2],\n transitions_agent2[i][3])\n agent.learn()\n return","def test_solve_one_player_1(self):\n self.rush_hour_data = rush_hour_data_1\n self.state_data = state_data_1\n self.execute_minimax_single_player()","def minimax(self, board: str):\n \"\"\" Your Code Here \"\"\"\n\n # ----------------------------BEGIN CODE----------------------------\n # disclaimer: I did only minimax (as said on the homework description https://drive.google.com/file/d/1JXBi_5JB8fwTWX34j0ZwN5YwjoIexh-Z/view)\n # my minimax does NOT try to prolong the game. It always goes for the best move!\n\n # initializing default values\n moveToMake = validMoves(board)[0]\n bestValue = -100\n\n # this will find the best move to go to, since value only returns the best score\n # util's setMove creates a copy, so we can use that as the successor\n for validmove in validMoves(board):\n currentValue = self.value(\n setMove(board, validmove, whoseMove(board)), 0)\n if currentValue > bestValue:\n bestValue = currentValue\n moveToMake = validmove\n\n # currently the val and game_length tuple is arbitrary because i have not implemented depth!\n return (moveToMake)","def minimaxLocalSearch(gamestate, depth, timeTotal, alpha, beta, maxEntity):\n bonus = 0\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\n # Basis Rekursif\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\n bonus = 10\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\n bonus = -10\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\n\n # Rekurens\n if (gamestate.currentPlayer.noPlayer == maxEntity):\n # Choose the maximum utility of the state\n # Iterate all pion and its possible moves\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n maxValue = -math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n # Choose the best move from local search heuristic\n if (len(all_possible_moves) > 0):\n move = getBestMove(all_possible_moves, gamestate)\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n \n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimaxLocalSearch(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old max value\n if (utility > maxValue):\n maxValue = utility\n maxGameState = newGameState\n \n alpha = max(alpha, maxValue)\n if (beta <= alpha):\n return maxGameState, maxValue\n\n return maxGameState, maxValue\n\n else:\n # Choose the minimum utility of the state\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n minValue = math.inf\n\n # Iterate all pion index\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\n\n if (len(all_possible_moves) > 0):\n # Choose the best move from local search heuristic\n move = getBestMove(all_possible_moves, gamestate)\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\n\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\n recursiveState.nextTurn()\n dummyState, utility = minimaxLocalSearch(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\n\n # Compare with the old min value\n if (utility < minValue):\n minValue = utility\n minGameState = newGameState\n \n beta = min(beta, minValue)\n if (beta <= alpha):\n return minGameState, minValue\n \n return minGameState, minValue","def utility(state:State,maximizing_player):\n best_move_score = -1\n #######################[Goal]#########################\n is_current_player_stuck = is_stuck(state,state.player_type)\n other_player = RIVAL if state.player_type == PLAYER else PLAYER\n # Check if stuck\n if is_current_player_stuck:\n if state.player_type == PLAYER:\n state.players_score[state.player_type] -= state.penalty_score\n else:\n state.players_score[state.player_type] += state.penalty_score\n return state.players_score[state.player_type] - state.players_score[other_player] \n ######################################################\n # Else\n #--------------------------------------------------\n ################# Available Steps #################\n #--------------------------------------------------\n player_available_steps = availables(state.board, state.locations[PLAYER])\n h1 = 4-player_available_steps\n h4 = player_available_steps\n #--------------------------------------------------\n ################# Fruits Distance #################\n #--------------------------------------------------\n h2 = -1\n if state.fruits_ttl > 0 and len(state.fruits_dict) > 0:\n min_fruit_dist = float('inf')\n for fruit_loc in state.fruits_dict:\n curr_fruit_dist = Manhattan(state.locations[state.player_type], fruit_loc)\n # Check what is the closest fruit reachable\n if curr_fruit_dist < min_fruit_dist and curr_fruit_dist <= state.fruits_ttl:\n other_player_fruit_dist = Manhattan(state.locations[other_player], fruit_loc)\n if curr_fruit_dist < other_player_fruit_dist:\n min_fruit_dist = curr_fruit_dist\n max_dist = len(state.board)+len(state.board[0])\n h2 = (max_dist*10.0/min_fruit_dist)+1 if min_fruit_dist < float('inf') else -1\n #--------------------------------------------------\n ################# Reachable Squrs #################\n #--------------------------------------------------\n reachables_player = reachables(state.board,state.locations[PLAYER])\n reachables_rival = reachables(state.board,state.locations[RIVAL])\n h3 = reachables_player - reachables_rival # We want more for us\n #--------------------------------------------------\n ################# Combine it all. #################\n #--------------------------------------------------\n if not state.half_game():\n w = 0.8 if h2 > 0 else 1\n best_move_score = w*(h1-h3) + (1-w)*h2 \n else:\n w = 0.7 if h2 > 0 else 1\n best_move_score = w*(h4+h3) + (1-w)*h2 \n\n best_move_score += state.players_score[state.player_type]\n return best_move_score","def iterative_minimax(game: Any):\n moves_scores = []\n moves = game.current_state.get_possible_moves()\n\n for move in moves:\n g = copy.deepcopy(game)\n s = g.current_state.make_move(move)\n g.current_state = s\n\n moves_scores.append(-1*iterative_helper(g))\n\n return moves[moves_scores.index(max(moves_scores))]","def test_minimax(self):\n h, w = 7, 7 # board size\n starting_location = (2, 3)\n adversary_location = (0, 0) # top left corner\n iterative_search = False\n method = \"minimax\"\n\n # The agent under test starts at position (2, 3) on the board, which\n # gives eight (8) possible legal moves [(0, 2), (0, 4), (1, 1), (1, 5),\n # (3, 1), (3, 5), (4, 2), (4, 4)]. The search function will pick one of\n # those moves based on the estimated score for each branch. The value\n # only changes on odd depths because even depths end on when the\n # adversary has initiative.\n value_table = [[0] * w for _ in range(h)]\n value_table[1][5] = 1 # depth 1 & 2\n value_table[4][3] = 2 # depth 3 & 4\n value_table[6][6] = 3 # depth 5\n heuristic = makeEvalTable(value_table)\n\n # These moves are the branches that will lead to the cells in the value\n # table for the search depths.\n expected_moves = [set([(1, 5)]),\n set([(3, 1), (3, 5)]),\n set([(3, 5), (4, 2)])]\n\n # Expected number of node expansions during search\n counts = [(8, 8), (24, 10), (92, 27), (418, 32), (1650, 43)]\n\n # Test fixed-depth search; note that odd depths mean that the searching\n # player (student agent) has the last move, while even depths mean that\n # the adversary has the last move before calling the heuristic\n # evaluation function.\n for idx in range(5):\n test_depth = idx + 1\n agentUT, board = self.initAUT(test_depth, heuristic,\n iterative_search, method,\n loc1=starting_location,\n loc2=adversary_location)\n\n # disable search timeout by returning a constant value\n agentUT.time_left = lambda: 1e3\n _, move = agentUT.minimax(board, test_depth)\n\n num_explored_valid = board.counts[0] == counts[idx][0]\n num_unique_valid = board.counts[1] == counts[idx][1]\n\n self.assertTrue(num_explored_valid, WRONG_NUM_EXPLORED.format(\n method, test_depth, counts[idx][0], board.counts[0]))\n\n self.assertTrue(num_unique_valid, UNEXPECTED_VISIT.format(\n method, test_depth, counts[idx][1], board.counts[1]))\n\n self.assertIn(move, expected_moves[idx // 2], WRONG_MOVE.format(\n method, test_depth, expected_moves[idx // 2], move))","def minimax(board):\n current_player = player(board)\n \n if terminal(board):\n return \n if current_player == X:\n optimal_value = -math.inf\n \n else:\n optimal_value = math.inf\n \n for action in actions(board):\n new_board = result(board, action)\n \n minimax_value = minimax_aux(new_board, optimal_value)\n\n if current_player == X:\n minimax_value = max(optimal_value, minimax_value)\n\n if current_player == O:\n minimax_value = min(optimal_value, minimax_value)\n\n if optimal_value != minimax_value:\n optimal_value = minimax_value\n optimal_move = action\n\n return optimal_move","def recursive_minimax_strategy(game: Game) -> Any:\n candidate = game.current_state.get_possible_moves()\n canditate_prop = [\n -1 * get_state_score(game, game.current_state.make_move(\n move\n ))\n # get_state_score() provides the STATE SCORE for the OPPO player\n # in each resultent state.\n # -1 * ... to calculate the STATE SCORE for player taking action now.\n for move in candidate\n ]\n max_index = canditate_prop.index(max(canditate_prop))\n assert len(canditate_prop) == len(candidate), \"Inconsistent length.\"\n return candidate[max_index]","def minimax(self, game, depth):\n \n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n \n return self.minimax_helper(game, self.search_depth, maximizing_player = True)[1]","def minimax(board):\r\n player_moving = player(board)\r\n\r\n\r\n if board == [[EMPTY] * 3] * 3:\r\n return (0, 0)\r\n\r\n if player_moving == X:\r\n value = -math.inf\r\n selected_action = None\r\n for action in actions(board):\r\n minValueResult = minValue(result(board, action))\r\n if minValueResult > value:\r\n value = minValueResult\r\n selected_action = action\r\n elif player_moving == O:\r\n value = math.inf\r\n selected_action = None\r\n for action in actions(board):\r\n maxValueResult = maxValue(result(board, action))\r\n if maxValueResult < value:\r\n value = maxValueResult\r\n selected_action = action\r\n\r\n return selected_action","def test_solve_one_player_2(self):\n self.rush_hour_data = rush_hour_data_2\n self.state_data = state_data_2\n self.execute_minimax_single_player()","def test_minimax(self):\n \n # empty board\n board = \"EEEEEEEEE\"\n res = MinimaxApiView.get_next_move(board, 'O')\n self.assertEqual(res, 0)\n board = \"OEEEEEEEE\"\n res = MinimaxApiView.get_next_move(board, 'X')\n self.assertEqual(res, 4)","def make_move(self, time_limit, players_score):\n finish_time = time.time() + time_limit\n depth = 1\n best_move = (-np.inf, (-1, 0))\n while True:\n for direction in self.directions:\n initial_state = utils.State(self.board, direction, self.pos, self.current_turn,\n self.fruits_on_board_dict,\n finish_time)\n try:\n outcome = self.minimax_algo.search(initial_state, depth, True)\n if outcome[0] > best_move[0]:\n best_move = outcome\n except TimeoutError:\n self.board[self.pos[0]][self.pos[1]] = -1\n self.pos = (self.pos[0] + best_move[1][0], self.pos[1] + best_move[1][1])\n self.board[self.pos[0]][self.pos[1]] = 1\n\n return best_move[1]\n depth += 1\n # print('bigger_depth : {} '.format(depth))","def test_minimax():\n board = Board(*TEST_AGRU1)\n comp = Computer(board, COMP_DISK, HUMAN_DISK)\n comp.b.board = [\n [COMP_DISK, COMP_DISK, 0, 0, 0],\n [HUMAN_DISK, HUMAN_DISK, HUMAN_DISK, 0, 0],\n ]\n comp.b.columns_list = [\n [COMP_DISK, HUMAN_DISK],\n [COMP_DISK, HUMAN_DISK],\n [HUMAN_DISK],\n [],\n [],\n ]\n comp.b.add_to_board(0, INDEX_TWO, COMP_DISK)\n assert comp.minimax(comp.b, 1, MAX_START_SCORE, MINI_START_SCORE, False) \\\n == -1\n\n board = Board(*TEST_AGRU1)\n comp = Computer(board, COMP_DISK, HUMAN_DISK)\n comp.b.board = [\n [HUMAN_DISK, 0, HUMAN_DISK, HUMAN_DISK, 0],\n [HUMAN_DISK, 0, COMP_DISK, COMP_DISK, COMP_DISK],\n ]\n comp.b.columns_list = [\n [HUMAN_DISK, HUMAN_DISK],\n [],\n [HUMAN_DISK, COMP_DISK],\n [HUMAN_DISK, COMP_DISK],\n [],\n ]\n comp.b.add_to_board(1, 1, COMP_DISK)\n assert comp.minimax(comp.b, 1, MAX_START_SCORE, MINI_START_SCORE, False) \\\n == SCORE","def minimax(board):\n\n if terminal(board):\n return None\n\n action_x = []\n value_x = []\n action_y = []\n value_y = []\n\n def max_value(board):\n v = -float('inf')\n if terminal(board):\n return utility(board)\n\n for action in actions(board):\n v = max(v, min_value(result(board, action)))\n\n\n return v\n\n def min_value(board):\n v = float('inf')\n if terminal(board):\n return utility(board)\n for action in actions(board):\n v = min(v, max_value(result(board, action)))\n\n return v\n\n for action in actions(board):\n if player(board) == X:\n action_x.append(action)\n value_x.append(min_value(result(board, action)))\n\n elif player(board) == O:\n action_y.append(action)\n value_y.append(max_value(result(board, action)))\n\n if player(board) == X:\n return action_x[value_x.index(max(value_x))]\n elif player(board) == O:\n return action_y[value_y.index(min(value_y))]","def play_minimax(self, board, depth, max_player, game):\n if depth == 0 or (game.check_if_over() and game.winner != 0):\n return board.evaluate(), board\n\n elif max_player:\n max_eval = float('-inf')\n best_action = None\n all_valid_actions = self.simulate_all_valid_actions(board, game.board.top_opponent_color)\n random.shuffle(all_valid_actions) # Remove the shuffling if the minimax deapth increases\n for action in all_valid_actions:\n evaluation = self.play_minimax(action, depth-1, False, game)[0]\n max_eval = max(max_eval, evaluation)\n if max_eval == evaluation:\n best_action = action\n return max_eval, best_action\n\n else:\n min_eval = float('inf')\n best_action = None\n all_valid_actions = self.simulate_all_valid_actions(board, game.board.bottom_player_color)\n random.shuffle(all_valid_actions) # Remove the shuffling if the minimax deapth increases\n for action in all_valid_actions:\n evaluation = self.play_minimax(action, depth-1, True, game)[0]\n min_eval = min(min_eval, evaluation)\n if min_eval == evaluation:\n best_action = action\n return min_eval, best_action","def minimax(board):\n if terminal(board):\n return None\n \n # If AI is X, ie, maximizing player\n if player(board) is X:\n _, bestAction = maximum(board, -math.inf, math.inf)\n return bestAction\n elif player(board) is O:\n _, bestAction = minimum(board, -math.inf, math.inf)\n return bestAction","def minimax(board):\n if terminal(board) == True:\n return None\n elif player(board) == X:\n action = maxit(board)[1:]\n elif player(board) == O:\n action = minit(board)[1:]\n return action","def run_ai():\n print(\"Vivian\") # First line is the name of this AI \n color = int(input()) # Then we read the color: 1 for dark (goes first), \n # 2 for light. \n\n while True: # This is the main loop \n # Read in the current game status, for example:\n # \"SCORE 2 2\" or \"FINAL 33 31\" if the game is over.\n # The first number is the score for player 1 (dark), the second for player 2 (light)\n next_input = input() \n status, dark_score_s, light_score_s = next_input.strip().split()\n dark_score = int(dark_score_s)\n light_score = int(light_score_s)\n\n if status == \"FINAL\": # Game is over. \n print \n else: \n board = eval(input()) # Read in the input and turn it into a Python\n # object. The format is a list of rows. The \n # squares in each row are represented by \n # 0 : empty square\n # 1 : dark disk (player 1)\n # 2 : light disk (player 2)\n \n # Select the move and send it to the manager \n# movei, movej = select_move_minimax(board, color)\n movei, movej = select_move_alphabeta(board, color)\n print(\"{} {}\".format(movei, movej))","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n #Fetching legal moves for the active player at max level\n legal_moves = game.get_legal_moves()\n #Terminial condition - if there are no legal moves left will call the utility function\n if not legal_moves:\n return game.utility(self) #Returning utility function\n #Assigning default value to best move\n best_move = legal_moves[0]\n #Assigning default value to best score as -inf\n best_score = float('-inf')\n #for each future legal move of active player\n for move in legal_moves:\n #Fetching next state forecast moves\n next_state = game.forecast_move(move)\n #Calling min_value function for score - Return type of min_value function is score\n score = self.min_value(next_state, depth-1)\n if score > best_score:\n best_move = move\n best_score = score\n return best_move #Return best_move","def test_solve_one_player_3(self):\n self.rush_hour_data = rush_hour_data_3\n self.state_data = state_data_3\n self.execute_minimax_single_player()","def getAction(self, gameState):\n def Minimaxer(sucGameState, depth, curAgent, alpha, beta):\n if sucGameState.isWin() or sucGameState.isLose():\n return self.evaluationFunction(sucGameState)\n if depth == 0:\n return self.evaluationFunction(sucGameState)\n stateValue = 9999\n curDepthCurAgentActions = sucGameState.getLegalActions(curAgent)\n if curAgent == sucGameState.getNumAgents()-1:\n for curAction in curDepthCurAgentActions:\n stateValue = min(stateValue, miniMaxer(sucGameState.generateSuccessor(curAgent,curAction), depth-1, alpha, beta) )\n if alpha > stateValue:\n return stateValue\n beta = min(beta, stateValue)\n else:\n for curAction in curDepthCurAgentActions:\n stateValue = min(stateValue, Minimaxer(sucGameState.generateSuccessor(curAgent,curAction), depth, curAgent + 1, alpha, beta))\n if alpha > stateValue:\n return stateValue\n beta = min(beta, stateValue)\n return stateValue\n\n def miniMaxer(sucGameState, depth, alpha, beta):\n if sucGameState.isWin() or sucGameState.isLose():\n return self.evaluationFunction(sucGameState)\n if depth == 0:\n return self.evaluationFunction(sucGameState)\n stateValue = -9999\n curDepthCurAgentActions = sucGameState.getLegalActions(0)\n for curAction in curDepthCurAgentActions:\n stateValue = max(stateValue, Minimaxer(sucGameState.generateSuccessor(0,curAction), depth, 1, alpha, beta ))\n if beta < stateValue:\n return stateValue\n alpha = max(stateValue, alpha)\n return stateValue\n\n numAgents = gameState.getNumAgents()\n numGhosts = numAgents - 1\n pacmanLegalActions = gameState.getLegalActions()\n\n bestScore = -9999\n optimalAction = Directions.STOP\n alpha = -9999\n beta = 9999\n\n\n for action in pacmanLegalActions:\n prevActionScore = bestScore\n bestScore = max(prevActionScore, Minimaxer(gameState.generateSuccessor(0, action), self.depth, 1, alpha, beta))\n if bestScore > prevActionScore:\n prevActionScore = bestScore\n optimalAction = action\n if beta < bestScore:\n return bestScore\n alpha = max(bestScore, alpha)\n return optimalAction","def recursive_minimax(game: Any) -> Any:\n moves_scores = []\n moves = game.current_state.get_possible_moves()\n\n for move in moves:\n g = copy.deepcopy(game)\n s = g.current_state.make_move(move)\n g.current_state = s\n\n moves_scores.append(-1*recursive_helper(g))\n return moves[moves_scores.index(max(moves_scores))]","def minimax(board: bytearray,\n depth: int, # depth of current plies (0 = deepest)\n alpha: int, \n beta: int, \n max_player: bool, # is this maximzing player?\n at_top: bool=False, # are we the top call to this?\n ):\n \n # base cases:\n # - Player will win w/this board (since AI loses, return massive negative)\n # - AI will win w/this board (return massive positive)\n # - reached the depth of recursion (score this leaf for AI)\n # - board is full (no score for this leaf)\n\n won_by: int = 0\n for c1, c2, c3, c4 in _WINDOWS:\n if board[c1] and (board[c1] == board[c2] == board[c3] == board[c4]):\n won_by = board[c1]\n break\n \n if won_by == _PLAYER:\n # subtract depth so we delay loss as much as possible \n return -1000 - depth \n if won_by == _AI:\n # add depth so faster wins are more attractive\n return 1000 + depth \n if depth == 0:\n score = score_position(board, _AI) \n return score\n\n # (these are arranged _CENTER-out to help make a/b pruning most efficient)\n valid_locations: list[int] = [\n col % 7 for col in (38,37,39,36,40,35,41) if board[col] == _EMPTY]\n\n if not valid_locations:\n return 0\n \n # minimax strategy: alternate if AI is looking for best move (maximizing)\n # or the most harmful response from the player (minimizing).\n value: int\n new_col: int\n row: int\n \n if max_player:\n value = _MINUS_INFINITY\n new_col = random.choice(valid_locations)\n for col in valid_locations: \n for r in (0, 1, 2, 3, 4, 5):\n if board[7 * r + col] == 0:\n row = r\n break\n b_copy = bytearray(board)\n b_copy[row * 7 + col] = _AI\n new_score: int = minimax(b_copy, depth-1, alpha, beta, False)\n if new_score > value:\n value = new_score\n new_col = col\n alpha = max(alpha, value)\n if alpha >= beta:\n break\n\n else:\n value = _INFINITY\n for col in valid_locations:\n for r in (0, 1, 2, 3, 4, 5):\n if board[7 * r + col] == 0:\n row = r\n break\n b_copy = bytearray(board)\n b_copy[row * 7 + col] = _PLAYER\n new_score: int = minimax(b_copy, depth-1, alpha, beta, True)\n if new_score < value:\n value = new_score\n beta = min(beta, value)\n if alpha >= beta:\n break\n\n # For speed, return simple score except when exiting first recursive call,\n # and return the chosen column & the score in that case.\n if not at_top:\n return value\n else:\n return new_col % 7, value","def minimax(board):\r\n if terminal(board):\r\n return None\r\n \r\n acts = actions(board)\r\n if player(board) == \"X\":\r\n vals = []\r\n for a in acts:\r\n vals.append(min_value(result(board, a)))\r\n return acts[vals.indexof(max(vals))]\r\n elif player(board) == \"O\":\r\n vals = []\r\n for a in acts:\r\n vals.append(max_value(result(board, a)))\r\n return acts[vals.indexof(min(vals))]\r\n\r\n \r\n raise NotImplementedError","def player_loop(self):\n\n # Generate game tree object\n first_msg = self.receiver()\n # Initialize your minimax model\n model = self.initialize_model(initial_data=first_msg)\n\n while True:\n msg = self.receiver()\n\n # Create the root node of the game tree\n node = Node(message=msg, player=0)\n\n # Possible next moves: \"stay\", \"left\", \"right\", \"up\", \"down\"\n best_move = self.search_best_next_move(\n model=model, initial_tree_node=node)\n\n # Execute next action\n self.sender({\"action\": best_move, \"search_time\": None})","def minimax(board):\n \n if terminal(board):\n return None\n else:\n if len(actions(board)) == 9:\n for action in actions(board):\n return action\n else:\n if player(board) == 'X':\n# v = max_value(board)\n# for action in actions(board):\n# if v == min_value(result(board, action)):\n# return action\n return (max_value((board)))[1]\n if player(board) == 'O':\n# v = min_value(board)\n# for action in actions(board):\n# if v == max_value(result(board, action)):\n# return action\n return (min_value((board)))[1]","def custom_score_2(game, player):\n\n '''\n =========\n STRATEGY:\n =========\n Staged player: starts aggressively, but becomes increasingly defensive. Uses a shallow beam\n search of own or opponent's moves depending on game stage. Ignores alignment with knight's\n tour path or centrality.\n\n Could play better with deeper beam search of own position (and opponent's for defensive\n purposes), but this would require a longer timeout.\n Maximising the number of moves searched at depth 2 is a reasonable proxy.\n\n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing\n from opportunity to deepen search.\n '''\n\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\n USE_EVAL_DICT = False\n USE_TRANSFORMATIONS = False\n\n # Captures stats to global dict.\n GET_STATS = False\n\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\n\n if progress <= 20.0:\n '''\n ==============================================================================================================\n EARLY GAME\n ...\n ==============================================================================================================\n '''\n\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\n OPP_ISOL_SEARCH_DEPTH = 1\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\n PLAYER_SAFE_SEARCH_DEPTH = 2\n OPP_ISOL_MOVES_WEIGHT = 250.0\n PLAYER_SAFE_MOVES_WEIGHT = 150.0\n KT_WEIGHT = 0.0\n LATE_CENTRALITY_WEIGHT = 0.0\n KT_PROGRESS_MEASURED_TO = 0.0\n\n elif progress <= 80.0:\n '''\n ==============================================================================================================\n MID GAME\n ...\n ==============================================================================================================\n '''\n\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\n OPP_ISOL_SEARCH_DEPTH = 1\n PLAYER_SAFE_SEARCH_PATHS = 2 # ignored if search depth < 2\n PLAYER_SAFE_SEARCH_DEPTH = 2\n OPP_ISOL_MOVES_WEIGHT = 150.0\n PLAYER_SAFE_MOVES_WEIGHT = 250.0\n KT_WEIGHT = 0.0\n LATE_CENTRALITY_WEIGHT = 0.0\n KT_PROGRESS_MEASURED_TO = 0.0\n\n else:\n '''\n ==============================================================================================================\n END GAME\n ...\n ==============================================================================================================\n '''\n USE_EVAL_DICT = False\n\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\n OPP_ISOL_SEARCH_DEPTH = 2\n PLAYER_SAFE_SEARCH_PATHS = 2 # ignored if search depth < 2\n PLAYER_SAFE_SEARCH_DEPTH = 2\n OPP_ISOL_MOVES_WEIGHT = 100.0\n PLAYER_SAFE_MOVES_WEIGHT = 300.0\n KT_WEIGHT = 0.0\n LATE_CENTRALITY_WEIGHT = 0.0\n KT_PROGRESS_MEASURED_TO = 0.0\n\n\n\n\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\n # opening_book_weight=OPENING_BOOK_WEIGHT,\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)","def minimax(state, depth, player):\n if depth == 9:\n row = choice([0, 1, 2])\n col = choice([0, 1, 2])\n return row, col, ''\n\n if player == COMP:\n best = [-1, -1, float(\"-inf\")]\n else:\n best = [-1, -1, float(\"inf\")]\n\n if depth == 0 or state.has_tic_tac_toe(COMP) or state.has_tic_tac_toe(HUMAN):\n score = heuristic(state, depth)\n return [-1, -1, score]\n \"\"\"\n Checks if any of the player is one away from winning in any board and make the appropriate move.\n \"\"\"\n if player==COMP:\n empty_cells=get_empty_cells(state)\n dangerous_cells=state.is_one_away_from_tic_tac_toe((player%2)+1)\n if dangerous_cells:\n found_dangerous_cells=True\n else:\n found_dangerous_cells=False\n print \"no dangerous local boards\"\n favoring_cells=state.is_one_away_from_tic_tac_toe(player)\n if favoring_cells:\n found_favoring_cells=True\n else:\n found_favoring_cells=False\n print \"no favoring local boards\"\n if found_dangerous_cells==False and found_favoring_cells==False:\n pass\n if found_dangerous_cells==False and found_favoring_cells==True:\n empty_cells[:]=[]\n for cell in favoring_cells:\n empty_cells.append(cell)\n if found_dangerous_cells==True and found_favoring_cells==False:\n empty_cells[:]=[]\n for cell in dangerous_cells:\n empty_cells.append(cell)\n if found_dangerous_cells==True and found_favoring_cells==True:\n empty_cells[:]=[]\n for cell in dangerous_cells:\n empty_cells.append(cell)\n else:\n empty_cells=get_empty_cells(state)\n for cell in empty_cells:\n row, col = cell[0], cell[1]\n state.board[row][col] = player\n score = minimax(state, depth - 1, (player % 2) + 1)\n state.board[row][col] = 0\n score[0], score[1] = row, col\n if player == COMP:\n if score[2] >= best[2]:\n if score[2]==best[2]:\n \"\"\"\n Favors middle positions over sides or corners\n MIDDLE > CORNERS > SIDES\n \"\"\"\n if (best[0]==0 and best[1]==0) or (best[0]==0 and best[1]==2) or (best[0]==2 and best[1]==0) or (best[0]==2 and best[1]==2):\n if score[0]==0 and score[1]==0: #favoring centre position over diagonal position\n best=score\n print(\"centre position chosen over diagonal positions\")\n else:\n if ((score[0]==0 and score[1]==1) or (score[0]==1 and score[1]==0) or (score[0]==1 and score[1]==2) or (score[0]==2 and score[1]==1))==0:\n best=score #favoring any position over side position as long as the new position is not a side position too\n print(\"diagonal and centre positions chosen over side positions\")\n else:\n best = score\n else:\n bestMoves=[]\n if score[2] < best[2]:\n best=score\n return best","def make_move(self):\n\n # get relavent information\n affinity = self.get_affinity()\n sample_space = self.get_game_space()\n depth_limit = self.__search_depth\n\n # run a minimax search and get the best value\n bestval = MinimaxTree.alphabeta(self, sample_space, affinity, depth_limit, -10000, 10001, True)\n if bestval[0] is None: bestval = ((0,6),'x', 0)\n\n # print the number of nodes expanded \n print(self.nodes_expanded)\n\n # make the move found by the search \n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)","def minimax(board):\n if terminal(board):\n return None\n\n player_id = player(board)\n best_score = -math.inf if player_id == X else math.inf\n optimal_action = None\n\n for action in actions(board):\n if player_id == X:\n this_score = min_score(result(board, action))\n if this_score > best_score:\n optimal_action = action\n best_score = this_score\n else:\n this_score = max_score(result(board, action))\n if this_score < best_score:\n optimal_action = action\n best_score = this_score\n return optimal_action","def minimax(self, game, depth):\n _, move = self.minimax_search(game, depth)\n return move","def minimax(board):\n\n # If terminal board, return None\n if terminal(board):\n return None\n\n # Determine whose turn it is and the possible actions they can make\n current_player = player(board)\n moves = actions(board)\n\n if current_player == \"X\":\n utility_from_action = list()\n # Create pairings between the possible move and its eventual outcome\n for action in moves:\n utility_from_action.append((min_value(result(board, action)), action))\n temp = -(math.inf)\n optimal_move = None\n # Find the action that leads to maximized utility\n for (utility, action) in utility_from_action:\n if utility > temp:\n temp = utility\n optimal_move = action\n return optimal_move\n\n elif current_player == \"O\":\n utility_from_action = list()\n # Create pairings between the possible move and its eventual outcome\n for action in moves:\n utility_from_action.append((max_value(result(board, action)), action))\n temp = math.inf\n optimal_move = None\n # Find the action that leads to minimized utility\n for (utility, action) in utility_from_action:\n if utility < temp:\n temp = utility\n optimal_move = action\n return optimal_move\n\n else:\n return None","def minimax(board):\n best_act = None\n if terminal(board):\n return best_act\n if player(board) == X:\n key = -999999\n for action in actions(board):\n if key < min_value(result(board, action)):\n key = min_value(result(board, action))\n best_act = action\n return best_act\n if player(board) == O:\n key = 999999\n for action in actions(board):\n if key >= max_value(result(board, action)):\n key = max_value(result(board, action))\n best_act = action\n return best_act","def minimax(self, board, player):\n avail_spots = self.get_empty_cells(board)\n\n # If opponent wins return -10\n if self.check_win(board, self.get_next_move()):\n return {'score': -10}\n # If current ai wins, return 10, this is the wanted scenario\n elif self.check_win(board, self.move):\n return {'score': 10}\n elif len(avail_spots) == 0:\n return {'score': 0}\n else:\n moves = []\n for i in avail_spots:\n move = {'index': i}\n board[i] = player\n\n if player == self.move:\n result = self.minimax(board, self.get_next_move())\n else:\n result = self.minimax(board, self.move)\n\n # Update current move score and moves list\n move.update({'score': result['score']})\n moves.append(move)\n\n # Reset current board\n board[i] = ' '\n\n # Choose move with highest score\n if player == self.move:\n best_score = -20\n for move in moves:\n if move['score'] > best_score:\n best_score = move['score']\n best_move = move\n # Choose move with lowest score\n else:\n best_score = 20\n for move in moves:\n if move['score'] < best_score:\n best_score = move['score']\n best_move = move\n\n return best_move","def UCTPlayGame(itermax):\r\n print(\"Welcome to Ultimate Tic-Tac-Toe!\")\r\n player = 2 if input(\"Do you want to go first? [Y/N]: \") == \"N\" else 1\r\n\r\n state = GameState()\r\n while state.GetMoves():\r\n currentPlayer = state.NextPlayer()\r\n\r\n print(str(state))\r\n print(\"Moves for player \" + str(currentPlayer) + \": \")\r\n print(np.matrix(state.GetMoves()), \"\\n\")\r\n\r\n if currentPlayer == player:\r\n m = None\r\n while m not in state.GetMoves():\r\n try:\r\n m = int(input(\"Your move: \"))\r\n except ValueError:\r\n continue\r\n # m = random.choice(state.GetMoves())\r\n else:\r\n m = UCT(rootstate=state, itermax=itermax, verbose=False)\r\n print(\"AI played: \" + str(m))\r\n state.DoMove(m)\r\n print(str(state))\r\n\r\n if state.GetResult(state.playerJustMoved) == 1.0:\r\n print(\"Player \" + str(state.playerJustMoved) + \" wins!\")\r\n return state.playerJustMoved\r\n elif state.GetResult(state.playerJustMoved) == 0.0:\r\n print(\"Player \" + str(state.NextPlayer()) + \" wins!\")\r\n return state.NextPlayer()\r\n else:\r\n print(\"Nobody wins!\")\r\n return 0","def minimax(self, game, depth, maximizing_player=True):\n\n #logging.debug(\"minimax(%d, %s)\", depth, maximizing_player)\n\n # If we are out of time then jump out\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout() \n \n if depth <= 0: # Last row to search so return score of this board\n return self.score(game, self),(-1,-1)\n \n # Otherwise search the next layer\n legal_moves = game.get_legal_moves()\n \n # Check for some legal moves - if none return score of this board\n if len(legal_moves) == 0:\n return self.score(game, self),(-1,-1)\n\n results = []\n for m in legal_moves:\n score, _ = self.minimax(game.forecast_move(m), depth-1, not maximizing_player)\n results.append((score,m))\n \n if maximizing_player:\n return max(results)\n else:\n return min(results)","def minimax(board):\n act=list(actions(board))[0]\n if player(board)==X:\n val=-1\n for a in actions(board):\n minval=min_val(result(board, a))\n if minval>val:\n act=a\n val=minval\n if player(board)==O:\n val=1\n for a in actions(board):\n maxval=max_val(result(board, a))\n if maxval<val:\n act=a\n val=maxval\n\n return act\n\n raise NotImplementedError","def custom_score_3(game, player):\n\n \n '''\n =========\n STRATEGY:\n =========\n Aggressive player with shallow beam search of opponent's moves (looking to minimise \n opportunities to reach states with one or more moves at depth 2), with weight toward \n centrality after 30% of the game. Could play better with deeper beam search of opponents \n position (and own for defensive purposes), but this would require a longer timeout. Minimising \n the number of opponent moves at depth 2 is a reasonable proxy.\n \n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing \n from opportunity to deepen search.\n '''\n\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\n USE_EVAL_DICT = False\n USE_TRANSFORMATIONS = False\n\n # Captures stats to global dict.\n GET_STATS = False\n\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\n\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\n OPP_ISOL_SEARCH_DEPTH = 2\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\n PLAYER_SAFE_SEARCH_DEPTH = 1\n OPP_ISOL_MOVES_WEIGHT = 300.0\n PLAYER_SAFE_MOVES_WEIGHT = 100.0\n KT_WEIGHT = 50.0\n LATE_CENTRALITY_WEIGHT = 80.0\n KT_PROGRESS_MEASURED_TO = 30.0\n\n\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\n # opening_book_weight=OPENING_BOOK_WEIGHT,\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)","def minimax(board):\n current_player = player(board)\n if(terminal(board)):\n return None\n\n if (board == initial_state()):\n x = random.choice([0, 2])\n y = random.choice([0, 2])\n return(x, y)\n\n if(current_player == X):\n v = -math.inf\n for action in actions(board):\n mini = min_value(result(board, action))\n if mini > v:\n v = mini\n best_move = action\n else:\n v = math.inf\n for action in actions(board):\n maxi = max_value(result(board, action))\n if maxi < v:\n v = maxi\n best_move = action\n return best_move","def test_id(self):\n\n w, h = 11, 11\n method = \"minimax\"\n value_table = [[0] * w for _ in range(h)]\n value_table[3][0] = 1\n value_table[2][3] = 1\n value_table[4][4] = 2\n value_table[7][2] = 3\n eval_fn = EvalTable(value_table)\n\n depths = [\"7+\", \"6\", \"5\", \"4\", \"3\", \"2\", \"1\"]\n exact_counts = [((4, 4), set([(2, 3), (3, 0)])),\n ((16, 6), set([(2, 3), (3, 0)])),\n ((68, 20), set([(2, 3), (3, 2)])),\n ((310, 21), set([(2, 3), (3, 2)])),\n ((1582, 45), set([(3, 0), (3, 2)])),\n ((7534, 45), set([(3, 0), (3, 2)])),\n ((38366, 74), set([(0, 3), (2, 3), (3, 0), (3, 2)]))]\n\n time_limit = 3200\n while time_limit >= TIMER_MARGIN:\n agentUT, board = self.initAUT(-1, eval_fn, True, method, (1, 1), (0, 0), w, h)\n\n legal_moves = board.get_legal_moves()\n timer_start = curr_time_millis()\n time_left = lambda : time_limit - (curr_time_millis() - timer_start)\n move = agentUT.get_move(board, legal_moves, time_left)\n finish_time = time_left()\n\n self.assertTrue(len(board.visited) > 4, ID_FAIL)\n\n self.assertTrue(finish_time > 0,\n \"Your search failed iterative deepening due to timeout.\")\n\n # print time_limit, board.counts, move\n\n time_limit /= 2\n # Skip testing if the search exceeded 7 move horizon\n if (board.counts[0] > exact_counts[-1][0][0] or\n board.counts[1] > exact_counts[-1][0][1] or\n finish_time < 5):\n continue\n\n for idx, ((n, m), c) in enumerate(exact_counts[::-1]):\n if n > board.counts[0]:\n continue\n self.assertIn(move, c, ID_ERROR.format(depths[idx], 2 * time_limit, move, *board.counts))\n break","def minimax(self, state, player, visited, alpha, beta):\n if self.terminal(state, visited[player]):\n return self.utility(state, player)\n\n if player == PACMAN:\n return self.max_player(state, player, visited, alpha, beta)\n else:\n return self.min_player(state, player, visited, alpha, beta)","def generate_move_minimax_ab(\r\n board: np.ndarray, player: BoardPiece, saved_state: Optional[SavedState]\r\n) -> Tuple[PlayerAction, Optional[SavedState]]:\r\n depth = 4\r\n # choose which heuristic to use\r\n heuristic = heuristic_basic\r\n # heuristic = heuristic_better\r\n alpha, beta = int(-1e10), int(1e10) # starting alpha-beta values\r\n action_set = minimax_ab(board, alpha, beta, player, depth, True, heuristic=heuristic)\r\n print(action_set)\r\n # if np.all(board) == 0: # if the board is empty\r\n if len(set(action_set)) == 1: # if all options are the same\r\n action = 3 # put piece in the center\r\n else:\r\n action = np.argmax(action_set) # maximize the best move\r\n return PlayerAction(action), saved_state","def minimax(board):\n if player(board) == X:\n return optimal_max(board)[0]\n else:\n return optimal_min(board)[0]","def evaluateBoardState(self, board):\n\n \"\"\"\n These are the variables and functions for board objects which may be helpful when creating your Agent.\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\n\n Board Variables:\n board.width \n board.height\n board.last_move\n board.num_to_connect\n board.winning_zones\n board.score_array \n board.current_player_score\n\n Board Functions:\n get_cell_value(row, col)\n try_move(col)\n valid_move(row, col)\n valid_moves()\n terminal(self)\n legal_moves()\n next_state(turn)\n winner()\n \"\"\"\n if self.id == 1:\n opponent_id = 2\n else:\n opponent_id = 1\n\n maxvalue = 100000\n minvalue = -maxvalue\n winner = board.winner()\n if winner == self.id:\n return maxvalue\n elif winner == opponent_id:\n return minvalue\n size_y = board.height\n size_x = board.width\n map_ = []\n num_to_connect = board.num_to_connect\n total_points = 0\n\n multiply_reachable = 1\n multiply_oddeven = 1\n # basically this function is calculating all the possible win positions\n # more pieces in a possible win position will be counted with more weights\n # a win position with X pieces in it will be counted as X^2 points\n # initialise the zones maps\n for i in range(size_y):\n map_.append([])\n for j in range(size_x):\n map_[i].append([])\n\n # Fill in the horizontal win positions\n for i in range(size_y):\n for j in range(size_x - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i][j + k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i][j + k] == self.id:\n points += len(board.winning_zones[j+k][i])\n if (self.id == 1 and i % 2 == 1) or (self.id == 2 and i%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and opponent_pieces_count == 0:\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\n return maxvalue\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\n points *= multiply_reachable\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\n return minvalue\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the vertical win positions\n for i in range(size_x):\n for j in range(size_y - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[j + k][i] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[j + k][i] == self.id:\n points += len(board.winning_zones[i][j+k])\n if (self.id == 1 and (j+k) % 2 == 1) or (self.id == 2 and (j+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n points *= multiply_reachable\n # if opponent_pieces_count == 3 and self_pieces_count == 0:\n # points *= -1\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the forward diagonal win positions\n for i in range(size_y - num_to_connect + 1):\n for j in range(size_x - num_to_connect + 1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i + k][j + k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i + k][j + k] == self.id:\n points += len(board.winning_zones[j+k][i+k])\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and opponent_pieces_count == 0:\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\n return maxvalue\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\n points *= multiply_reachable\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\n return minvalue\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n\n # Fill in the backward diagonal win positions\n for i in range(size_y - num_to_connect + 1):\n for j in range(size_x - 1, num_to_connect - 1 - 1, -1):\n points = 0\n self_pieces_count = 0\n opponent_pieces_count = 0\n for k in range(num_to_connect):\n if board.board[i + k][j - k] == opponent_id:\n opponent_pieces_count += 1\n elif board.board[i + k][j - k] == self.id:\n points += len(board.winning_zones[j-k][i+k])\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\n points *= multiply_oddeven\n self_pieces_count += 1\n if self_pieces_count == 3 and self_pieces_count == 0:\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\n return maxvalue\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\n return maxvalue\n else:\n for k in range(num_to_connect):\n if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\n points *= multiply_reachable\n\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\n return minvalue\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\n return minvalue\n # else:\n # for k in range(num_to_connect):\n # if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\n # points *= -multiply_reachable\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\n total_points += points\n return total_points","def minimax(board):\n move = None\n if player(board) == X:\n highValue = float(\"-inf\")\n for action in actions(board):\n value = minValue(result(board,action))\n if value == 1:\n move = action\n highValue = value\n elif value >= highValue:\n move = action\n highValue = value\n\n else:\n lowValue = float(\"inf\")\n for action in actions(board):\n value = maxValue(result(board, action))\n if value == -1:\n move = action\n lowValue = value\n elif value <= lowValue:\n move = action\n lowValue = value\n return move\n\n\n\n\n\n # raise NotImplementedError","def solveOneStep(self):\n ### Student code goes here\n if self.first_step == False:\n self.first_step = True\n if self.solveOneStep():\n return True\n if self.queue:\n self.gm_init()\n ele = self.queue.get()\n #print (len(ele))\n state = ele[0]\n premoves = ele[1]\n\n for m in premoves:\n self.gm.makeMove(m)\n if state.state == self.victoryCondition:\n return True\n self.visited[state] = True\n print(\"CURRENTSTATE:\")\n print(self.gm.getGameState())\n print(\"*******\")\n moves = self.gm.getMovables()\n for m in moves:\n self.gm.makeMove(m)\n if (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\n self.gm.reverseMove(m)\n continue\n self.visited[GameState(self.gm.getGameState(), 0, None)] = True\n new_pmv = [i for i in premoves]\n new_pmv.append(m)\n next_state = GameState(self.gm.getGameState(), state.depth+1, m)\n next_state.parent = state\n state.children.append(next_state)\n self.queue.put([next_state, new_pmv])\n self.gm.reverseMove(m)\n self.currentState = state\n\n #for i in range(len(premoves)-1, -1, -1):\n # mv = premoves[i]\n # self.gm.reverseMove(mv)\n return False","def minimax(state, depth, player):\n\n if player == COMP:\n best = [-1, -1, inf]\n else:\n best = [-1, -1, -inf]\n\n if depth == 0 or game_over(state):\n score = evaluate(state)\n return [-1, -1, score]\n\n for cell in empty_cells(state):\n x, y = cell[0], cell[1]\n state[x][y] = player\n score = minimax(state, depth - 1, -player)\n state[x][y] = 0\n score[0], score[1] = x, y\n\n if player == COMP:\n if score[2] < best[2]:\n best = score\n else:\n if score[2] > best[2]:\n best = score\n\n return best","def moveManager(self):\r\n \r\n (nb1,nb2) = self._board.get_nb_pieces() \r\n val = 0\r\n alphaBeta_instance = AlphaBeta()\r\n \r\n # Early-Game: Check opening move in a custom bloom filter\r\n if(nb1+nb2 < MoveManager.__AI_OPENING_MOVE_VALUE__()): \r\n print(\"Check if \", Utils.HashingOperation.BoardToHashCode(self._board), \"is present\")\r\n move = self._openingMover.GetMove(self._board)\r\n \r\n if(move is None): #No Opening Move has been found, need to calculate the AB-pruning\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \r\n depth=3,\r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # End-Game: Special depth alpha-beta\r\n elif ((nb1+nb2) > MoveManager.__AI_ENDGAME_VALUE__(self._board)): \r\n# self._maxDepth = WIDTH*HEIGHT - (nb1+nb2)\r\n print(\"Special depth For Pruning: \", nb1+nb2)\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self,\r\n depth=self._board._boardsize * self._board._boardsize - (nb1+nb2), \r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # Mid-Game: Usual Case. Alpha Beta. Can use the parallelization, or chose to check a bloom filter if a good board has already been find \r\n else: \r\n #Alpha and Beta should be set directly on the AlphaBeta class\r\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \r\n depth=3,\r\n Parallelization=False,\r\n BloomCheckerFirst=False)\r\n \r\n # No move has been find, generate one with a simple heuristic\r\n if move is None: \r\n print(\"\")\r\n print(\"\")\r\n print(\"Default value. No move has been found\")\r\n val = -7578748789\r\n# time.sleep(1)\r\n (move, _) = MoveManager.MoveForGameBeginning(self, self._board.legal_moves()) \r\n \r\n print(\"\")\r\n print(\"\")\r\n print(\"\")\r\n print(\"Val is:\", val)\r\n# time.sleep(1)\r\n return move","def minimax(board):\n\n if len(actions(board)) == 9:\n action = actions(board)\n return action[random.randint(0, len(actions(board)) - 1)]\n\n if terminal(board):\n return None\n\n best_move = None\n\n if player(board) == X:\n best_score = -1\n else:\n best_score = 1\n\n for action in actions(board):\n if player(board) == X:\n score = minimize(result(board, action))\n\n if score >= best_score:\n best_move = action\n best_score = score\n else:\n score = maximize(result(board, action))\n\n if score <= best_score:\n best_move = action\n best_score = score\n\n return best_move","def minimax(board):\n if terminal(board):\n return utility(board)\n\n chance = player(board)\n if chance == X:\n v = -math.inf\n best_action = None\n\n for action in actions(board):\n v_temp = min_target(result(board, action), 0, -math.inf, math.inf)\n\n if v_temp > v:\n best_action = action\n v = v_temp\n\n else:\n v = math.inf\n best_action = None\n\n for action in actions(board):\n v_temp = max_target(result(board, action), 0, -math.inf, math.inf)\n\n if v_temp < v:\n best_action = action\n v = v_temp\n\n return best_action","def minimax(board):\n if terminal(board):\n return None\n # return the optimal move for the player\n # possible outcomes 1(X wins) 0(No winner) -1(O wins)\n if player(board) == X:\n _ , action = max_value(board)\n return action\n elif player(board) == O:\n _ , action = min_value(board)\n return action","def make_move(self):\n\n # get relavent information\n affinity = self.get_affinity()\n sample_space = self.get_game_space()\n depth_limit = self.__search_depth\n\n # run a minimax search and get the best value\n bestval = MinimaxTree.minimax(self, sample_space, affinity, depth_limit, True)\n if bestval[0] is None: bestval = ((0,6),'x', 0)\n\n # print the number of nodes expanded \n print(self.nodes_expanded)\n\n # make the move found by the search \n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)","def minimax(self, game, depth, maximizing_player=True, tab='\\t'):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n legal_moves = game.get_legal_moves(game.active_player)\n if legal_moves is not None and len(legal_moves)>0:\n if depth>0: # Recursive case:\n if maximizing_player: # MAXIMIZING ply\n score, move = None, None\n for i,m in enumerate(legal_moves):\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\t')\n if score is None or newscore > score:\n score, move = newscore, m\n else: # MINIMIZING ply\n score, move = None, None\n for i,m in enumerate(legal_moves):\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\t')\n if score is None or newscore < score:\n score, move = newscore, m\n else: # Base case (depth==0)\n score, move = self.score(game, self), None\n else: # We are at a DEAD-END here\n score, move = self.score(game, self), (-1, -1)\n\n return score, move","def minimax_decision(self, state):\r\n\r\n # Here implementing custom version of arg max, keeping all the problem\r\n # criterion in mind.\r\n player_current = self.player(state, self.initial_turn)\r\n best_action = ()\r\n\r\n # Early terminated alpha-beta pruned minimax algorithm\r\n if player_current == 'x':\r\n best_action = self.max_value_prune_et(state, (9, 9, 9), -999, 999, 0, player_current)\r\n else:\r\n best_action = self.min_value_prune_et(state, (9, 9, 9), -999, 999, 0, player_current)\r\n\r\n # Tuple of best action (best action value, to co-ordinate, from co-ordinate)\r\n return best_action","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def agentCounter(gameState, index, depth):\n \"\"\"When index is out of bounds return pacmans index and\n reduce depth by 1\"\"\"\n if index == gameState.getNumAgents():\n return [depth-1, 0]\n else:\n return [depth, index]\n\n def minimax(self, gameState, depth, index):\n \"\"\"Implement minimax function for pacman game. \n return an array with score and best move\"\"\"\n ultimateMove = None # The best move the agent can use\n if depth == 0 or gameState.isWin() or gameState.isLose():\n # if leaf node return value.\n return [self.evaluationFunction(gameState), ultimateMove]\n else:\n if index == 0: # if pacman => agent is max agent\n value = -math.inf\n maxValue = value\n # iterates through max agent w/index=0 moves\n for action in gameState.getLegalActions(0):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action) # generates the next state when move is done\n value = max(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\n if maxValue != value: # If value has changed update values\n ultimateMove = action\n maxValue = value\n return [value, ultimateMove]\n else: # is ghost => agent is min agent\n value = math.inf\n minValue = value\n # Iterate through the moves of a min agent w/index not 0\n for action in gameState.getLegalActions(index):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action)\n value = min(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\n if minValue != value: # If value has changed update values\n ultimateMove = action\n minValue = value\n return [value, ultimateMove]\n\n best = minimax(self, gameState, self.depth, self.index)\n #print(\"Move: \", best[1], \" | Score: \", best[0])\n return best[1]","def minimax(board):\n if terminal(board):\n return None\n\n max_action_value = -1\n min_action_value = 1\n best_action = None\n\n for action in actions(board):\n if player(board) == X:\n # Action value given by O player minimizing the action value on next state\n action_value = min_value(result(board, action))\n # Choose action with maximum value\n if action_value > max_action_value:\n best_action = action\n max_action_value = action_value\n # An action with max possible value was reached\n if action_value == 1:\n return action\n else:\n # Action value given by X player maximizing the action value on next state\n action_value = max_value(result(board, action))\n # Choose action with minimum value\n if action_value < min_action_value:\n best_action = action\n min_action_value = action_value\n # An action with minimum possible value was reached\n if action_value == -1:\n return action\n \n return best_action","def minimax(board):\n play = player(board)\n\n bestMove = (-1, -1)\n if play == X:\n bestVal = -1000\n # Traverse all cells, evaluate minimax function for\n # all empty cells. And return the cell with optimal\n # value.\n for i in range(3) : \n for j in range(3) :\n \n # Check if cell is empty\n if (board[i][j] == EMPTY) :\n \n # Make the move\n board[i][j] = play\n \n # compute evaluation function for this\n # move.\n moveVal = minimaxScore(board)\n \n # Undo the move\n board[i][j] = EMPTY\n \n # If the value of the current move is\n # more than the best value, then update\n # best/\n if (moveVal > bestVal) : \n bestMove = (i, j)\n bestVal = moveVal\n else:\n bestVal = 1000\n # Traverse all cells, evaluate minimax function for\n # all empty cells. And return the cell with optimal\n # value.\n for i in range(3) : \n for j in range(3) :\n \n # Check if cell is empty\n if (board[i][j] == EMPTY) :\n \n # Make the move\n board[i][j] = play\n \n # compute evaluation function for this\n # move.\n moveVal = minimaxScore(board)\n \n # Undo the move\n board[i][j] = EMPTY\n \n # If the value of the current move is\n # more than the best value, then update\n # best/\n if (moveVal < bestVal) : \n bestMove = (i, j)\n bestVal = moveVal\n \n return bestMove","def minimax_helper(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n \n # Get all the available moves at the current state\n legal_moves = game.get_legal_moves()\n\n # Handle a terminal event/exhaustive search completion\n # at least in relation to depth sought\n if (not legal_moves) or (depth == 0):\n if maximizing_player:\n return (self.score(game, game.active_player), (-1, -1))\n else:\n return (self.score(game, game.inactive_player), (-1, -1))\n\n if maximizing_player: # the current player\n this_score = float(\"-inf\")\n for move in legal_moves:\n next_ply_state = game.forecast_move(move)\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\n depth-1, False)\n\n # Identify the maximum score branch for the current player.\n if next_ply_score >= this_score:\n this_move = move\n this_score = next_ply_score\n\n else: # the current player's opponent\n this_score = float(\"inf\")\n for move in legal_moves:\n next_ply_state = game.forecast_move(move)\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\n depth-1, True) \n\n # Identify the minimum score branch for the opponent\n if next_ply_score <= this_score:\n this_move = move\n this_score = next_ply_score\n\n return this_score, this_move","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n\n \"\"\"\n From AIMA psuedocode:\n\n function MINIMAX-DECISION(state) returns an action\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\n \"\"\"\n\n best_move = (-1,-1)\n best_score = float(\"-inf\")\n actions = game.get_legal_moves()\n\n if not actions:\n return best_move\n else:\n best_move = actions[randint(0, len(actions) - 1)]\n\n try:\n # The try/except block will automatically catch the exception\n # raised when the timer is about to expire.\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\n for action in actions:\n score = self._min_value(game.forecast_move(action), 1)\n if score > best_score:\n best_score = score\n best_move = action\n\n except SearchTimeout:\n pass\n\n return best_move","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n legalActions = gameState.getLegalPacmanActions()\n scoresForAction = {}\n maxAction = \"\"\n maxScore = -99999999999999\n for action in legalActions:\n scoresForAction[action] = self.minimax2(gameState.generatePacmanSuccessor(action), self.depth, False)\n for x,y in scoresForAction.iteritems():\n if(maxScore < y):\n maxScore = y\n maxAction = x\n return maxAction\n # return self.miniMax(gameState, self.depth, 0)","def solveOneStep(self):\n ### Student code goes here\n if (self.currentState.state == self.victoryCondition) or (self.currentState not in self.visited):\n self.visited[self.currentState] = True\n win_or_not = self.currentState.state == self.victoryCondition\n return win_or_not\n\n if not self.currentState.nextChildToVisit: \n its = 0\n for movable in self.gm.getMovables():\n its += 1\n # time test\n # too long \n if its == \"too long\":\n return \"too long\"\n #make every move in movable\n self.gm.makeMove(movable)\n new = self.gm.getGameState()\n new_gs = GameState(new, self.currentState.depth+1, movable)\n \n if new_gs not in self.visited:\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.gm.reverseMove(movable) \n \n num_children = len(self.currentState.children)\n if self.currentState.nextChildToVisit < num_children:\n new = self.currentState.children[self.currentState.nextChildToVisit]\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\n self.gm.makeMove(new.requiredMovable)\n self.currentState = new\n #recurse\n return self.solveOneStep()\n else:\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n #recurse\n return self.solveOneStep()","def __init__(self, size, block_positions, starts, player_1, player_2, \n terminal_viz, print_game_in_terminal, \n time_to_make_a_move=2, game_time=100, \n penalty_score=300, max_fruit_score=300, max_fruit_time=15):\n\n # check that each Player implements the following methods:\n self.players = [player_1, player_2]\n for player in self.players:\n assert hasattr(player, 'set_game_params')\n assert hasattr(player, 'make_move')\n assert hasattr(player, 'set_rival_move')\n assert hasattr(player, 'update_fruits')\n\n self.print_game_in_terminal = print_game_in_terminal\n self.terminal_viz = terminal_viz\n self.time_to_make_a_move = time_to_make_a_move\n self.penalty_score = penalty_score\n self.some_player_cant_move = False\n \n \n self.game_time_left_for_players = [game_time, game_time]\n\n initial_board = self.set_initial_board(size, block_positions, starts)\n\n self.game = Game(initial_board, starts, max_fruit_score=max_fruit_score, max_fruit_time=max_fruit_time, \n animated=True, animation_func=self.animate_func)\n\n for i, player in enumerate(self.players):\n player.set_game_params(self.game.get_map_for_player_i(player_id=i))","def minimax(state, depth, player):\r\n if player == COMP:\r\n best = [-1, -1, -infinity]\r\n else:\r\n best = [-1, -1, +infinity]\r\n\r\n if depth == 0 or game_over(state):\r\n score = evaluate(state)\r\n return [-1, -1, score]\r\n\r\n for cell in empty_cells(state):\r\n x, y = cell[0], cell[1]\r\n state[x][y] = player\r\n score = minimax(state, depth - 1, -player)\r\n state[x][y] = 0\r\n score[0], score[1] = x, y\r\n\r\n if player == COMP:\r\n if score[2] > best[2]:\r\n best = score # max value\r\n else:\r\n if score[2] < best[2]:\r\n best = score # min value\r\n\r\n return best","def action(self):\n\n self.start_timer()\n\n minimax_probability = self.norm.cdf(self.root.branching)\n use_minimax = boolean_from_probability(minimax_probability)\n if self.time_consumed > 53:\n # Time is starting to run low, use the faster option\n use_minimax=True\n\n if self.time_consumed < 59:\n if self.root.turn < 4:\n result = book_first_four_moves(self.root)\n elif use_minimax:\n result = minimax_paranoid_reduction(self.root)\n else:\n result = monte_carlo_tree_search(\n self.root,\n playout_amount=3,\n node_cutoff=4,\n outer_cutoff=4,\n num_iterations=1200,\n turn_time=0.75,\n exploration_constant=1.7,\n use_slow_culling=False,\n verbosity=0,\n use_prior=True,\n num_priors=4,\n use_fast_prune_eval=False,\n use_fast_rollout_eval=False,\n )\n else:\n result = greedy_choose(self.root)\n\n self.end_timer()\n\n return result","def alphabeta_search(state):\r\n \r\n '''\r\n Terminates when game.actions is empty\r\n Class Game needs the following functions:\r\n - game.result(state, a) -- successor\r\n - game.actions(state) -- possible moves\r\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\r\n \r\n '''\r\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\r\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\r\n \r\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\r\n cutoff_test=None\r\n sort_fn = [vitalpoint, eyeHeur]\r\n eval_fn = survivalheur \r\n #randnumheuristics \r\n player = state.to_move()\r\n prune = 0\r\n pruned = {} #this will store the depth of the prune\r\n totaldepth = [0]\r\n visited = {}\r\n heuristicInd = 0\r\n \r\n def max_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = -infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #max wants decreasing\r\n #sorted(state.actions(), key = eval_sort, reverse = True)\r\n \r\n #sort by favorites first, returns a list of actions\r\n # for sorts in sort_fn:\r\n tempher = heuristicInd\r\n\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n ''''''\r\n for a in sortedactions:\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n \r\n onbranch += 1\r\n v = max(v, min_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\r\n if v >= beta: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n alpha = max(alpha, v)\r\n \r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n \r\n return v\r\n\r\n def min_value(state, alpha, beta, depth, heuristicInd):\r\n branches = len(state.actions())\r\n onbranch = 0\r\n \r\n if totaldepth[0] < depth:\r\n totaldepth[0] = depth\r\n if cutoff_test(state, depth):\r\n return eval_fn(state)\r\n v = infinity\r\n \r\n #sort state.actions based on heuristics before calling\r\n #min wants increasing\r\n #sorted(state.actions(), key = eval_sort)\r\n #Shayne\r\n tempher = heuristicInd\r\n sorts = sort_fn[heuristicInd]\r\n sortedactions, heuristicInd = sorts(state, 1)\r\n #if heuristicInd != tempher:\r\n # print 's',\r\n for a in sortedactions: #state.actions():\r\n onbranch += 1\r\n if visited.get(depth) == None:\r\n visited[depth] = [a]\r\n else:\r\n visited[depth].append(a)\r\n v = min(v, max_value(state.result(a),\r\n alpha, beta, depth+1, heuristicInd))\r\n if v <= alpha: #pruning happens here, but in branches\r\n if pruned.get(depth) == None:\r\n pruned[depth] = branches - onbranch\r\n else:\r\n pruned[depth] += (branches - onbranch)\r\n #print \"prune\", depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n beta = min(beta, v)\r\n #print depth, \" \", state.actions()\r\n #state.display()\r\n return v\r\n\r\n # Body of alphabeta_search starts here:\r\n #def cutoff_test and eval_fn \r\n cutoff_test = (cutoff_test or\r\n (lambda state,depth: depth>d or state.terminal_test()))\r\n eval_fn = eval_fn or (lambda state: state.utility(player))\r\n #by default, utility score is used\r\n \r\n \r\n #argmax goes through all the possible actions and \r\n # applies the alphabeta search onto all of them\r\n # and returns the move with the best score \r\n #print state.actions()\r\n heuristicInd = 0\r\n sorts = sort_fn[heuristicInd]\r\n sortedact, heuristicInd = sorts(state)\r\n abmove = argmax(sortedact,\r\n lambda a: min_value(state.result(a),\r\n -infinity, infinity, 0, heuristicInd))\r\n\r\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\r\n for i in range(1, len(visited)):\r\n if len(pruned) < i:\r\n pruned[i] = 0\r\n print i, \",\", len(visited[i]), \",\", pruned[i]\r\n \r\n return abmove","def getAction(self, gameState):\n def Minimaxer(sucGameState, depth, curAgent, numGhosts):\n if sucGameState.isWin() or sucGameState.isLose():\n return self.evaluationFunction(sucGameState)\n if depth == 0:\n return self.evaluationFunction(sucGameState)\n stateValue = 9999\n curDepthCurAgentActions = sucGameState.getLegalActions(curAgent)\n if curAgent == numGhosts:\n for curAction in curDepthCurAgentActions:\n stateValue = min(stateValue, miniMaxer(sucGameState.generateSuccessor(curAgent,curAction), depth-1, numGhosts) )\n else:\n for curAction in curDepthCurAgentActions:\n stateValue = min(stateValue, Minimaxer(sucGameState.generateSuccessor(curAgent,curAction), depth, curAgent + 1, numGhosts))\n return stateValue\n\n def miniMaxer(sucGameState, depth, numGhosts):\n if sucGameState.isWin() or sucGameState.isLose():\n return self.evaluationFunction(sucGameState)\n if depth == 0:\n return self.evaluationFunction(sucGameState)\n stateValue = -9999\n curDepthCurAgentActions = sucGameState.getLegalActions(0)\n for curAction in curDepthCurAgentActions:\n stateValue = max(stateValue, Minimaxer(sucGameState.generateSuccessor(0,curAction), depth, 1, numGhosts ))\n return stateValue\n\n numAgents = gameState.getNumAgents()\n numGhosts = numAgents - 1\n pacmanLegalActions = gameState.getLegalActions()\n\n bestScore = -9999\n optimalAction = Directions.STOP\n\n\n for action in pacmanLegalActions:\n prevActionScore = bestScore\n bestScore = max(prevActionScore, Minimaxer(gameState.generateSuccessor(0, action), self.depth, 1, numGhosts))\n if bestScore > prevActionScore:\n optimalAction = action\n return optimalAction","def winningMove():\r\n\tglobal turn, tile1, tile2, tile3, tile4, tile5, tile6, tile7, tile8, tile9\r\n\r\n\tnoWin=True\r\n\tmove=False\r\n\tif turn==\"Player1\":\r\n\t\tif validMove(1):\r\n\t\t\ttile1+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove=1\t\r\n\t\t\ttile1+=-1\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\t\tif validMove(2):\r\n\t\t\ttile2+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 2\r\n\t\t\ttile2+=-1\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\t\tif validMove(3):\r\n\t\t\ttile3+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 3\r\n\t\t\ttile3+=-1\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\t\t\r\n\t\tif validMove(4):\r\n\t\t\ttile4+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 4\t\r\n\t\t\ttile4+=-1\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\t\r\n\t\tif validMove(5):\r\n\t\t\ttile5+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 5\t\t\r\n\t\t\ttile5+=-1\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(6):\r\n\t\t\ttile6+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 6\t\r\n\t\t\ttile6+=-1\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(7):\r\n\t\t\ttile7+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 7\t\r\n\t\t\ttile7+=-1\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(8):\r\n\t\t\ttile8+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 8\t\r\n\t\t\ttile8+=-1\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(9):\r\n\t\t\ttile9+=1\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 9\t\t\r\n\t\t\ttile9+=-1\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\r\n\telif turn==\"Player2\":\r\n\t\tif validMove(1):\r\n\t\t\ttile1+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 1\t\t\t\t\r\n\t\t\ttile1+=-2\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\t\tif validMove(2):\r\n\t\t\ttile2+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 2\r\n\t\t\ttile2+=-2\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\t\tif validMove(3):\r\n\t\t\ttile3+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 3\r\n\t\t\ttile3+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(4):\r\n\t\t\ttile4+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 4\t\r\n\t\t\ttile4+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(5):\r\n\t\t\ttile5+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 5\t\r\n\t\t\ttile5+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(6):\r\n\t\t\ttile6+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 6\t\r\n\t\t\ttile6+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(7):\r\n\t\t\ttile7+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 7\t\r\n\t\t\ttile7+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(8):\r\n\t\t\ttile8+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 8\t\r\n\t\t\ttile8+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\t\r\n\t\tif validMove(9):\r\n\t\t\ttile9+=2\r\n\t\t\tif win():\r\n\t\t\t\tnoWin=False\r\n\t\t\t\tmove= 9\r\n\t\t\ttile9+=-2\t\t\r\n\t\t\tif move:\r\n\t\t\t\treturn move\t\r\n\tif noWin:\r\n\t\treturn False","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n while to_move < len(movables):\n # Make the move\n movable_statement = movables[to_move]\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n\n # Find out if this state has already been explored\n visited = False\n for visited_state in self.visited.keys():\n if visited_state.state == new_state:\n visited = True\n\n # If the new state hasn't been visited then add it as a child then move down to this child\n if not visited:\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.currentState = new_gs\n break\n\n # Else skip this state and try going to the next movable statement\n else:\n # print(\"SKIP THIS STATE\")\n self.gm.reverseMove(movable_statement)\n to_move += 1\n\n # Went all the way down to a leaf, backtrack\n if (to_move >= len(movables)):\n self.gm.reverseMove(self.currentState.requiredMovable)\n self.currentState = self.currentState.parent\n\n return False","def minimax(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n legal_moves = game.get_legal_moves()\n\n best_move = (-1, -1)\n if maximizing_player:\n score = float(\"-inf\")\n else:\n score = float(\"inf\")\n\n #At bottom of minimax tree\n if depth == 1:\n for each_move in legal_moves:\n new_game = game.forecast_move(each_move)\n if maximizing_player and self.score(new_game, self) > score:\n score = self.score(new_game, self)\n best_move = each_move\n elif not maximizing_player and self.score(new_game, self) < score:\n score = self.score(new_game, self)\n best_move = each_move\n\n return score, best_move\n\n #Not at bottom of minimax tree\n for each_move in legal_moves:\n #Return each_move that gets the highest score\n new_game = game.forecast_move(each_move)\n new_score , new_move = self.minimax(new_game, depth-1, not maximizing_player)\n if maximizing_player and new_score > score:\n score = new_score\n best_move = each_move\n elif not maximizing_player and new_score < score:\n score = new_score\n best_move = each_move\n\n return score, best_move","def minimax(board):\n if terminal(board):\n return None\n \n if player(board) == O:\n v = math.inf\n for action in actions(board):\n move = max_value(result(board, action))\n if move < v:\n v = move\n bestMove = action\n\n else:\n v = -math.inf\n for action in actions(board):\n move = min_value(result(board, action))\n if move > v:\n v = move\n bestMove = action\n \n return bestMove","def custom_score(game, player):\n\n '''\n =========\n STRATEGY:\n =========\n Defensive player with shallow beam search of own moves (looking to maximise \n opportunities to reach states with one or more moves at depth 2), with weight toward \n centrality after 30% of the game. Could play better with deeper beam search of own \n position (and opponent's for defensive purposes), but this would require a longer timeout. \n Maximising the number of own moves at depth 2 is a reasonable proxy.\n \n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing \n from opportunity to deepen search.\n '''\n\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\n USE_EVAL_DICT = False\n USE_TRANSFORMATIONS = False\n\n # Captures stats to global dict.\n GET_STATS = False\n\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\n\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\n OPP_ISOL_SEARCH_DEPTH = 1\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\n PLAYER_SAFE_SEARCH_DEPTH = 2\n OPP_ISOL_MOVES_WEIGHT = 100.0\n PLAYER_SAFE_MOVES_WEIGHT = 300.0\n KT_WEIGHT = 50.0\n LATE_CENTRALITY_WEIGHT = 80.0\n KT_PROGRESS_MEASURED_TO = 30.0\n\n\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\n # opening_book_weight=OPENING_BOOK_WEIGHT,\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)","def make_move(self, time_limit, players_score):\n \n start_time = time.time()\n d = 1 \n \n reach_the_end = False\n best_direction = None\n chosen_state = None\n \n time_limit = (2 * self.game_time * float(self.player_turns - self.turns + 1)) / ((self.player_turns + 1) * self.player_turns)\n time_limit += self.spaire_time\n\n if time_limit >= 5:\n TIME_ESTIMATION = 0.9 \n else:\n TIME_ESTIMATION = 0.85\n\n while not reach_the_end: \n \n iter_time_limit = TIME_ESTIMATION * ( time_limit - (time.time() - start_time) )\n \n state = State(get_directions(),self.board,self.locations,self.fruits_on_board_dict,PLAYER,players_score,self.penalty_score,self.fruits_ttl,self.turns)\n\n try:\n _, best_direction, reach_the_end,chosen_state = self.alphabeta.search(state,d,True,iter_time_limit,alpha=float('-inf'), beta=float('inf'))\n d += 1\n except Exception as e:\n self.spaire_time = time_limit - (time.time() - start_time)\n break\n \n # Set new location \n if best_direction == None:\n best_direction = self.get_random_move() \n self.set_player_location(best_direction)\n \n self.turns += 1\n return best_direction","def minimax(self, game, depth, maximizing_player=True):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise Timeout()\n\n if game.get_legal_moves():\n scores = [(self.minvalue(game.forecast_move(move), depth), move) for move in game.get_legal_moves()]\n else:\n return (self.score(game, self), (-1,-1)) \n\n return max(scores)","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def MaxValue(gameState, currentDepth, agentNumber):\n \n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n \n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n #print 'depth ',currentDepth\n \n largestValue = float(\"-inf\")\n bestAction = Directions.NORTH\n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for pacman ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\n if(successorValue > largestValue):\n largestValue = successorValue\n bestAction = action\n return (largestValue, bestAction)\n \n def MinValue(gameState, currentDepth, agentNumber):\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n \n #print 'depth ',currentDepth\n \n smallestValue = float(\"inf\")\n bestAction = Directions.NORTH \n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for ghost ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\n if nextAgentNumber is 0:\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\n else:\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\n if(successorValue < smallestValue):\n smallestValue = successorValue\n bestAction = action\n return (smallestValue, bestAction)\n\n result = MaxValue(gameState, 0, 0)\n resultActionToTake = result[1]\n #print 'Minimax value for depth ', self.depth,' ',result[0]\n #import time\n #time.sleep(1000000)\n return resultActionToTake","def minimax(board):\n if terminal(board):\n return None\n possible_actions = actions(board)\n if player(board) == X:\n max_utility = -math.inf\n for action in possible_actions:\n action_val = min_val(result(board, action))\n if action_val > max_utility:\n max_utility = action_val\n optimal_action = action\n else:\n min_utility = math.inf\n for action in possible_actions:\n action_val = max_val(result(board, action))\n if action_val < min_utility:\n min_utility = action_val\n optimal_action = action\n return optimal_action","def minimax(board):\n if terminal(board):\n return None\n if player(board)==X:\n value, move = max_value(board)\n return move\n if player(board)==O:\n value, move = min_value(board)\n return move","def solveOneStep(self):\n ### Student code goes here\n # Mark this move as explored\n self.visited[self.currentState] = True\n self.visited_states.append(self.currentState.state)\n\n # Get move to make\n movables = self.gm.getMovables()\n # print(\"EXPLORING GAME STATE \" + str(self.gm.getGameState()) + \"---------------------------------------------------------\")\n to_move = self.currentState.nextChildToVisit # movables index\n # print(\"depth \", self.currentState.depth)\n\n # Return if done\n if self.currentState.state == self.victoryCondition:\n # print(\"DONE\")\n return True\n\n # If current state has no children, make children\n if not self.currentState.children:\n for movable_statement in movables:\n # Make the move\n # print(\"implementing move \", movable_statement)\n self.gm.makeMove(movable_statement)\n\n # Create a new state with this move made\n new_state = self.gm.getGameState()\n # print (\"new state \", new_state)\n\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\n if (new_state not in self.visited_states):\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\n new_gs.parent = self.currentState\n self.currentState.children.append(new_gs)\n self.currentState.nextChildToVisit = to_move + 1\n self.visited[new_gs] = True\n self.visited_states.append(new_state)\n self.gs_queue.append(new_gs)\n\n self.gm.reverseMove(movable_statement)\n\n # Return false if no more to explore\n if not self.gs_queue:\n return False\n\n # Revert to state at when current and next start to change\n root_curr = self.currentState\n self.currentState = self.gs_queue.popleft()\n root_new = self.currentState\n\n # Backtrack to when current node and new node start to diverge\n if root_new.depth == root_curr.depth:\n while root_curr.state != root_new.state:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n root_new = root_new.parent\n else:\n while root_curr.requiredMovable:\n self.gm.reverseMove(root_curr.requiredMovable)\n root_curr = root_curr.parent\n\n # Return game master to state that we are exploring\n # Find path between root and current state\n path = []\n currNode = self.currentState\n while currNode != root_curr:\n path.append(currNode.requiredMovable)\n currNode = currNode.parent\n\n # Created backwards path, now make moves from root to current state\n path.reverse()\n for movable_statement in path:\n self.gm.makeMove(movable_statement)\n\n return False","def expectimax_move(game, method='score'):\n\n if method == 'score':\n def val(g):\n return g[1]\n elif method == 'empty':\n val = empty_squares\n elif method == 'gradient':\n val = gradient_value\n else:\n print('Invalid method given to expectimax function')\n exit(1)\n\n _, move = expectimax(game, 2, val)\n return move","def minimax(board):\n if (terminal(board)):\n return None\n if (player(board) == X):\n best_so_far = -2\n else:\n best_so_far = 2\n best_move = ()\n for move in actions(board):\n new_board = [row[:] for row in board]\n res = recursion(result(new_board, move))\n if (player(board) == X):\n if (res > best_so_far):\n best_so_far = res\n best_move = move\n if (res == 1):\n break\n else:\n if (res < best_so_far):\n best_so_far = res\n best_move = move\n if (res == -1):\n break\n \n return best_move","def _find_move(self, current, ply, difficulty_level, player):\n\n #check the score of this state\n node_score = current.get_score()\n #if this state is a win for either side, or if we're at the end of our difficulty depth level\n if ply == difficulty_level or node_score > 100000000 or node_score < -100000000: #base case\n return node_score * (difficulty_level+1-ply) #NOTE: I'm not sure if this is paranoid, but I want to make sure it doesn't multiply by 0 if we hit a win condition at the end of our search\n\n #recursive\n else:\n options = []\n #we're either player one (Min) or player two (Max)\n\n #for a column at c in the rack\n for c in range(WIDTH):\n\n #simulate a move in that column, making an attempt State\n attempt = current.simul_move(c, player)\n\n if attempt is not None: #if this produced a move\n if player == 1: next_player = 2\n else: next_player = 1\n\n #recurse down this attempted move\n attempt_score = self._find_move(attempt, ply+1, difficulty_level, next_player)\n #add the results of each column move into options\n options.append(attempt_score)\n if len(options) == 0: return 0\n #based on whether we're the current player or not, max (if we are) or min (if we aren't) and pass back the result\n if player == self.player_id: return max(options)\n else: return min(options)","def Pwin(state):\n # Assumes opponent also plays with optimal strategy\n p, me, you, pending = state\n if me + pending >= goal:\n return 1\n elif you >= goal:\n return 0\n else:\n return max(Q_pig(state, action, Pwin) for action in pig_actions(state))","def mm_move(board, player):\n result = board.check_win() # get result of the current board\n if result == None:\n move_list = board.get_empty_squares() # get the tree branches and possible next moves\n best = (None, (-1, -1))\n for step in move_list:\n bd_clone = board.clone()\n bd_clone.move(step[0], step[1], player) #make a move on a cloned board\n next_player = provided.switch_player(player)\n next_score = mm_move(bd_clone, next_player) #make a recursive call to mm_move() pasing the cloned board and the 'other' player\n if player == 3: #if it is oppo O--min\n if best[0] == None or (next_score[0] < best[0]):\n best = (next_score[0], step)\n #print best\n elif player ==2: #if it is X--max\n if best[0] == None or (next_score[0] > best[0]):\n best = (next_score[0], step)\n return best\n else:\n return SCORES[result], (-1, -1)","def minimax_minimize_play(self, game, legal_moves, depth):\n lowest_score, selected_move = (float('inf'), (-1, -1))\n for move in legal_moves:\n score, _ = self.minimax(game.forecast_move(move), depth - 1)\n lowest_score, selected_move = min((lowest_score, selected_move), (score, move))\n return (lowest_score, selected_move)","def getMove(self, grid):\n# global prune\n# prune = 0\n def Terminal(stateTup):\n \"\"\"\n Checks if the node is a terminal node\n Returns eval(state) if it is terminal\n \"\"\"\n state = stateTup[0]\n maxDepth = self.depthLimit\n if stateTup[1] == maxDepth:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n elif len(stateTup[0].getAvailableMoves()) == 0:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n\n def Eval(state):\n \"\"\"\n This is the eval function which combines many heuristics and assigns\n weights to each of them\n Returns a single value\n \"\"\"\n\n# H1 = htest2(state)\n# return H1\n H2 = h1(state)*monotonic(state)\n return H2\n\n\n def h1(state):\n Max = state.getMaxTile()\n left = len(state.getAvailableCells())/16\n if state.getCellValue([0,0]) == Max:\n v = 1\n else:\n v= 0.3\n Max = Max/1024\n return Max*left*v\n\n def mono(state):\n mon = 0\n# for i in range(4):\n# row = 0\n# for j in range(3):\n# if state.map[i][j] > state.map[i][j+1]:\n# row+=1\n# if row == 4:\n# mon += 1\n# for i in range(4):\n# column = 0\n# for j in range(3):\n# if state.map[j][i] > state.map[j+1][i]:\n# column +=1\n# if column == 4:\n# mon +=1\n#\n#\n# return mon/8\n for i in range(4):\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\n mon+=1\n\n return mon/8\n\n def monotonic(state):\n cellvals = {}\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n for i in Path1:\n cellvals[i] = state.getCellValue(i)\n mon = 0\n for i in range(4):\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\n mon +=1\n for j in range(4):\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\n mon+=1\n return mon/8\n\n\n\n def htest2(state):\n score1 = 0\n score2 = 0\n r = 0.5\n\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\n valDict = {}\n for n in range(16):\n valDict[Path1[n]] = state.getCellValue(Path1[n])\n for n in range(16):\n if n%3 == 0:\n self.emergency()\n cell1 = valDict.get(Path1[n])\n cell2 = valDict.get(Path2[n])\n score1 += (cell1) * (r**n)\n score2 += (cell2) * (r**n)\n return max(score1,score2)\n\n\n def Maximize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n maxChild , maxUtility = None,-999999999\n state = stateTup[0]\n Map = self.dict.get(str(state.map))\n if Map == None:\n children = []\n for M in range(4):\n g = state.clone()\n if g.move(M):\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Minimize(childTup,A,B)[1]\n if utility > maxUtility:\n maxChild , maxUtility = child , utility\n if maxUtility >= B:\n# global prune\n# prune +=1\n break\n if maxUtility > A:\n A = maxUtility\n\n return (maxChild,maxUtility)\n\n\n def Minimize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n minChild , minUtility = None,999999999\n state = stateTup[0]\n Map= self.dict.get(str(state.map))\n if Map == None:\n cells= state.getAvailableCells()\n children = []\n tiles = [2,4]\n for i in cells:\n for j in tiles:\n g = state.clone()\n g.insertTile(i,j)\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Maximize(childTup,A,B)[1]\n if utility < minUtility:\n minChild , minUtility = child , utility\n if minUtility <= A:\n# global prune\n# prune +=1\n break\n if minUtility < B:\n B = minUtility\n\n return (minChild,minUtility)\n\n\n\n def decision(grid):\n \"\"\"\n Decision function which returns the move which led to the state\n \"\"\"\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()\n\n self.dict = {}\n self.h = {}\n self.prevTime = time.clock()\n self.depthLimit = 1\n self.mL = []\n self.over = False\n while self.over == False:\n self.depthLimit +=1\n try :\n self.mL.append(decision(grid))\n\n except KeyError:\n# print(self.depthLimit)\n return self.mL[-1]\n except IndexError:\n return random.randint(0,3)\n self.Alarm(time.clock())\n return self.mL[-1]","def play(self):\r\n state = copy.deepcopy(self.initial_state)\r\n # calculating the best move value and action for the given state\r\n best_action = self.minimax_decision(state)\r\n\r\n # To handle the case where there are no possible moves from the initial state\r\n if best_action[1] not in [(9, 9, 9), (6, 6), (5, 5)]:\r\n # Making the best move corresponding to the initial state\r\n state = copy.deepcopy(self.initial_state)\r\n expected_state = self.result(state, best_action[1])\r\n\r\n # Printing the board state resulting from the best move.\r\n print '{}'.format(self.convert_matrix_rastor(expected_state))"],"string":"[\n \"def iterative_minimax_strategy(game: Any) -> Any:\\n s = Stack()\\n id0 = 0\\n d = {0: Tree([id0, game, None])}\\n s.add(0)\\n\\n while not s.is_empty():\\n id1 = s.remove()\\n item = [id1]\\n if d[id1].children == []:\\n for move in d[id1].value[1].current_state.get_possible_moves():\\n game1 = copy.deepcopy(d[id1].value[1])\\n game1.current_state = game1.current_state.make_move(move)\\n id0 += 1\\n d[id0] = Tree([id0, game1, None])\\n d[id1].children.append(id0)\\n item.append(id0)\\n else:\\n item.extend(d[id1].children)\\n for num in item:\\n if d[num].value[1].is_over(d[num].value[1].current_state):\\n d[num].value[2] = -1\\n elif d[num].children != [] and all(d[x].value[2] is not None\\n for x in d[num].children):\\n d[num].value[2] = max([(-1) * d[y].value[2]\\n for y in d[num].children])\\n else:\\n s.add(num)\\n i = 0\\n for q in d[0].children:\\n if d[q].value[2] == -1:\\n i = d[0].children.index(q)\\n return game.current_state.get_possible_moves()[i]\",\n \"def minimax(board):\\n\\n current_player = player(board)\",\n \"def get_ai_move_minimax(self, gamestate, depth, current_player):\\n multiplier = 1 if current_player else -1\\n # Base case\\n if depth == 0:\\n return (\\n self.evaluate_board(\\n gamestate.board,\\n gamestate.white_checkmate,\\n gamestate.black_checkmate,\\n gamestate.stalemate,\\n )\\n * multiplier\\n )\\n\\n best_score = self.BLACK_CHECKMATE\\n for move in gamestate.get_valid_moves():\\n # Execute the move\\n (current_row, current_column), (new_row, new_column) = move\\n current_piece = gamestate.board.board[current_row][current_column]\\n piece_at_new_square = gamestate.board.board[new_row][new_column]\\n\\n gamestate.board.board[current_row][current_column] = None\\n gamestate.board.board[new_row][new_column] = current_piece\\n\\n # Update King's location\\n if isinstance(current_piece, King):\\n if current_player:\\n gamestate.white_king_location = (new_row, new_column)\\n else:\\n gamestate.black_king_location = (new_row, new_column)\\n\\n # Execute pawn promotion\\n elif isinstance(current_piece, Pawn):\\n if current_piece.colour and new_row == 0:\\n new_piece = Queen(new_row, new_column, True)\\n gamestate.board.white_pieces.remove(current_piece)\\n gamestate.board.white_pieces.append(new_piece)\\n gamestate.board.board[new_row][new_column] = new_piece\\n\\n elif not current_piece.colour and new_row == 7:\\n new_piece = Queen(new_row, new_column, False)\\n gamestate.board.black_pieces.remove(current_piece)\\n gamestate.board.black_pieces.append(new_piece)\\n gamestate.board.board[new_row][new_column] = new_piece\\n\\n # Switch player\\n gamestate.current_player_colour = not gamestate.current_player_colour\\n\\n if current_piece is None:\\n return self.BLACK_CHECKMATE\\n\\n current_piece.row = new_row\\n current_piece.column = new_column\\n\\n if piece_at_new_square:\\n if piece_at_new_square.colour:\\n gamestate.board.white_pieces.remove(piece_at_new_square)\\n else:\\n gamestate.board.black_pieces.remove(piece_at_new_square)\\n\\n gamestate.is_checkmate_or_stalemate()\\n gamestate.check_draw()\\n\\n # Evaluate score for gamestate recursively\\n score = -1 * self.get_ai_move_minimax(\\n gamestate, depth - 1, not current_player\\n )\\n\\n # Undo the move\\n gamestate.board.board[current_row][current_column] = current_piece\\n gamestate.board.board[new_row][new_column] = piece_at_new_square\\n\\n if isinstance(current_piece, King):\\n if current_player:\\n gamestate.white_king_location = (current_row, current_column)\\n else:\\n gamestate.black_king_location = (current_row, current_column)\\n\\n # Undo pawn promotion\\n elif isinstance(current_piece, Pawn):\\n if current_piece.colour and new_row == 0:\\n gamestate.board.white_pieces.append(current_piece)\\n gamestate.board.white_pieces.remove(new_piece)\\n elif not current_piece.colour and new_row == 7:\\n gamestate.board.black_pieces.append(current_piece)\\n gamestate.board.black_pieces.remove(new_piece)\\n\\n # Switch player back\\n gamestate.current_player_colour = not gamestate.current_player_colour\\n\\n current_piece.row = current_row\\n current_piece.column = current_column\\n\\n if piece_at_new_square:\\n if piece_at_new_square.colour:\\n gamestate.board.white_pieces.append(piece_at_new_square)\\n else:\\n gamestate.board.black_pieces.append(piece_at_new_square)\\n\\n gamestate.white_checkmate = False\\n gamestate.black_checkmate = False\\n gamestate.stalemate = False\\n\\n # Check if best score and update list of best moves\\n if score > best_score:\\n best_score = score\\n if depth == self.DEPTH:\\n self.minimax_best_moves = [move]\\n\\n elif score == best_score and depth == self.DEPTH:\\n self.minimax_best_moves.append(move)\\n\\n return best_score\",\n \"def test_minimax_interface(self):\\n h, w = 7, 7 # board size\\n test_depth = 1\\n starting_location = (5, 3)\\n adversary_location = (0, 0) # top left corner\\n iterative_search = False\\n search_method = \\\"minimax\\\"\\n heuristic = lambda g, p: 0. # return 0 everywhere\\n\\n # create a player agent & a game board\\n agentUT = game_agent.CustomPlayer(\\n test_depth, heuristic, iterative_search, search_method)\\n agentUT.time_left = lambda: 99 # ignore timeout for fixed-depth search\\n board = isolation.Board(agentUT, 'null_agent', w, h)\\n\\n # place two \\\"players\\\" on the board at arbitrary (but fixed) locations\\n board.apply_move(starting_location)\\n board.apply_move(adversary_location)\\n\\n for move in board.get_legal_moves():\\n next_state = board.forecast_move(move)\\n v, _ = agentUT.minimax(next_state, test_depth)\\n\\n self.assertTrue(type(v) == float,\\n (\\\"Minimax function should return a floating \\\" +\\n \\\"point value approximating the score for the \\\" +\\n \\\"branch being searched.\\\"))\",\n \"def play_against_minimax():\\n global FIRST_MOVE\\n global done\\n done = False\\n g = Game()\\n turn = np.random.randint(2)\\n # if turn == RED:\\n # FIRST_MOVE = False\\n transitions_agent = []\\n agent.epsilon = agent.eps_min\\n while done == False:\\n g.printBoard()\\n # print(g.board)\\n if turn == PLAYER:\\n row = input('{}\\\\'s turn:'.format('Red'))\\n g.insert(int(row), PLAYER_PIECE)\\n else:\\n observation = []\\n obs = np.zeros((6, 7))\\n for row, sublist in enumerate(g.board):\\n for col, i in enumerate(sublist):\\n observation.append(i)\\n obs[col, row] = i\\n\\n observation = np.asarray(observation)\\n action, _ = minimax(np.flipud(obs), 5, -math.inf, math.inf, True)\\n if g.check_if_action_valid(action):\\n print('{}\\\\'s turn: %d'.format('Yellow') % action)\\n g.insert(action, AI_PIECE)\\n else:\\n while g.check_if_action_valid(action) == False:\\n agent.store_transition(observation, action, -100, observation, done)\\n action = np.random.randint(7)\\n print('{}\\\\'s turn: %d'.format('Yellow') % action)\\n g.insert(action, AI_PIECE)\\n observation_ = []\\n for sublist in g.board:\\n for i in sublist:\\n observation_.append(i)\\n observation_ = np.asarray(observation_)\\n transitions_agent += [(observation, action, observation_, done)]\\n turn = (turn + 1) % 2\\n return\",\n \"def minimax(board):\\n #This function will return the best move. \\n #If Ai is playing as X, I can reduce the processing time by creating a random first move. \\n if (board == initial_state()):\\n coord1 = randint(0,2)\\n coord2 = randint(0,2)\\n return ((coord1,coord2))\\n #first I determine which player's turn it is\\n player_to_move = player(board)\\n best_action = None\\n #If I am X\\n if(player_to_move == \\\"X\\\"):\\n current_max = float('-inf')\\n #for every possible action I have right now, I'll call my \\\"future\\\" Min_Value since I will asume what will happen if I take this move.\\n for action in actions(board):\\n #peak on the future if I take that move\\n curr_score = Min_Value(result(board,action))\\n #if my future is favorable, I will store it as my current best option.\\n if curr_score>= current_max:\\n current_max = curr_score\\n best_action = action\\n else:\\n #If I am O, I do something similar. \\n current_max = float('inf')\\n #for every action I peak on the future for favorable results\\n for action in actions(board):\\n #this time, however, it would be X's turn so I need to start with Max_Value\\n curr_score = Max_Value(result(board,action))\\n #if my future is favorable, I store it\\n if curr_score<= current_max:\\n current_max = curr_score\\n best_action = action\\n #I return the best move.\\n return best_action\",\n \"def minimax(gamestate, depth, timeTotal, alpha, beta, maxEntity):\\n\\n bonus = 0\\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\\n # Basis Rekursif\\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\\n bonus = 10\\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\\n bonus = -10\\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\\n\\n # Rekurens\\n if (gamestate.currentPlayer.noPlayer == maxEntity):\\n # Choose the maximum utility of the state\\n # Iterate all pion and its possible moves\\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n maxValue = -math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n # Iterate all possible moves of pion index\\n for move in all_possible_moves:\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n\\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old max value\\n if (utility > maxValue):\\n maxValue = utility\\n maxGameState = newGameState\\n \\n alpha = max(alpha, maxValue)\\n if (beta <= alpha):\\n return maxGameState, maxValue\\n return maxGameState, maxValue\\n\\n else:\\n # Choose the minimum utility of the state\\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n minValue = math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n # Iterate all possible moves of pion index\\n for move in all_possible_moves:\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n\\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimax(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old min value\\n if (utility < minValue):\\n minValue = utility\\n minGameState = newGameState\\n \\n beta = min(beta, minValue)\\n if (beta <= alpha):\\n return minGameState, minValue\\n \\n return minGameState, minValue\",\n \"def run_ai():\\n print(\\\"Minimax AI\\\") # First line is the name of this AI \\n color = int(input()) # Then we read the color: 1 for dark (goes first), \\n # 2 for light. \\n\\n while True: # This is the main loop \\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input() \\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n\\n if status == \\\"FINAL\\\": # Game is over. \\n print \\n else: \\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The \\n # squares in each row are represented by \\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n \\n # Select the move and send it to the manager\\n movei, movej = select_move_minimax(board, color)\\n # movei, movej = select_move_alphabeta(board, color)\\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def recursive_minimax_strategy(game: Any) -> Any:\\n lista = []\\n if game.current_state.p1_turn:\\n for i in game.current_state.get_possible_moves():\\n game2 = copy.deepcopy(game)\\n new_state = game2.current_state.make_move(i)\\n game2.current_state = new_state\\n lista.append(recursive1(game2, []))\\n\\n else:\\n for i in game.current_state.get_possible_moves():\\n game2 = copy.deepcopy(game)\\n new_state = game2.current_state.make_move(i)\\n game2.current_state = new_state\\n lista.append(recursive2(game2, []))\\n\\n if 1 in lista:\\n return game.current_state.get_possible_moves()[lista.index(1)]\\n return game.current_state.get_possible_moves()[0]\",\n \"def action(self):\\r\\n\\r\\n\\r\\n #have we just started?\\r\\n if self.player_information[\\\"us\\\"][\\\"nTokens\\\"] == 0:\\r\\n move = generate_starting_move(self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array)\\r\\n return move\\r\\n\\r\\n #otherwise do minimax \\r\\n \\r\\n #start off with some shallow depth:\\r\\n if self.turn_no < 5:\\r\\n depth = 3\\r\\n else:\\r\\n depth = 2\\r\\n \\r\\n #set a constraint for search depth\\r\\n if self.total_tokens_on_board < 6:\\r\\n depth = 3\\r\\n elif self.total_tokens_on_board < 10:\\r\\n depth = 2\\r\\n else:\\r\\n depth = 1\\r\\n \\r\\n #have a time reference\\r\\n print(f'nthrows: {self.player_information[\\\"us\\\"][\\\"nThrowsRemaining\\\"]}')\\r\\n starting_time = int(round(time.time(), 0))\\r\\n #salvage result from minimax\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, depth, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, True, self.turn_no)\\r\\n\\r\\n #clean it up a bit \\r\\n print(self.board_dict)\\r\\n #tidy it up\\r\\n result = result[0]\\r\\n print(f'pre: {result}')\\r\\n #in case we get a bad move redo but make it very shallow\\r\\n if len(result) == 1 or result == (-5, -5):\\r\\n #force it to return a usable move\\r\\n counter = 0\\r\\n while (len(result) == 1) or (result == (-5, -5)):\\r\\n result = minimax(self.board_dict.copy(), self.player_tokens.copy(), self.co_existance_dict.copy(),\\r\\n None, None, None, 1, True, -math.inf, math.inf,\\r\\n (-5, -5), self.player_information.copy(), self.board_array, self.board_edge, \\r\\n starting_time, False, self.turn_no)\\r\\n result = result[0]\\r\\n counter += 1\\r\\n \\r\\n #if its taking too long\\r\\n if counter > 2: \\r\\n #generate one random possible move to use \\r\\n allied_tokens = [token for token in self.player_tokens if self.player_tokens[token] == \\\"us\\\"]\\r\\n move_list = generate_moves(self.board_dict, self.player_tokens, self.co_existance_dict, allied_tokens,\\r\\n self.player_information, self.board_array, True, \\\"all\\\")\\r\\n \\r\\n \\r\\n #if there are no moves\\r\\n if len(move_list) == 0:\\r\\n if self.player_information['us']['nThrowsRemaining'] > 0:\\r\\n throws = generate_possible_throws(self.board_dict, self.player_tokens, self.co_existance_dict, self.player_information, \\\"us\\\",\\r\\n self.player_information[\\\"us\\\"][\\\"player_side\\\"], self.board_array, \\\"all\\\" )\\r\\n result = random.choice(throws)\\r\\n \\r\\n else:\\r\\n result = random.choice(move_list)\\r\\n print(f'random: {result}')\\r\\n break\\r\\n\\r\\n print(f' inside: {result}')\\r\\n\\r\\n print(result)\\r\\n #otherwise clean it up\\r\\n if result[0] == 'throw':\\r\\n final_result = (result[0].upper(), result[1], result[2])\\r\\n else:\\r\\n final_result = (result[0].upper(), result[2], result[3])\\r\\n # return final result \\r\\n return final_result\",\n \"def minimaxTest(yourAgent, minimax_fn):\\n\\n # create dummy 5x5 board\\n print(\\\"Now running the Minimax test.\\\")\\n print()\\n try:\\n def time_left(): # For these testing purposes, let's ignore timeouts\\n return 10000\\n\\n player = yourAgent() #using as a dummy player to create a board\\n sample_board = Board(player, RandomPlayer())\\n # setting up the board as though we've been playing\\n board_state = [\\n [\\\"Q1\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\"Q2\\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"]\\n ]\\n sample_board.set_state(board_state, True)\\n\\n test_pass = True\\n\\n expected_depth_scores = [(1, 4), (2, -2), (3, 4), (4, -2), (5, 2)]\\n\\n for depth, exp_score in expected_depth_scores:\\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\\n if exp_score != score:\\n print(\\\"Minimax failed for depth: \\\", depth)\\n test_pass = False\\n\\n if test_pass:\\n player = yourAgent()\\n sample_board = Board(player, RandomPlayer())\\n # setting up the board as though we've been playing\\n board_state = [\\n [\\\" \\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\"Q2\\\", \\\" \\\"],\\n [\\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"],\\n [\\\"X\\\", \\\"X\\\", \\\"X\\\", \\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\"Q1\\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\"X\\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\"X\\\", \\\" \\\"],\\n [\\\"X\\\", \\\" \\\", \\\" \\\", \\\" \\\", \\\"X\\\", \\\" \\\", \\\" \\\"]\\n ]\\n sample_board.set_state(board_state, True)\\n\\n test_pass = True\\n\\n expected_depth_scores = [(1, 5), (2, 5), (3, 5), (4, 6), (5, 6)]\\n\\n for depth, exp_score in expected_depth_scores:\\n move, score = minimax_fn(player, sample_board, time_left, depth=depth, my_turn=True)\\n if exp_score != score:\\n print(\\\"Minimax failed for depth: \\\", depth)\\n test_pass = False\\n\\n if test_pass:\\n print(\\\"Minimax Test: Runs Successfully!\\\")\\n\\n except NotImplementedError:\\n print('Minimax Test: Not implemented')\\n except:\\n print('Minimax Test: ERROR OCCURRED')\\n print(traceback.format_exc())\",\n \"def minimax(board: list, player_turn: chr):\\n if player_turn == 'b':\\n enemy_turn = 'w'\\n else:\\n enemy_turn = 'b'\\n player_moves, enemy_start_boards = Evaluator.generate_options(board, player_turn)\\n\\n player_scores = [x.get(\\\"final_score\\\") for x in player_moves]\\n enemy_scores = []\\n\\n for enemy_start_board in enemy_start_boards:\\n board_index = enemy_start_boards.index(enemy_start_board)\\n player_score = player_scores[board_index]\\n enemy_moves, player_start_boards = Evaluator.generate_options(enemy_start_board, enemy_turn)\\n\\n # Gets highest white score for first board.\\n if enemy_start_boards.index(enemy_start_board) == 0:\\n best_enemy_score = -10000000\\n for move in enemy_moves:\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > best_enemy_score:\\n best_enemy_score = score\\n enemy_scores.append(best_enemy_score)\\n else:\\n current_min = min(enemy_scores)\\n best_enemy_score = -10000000\\n break_flag = False\\n\\n # Checks moves where active player performs push, more likely to yield high score -> move ordering.\\n push_moves = filter(Evaluator.filter_push, enemy_moves)\\n for move in push_moves:\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > current_min:\\n enemy_scores.append(score)\\n break_flag = True\\n break\\n if break_flag:\\n continue\\n\\n for move in enemy_moves:\\n if move.get(\\\"pushes\\\") > 0:\\n continue\\n score = move.get(\\\"final_score\\\") - player_score\\n if score > current_min:\\n enemy_scores.append(score)\\n break_flag = True\\n break\\n if score > best_enemy_score:\\n best_enemy_score = score\\n if not break_flag:\\n enemy_scores.append(best_enemy_score)\\n # print(enemy_start_board)\\n # [print(x) for x in enemy_moves]\\n # print(\\\"======================\\\")\\n\\n # Gets the lowest score aka worst board state for the opponent which will be the best move for us.\\n min_val = min(enemy_scores)\\n check_scores = numpy.array(enemy_scores)\\n min_index = numpy.where(check_scores == min_val)[0]\\n\\n best_index = 0\\n best_score = -100000\\n\\n for i in min_index:\\n if player_moves[i].get(\\\"final_score\\\") > best_score:\\n best_score = player_moves[i].get(\\\"final_score\\\")\\n best_index = i\\n\\n return player_moves[best_index]\",\n \"def run_ai():\\n print(\\\"Othello AI\\\") # First line is the name of this AI\\n arguments = input().split(\\\",\\\")\\n \\n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \\n limit = int(arguments[1]) #Depth limit\\n minimax = int(arguments[2]) #Minimax or alpha beta\\n caching = int(arguments[3]) #Caching \\n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\\n\\n if (minimax == 1): eprint(\\\"Running MINIMAX\\\")\\n else: eprint(\\\"Running ALPHA-BETA\\\")\\n\\n if (caching == 1): eprint(\\\"State Caching is ON\\\")\\n else: eprint(\\\"State Caching is OFF\\\")\\n\\n if (ordering == 1): eprint(\\\"Node Ordering is ON\\\")\\n else: eprint(\\\"Node Ordering is OFF\\\")\\n\\n if (limit == -1): eprint(\\\"Depth Limit is OFF\\\")\\n else: eprint(\\\"Depth Limit is \\\", limit)\\n\\n if (minimax == 1 and ordering == 1): eprint(\\\"Node Ordering should have no impact on Minimax\\\")\\n\\n while True: # This is the main loop\\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input()\\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over.\\n print\\n else:\\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The\\n # squares in each row are represented by\\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n\\n # Select the move and send it to the manager\\n if (minimax == 1): #run this if the minimax flag is given\\n movei, movej = select_move_minimax(board, color, limit, caching)\\n else: #else run alphabeta\\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\\n \\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def run_ai():\\n print(\\\"Othello AI\\\") # First line is the name of this AI\\n arguments = input().split(\\\",\\\")\\n \\n color = int(arguments[0]) #Player color: 1 for dark (goes first), 2 for light. \\n limit = int(arguments[1]) #Depth limit\\n minimax = int(arguments[2]) #Minimax or alpha beta\\n caching = int(arguments[3]) #Caching \\n ordering = int(arguments[4]) #Node-ordering (for alpha-beta only)\\n\\n if (minimax == 1): eprint(\\\"Running MINIMAX\\\")\\n else: eprint(\\\"Running ALPHA-BETA\\\")\\n\\n if (caching == 1): eprint(\\\"State Caching is ON\\\")\\n else: eprint(\\\"State Caching is OFF\\\")\\n\\n if (ordering == 1): eprint(\\\"Node Ordering is ON\\\")\\n else: eprint(\\\"Node Ordering is OFF\\\")\\n\\n if (limit == -1): eprint(\\\"Depth Limit is OFF\\\")\\n else: eprint(\\\"Depth Limit is \\\", limit)\\n\\n if (minimax == 1 and ordering == 1): eprint(\\\"Node Ordering should have no impact on Minimax\\\")\\n\\n while True: # This is the main loop\\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input()\\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over.\\n print\\n else:\\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The\\n # squares in each row are represented by\\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n\\n # Select the move and send it to the manager\\n if (minimax == 1): #run this if the minimax flag is given\\n movei, movej = select_move_minimax(board, color, limit, caching)\\n else: #else run alphabeta\\n movei, movej = select_move_alphabeta(board, color, limit, caching, ordering)\\n \\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def play_minimax(minimax_dep):\\n global win_cntr\\n global lose_cntr\\n global done\\n global vertical_win\\n vertical_win = False\\n g = Game()\\n turn = np.random.randint(2)\\n done = False\\n transitions_agent = []\\n transitions_agent2 = []\\n while done == False:\\n #g.printBoard()\\n\\n # Player 1 dqn agent\\n if turn == PLAYER:\\n observation = []\\n for row, sublist in enumerate(g.board):\\n for col, obs in enumerate(sublist):\\n observation.append(obs)\\n\\n observation = np.asarray(observation)\\n action = agent.choose_action(observation)\\n if g.check_if_action_valid(action):\\n g.insert(action, PLAYER_PIECE)\\n else:\\n while g.check_if_action_valid(action) == False:\\n agent.store_transition(observation, action, -100, observation, done)\\n action = np.random.randint(7)\\n g.insert(action, PLAYER_PIECE)\\n observation_ = []\\n for sublist in g.board:\\n for obs in sublist:\\n observation_.append(obs)\\n observation_ = np.asarray(observation_)\\n transitions_agent2 += [(observation, action, observation_, done)]\\n\\n # Player 2 Minimax\\n else:\\n observation = []\\n obs = np.zeros((6, 7))\\n for row, sublist in enumerate(g.board):\\n for col, sub in enumerate(sublist):\\n observation.append(sub)\\n obs[col, row] = sub\\n\\n observation = np.asarray(observation)\\n\\n if minimax_dep > 0: #and np.random.rand(1) > 0.05\\n action, _ = minimax(np.flipud(obs), minimax_dep, -math.inf, math.inf, True)\\n else:\\n action = np.random.randint(7)\\n\\n if g.check_if_action_valid(action):\\n g.insert(action, AI_PIECE)\\n else:\\n while not g.check_if_action_valid(action):\\n agent.store_transition(observation, action, -100, observation, done)\\n action = np.random.randint(7)\\n\\n g.insert(action, AI_PIECE)\\n\\n observation_ = []\\n for sublist in g.board:\\n for sub in sublist:\\n observation_.append(sub)\\n observation_ = np.asarray(observation_)\\n transitions_agent += [(observation, action, observation_, done)]\\n turn = (turn + 1) % 2\\n\\n if g.getWinner() == Tie:\\n #reward_minimax = -1\\n reward_nn = -1\\n else:\\n winner = AI if turn == PLAYER else PLAYER\\n\\n if winner == AI:\\n lose_cntr += 1\\n #reward_minimax = 20\\n reward_nn = -20\\n else:\\n win_cntr += 1\\n #reward_minimax = -20\\n reward_nn = 20\\n\\n '''for obs in range(len(transitions_agent)):\\n agent.store_transition(transitions_agent[obs][0], transitions_agent[obs][1], reward_minimax,\\n transitions_agent[obs][2], transitions_agent[obs][3])'''\\n for i in range(len(transitions_agent2)):\\n agent.store_transition(transitions_agent2[i][0], transitions_agent2[i][1], reward_nn, transitions_agent2[i][2],\\n transitions_agent2[i][3])\\n agent.learn()\\n return\",\n \"def test_solve_one_player_1(self):\\n self.rush_hour_data = rush_hour_data_1\\n self.state_data = state_data_1\\n self.execute_minimax_single_player()\",\n \"def minimax(self, board: str):\\n \\\"\\\"\\\" Your Code Here \\\"\\\"\\\"\\n\\n # ----------------------------BEGIN CODE----------------------------\\n # disclaimer: I did only minimax (as said on the homework description https://drive.google.com/file/d/1JXBi_5JB8fwTWX34j0ZwN5YwjoIexh-Z/view)\\n # my minimax does NOT try to prolong the game. It always goes for the best move!\\n\\n # initializing default values\\n moveToMake = validMoves(board)[0]\\n bestValue = -100\\n\\n # this will find the best move to go to, since value only returns the best score\\n # util's setMove creates a copy, so we can use that as the successor\\n for validmove in validMoves(board):\\n currentValue = self.value(\\n setMove(board, validmove, whoseMove(board)), 0)\\n if currentValue > bestValue:\\n bestValue = currentValue\\n moveToMake = validmove\\n\\n # currently the val and game_length tuple is arbitrary because i have not implemented depth!\\n return (moveToMake)\",\n \"def minimaxLocalSearch(gamestate, depth, timeTotal, alpha, beta, maxEntity):\\n bonus = 0\\n isTerminalState = gamestate.board.checkTerminalState(gamestate.currentPlayer.noPlayer)\\n # Basis Rekursif\\n if ((depth == 0) or (time.time() > timeTotal) or (isTerminalState)):\\n if (isTerminalState) and (gamestate.currentPlayer.noPlayer == maxEntity):\\n bonus = 10\\n elif (isTerminalState) and (gamestate.currentPlayer.noPlayer != maxEntity):\\n bonus = -10\\n return gamestate, U_Function(gamestate.currentPlayer, gamestate.oppositePlayer, gamestate.board.size, maxEntity) + bonus\\n\\n # Rekurens\\n if (gamestate.currentPlayer.noPlayer == maxEntity):\\n # Choose the maximum utility of the state\\n # Iterate all pion and its possible moves\\n maxGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n maxValue = -math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n # Choose the best move from local search heuristic\\n if (len(all_possible_moves) > 0):\\n move = getBestMove(all_possible_moves, gamestate)\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n \\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimaxLocalSearch(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old max value\\n if (utility > maxValue):\\n maxValue = utility\\n maxGameState = newGameState\\n \\n alpha = max(alpha, maxValue)\\n if (beta <= alpha):\\n return maxGameState, maxValue\\n\\n return maxGameState, maxValue\\n\\n else:\\n # Choose the minimum utility of the state\\n minGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n minValue = math.inf\\n\\n # Iterate all pion index\\n for idx in range(len(gamestate.currentPlayer.arrayPion)):\\n all_possible_moves = gamestate.currentPlayer.listAllPossibleMove(idx, gamestate.board)\\n\\n if (len(all_possible_moves) > 0):\\n # Choose the best move from local search heuristic\\n move = getBestMove(all_possible_moves, gamestate)\\n newGameState = GameState.GameState(gamestate.board, gamestate.currentPlayer, gamestate.oppositePlayer)\\n newGameState.currentPlayer.movePion(idx, move, newGameState.board)\\n\\n recursiveState = GameState.GameState(newGameState.board, newGameState.currentPlayer, newGameState.oppositePlayer)\\n recursiveState.nextTurn()\\n dummyState, utility = minimaxLocalSearch(recursiveState, depth-1, timeTotal, alpha, beta, maxEntity)\\n\\n # Compare with the old min value\\n if (utility < minValue):\\n minValue = utility\\n minGameState = newGameState\\n \\n beta = min(beta, minValue)\\n if (beta <= alpha):\\n return minGameState, minValue\\n \\n return minGameState, minValue\",\n \"def utility(state:State,maximizing_player):\\n best_move_score = -1\\n #######################[Goal]#########################\\n is_current_player_stuck = is_stuck(state,state.player_type)\\n other_player = RIVAL if state.player_type == PLAYER else PLAYER\\n # Check if stuck\\n if is_current_player_stuck:\\n if state.player_type == PLAYER:\\n state.players_score[state.player_type] -= state.penalty_score\\n else:\\n state.players_score[state.player_type] += state.penalty_score\\n return state.players_score[state.player_type] - state.players_score[other_player] \\n ######################################################\\n # Else\\n #--------------------------------------------------\\n ################# Available Steps #################\\n #--------------------------------------------------\\n player_available_steps = availables(state.board, state.locations[PLAYER])\\n h1 = 4-player_available_steps\\n h4 = player_available_steps\\n #--------------------------------------------------\\n ################# Fruits Distance #################\\n #--------------------------------------------------\\n h2 = -1\\n if state.fruits_ttl > 0 and len(state.fruits_dict) > 0:\\n min_fruit_dist = float('inf')\\n for fruit_loc in state.fruits_dict:\\n curr_fruit_dist = Manhattan(state.locations[state.player_type], fruit_loc)\\n # Check what is the closest fruit reachable\\n if curr_fruit_dist < min_fruit_dist and curr_fruit_dist <= state.fruits_ttl:\\n other_player_fruit_dist = Manhattan(state.locations[other_player], fruit_loc)\\n if curr_fruit_dist < other_player_fruit_dist:\\n min_fruit_dist = curr_fruit_dist\\n max_dist = len(state.board)+len(state.board[0])\\n h2 = (max_dist*10.0/min_fruit_dist)+1 if min_fruit_dist < float('inf') else -1\\n #--------------------------------------------------\\n ################# Reachable Squrs #################\\n #--------------------------------------------------\\n reachables_player = reachables(state.board,state.locations[PLAYER])\\n reachables_rival = reachables(state.board,state.locations[RIVAL])\\n h3 = reachables_player - reachables_rival # We want more for us\\n #--------------------------------------------------\\n ################# Combine it all. #################\\n #--------------------------------------------------\\n if not state.half_game():\\n w = 0.8 if h2 > 0 else 1\\n best_move_score = w*(h1-h3) + (1-w)*h2 \\n else:\\n w = 0.7 if h2 > 0 else 1\\n best_move_score = w*(h4+h3) + (1-w)*h2 \\n\\n best_move_score += state.players_score[state.player_type]\\n return best_move_score\",\n \"def iterative_minimax(game: Any):\\n moves_scores = []\\n moves = game.current_state.get_possible_moves()\\n\\n for move in moves:\\n g = copy.deepcopy(game)\\n s = g.current_state.make_move(move)\\n g.current_state = s\\n\\n moves_scores.append(-1*iterative_helper(g))\\n\\n return moves[moves_scores.index(max(moves_scores))]\",\n \"def test_minimax(self):\\n h, w = 7, 7 # board size\\n starting_location = (2, 3)\\n adversary_location = (0, 0) # top left corner\\n iterative_search = False\\n method = \\\"minimax\\\"\\n\\n # The agent under test starts at position (2, 3) on the board, which\\n # gives eight (8) possible legal moves [(0, 2), (0, 4), (1, 1), (1, 5),\\n # (3, 1), (3, 5), (4, 2), (4, 4)]. The search function will pick one of\\n # those moves based on the estimated score for each branch. The value\\n # only changes on odd depths because even depths end on when the\\n # adversary has initiative.\\n value_table = [[0] * w for _ in range(h)]\\n value_table[1][5] = 1 # depth 1 & 2\\n value_table[4][3] = 2 # depth 3 & 4\\n value_table[6][6] = 3 # depth 5\\n heuristic = makeEvalTable(value_table)\\n\\n # These moves are the branches that will lead to the cells in the value\\n # table for the search depths.\\n expected_moves = [set([(1, 5)]),\\n set([(3, 1), (3, 5)]),\\n set([(3, 5), (4, 2)])]\\n\\n # Expected number of node expansions during search\\n counts = [(8, 8), (24, 10), (92, 27), (418, 32), (1650, 43)]\\n\\n # Test fixed-depth search; note that odd depths mean that the searching\\n # player (student agent) has the last move, while even depths mean that\\n # the adversary has the last move before calling the heuristic\\n # evaluation function.\\n for idx in range(5):\\n test_depth = idx + 1\\n agentUT, board = self.initAUT(test_depth, heuristic,\\n iterative_search, method,\\n loc1=starting_location,\\n loc2=adversary_location)\\n\\n # disable search timeout by returning a constant value\\n agentUT.time_left = lambda: 1e3\\n _, move = agentUT.minimax(board, test_depth)\\n\\n num_explored_valid = board.counts[0] == counts[idx][0]\\n num_unique_valid = board.counts[1] == counts[idx][1]\\n\\n self.assertTrue(num_explored_valid, WRONG_NUM_EXPLORED.format(\\n method, test_depth, counts[idx][0], board.counts[0]))\\n\\n self.assertTrue(num_unique_valid, UNEXPECTED_VISIT.format(\\n method, test_depth, counts[idx][1], board.counts[1]))\\n\\n self.assertIn(move, expected_moves[idx // 2], WRONG_MOVE.format(\\n method, test_depth, expected_moves[idx // 2], move))\",\n \"def minimax(board):\\n current_player = player(board)\\n \\n if terminal(board):\\n return \\n if current_player == X:\\n optimal_value = -math.inf\\n \\n else:\\n optimal_value = math.inf\\n \\n for action in actions(board):\\n new_board = result(board, action)\\n \\n minimax_value = minimax_aux(new_board, optimal_value)\\n\\n if current_player == X:\\n minimax_value = max(optimal_value, minimax_value)\\n\\n if current_player == O:\\n minimax_value = min(optimal_value, minimax_value)\\n\\n if optimal_value != minimax_value:\\n optimal_value = minimax_value\\n optimal_move = action\\n\\n return optimal_move\",\n \"def recursive_minimax_strategy(game: Game) -> Any:\\n candidate = game.current_state.get_possible_moves()\\n canditate_prop = [\\n -1 * get_state_score(game, game.current_state.make_move(\\n move\\n ))\\n # get_state_score() provides the STATE SCORE for the OPPO player\\n # in each resultent state.\\n # -1 * ... to calculate the STATE SCORE for player taking action now.\\n for move in candidate\\n ]\\n max_index = canditate_prop.index(max(canditate_prop))\\n assert len(canditate_prop) == len(candidate), \\\"Inconsistent length.\\\"\\n return candidate[max_index]\",\n \"def minimax(self, game, depth):\\n \\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n \\n return self.minimax_helper(game, self.search_depth, maximizing_player = True)[1]\",\n \"def minimax(board):\\r\\n player_moving = player(board)\\r\\n\\r\\n\\r\\n if board == [[EMPTY] * 3] * 3:\\r\\n return (0, 0)\\r\\n\\r\\n if player_moving == X:\\r\\n value = -math.inf\\r\\n selected_action = None\\r\\n for action in actions(board):\\r\\n minValueResult = minValue(result(board, action))\\r\\n if minValueResult > value:\\r\\n value = minValueResult\\r\\n selected_action = action\\r\\n elif player_moving == O:\\r\\n value = math.inf\\r\\n selected_action = None\\r\\n for action in actions(board):\\r\\n maxValueResult = maxValue(result(board, action))\\r\\n if maxValueResult < value:\\r\\n value = maxValueResult\\r\\n selected_action = action\\r\\n\\r\\n return selected_action\",\n \"def test_solve_one_player_2(self):\\n self.rush_hour_data = rush_hour_data_2\\n self.state_data = state_data_2\\n self.execute_minimax_single_player()\",\n \"def test_minimax(self):\\n \\n # empty board\\n board = \\\"EEEEEEEEE\\\"\\n res = MinimaxApiView.get_next_move(board, 'O')\\n self.assertEqual(res, 0)\\n board = \\\"OEEEEEEEE\\\"\\n res = MinimaxApiView.get_next_move(board, 'X')\\n self.assertEqual(res, 4)\",\n \"def make_move(self, time_limit, players_score):\\n finish_time = time.time() + time_limit\\n depth = 1\\n best_move = (-np.inf, (-1, 0))\\n while True:\\n for direction in self.directions:\\n initial_state = utils.State(self.board, direction, self.pos, self.current_turn,\\n self.fruits_on_board_dict,\\n finish_time)\\n try:\\n outcome = self.minimax_algo.search(initial_state, depth, True)\\n if outcome[0] > best_move[0]:\\n best_move = outcome\\n except TimeoutError:\\n self.board[self.pos[0]][self.pos[1]] = -1\\n self.pos = (self.pos[0] + best_move[1][0], self.pos[1] + best_move[1][1])\\n self.board[self.pos[0]][self.pos[1]] = 1\\n\\n return best_move[1]\\n depth += 1\\n # print('bigger_depth : {} '.format(depth))\",\n \"def test_minimax():\\n board = Board(*TEST_AGRU1)\\n comp = Computer(board, COMP_DISK, HUMAN_DISK)\\n comp.b.board = [\\n [COMP_DISK, COMP_DISK, 0, 0, 0],\\n [HUMAN_DISK, HUMAN_DISK, HUMAN_DISK, 0, 0],\\n ]\\n comp.b.columns_list = [\\n [COMP_DISK, HUMAN_DISK],\\n [COMP_DISK, HUMAN_DISK],\\n [HUMAN_DISK],\\n [],\\n [],\\n ]\\n comp.b.add_to_board(0, INDEX_TWO, COMP_DISK)\\n assert comp.minimax(comp.b, 1, MAX_START_SCORE, MINI_START_SCORE, False) \\\\\\n == -1\\n\\n board = Board(*TEST_AGRU1)\\n comp = Computer(board, COMP_DISK, HUMAN_DISK)\\n comp.b.board = [\\n [HUMAN_DISK, 0, HUMAN_DISK, HUMAN_DISK, 0],\\n [HUMAN_DISK, 0, COMP_DISK, COMP_DISK, COMP_DISK],\\n ]\\n comp.b.columns_list = [\\n [HUMAN_DISK, HUMAN_DISK],\\n [],\\n [HUMAN_DISK, COMP_DISK],\\n [HUMAN_DISK, COMP_DISK],\\n [],\\n ]\\n comp.b.add_to_board(1, 1, COMP_DISK)\\n assert comp.minimax(comp.b, 1, MAX_START_SCORE, MINI_START_SCORE, False) \\\\\\n == SCORE\",\n \"def minimax(board):\\n\\n if terminal(board):\\n return None\\n\\n action_x = []\\n value_x = []\\n action_y = []\\n value_y = []\\n\\n def max_value(board):\\n v = -float('inf')\\n if terminal(board):\\n return utility(board)\\n\\n for action in actions(board):\\n v = max(v, min_value(result(board, action)))\\n\\n\\n return v\\n\\n def min_value(board):\\n v = float('inf')\\n if terminal(board):\\n return utility(board)\\n for action in actions(board):\\n v = min(v, max_value(result(board, action)))\\n\\n return v\\n\\n for action in actions(board):\\n if player(board) == X:\\n action_x.append(action)\\n value_x.append(min_value(result(board, action)))\\n\\n elif player(board) == O:\\n action_y.append(action)\\n value_y.append(max_value(result(board, action)))\\n\\n if player(board) == X:\\n return action_x[value_x.index(max(value_x))]\\n elif player(board) == O:\\n return action_y[value_y.index(min(value_y))]\",\n \"def play_minimax(self, board, depth, max_player, game):\\n if depth == 0 or (game.check_if_over() and game.winner != 0):\\n return board.evaluate(), board\\n\\n elif max_player:\\n max_eval = float('-inf')\\n best_action = None\\n all_valid_actions = self.simulate_all_valid_actions(board, game.board.top_opponent_color)\\n random.shuffle(all_valid_actions) # Remove the shuffling if the minimax deapth increases\\n for action in all_valid_actions:\\n evaluation = self.play_minimax(action, depth-1, False, game)[0]\\n max_eval = max(max_eval, evaluation)\\n if max_eval == evaluation:\\n best_action = action\\n return max_eval, best_action\\n\\n else:\\n min_eval = float('inf')\\n best_action = None\\n all_valid_actions = self.simulate_all_valid_actions(board, game.board.bottom_player_color)\\n random.shuffle(all_valid_actions) # Remove the shuffling if the minimax deapth increases\\n for action in all_valid_actions:\\n evaluation = self.play_minimax(action, depth-1, True, game)[0]\\n min_eval = min(min_eval, evaluation)\\n if min_eval == evaluation:\\n best_action = action\\n return min_eval, best_action\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n \\n # If AI is X, ie, maximizing player\\n if player(board) is X:\\n _, bestAction = maximum(board, -math.inf, math.inf)\\n return bestAction\\n elif player(board) is O:\\n _, bestAction = minimum(board, -math.inf, math.inf)\\n return bestAction\",\n \"def minimax(board):\\n if terminal(board) == True:\\n return None\\n elif player(board) == X:\\n action = maxit(board)[1:]\\n elif player(board) == O:\\n action = minit(board)[1:]\\n return action\",\n \"def run_ai():\\n print(\\\"Vivian\\\") # First line is the name of this AI \\n color = int(input()) # Then we read the color: 1 for dark (goes first), \\n # 2 for light. \\n\\n while True: # This is the main loop \\n # Read in the current game status, for example:\\n # \\\"SCORE 2 2\\\" or \\\"FINAL 33 31\\\" if the game is over.\\n # The first number is the score for player 1 (dark), the second for player 2 (light)\\n next_input = input() \\n status, dark_score_s, light_score_s = next_input.strip().split()\\n dark_score = int(dark_score_s)\\n light_score = int(light_score_s)\\n\\n if status == \\\"FINAL\\\": # Game is over. \\n print \\n else: \\n board = eval(input()) # Read in the input and turn it into a Python\\n # object. The format is a list of rows. The \\n # squares in each row are represented by \\n # 0 : empty square\\n # 1 : dark disk (player 1)\\n # 2 : light disk (player 2)\\n \\n # Select the move and send it to the manager \\n# movei, movej = select_move_minimax(board, color)\\n movei, movej = select_move_alphabeta(board, color)\\n print(\\\"{} {}\\\".format(movei, movej))\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n #Fetching legal moves for the active player at max level\\n legal_moves = game.get_legal_moves()\\n #Terminial condition - if there are no legal moves left will call the utility function\\n if not legal_moves:\\n return game.utility(self) #Returning utility function\\n #Assigning default value to best move\\n best_move = legal_moves[0]\\n #Assigning default value to best score as -inf\\n best_score = float('-inf')\\n #for each future legal move of active player\\n for move in legal_moves:\\n #Fetching next state forecast moves\\n next_state = game.forecast_move(move)\\n #Calling min_value function for score - Return type of min_value function is score\\n score = self.min_value(next_state, depth-1)\\n if score > best_score:\\n best_move = move\\n best_score = score\\n return best_move #Return best_move\",\n \"def test_solve_one_player_3(self):\\n self.rush_hour_data = rush_hour_data_3\\n self.state_data = state_data_3\\n self.execute_minimax_single_player()\",\n \"def getAction(self, gameState):\\n def Minimaxer(sucGameState, depth, curAgent, alpha, beta):\\n if sucGameState.isWin() or sucGameState.isLose():\\n return self.evaluationFunction(sucGameState)\\n if depth == 0:\\n return self.evaluationFunction(sucGameState)\\n stateValue = 9999\\n curDepthCurAgentActions = sucGameState.getLegalActions(curAgent)\\n if curAgent == sucGameState.getNumAgents()-1:\\n for curAction in curDepthCurAgentActions:\\n stateValue = min(stateValue, miniMaxer(sucGameState.generateSuccessor(curAgent,curAction), depth-1, alpha, beta) )\\n if alpha > stateValue:\\n return stateValue\\n beta = min(beta, stateValue)\\n else:\\n for curAction in curDepthCurAgentActions:\\n stateValue = min(stateValue, Minimaxer(sucGameState.generateSuccessor(curAgent,curAction), depth, curAgent + 1, alpha, beta))\\n if alpha > stateValue:\\n return stateValue\\n beta = min(beta, stateValue)\\n return stateValue\\n\\n def miniMaxer(sucGameState, depth, alpha, beta):\\n if sucGameState.isWin() or sucGameState.isLose():\\n return self.evaluationFunction(sucGameState)\\n if depth == 0:\\n return self.evaluationFunction(sucGameState)\\n stateValue = -9999\\n curDepthCurAgentActions = sucGameState.getLegalActions(0)\\n for curAction in curDepthCurAgentActions:\\n stateValue = max(stateValue, Minimaxer(sucGameState.generateSuccessor(0,curAction), depth, 1, alpha, beta ))\\n if beta < stateValue:\\n return stateValue\\n alpha = max(stateValue, alpha)\\n return stateValue\\n\\n numAgents = gameState.getNumAgents()\\n numGhosts = numAgents - 1\\n pacmanLegalActions = gameState.getLegalActions()\\n\\n bestScore = -9999\\n optimalAction = Directions.STOP\\n alpha = -9999\\n beta = 9999\\n\\n\\n for action in pacmanLegalActions:\\n prevActionScore = bestScore\\n bestScore = max(prevActionScore, Minimaxer(gameState.generateSuccessor(0, action), self.depth, 1, alpha, beta))\\n if bestScore > prevActionScore:\\n prevActionScore = bestScore\\n optimalAction = action\\n if beta < bestScore:\\n return bestScore\\n alpha = max(bestScore, alpha)\\n return optimalAction\",\n \"def recursive_minimax(game: Any) -> Any:\\n moves_scores = []\\n moves = game.current_state.get_possible_moves()\\n\\n for move in moves:\\n g = copy.deepcopy(game)\\n s = g.current_state.make_move(move)\\n g.current_state = s\\n\\n moves_scores.append(-1*recursive_helper(g))\\n return moves[moves_scores.index(max(moves_scores))]\",\n \"def minimax(board: bytearray,\\n depth: int, # depth of current plies (0 = deepest)\\n alpha: int, \\n beta: int, \\n max_player: bool, # is this maximzing player?\\n at_top: bool=False, # are we the top call to this?\\n ):\\n \\n # base cases:\\n # - Player will win w/this board (since AI loses, return massive negative)\\n # - AI will win w/this board (return massive positive)\\n # - reached the depth of recursion (score this leaf for AI)\\n # - board is full (no score for this leaf)\\n\\n won_by: int = 0\\n for c1, c2, c3, c4 in _WINDOWS:\\n if board[c1] and (board[c1] == board[c2] == board[c3] == board[c4]):\\n won_by = board[c1]\\n break\\n \\n if won_by == _PLAYER:\\n # subtract depth so we delay loss as much as possible \\n return -1000 - depth \\n if won_by == _AI:\\n # add depth so faster wins are more attractive\\n return 1000 + depth \\n if depth == 0:\\n score = score_position(board, _AI) \\n return score\\n\\n # (these are arranged _CENTER-out to help make a/b pruning most efficient)\\n valid_locations: list[int] = [\\n col % 7 for col in (38,37,39,36,40,35,41) if board[col] == _EMPTY]\\n\\n if not valid_locations:\\n return 0\\n \\n # minimax strategy: alternate if AI is looking for best move (maximizing)\\n # or the most harmful response from the player (minimizing).\\n value: int\\n new_col: int\\n row: int\\n \\n if max_player:\\n value = _MINUS_INFINITY\\n new_col = random.choice(valid_locations)\\n for col in valid_locations: \\n for r in (0, 1, 2, 3, 4, 5):\\n if board[7 * r + col] == 0:\\n row = r\\n break\\n b_copy = bytearray(board)\\n b_copy[row * 7 + col] = _AI\\n new_score: int = minimax(b_copy, depth-1, alpha, beta, False)\\n if new_score > value:\\n value = new_score\\n new_col = col\\n alpha = max(alpha, value)\\n if alpha >= beta:\\n break\\n\\n else:\\n value = _INFINITY\\n for col in valid_locations:\\n for r in (0, 1, 2, 3, 4, 5):\\n if board[7 * r + col] == 0:\\n row = r\\n break\\n b_copy = bytearray(board)\\n b_copy[row * 7 + col] = _PLAYER\\n new_score: int = minimax(b_copy, depth-1, alpha, beta, True)\\n if new_score < value:\\n value = new_score\\n beta = min(beta, value)\\n if alpha >= beta:\\n break\\n\\n # For speed, return simple score except when exiting first recursive call,\\n # and return the chosen column & the score in that case.\\n if not at_top:\\n return value\\n else:\\n return new_col % 7, value\",\n \"def minimax(board):\\r\\n if terminal(board):\\r\\n return None\\r\\n \\r\\n acts = actions(board)\\r\\n if player(board) == \\\"X\\\":\\r\\n vals = []\\r\\n for a in acts:\\r\\n vals.append(min_value(result(board, a)))\\r\\n return acts[vals.indexof(max(vals))]\\r\\n elif player(board) == \\\"O\\\":\\r\\n vals = []\\r\\n for a in acts:\\r\\n vals.append(max_value(result(board, a)))\\r\\n return acts[vals.indexof(min(vals))]\\r\\n\\r\\n \\r\\n raise NotImplementedError\",\n \"def player_loop(self):\\n\\n # Generate game tree object\\n first_msg = self.receiver()\\n # Initialize your minimax model\\n model = self.initialize_model(initial_data=first_msg)\\n\\n while True:\\n msg = self.receiver()\\n\\n # Create the root node of the game tree\\n node = Node(message=msg, player=0)\\n\\n # Possible next moves: \\\"stay\\\", \\\"left\\\", \\\"right\\\", \\\"up\\\", \\\"down\\\"\\n best_move = self.search_best_next_move(\\n model=model, initial_tree_node=node)\\n\\n # Execute next action\\n self.sender({\\\"action\\\": best_move, \\\"search_time\\\": None})\",\n \"def minimax(board):\\n \\n if terminal(board):\\n return None\\n else:\\n if len(actions(board)) == 9:\\n for action in actions(board):\\n return action\\n else:\\n if player(board) == 'X':\\n# v = max_value(board)\\n# for action in actions(board):\\n# if v == min_value(result(board, action)):\\n# return action\\n return (max_value((board)))[1]\\n if player(board) == 'O':\\n# v = min_value(board)\\n# for action in actions(board):\\n# if v == max_value(result(board, action)):\\n# return action\\n return (min_value((board)))[1]\",\n \"def custom_score_2(game, player):\\n\\n '''\\n =========\\n STRATEGY:\\n =========\\n Staged player: starts aggressively, but becomes increasingly defensive. Uses a shallow beam\\n search of own or opponent's moves depending on game stage. Ignores alignment with knight's\\n tour path or centrality.\\n\\n Could play better with deeper beam search of own position (and opponent's for defensive\\n purposes), but this would require a longer timeout.\\n Maximising the number of moves searched at depth 2 is a reasonable proxy.\\n\\n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing\\n from opportunity to deepen search.\\n '''\\n\\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\\n USE_EVAL_DICT = False\\n USE_TRANSFORMATIONS = False\\n\\n # Captures stats to global dict.\\n GET_STATS = False\\n\\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\\n\\n if progress <= 20.0:\\n '''\\n ==============================================================================================================\\n EARLY GAME\\n ...\\n ==============================================================================================================\\n '''\\n\\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\\n OPP_ISOL_SEARCH_DEPTH = 1\\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\\n PLAYER_SAFE_SEARCH_DEPTH = 2\\n OPP_ISOL_MOVES_WEIGHT = 250.0\\n PLAYER_SAFE_MOVES_WEIGHT = 150.0\\n KT_WEIGHT = 0.0\\n LATE_CENTRALITY_WEIGHT = 0.0\\n KT_PROGRESS_MEASURED_TO = 0.0\\n\\n elif progress <= 80.0:\\n '''\\n ==============================================================================================================\\n MID GAME\\n ...\\n ==============================================================================================================\\n '''\\n\\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\\n OPP_ISOL_SEARCH_DEPTH = 1\\n PLAYER_SAFE_SEARCH_PATHS = 2 # ignored if search depth < 2\\n PLAYER_SAFE_SEARCH_DEPTH = 2\\n OPP_ISOL_MOVES_WEIGHT = 150.0\\n PLAYER_SAFE_MOVES_WEIGHT = 250.0\\n KT_WEIGHT = 0.0\\n LATE_CENTRALITY_WEIGHT = 0.0\\n KT_PROGRESS_MEASURED_TO = 0.0\\n\\n else:\\n '''\\n ==============================================================================================================\\n END GAME\\n ...\\n ==============================================================================================================\\n '''\\n USE_EVAL_DICT = False\\n\\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\\n OPP_ISOL_SEARCH_DEPTH = 2\\n PLAYER_SAFE_SEARCH_PATHS = 2 # ignored if search depth < 2\\n PLAYER_SAFE_SEARCH_DEPTH = 2\\n OPP_ISOL_MOVES_WEIGHT = 100.0\\n PLAYER_SAFE_MOVES_WEIGHT = 300.0\\n KT_WEIGHT = 0.0\\n LATE_CENTRALITY_WEIGHT = 0.0\\n KT_PROGRESS_MEASURED_TO = 0.0\\n\\n\\n\\n\\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\\n # opening_book_weight=OPENING_BOOK_WEIGHT,\\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)\",\n \"def minimax(state, depth, player):\\n if depth == 9:\\n row = choice([0, 1, 2])\\n col = choice([0, 1, 2])\\n return row, col, ''\\n\\n if player == COMP:\\n best = [-1, -1, float(\\\"-inf\\\")]\\n else:\\n best = [-1, -1, float(\\\"inf\\\")]\\n\\n if depth == 0 or state.has_tic_tac_toe(COMP) or state.has_tic_tac_toe(HUMAN):\\n score = heuristic(state, depth)\\n return [-1, -1, score]\\n \\\"\\\"\\\"\\n Checks if any of the player is one away from winning in any board and make the appropriate move.\\n \\\"\\\"\\\"\\n if player==COMP:\\n empty_cells=get_empty_cells(state)\\n dangerous_cells=state.is_one_away_from_tic_tac_toe((player%2)+1)\\n if dangerous_cells:\\n found_dangerous_cells=True\\n else:\\n found_dangerous_cells=False\\n print \\\"no dangerous local boards\\\"\\n favoring_cells=state.is_one_away_from_tic_tac_toe(player)\\n if favoring_cells:\\n found_favoring_cells=True\\n else:\\n found_favoring_cells=False\\n print \\\"no favoring local boards\\\"\\n if found_dangerous_cells==False and found_favoring_cells==False:\\n pass\\n if found_dangerous_cells==False and found_favoring_cells==True:\\n empty_cells[:]=[]\\n for cell in favoring_cells:\\n empty_cells.append(cell)\\n if found_dangerous_cells==True and found_favoring_cells==False:\\n empty_cells[:]=[]\\n for cell in dangerous_cells:\\n empty_cells.append(cell)\\n if found_dangerous_cells==True and found_favoring_cells==True:\\n empty_cells[:]=[]\\n for cell in dangerous_cells:\\n empty_cells.append(cell)\\n else:\\n empty_cells=get_empty_cells(state)\\n for cell in empty_cells:\\n row, col = cell[0], cell[1]\\n state.board[row][col] = player\\n score = minimax(state, depth - 1, (player % 2) + 1)\\n state.board[row][col] = 0\\n score[0], score[1] = row, col\\n if player == COMP:\\n if score[2] >= best[2]:\\n if score[2]==best[2]:\\n \\\"\\\"\\\"\\n Favors middle positions over sides or corners\\n MIDDLE > CORNERS > SIDES\\n \\\"\\\"\\\"\\n if (best[0]==0 and best[1]==0) or (best[0]==0 and best[1]==2) or (best[0]==2 and best[1]==0) or (best[0]==2 and best[1]==2):\\n if score[0]==0 and score[1]==0: #favoring centre position over diagonal position\\n best=score\\n print(\\\"centre position chosen over diagonal positions\\\")\\n else:\\n if ((score[0]==0 and score[1]==1) or (score[0]==1 and score[1]==0) or (score[0]==1 and score[1]==2) or (score[0]==2 and score[1]==1))==0:\\n best=score #favoring any position over side position as long as the new position is not a side position too\\n print(\\\"diagonal and centre positions chosen over side positions\\\")\\n else:\\n best = score\\n else:\\n bestMoves=[]\\n if score[2] < best[2]:\\n best=score\\n return best\",\n \"def make_move(self):\\n\\n # get relavent information\\n affinity = self.get_affinity()\\n sample_space = self.get_game_space()\\n depth_limit = self.__search_depth\\n\\n # run a minimax search and get the best value\\n bestval = MinimaxTree.alphabeta(self, sample_space, affinity, depth_limit, -10000, 10001, True)\\n if bestval[0] is None: bestval = ((0,6),'x', 0)\\n\\n # print the number of nodes expanded \\n print(self.nodes_expanded)\\n\\n # make the move found by the search \\n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n\\n player_id = player(board)\\n best_score = -math.inf if player_id == X else math.inf\\n optimal_action = None\\n\\n for action in actions(board):\\n if player_id == X:\\n this_score = min_score(result(board, action))\\n if this_score > best_score:\\n optimal_action = action\\n best_score = this_score\\n else:\\n this_score = max_score(result(board, action))\\n if this_score < best_score:\\n optimal_action = action\\n best_score = this_score\\n return optimal_action\",\n \"def minimax(self, game, depth):\\n _, move = self.minimax_search(game, depth)\\n return move\",\n \"def minimax(board):\\n\\n # If terminal board, return None\\n if terminal(board):\\n return None\\n\\n # Determine whose turn it is and the possible actions they can make\\n current_player = player(board)\\n moves = actions(board)\\n\\n if current_player == \\\"X\\\":\\n utility_from_action = list()\\n # Create pairings between the possible move and its eventual outcome\\n for action in moves:\\n utility_from_action.append((min_value(result(board, action)), action))\\n temp = -(math.inf)\\n optimal_move = None\\n # Find the action that leads to maximized utility\\n for (utility, action) in utility_from_action:\\n if utility > temp:\\n temp = utility\\n optimal_move = action\\n return optimal_move\\n\\n elif current_player == \\\"O\\\":\\n utility_from_action = list()\\n # Create pairings between the possible move and its eventual outcome\\n for action in moves:\\n utility_from_action.append((max_value(result(board, action)), action))\\n temp = math.inf\\n optimal_move = None\\n # Find the action that leads to minimized utility\\n for (utility, action) in utility_from_action:\\n if utility < temp:\\n temp = utility\\n optimal_move = action\\n return optimal_move\\n\\n else:\\n return None\",\n \"def minimax(board):\\n best_act = None\\n if terminal(board):\\n return best_act\\n if player(board) == X:\\n key = -999999\\n for action in actions(board):\\n if key < min_value(result(board, action)):\\n key = min_value(result(board, action))\\n best_act = action\\n return best_act\\n if player(board) == O:\\n key = 999999\\n for action in actions(board):\\n if key >= max_value(result(board, action)):\\n key = max_value(result(board, action))\\n best_act = action\\n return best_act\",\n \"def minimax(self, board, player):\\n avail_spots = self.get_empty_cells(board)\\n\\n # If opponent wins return -10\\n if self.check_win(board, self.get_next_move()):\\n return {'score': -10}\\n # If current ai wins, return 10, this is the wanted scenario\\n elif self.check_win(board, self.move):\\n return {'score': 10}\\n elif len(avail_spots) == 0:\\n return {'score': 0}\\n else:\\n moves = []\\n for i in avail_spots:\\n move = {'index': i}\\n board[i] = player\\n\\n if player == self.move:\\n result = self.minimax(board, self.get_next_move())\\n else:\\n result = self.minimax(board, self.move)\\n\\n # Update current move score and moves list\\n move.update({'score': result['score']})\\n moves.append(move)\\n\\n # Reset current board\\n board[i] = ' '\\n\\n # Choose move with highest score\\n if player == self.move:\\n best_score = -20\\n for move in moves:\\n if move['score'] > best_score:\\n best_score = move['score']\\n best_move = move\\n # Choose move with lowest score\\n else:\\n best_score = 20\\n for move in moves:\\n if move['score'] < best_score:\\n best_score = move['score']\\n best_move = move\\n\\n return best_move\",\n \"def UCTPlayGame(itermax):\\r\\n print(\\\"Welcome to Ultimate Tic-Tac-Toe!\\\")\\r\\n player = 2 if input(\\\"Do you want to go first? [Y/N]: \\\") == \\\"N\\\" else 1\\r\\n\\r\\n state = GameState()\\r\\n while state.GetMoves():\\r\\n currentPlayer = state.NextPlayer()\\r\\n\\r\\n print(str(state))\\r\\n print(\\\"Moves for player \\\" + str(currentPlayer) + \\\": \\\")\\r\\n print(np.matrix(state.GetMoves()), \\\"\\\\n\\\")\\r\\n\\r\\n if currentPlayer == player:\\r\\n m = None\\r\\n while m not in state.GetMoves():\\r\\n try:\\r\\n m = int(input(\\\"Your move: \\\"))\\r\\n except ValueError:\\r\\n continue\\r\\n # m = random.choice(state.GetMoves())\\r\\n else:\\r\\n m = UCT(rootstate=state, itermax=itermax, verbose=False)\\r\\n print(\\\"AI played: \\\" + str(m))\\r\\n state.DoMove(m)\\r\\n print(str(state))\\r\\n\\r\\n if state.GetResult(state.playerJustMoved) == 1.0:\\r\\n print(\\\"Player \\\" + str(state.playerJustMoved) + \\\" wins!\\\")\\r\\n return state.playerJustMoved\\r\\n elif state.GetResult(state.playerJustMoved) == 0.0:\\r\\n print(\\\"Player \\\" + str(state.NextPlayer()) + \\\" wins!\\\")\\r\\n return state.NextPlayer()\\r\\n else:\\r\\n print(\\\"Nobody wins!\\\")\\r\\n return 0\",\n \"def minimax(self, game, depth, maximizing_player=True):\\n\\n #logging.debug(\\\"minimax(%d, %s)\\\", depth, maximizing_player)\\n\\n # If we are out of time then jump out\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout() \\n \\n if depth <= 0: # Last row to search so return score of this board\\n return self.score(game, self),(-1,-1)\\n \\n # Otherwise search the next layer\\n legal_moves = game.get_legal_moves()\\n \\n # Check for some legal moves - if none return score of this board\\n if len(legal_moves) == 0:\\n return self.score(game, self),(-1,-1)\\n\\n results = []\\n for m in legal_moves:\\n score, _ = self.minimax(game.forecast_move(m), depth-1, not maximizing_player)\\n results.append((score,m))\\n \\n if maximizing_player:\\n return max(results)\\n else:\\n return min(results)\",\n \"def minimax(board):\\n act=list(actions(board))[0]\\n if player(board)==X:\\n val=-1\\n for a in actions(board):\\n minval=min_val(result(board, a))\\n if minval>val:\\n act=a\\n val=minval\\n if player(board)==O:\\n val=1\\n for a in actions(board):\\n maxval=max_val(result(board, a))\\n if maxval<val:\\n act=a\\n val=maxval\\n\\n return act\\n\\n raise NotImplementedError\",\n \"def custom_score_3(game, player):\\n\\n \\n '''\\n =========\\n STRATEGY:\\n =========\\n Aggressive player with shallow beam search of opponent's moves (looking to minimise \\n opportunities to reach states with one or more moves at depth 2), with weight toward \\n centrality after 30% of the game. Could play better with deeper beam search of opponents \\n position (and own for defensive purposes), but this would require a longer timeout. Minimising \\n the number of opponent moves at depth 2 is a reasonable proxy.\\n \\n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing \\n from opportunity to deepen search.\\n '''\\n\\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\\n USE_EVAL_DICT = False\\n USE_TRANSFORMATIONS = False\\n\\n # Captures stats to global dict.\\n GET_STATS = False\\n\\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\\n\\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\\n OPP_ISOL_SEARCH_DEPTH = 2\\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\\n PLAYER_SAFE_SEARCH_DEPTH = 1\\n OPP_ISOL_MOVES_WEIGHT = 300.0\\n PLAYER_SAFE_MOVES_WEIGHT = 100.0\\n KT_WEIGHT = 50.0\\n LATE_CENTRALITY_WEIGHT = 80.0\\n KT_PROGRESS_MEASURED_TO = 30.0\\n\\n\\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\\n # opening_book_weight=OPENING_BOOK_WEIGHT,\\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)\",\n \"def minimax(board):\\n current_player = player(board)\\n if(terminal(board)):\\n return None\\n\\n if (board == initial_state()):\\n x = random.choice([0, 2])\\n y = random.choice([0, 2])\\n return(x, y)\\n\\n if(current_player == X):\\n v = -math.inf\\n for action in actions(board):\\n mini = min_value(result(board, action))\\n if mini > v:\\n v = mini\\n best_move = action\\n else:\\n v = math.inf\\n for action in actions(board):\\n maxi = max_value(result(board, action))\\n if maxi < v:\\n v = maxi\\n best_move = action\\n return best_move\",\n \"def test_id(self):\\n\\n w, h = 11, 11\\n method = \\\"minimax\\\"\\n value_table = [[0] * w for _ in range(h)]\\n value_table[3][0] = 1\\n value_table[2][3] = 1\\n value_table[4][4] = 2\\n value_table[7][2] = 3\\n eval_fn = EvalTable(value_table)\\n\\n depths = [\\\"7+\\\", \\\"6\\\", \\\"5\\\", \\\"4\\\", \\\"3\\\", \\\"2\\\", \\\"1\\\"]\\n exact_counts = [((4, 4), set([(2, 3), (3, 0)])),\\n ((16, 6), set([(2, 3), (3, 0)])),\\n ((68, 20), set([(2, 3), (3, 2)])),\\n ((310, 21), set([(2, 3), (3, 2)])),\\n ((1582, 45), set([(3, 0), (3, 2)])),\\n ((7534, 45), set([(3, 0), (3, 2)])),\\n ((38366, 74), set([(0, 3), (2, 3), (3, 0), (3, 2)]))]\\n\\n time_limit = 3200\\n while time_limit >= TIMER_MARGIN:\\n agentUT, board = self.initAUT(-1, eval_fn, True, method, (1, 1), (0, 0), w, h)\\n\\n legal_moves = board.get_legal_moves()\\n timer_start = curr_time_millis()\\n time_left = lambda : time_limit - (curr_time_millis() - timer_start)\\n move = agentUT.get_move(board, legal_moves, time_left)\\n finish_time = time_left()\\n\\n self.assertTrue(len(board.visited) > 4, ID_FAIL)\\n\\n self.assertTrue(finish_time > 0,\\n \\\"Your search failed iterative deepening due to timeout.\\\")\\n\\n # print time_limit, board.counts, move\\n\\n time_limit /= 2\\n # Skip testing if the search exceeded 7 move horizon\\n if (board.counts[0] > exact_counts[-1][0][0] or\\n board.counts[1] > exact_counts[-1][0][1] or\\n finish_time < 5):\\n continue\\n\\n for idx, ((n, m), c) in enumerate(exact_counts[::-1]):\\n if n > board.counts[0]:\\n continue\\n self.assertIn(move, c, ID_ERROR.format(depths[idx], 2 * time_limit, move, *board.counts))\\n break\",\n \"def minimax(self, state, player, visited, alpha, beta):\\n if self.terminal(state, visited[player]):\\n return self.utility(state, player)\\n\\n if player == PACMAN:\\n return self.max_player(state, player, visited, alpha, beta)\\n else:\\n return self.min_player(state, player, visited, alpha, beta)\",\n \"def generate_move_minimax_ab(\\r\\n board: np.ndarray, player: BoardPiece, saved_state: Optional[SavedState]\\r\\n) -> Tuple[PlayerAction, Optional[SavedState]]:\\r\\n depth = 4\\r\\n # choose which heuristic to use\\r\\n heuristic = heuristic_basic\\r\\n # heuristic = heuristic_better\\r\\n alpha, beta = int(-1e10), int(1e10) # starting alpha-beta values\\r\\n action_set = minimax_ab(board, alpha, beta, player, depth, True, heuristic=heuristic)\\r\\n print(action_set)\\r\\n # if np.all(board) == 0: # if the board is empty\\r\\n if len(set(action_set)) == 1: # if all options are the same\\r\\n action = 3 # put piece in the center\\r\\n else:\\r\\n action = np.argmax(action_set) # maximize the best move\\r\\n return PlayerAction(action), saved_state\",\n \"def minimax(board):\\n if player(board) == X:\\n return optimal_max(board)[0]\\n else:\\n return optimal_min(board)[0]\",\n \"def evaluateBoardState(self, board):\\n\\n \\\"\\\"\\\"\\n These are the variables and functions for board objects which may be helpful when creating your Agent.\\n Look into board.py for more information/descriptions of each, or to look for any other definitions which may help you.\\n\\n Board Variables:\\n board.width \\n board.height\\n board.last_move\\n board.num_to_connect\\n board.winning_zones\\n board.score_array \\n board.current_player_score\\n\\n Board Functions:\\n get_cell_value(row, col)\\n try_move(col)\\n valid_move(row, col)\\n valid_moves()\\n terminal(self)\\n legal_moves()\\n next_state(turn)\\n winner()\\n \\\"\\\"\\\"\\n if self.id == 1:\\n opponent_id = 2\\n else:\\n opponent_id = 1\\n\\n maxvalue = 100000\\n minvalue = -maxvalue\\n winner = board.winner()\\n if winner == self.id:\\n return maxvalue\\n elif winner == opponent_id:\\n return minvalue\\n size_y = board.height\\n size_x = board.width\\n map_ = []\\n num_to_connect = board.num_to_connect\\n total_points = 0\\n\\n multiply_reachable = 1\\n multiply_oddeven = 1\\n # basically this function is calculating all the possible win positions\\n # more pieces in a possible win position will be counted with more weights\\n # a win position with X pieces in it will be counted as X^2 points\\n # initialise the zones maps\\n for i in range(size_y):\\n map_.append([])\\n for j in range(size_x):\\n map_[i].append([])\\n\\n # Fill in the horizontal win positions\\n for i in range(size_y):\\n for j in range(size_x - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i][j + k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i][j + k] == self.id:\\n points += len(board.winning_zones[j+k][i])\\n if (self.id == 1 and i % 2 == 1) or (self.id == 2 and i%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and opponent_pieces_count == 0:\\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\\n return maxvalue\\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\\n points *= multiply_reachable\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if j - 1 >= 0 and board.board[i][j + 3] == 0 and board.board[i][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i and board.try_move(j - 1) == i:\\n return minvalue\\n elif j + 4 < size_y and board.board[i][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i][j + k] == 0 and board.try_move(j + k) == i:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the vertical win positions\\n for i in range(size_x):\\n for j in range(size_y - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[j + k][i] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[j + k][i] == self.id:\\n points += len(board.winning_zones[i][j+k])\\n if (self.id == 1 and (j+k) % 2 == 1) or (self.id == 2 and (j+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n points *= multiply_reachable\\n # if opponent_pieces_count == 3 and self_pieces_count == 0:\\n # points *= -1\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the forward diagonal win positions\\n for i in range(size_y - num_to_connect + 1):\\n for j in range(size_x - num_to_connect + 1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i + k][j + k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i + k][j + k] == self.id:\\n points += len(board.winning_zones[j+k][i+k])\\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and opponent_pieces_count == 0:\\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\\n return maxvalue\\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\\n points *= multiply_reachable\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if i - 1 >= 0 and j - 1 >= 0 and board.board[i + 3][j + 3] == 0 and board.board[i - 1][j - 1] == 0 \\\\\\n and board.try_move(j + 3) == i + 3 and board.try_move(j - 1) == i - 1:\\n return minvalue\\n elif i + 4 < size_y and j + 4 < size_x and board.board[i + 4][j + 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j + 4) == i + 4 and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i + k][j + k] == 0 and board.try_move(j + k) == i + k:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n\\n # Fill in the backward diagonal win positions\\n for i in range(size_y - num_to_connect + 1):\\n for j in range(size_x - 1, num_to_connect - 1 - 1, -1):\\n points = 0\\n self_pieces_count = 0\\n opponent_pieces_count = 0\\n for k in range(num_to_connect):\\n if board.board[i + k][j - k] == opponent_id:\\n opponent_pieces_count += 1\\n elif board.board[i + k][j - k] == self.id:\\n points += len(board.winning_zones[j-k][i+k])\\n if (self.id == 1 and (i+k) % 2 == 1) or (self.id == 2 and (i+k)%2 == 0):\\n points *= multiply_oddeven\\n self_pieces_count += 1\\n if self_pieces_count == 3 and self_pieces_count == 0:\\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\\\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\\n return maxvalue\\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\\n return maxvalue\\n else:\\n for k in range(num_to_connect):\\n if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\\n points *= multiply_reachable\\n\\n elif opponent_pieces_count == 3 and self_pieces_count == 0:\\n if board.board[i + 3][j - 3] == 0 and board.board[i - 1][j + 1] == 0 \\\\\\n and board.try_move(j - 3) == i + 3 and board.try_move(j + 1) == i - 1:\\n return minvalue\\n elif i + 4 < size_y and j - 4 >= 0 and board.board[i + 4][j - 4] == 0 and board.board[i][j] == 0 \\\\\\n and board.try_move(j - 4) == i + 4 and board.try_move(j) == i:\\n return minvalue\\n # else:\\n # for k in range(num_to_connect):\\n # if board.board[i + k][j - k] == 0 and board.try_move(j - k) == i + k:\\n # points *= -multiply_reachable\\n if (opponent_pieces_count == 3 and self_pieces_count == 0) or opponent_pieces_count == 0:\\n total_points += points\\n return total_points\",\n \"def minimax(board):\\n move = None\\n if player(board) == X:\\n highValue = float(\\\"-inf\\\")\\n for action in actions(board):\\n value = minValue(result(board,action))\\n if value == 1:\\n move = action\\n highValue = value\\n elif value >= highValue:\\n move = action\\n highValue = value\\n\\n else:\\n lowValue = float(\\\"inf\\\")\\n for action in actions(board):\\n value = maxValue(result(board, action))\\n if value == -1:\\n move = action\\n lowValue = value\\n elif value <= lowValue:\\n move = action\\n lowValue = value\\n return move\\n\\n\\n\\n\\n\\n # raise NotImplementedError\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n if self.first_step == False:\\n self.first_step = True\\n if self.solveOneStep():\\n return True\\n if self.queue:\\n self.gm_init()\\n ele = self.queue.get()\\n #print (len(ele))\\n state = ele[0]\\n premoves = ele[1]\\n\\n for m in premoves:\\n self.gm.makeMove(m)\\n if state.state == self.victoryCondition:\\n return True\\n self.visited[state] = True\\n print(\\\"CURRENTSTATE:\\\")\\n print(self.gm.getGameState())\\n print(\\\"*******\\\")\\n moves = self.gm.getMovables()\\n for m in moves:\\n self.gm.makeMove(m)\\n if (((state.parent is not None) and (self.gm.getGameState() == state.parent.state))) or GameState(self.gm.getGameState(), 0, None) in self.visited:\\n self.gm.reverseMove(m)\\n continue\\n self.visited[GameState(self.gm.getGameState(), 0, None)] = True\\n new_pmv = [i for i in premoves]\\n new_pmv.append(m)\\n next_state = GameState(self.gm.getGameState(), state.depth+1, m)\\n next_state.parent = state\\n state.children.append(next_state)\\n self.queue.put([next_state, new_pmv])\\n self.gm.reverseMove(m)\\n self.currentState = state\\n\\n #for i in range(len(premoves)-1, -1, -1):\\n # mv = premoves[i]\\n # self.gm.reverseMove(mv)\\n return False\",\n \"def minimax(state, depth, player):\\n\\n if player == COMP:\\n best = [-1, -1, inf]\\n else:\\n best = [-1, -1, -inf]\\n\\n if depth == 0 or game_over(state):\\n score = evaluate(state)\\n return [-1, -1, score]\\n\\n for cell in empty_cells(state):\\n x, y = cell[0], cell[1]\\n state[x][y] = player\\n score = minimax(state, depth - 1, -player)\\n state[x][y] = 0\\n score[0], score[1] = x, y\\n\\n if player == COMP:\\n if score[2] < best[2]:\\n best = score\\n else:\\n if score[2] > best[2]:\\n best = score\\n\\n return best\",\n \"def moveManager(self):\\r\\n \\r\\n (nb1,nb2) = self._board.get_nb_pieces() \\r\\n val = 0\\r\\n alphaBeta_instance = AlphaBeta()\\r\\n \\r\\n # Early-Game: Check opening move in a custom bloom filter\\r\\n if(nb1+nb2 < MoveManager.__AI_OPENING_MOVE_VALUE__()): \\r\\n print(\\\"Check if \\\", Utils.HashingOperation.BoardToHashCode(self._board), \\\"is present\\\")\\r\\n move = self._openingMover.GetMove(self._board)\\r\\n \\r\\n if(move is None): #No Opening Move has been found, need to calculate the AB-pruning\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \\r\\n depth=3,\\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # End-Game: Special depth alpha-beta\\r\\n elif ((nb1+nb2) > MoveManager.__AI_ENDGAME_VALUE__(self._board)): \\r\\n# self._maxDepth = WIDTH*HEIGHT - (nb1+nb2)\\r\\n print(\\\"Special depth For Pruning: \\\", nb1+nb2)\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self,\\r\\n depth=self._board._boardsize * self._board._boardsize - (nb1+nb2), \\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # Mid-Game: Usual Case. Alpha Beta. Can use the parallelization, or chose to check a bloom filter if a good board has already been find \\r\\n else: \\r\\n #Alpha and Beta should be set directly on the AlphaBeta class\\r\\n (val, move) = alphaBeta_instance.__alpha_beta_main_wrapper__(player=self, \\r\\n depth=3,\\r\\n Parallelization=False,\\r\\n BloomCheckerFirst=False)\\r\\n \\r\\n # No move has been find, generate one with a simple heuristic\\r\\n if move is None: \\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"Default value. No move has been found\\\")\\r\\n val = -7578748789\\r\\n# time.sleep(1)\\r\\n (move, _) = MoveManager.MoveForGameBeginning(self, self._board.legal_moves()) \\r\\n \\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n print(\\\"Val is:\\\", val)\\r\\n# time.sleep(1)\\r\\n return move\",\n \"def minimax(board):\\n\\n if len(actions(board)) == 9:\\n action = actions(board)\\n return action[random.randint(0, len(actions(board)) - 1)]\\n\\n if terminal(board):\\n return None\\n\\n best_move = None\\n\\n if player(board) == X:\\n best_score = -1\\n else:\\n best_score = 1\\n\\n for action in actions(board):\\n if player(board) == X:\\n score = minimize(result(board, action))\\n\\n if score >= best_score:\\n best_move = action\\n best_score = score\\n else:\\n score = maximize(result(board, action))\\n\\n if score <= best_score:\\n best_move = action\\n best_score = score\\n\\n return best_move\",\n \"def minimax(board):\\n if terminal(board):\\n return utility(board)\\n\\n chance = player(board)\\n if chance == X:\\n v = -math.inf\\n best_action = None\\n\\n for action in actions(board):\\n v_temp = min_target(result(board, action), 0, -math.inf, math.inf)\\n\\n if v_temp > v:\\n best_action = action\\n v = v_temp\\n\\n else:\\n v = math.inf\\n best_action = None\\n\\n for action in actions(board):\\n v_temp = max_target(result(board, action), 0, -math.inf, math.inf)\\n\\n if v_temp < v:\\n best_action = action\\n v = v_temp\\n\\n return best_action\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n # return the optimal move for the player\\n # possible outcomes 1(X wins) 0(No winner) -1(O wins)\\n if player(board) == X:\\n _ , action = max_value(board)\\n return action\\n elif player(board) == O:\\n _ , action = min_value(board)\\n return action\",\n \"def make_move(self):\\n\\n # get relavent information\\n affinity = self.get_affinity()\\n sample_space = self.get_game_space()\\n depth_limit = self.__search_depth\\n\\n # run a minimax search and get the best value\\n bestval = MinimaxTree.minimax(self, sample_space, affinity, depth_limit, True)\\n if bestval[0] is None: bestval = ((0,6),'x', 0)\\n\\n # print the number of nodes expanded \\n print(self.nodes_expanded)\\n\\n # make the move found by the search \\n self.get_game_space().set_tile(bestval[0][0], bestval[0][1], affinity)\",\n \"def minimax(self, game, depth, maximizing_player=True, tab='\\\\t'):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n legal_moves = game.get_legal_moves(game.active_player)\\n if legal_moves is not None and len(legal_moves)>0:\\n if depth>0: # Recursive case:\\n if maximizing_player: # MAXIMIZING ply\\n score, move = None, None\\n for i,m in enumerate(legal_moves):\\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\\\t')\\n if score is None or newscore > score:\\n score, move = newscore, m\\n else: # MINIMIZING ply\\n score, move = None, None\\n for i,m in enumerate(legal_moves):\\n newscore, _ = self.minimax(game.forecast_move(m), depth-1, maximizing_player=not maximizing_player, tab=tab+'\\\\t')\\n if score is None or newscore < score:\\n score, move = newscore, m\\n else: # Base case (depth==0)\\n score, move = self.score(game, self), None\\n else: # We are at a DEAD-END here\\n score, move = self.score(game, self), (-1, -1)\\n\\n return score, move\",\n \"def minimax_decision(self, state):\\r\\n\\r\\n # Here implementing custom version of arg max, keeping all the problem\\r\\n # criterion in mind.\\r\\n player_current = self.player(state, self.initial_turn)\\r\\n best_action = ()\\r\\n\\r\\n # Early terminated alpha-beta pruned minimax algorithm\\r\\n if player_current == 'x':\\r\\n best_action = self.max_value_prune_et(state, (9, 9, 9), -999, 999, 0, player_current)\\r\\n else:\\r\\n best_action = self.min_value_prune_et(state, (9, 9, 9), -999, 999, 0, player_current)\\r\\n\\r\\n # Tuple of best action (best action value, to co-ordinate, from co-ordinate)\\r\\n return best_action\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def agentCounter(gameState, index, depth):\\n \\\"\\\"\\\"When index is out of bounds return pacmans index and\\n reduce depth by 1\\\"\\\"\\\"\\n if index == gameState.getNumAgents():\\n return [depth-1, 0]\\n else:\\n return [depth, index]\\n\\n def minimax(self, gameState, depth, index):\\n \\\"\\\"\\\"Implement minimax function for pacman game. \\n return an array with score and best move\\\"\\\"\\\"\\n ultimateMove = None # The best move the agent can use\\n if depth == 0 or gameState.isWin() or gameState.isLose():\\n # if leaf node return value.\\n return [self.evaluationFunction(gameState), ultimateMove]\\n else:\\n if index == 0: # if pacman => agent is max agent\\n value = -math.inf\\n maxValue = value\\n # iterates through max agent w/index=0 moves\\n for action in gameState.getLegalActions(0):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action) # generates the next state when move is done\\n value = max(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\\n if maxValue != value: # If value has changed update values\\n ultimateMove = action\\n maxValue = value\\n return [value, ultimateMove]\\n else: # is ghost => agent is min agent\\n value = math.inf\\n minValue = value\\n # Iterate through the moves of a min agent w/index not 0\\n for action in gameState.getLegalActions(index):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action)\\n value = min(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\\n if minValue != value: # If value has changed update values\\n ultimateMove = action\\n minValue = value\\n return [value, ultimateMove]\\n\\n best = minimax(self, gameState, self.depth, self.index)\\n #print(\\\"Move: \\\", best[1], \\\" | Score: \\\", best[0])\\n return best[1]\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n\\n max_action_value = -1\\n min_action_value = 1\\n best_action = None\\n\\n for action in actions(board):\\n if player(board) == X:\\n # Action value given by O player minimizing the action value on next state\\n action_value = min_value(result(board, action))\\n # Choose action with maximum value\\n if action_value > max_action_value:\\n best_action = action\\n max_action_value = action_value\\n # An action with max possible value was reached\\n if action_value == 1:\\n return action\\n else:\\n # Action value given by X player maximizing the action value on next state\\n action_value = max_value(result(board, action))\\n # Choose action with minimum value\\n if action_value < min_action_value:\\n best_action = action\\n min_action_value = action_value\\n # An action with minimum possible value was reached\\n if action_value == -1:\\n return action\\n \\n return best_action\",\n \"def minimax(board):\\n play = player(board)\\n\\n bestMove = (-1, -1)\\n if play == X:\\n bestVal = -1000\\n # Traverse all cells, evaluate minimax function for\\n # all empty cells. And return the cell with optimal\\n # value.\\n for i in range(3) : \\n for j in range(3) :\\n \\n # Check if cell is empty\\n if (board[i][j] == EMPTY) :\\n \\n # Make the move\\n board[i][j] = play\\n \\n # compute evaluation function for this\\n # move.\\n moveVal = minimaxScore(board)\\n \\n # Undo the move\\n board[i][j] = EMPTY\\n \\n # If the value of the current move is\\n # more than the best value, then update\\n # best/\\n if (moveVal > bestVal) : \\n bestMove = (i, j)\\n bestVal = moveVal\\n else:\\n bestVal = 1000\\n # Traverse all cells, evaluate minimax function for\\n # all empty cells. And return the cell with optimal\\n # value.\\n for i in range(3) : \\n for j in range(3) :\\n \\n # Check if cell is empty\\n if (board[i][j] == EMPTY) :\\n \\n # Make the move\\n board[i][j] = play\\n \\n # compute evaluation function for this\\n # move.\\n moveVal = minimaxScore(board)\\n \\n # Undo the move\\n board[i][j] = EMPTY\\n \\n # If the value of the current move is\\n # more than the best value, then update\\n # best/\\n if (moveVal < bestVal) : \\n bestMove = (i, j)\\n bestVal = moveVal\\n \\n return bestMove\",\n \"def minimax_helper(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n \\n # Get all the available moves at the current state\\n legal_moves = game.get_legal_moves()\\n\\n # Handle a terminal event/exhaustive search completion\\n # at least in relation to depth sought\\n if (not legal_moves) or (depth == 0):\\n if maximizing_player:\\n return (self.score(game, game.active_player), (-1, -1))\\n else:\\n return (self.score(game, game.inactive_player), (-1, -1))\\n\\n if maximizing_player: # the current player\\n this_score = float(\\\"-inf\\\")\\n for move in legal_moves:\\n next_ply_state = game.forecast_move(move)\\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\\n depth-1, False)\\n\\n # Identify the maximum score branch for the current player.\\n if next_ply_score >= this_score:\\n this_move = move\\n this_score = next_ply_score\\n\\n else: # the current player's opponent\\n this_score = float(\\\"inf\\\")\\n for move in legal_moves:\\n next_ply_state = game.forecast_move(move)\\n next_ply_score, next_ply_move = self.minimax_helper(next_ply_state,\\n depth-1, True) \\n\\n # Identify the minimum score branch for the opponent\\n if next_ply_score <= this_score:\\n this_move = move\\n this_score = next_ply_score\\n\\n return this_score, this_move\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n\\n \\\"\\\"\\\"\\n From AIMA psuedocode:\\n\\n function MINIMAX-DECISION(state) returns an action\\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\\n \\\"\\\"\\\"\\n\\n best_move = (-1,-1)\\n best_score = float(\\\"-inf\\\")\\n actions = game.get_legal_moves()\\n\\n if not actions:\\n return best_move\\n else:\\n best_move = actions[randint(0, len(actions) - 1)]\\n\\n try:\\n # The try/except block will automatically catch the exception\\n # raised when the timer is about to expire.\\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\\n for action in actions:\\n score = self._min_value(game.forecast_move(action), 1)\\n if score > best_score:\\n best_score = score\\n best_move = action\\n\\n except SearchTimeout:\\n pass\\n\\n return best_move\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n legalActions = gameState.getLegalPacmanActions()\\n scoresForAction = {}\\n maxAction = \\\"\\\"\\n maxScore = -99999999999999\\n for action in legalActions:\\n scoresForAction[action] = self.minimax2(gameState.generatePacmanSuccessor(action), self.depth, False)\\n for x,y in scoresForAction.iteritems():\\n if(maxScore < y):\\n maxScore = y\\n maxAction = x\\n return maxAction\\n # return self.miniMax(gameState, self.depth, 0)\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n if (self.currentState.state == self.victoryCondition) or (self.currentState not in self.visited):\\n self.visited[self.currentState] = True\\n win_or_not = self.currentState.state == self.victoryCondition\\n return win_or_not\\n\\n if not self.currentState.nextChildToVisit: \\n its = 0\\n for movable in self.gm.getMovables():\\n its += 1\\n # time test\\n # too long \\n if its == \\\"too long\\\":\\n return \\\"too long\\\"\\n #make every move in movable\\n self.gm.makeMove(movable)\\n new = self.gm.getGameState()\\n new_gs = GameState(new, self.currentState.depth+1, movable)\\n \\n if new_gs not in self.visited:\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.gm.reverseMove(movable) \\n \\n num_children = len(self.currentState.children)\\n if self.currentState.nextChildToVisit < num_children:\\n new = self.currentState.children[self.currentState.nextChildToVisit]\\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\\n self.gm.makeMove(new.requiredMovable)\\n self.currentState = new\\n #recurse\\n return self.solveOneStep()\\n else:\\n self.currentState.nextChildToVisit = self.currentState.nextChildToVisit + 1\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n #recurse\\n return self.solveOneStep()\",\n \"def __init__(self, size, block_positions, starts, player_1, player_2, \\n terminal_viz, print_game_in_terminal, \\n time_to_make_a_move=2, game_time=100, \\n penalty_score=300, max_fruit_score=300, max_fruit_time=15):\\n\\n # check that each Player implements the following methods:\\n self.players = [player_1, player_2]\\n for player in self.players:\\n assert hasattr(player, 'set_game_params')\\n assert hasattr(player, 'make_move')\\n assert hasattr(player, 'set_rival_move')\\n assert hasattr(player, 'update_fruits')\\n\\n self.print_game_in_terminal = print_game_in_terminal\\n self.terminal_viz = terminal_viz\\n self.time_to_make_a_move = time_to_make_a_move\\n self.penalty_score = penalty_score\\n self.some_player_cant_move = False\\n \\n \\n self.game_time_left_for_players = [game_time, game_time]\\n\\n initial_board = self.set_initial_board(size, block_positions, starts)\\n\\n self.game = Game(initial_board, starts, max_fruit_score=max_fruit_score, max_fruit_time=max_fruit_time, \\n animated=True, animation_func=self.animate_func)\\n\\n for i, player in enumerate(self.players):\\n player.set_game_params(self.game.get_map_for_player_i(player_id=i))\",\n \"def minimax(state, depth, player):\\r\\n if player == COMP:\\r\\n best = [-1, -1, -infinity]\\r\\n else:\\r\\n best = [-1, -1, +infinity]\\r\\n\\r\\n if depth == 0 or game_over(state):\\r\\n score = evaluate(state)\\r\\n return [-1, -1, score]\\r\\n\\r\\n for cell in empty_cells(state):\\r\\n x, y = cell[0], cell[1]\\r\\n state[x][y] = player\\r\\n score = minimax(state, depth - 1, -player)\\r\\n state[x][y] = 0\\r\\n score[0], score[1] = x, y\\r\\n\\r\\n if player == COMP:\\r\\n if score[2] > best[2]:\\r\\n best = score # max value\\r\\n else:\\r\\n if score[2] < best[2]:\\r\\n best = score # min value\\r\\n\\r\\n return best\",\n \"def action(self):\\n\\n self.start_timer()\\n\\n minimax_probability = self.norm.cdf(self.root.branching)\\n use_minimax = boolean_from_probability(minimax_probability)\\n if self.time_consumed > 53:\\n # Time is starting to run low, use the faster option\\n use_minimax=True\\n\\n if self.time_consumed < 59:\\n if self.root.turn < 4:\\n result = book_first_four_moves(self.root)\\n elif use_minimax:\\n result = minimax_paranoid_reduction(self.root)\\n else:\\n result = monte_carlo_tree_search(\\n self.root,\\n playout_amount=3,\\n node_cutoff=4,\\n outer_cutoff=4,\\n num_iterations=1200,\\n turn_time=0.75,\\n exploration_constant=1.7,\\n use_slow_culling=False,\\n verbosity=0,\\n use_prior=True,\\n num_priors=4,\\n use_fast_prune_eval=False,\\n use_fast_rollout_eval=False,\\n )\\n else:\\n result = greedy_choose(self.root)\\n\\n self.end_timer()\\n\\n return result\",\n \"def alphabeta_search(state):\\r\\n \\r\\n '''\\r\\n Terminates when game.actions is empty\\r\\n Class Game needs the following functions:\\r\\n - game.result(state, a) -- successor\\r\\n - game.actions(state) -- possible moves\\r\\n - game.utility -- returns the state of the game (win/lose or tie, when game is terminal)\\r\\n \\r\\n '''\\r\\n #sort state.actions in increasing or decreasing based on max or min (alpha or beta)\\r\\n #use heuristics fn to get a value for each move (move is in format (x,y) where x and y are ints\\r\\n \\r\\n d = depthset[0] #this is the cutoff test depth value. if we exceed this value, stop\\r\\n cutoff_test=None\\r\\n sort_fn = [vitalpoint, eyeHeur]\\r\\n eval_fn = survivalheur \\r\\n #randnumheuristics \\r\\n player = state.to_move()\\r\\n prune = 0\\r\\n pruned = {} #this will store the depth of the prune\\r\\n totaldepth = [0]\\r\\n visited = {}\\r\\n heuristicInd = 0\\r\\n \\r\\n def max_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = -infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #max wants decreasing\\r\\n #sorted(state.actions(), key = eval_sort, reverse = True)\\r\\n \\r\\n #sort by favorites first, returns a list of actions\\r\\n # for sorts in sort_fn:\\r\\n tempher = heuristicInd\\r\\n\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n ''''''\\r\\n for a in sortedactions:\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n \\r\\n onbranch += 1\\r\\n v = max(v, min_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd)) #+ vitscore.count(a)\\r\\n if v >= beta: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n alpha = max(alpha, v)\\r\\n \\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n \\r\\n return v\\r\\n\\r\\n def min_value(state, alpha, beta, depth, heuristicInd):\\r\\n branches = len(state.actions())\\r\\n onbranch = 0\\r\\n \\r\\n if totaldepth[0] < depth:\\r\\n totaldepth[0] = depth\\r\\n if cutoff_test(state, depth):\\r\\n return eval_fn(state)\\r\\n v = infinity\\r\\n \\r\\n #sort state.actions based on heuristics before calling\\r\\n #min wants increasing\\r\\n #sorted(state.actions(), key = eval_sort)\\r\\n #Shayne\\r\\n tempher = heuristicInd\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedactions, heuristicInd = sorts(state, 1)\\r\\n #if heuristicInd != tempher:\\r\\n # print 's',\\r\\n for a in sortedactions: #state.actions():\\r\\n onbranch += 1\\r\\n if visited.get(depth) == None:\\r\\n visited[depth] = [a]\\r\\n else:\\r\\n visited[depth].append(a)\\r\\n v = min(v, max_value(state.result(a),\\r\\n alpha, beta, depth+1, heuristicInd))\\r\\n if v <= alpha: #pruning happens here, but in branches\\r\\n if pruned.get(depth) == None:\\r\\n pruned[depth] = branches - onbranch\\r\\n else:\\r\\n pruned[depth] += (branches - onbranch)\\r\\n #print \\\"prune\\\", depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n beta = min(beta, v)\\r\\n #print depth, \\\" \\\", state.actions()\\r\\n #state.display()\\r\\n return v\\r\\n\\r\\n # Body of alphabeta_search starts here:\\r\\n #def cutoff_test and eval_fn \\r\\n cutoff_test = (cutoff_test or\\r\\n (lambda state,depth: depth>d or state.terminal_test()))\\r\\n eval_fn = eval_fn or (lambda state: state.utility(player))\\r\\n #by default, utility score is used\\r\\n \\r\\n \\r\\n #argmax goes through all the possible actions and \\r\\n # applies the alphabeta search onto all of them\\r\\n # and returns the move with the best score \\r\\n #print state.actions()\\r\\n heuristicInd = 0\\r\\n sorts = sort_fn[heuristicInd]\\r\\n sortedact, heuristicInd = sorts(state)\\r\\n abmove = argmax(sortedact,\\r\\n lambda a: min_value(state.result(a),\\r\\n -infinity, infinity, 0, heuristicInd))\\r\\n\\r\\n print 'problem,', problemno[0], ', total tree depth,', totaldepth[0]\\r\\n for i in range(1, len(visited)):\\r\\n if len(pruned) < i:\\r\\n pruned[i] = 0\\r\\n print i, \\\",\\\", len(visited[i]), \\\",\\\", pruned[i]\\r\\n \\r\\n return abmove\",\n \"def getAction(self, gameState):\\n def Minimaxer(sucGameState, depth, curAgent, numGhosts):\\n if sucGameState.isWin() or sucGameState.isLose():\\n return self.evaluationFunction(sucGameState)\\n if depth == 0:\\n return self.evaluationFunction(sucGameState)\\n stateValue = 9999\\n curDepthCurAgentActions = sucGameState.getLegalActions(curAgent)\\n if curAgent == numGhosts:\\n for curAction in curDepthCurAgentActions:\\n stateValue = min(stateValue, miniMaxer(sucGameState.generateSuccessor(curAgent,curAction), depth-1, numGhosts) )\\n else:\\n for curAction in curDepthCurAgentActions:\\n stateValue = min(stateValue, Minimaxer(sucGameState.generateSuccessor(curAgent,curAction), depth, curAgent + 1, numGhosts))\\n return stateValue\\n\\n def miniMaxer(sucGameState, depth, numGhosts):\\n if sucGameState.isWin() or sucGameState.isLose():\\n return self.evaluationFunction(sucGameState)\\n if depth == 0:\\n return self.evaluationFunction(sucGameState)\\n stateValue = -9999\\n curDepthCurAgentActions = sucGameState.getLegalActions(0)\\n for curAction in curDepthCurAgentActions:\\n stateValue = max(stateValue, Minimaxer(sucGameState.generateSuccessor(0,curAction), depth, 1, numGhosts ))\\n return stateValue\\n\\n numAgents = gameState.getNumAgents()\\n numGhosts = numAgents - 1\\n pacmanLegalActions = gameState.getLegalActions()\\n\\n bestScore = -9999\\n optimalAction = Directions.STOP\\n\\n\\n for action in pacmanLegalActions:\\n prevActionScore = bestScore\\n bestScore = max(prevActionScore, Minimaxer(gameState.generateSuccessor(0, action), self.depth, 1, numGhosts))\\n if bestScore > prevActionScore:\\n optimalAction = action\\n return optimalAction\",\n \"def winningMove():\\r\\n\\tglobal turn, tile1, tile2, tile3, tile4, tile5, tile6, tile7, tile8, tile9\\r\\n\\r\\n\\tnoWin=True\\r\\n\\tmove=False\\r\\n\\tif turn==\\\"Player1\\\":\\r\\n\\t\\tif validMove(1):\\r\\n\\t\\t\\ttile1+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove=1\\t\\r\\n\\t\\t\\ttile1+=-1\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\t\\tif validMove(2):\\r\\n\\t\\t\\ttile2+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 2\\r\\n\\t\\t\\ttile2+=-1\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\t\\tif validMove(3):\\r\\n\\t\\t\\ttile3+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 3\\r\\n\\t\\t\\ttile3+=-1\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\t\\t\\r\\n\\t\\tif validMove(4):\\r\\n\\t\\t\\ttile4+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 4\\t\\r\\n\\t\\t\\ttile4+=-1\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\t\\r\\n\\t\\tif validMove(5):\\r\\n\\t\\t\\ttile5+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 5\\t\\t\\r\\n\\t\\t\\ttile5+=-1\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(6):\\r\\n\\t\\t\\ttile6+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 6\\t\\r\\n\\t\\t\\ttile6+=-1\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(7):\\r\\n\\t\\t\\ttile7+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 7\\t\\r\\n\\t\\t\\ttile7+=-1\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(8):\\r\\n\\t\\t\\ttile8+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 8\\t\\r\\n\\t\\t\\ttile8+=-1\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(9):\\r\\n\\t\\t\\ttile9+=1\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 9\\t\\t\\r\\n\\t\\t\\ttile9+=-1\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\r\\n\\telif turn==\\\"Player2\\\":\\r\\n\\t\\tif validMove(1):\\r\\n\\t\\t\\ttile1+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 1\\t\\t\\t\\t\\r\\n\\t\\t\\ttile1+=-2\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\t\\tif validMove(2):\\r\\n\\t\\t\\ttile2+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 2\\r\\n\\t\\t\\ttile2+=-2\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\t\\tif validMove(3):\\r\\n\\t\\t\\ttile3+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 3\\r\\n\\t\\t\\ttile3+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(4):\\r\\n\\t\\t\\ttile4+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 4\\t\\r\\n\\t\\t\\ttile4+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(5):\\r\\n\\t\\t\\ttile5+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 5\\t\\r\\n\\t\\t\\ttile5+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(6):\\r\\n\\t\\t\\ttile6+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 6\\t\\r\\n\\t\\t\\ttile6+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(7):\\r\\n\\t\\t\\ttile7+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 7\\t\\r\\n\\t\\t\\ttile7+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(8):\\r\\n\\t\\t\\ttile8+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 8\\t\\r\\n\\t\\t\\ttile8+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\t\\r\\n\\t\\tif validMove(9):\\r\\n\\t\\t\\ttile9+=2\\r\\n\\t\\t\\tif win():\\r\\n\\t\\t\\t\\tnoWin=False\\r\\n\\t\\t\\t\\tmove= 9\\r\\n\\t\\t\\ttile9+=-2\\t\\t\\r\\n\\t\\t\\tif move:\\r\\n\\t\\t\\t\\treturn move\\t\\r\\n\\tif noWin:\\r\\n\\t\\treturn False\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n while to_move < len(movables):\\n # Make the move\\n movable_statement = movables[to_move]\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n\\n # Find out if this state has already been explored\\n visited = False\\n for visited_state in self.visited.keys():\\n if visited_state.state == new_state:\\n visited = True\\n\\n # If the new state hasn't been visited then add it as a child then move down to this child\\n if not visited:\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.currentState = new_gs\\n break\\n\\n # Else skip this state and try going to the next movable statement\\n else:\\n # print(\\\"SKIP THIS STATE\\\")\\n self.gm.reverseMove(movable_statement)\\n to_move += 1\\n\\n # Went all the way down to a leaf, backtrack\\n if (to_move >= len(movables)):\\n self.gm.reverseMove(self.currentState.requiredMovable)\\n self.currentState = self.currentState.parent\\n\\n return False\",\n \"def minimax(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n legal_moves = game.get_legal_moves()\\n\\n best_move = (-1, -1)\\n if maximizing_player:\\n score = float(\\\"-inf\\\")\\n else:\\n score = float(\\\"inf\\\")\\n\\n #At bottom of minimax tree\\n if depth == 1:\\n for each_move in legal_moves:\\n new_game = game.forecast_move(each_move)\\n if maximizing_player and self.score(new_game, self) > score:\\n score = self.score(new_game, self)\\n best_move = each_move\\n elif not maximizing_player and self.score(new_game, self) < score:\\n score = self.score(new_game, self)\\n best_move = each_move\\n\\n return score, best_move\\n\\n #Not at bottom of minimax tree\\n for each_move in legal_moves:\\n #Return each_move that gets the highest score\\n new_game = game.forecast_move(each_move)\\n new_score , new_move = self.minimax(new_game, depth-1, not maximizing_player)\\n if maximizing_player and new_score > score:\\n score = new_score\\n best_move = each_move\\n elif not maximizing_player and new_score < score:\\n score = new_score\\n best_move = each_move\\n\\n return score, best_move\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n \\n if player(board) == O:\\n v = math.inf\\n for action in actions(board):\\n move = max_value(result(board, action))\\n if move < v:\\n v = move\\n bestMove = action\\n\\n else:\\n v = -math.inf\\n for action in actions(board):\\n move = min_value(result(board, action))\\n if move > v:\\n v = move\\n bestMove = action\\n \\n return bestMove\",\n \"def custom_score(game, player):\\n\\n '''\\n =========\\n STRATEGY:\\n =========\\n Defensive player with shallow beam search of own moves (looking to maximise \\n opportunities to reach states with one or more moves at depth 2), with weight toward \\n centrality after 30% of the game. Could play better with deeper beam search of own \\n position (and opponent's for defensive purposes), but this would require a longer timeout. \\n Maximising the number of own moves at depth 2 is a reasonable proxy.\\n \\n Cache is disabled throughout game - doesn't seem to help, lookup misses are probably stealing \\n from opportunity to deepen search.\\n '''\\n\\n # Cache. Accumulates across games. Best used with higher search depths, longer timeouts.\\n # If specified, USE_TRANSFORMATIONS will check for matches by rotating and flipping the board.\\n USE_EVAL_DICT = False\\n USE_TRANSFORMATIONS = False\\n\\n # Captures stats to global dict.\\n GET_STATS = False\\n\\n # Get rough progress to endgame (0 to 100) based on the number of empty cells remaining.\\n # Pessimistic (tends to over-estimate by about 20%), scales with board size\\n progress = 100.0 * (exp(game.move_count / (game.width * game.height)) - 1.0)\\n\\n OPP_ISOL_SEARCH_PATHS = 1 # ignored if search depth < 2\\n OPP_ISOL_SEARCH_DEPTH = 1\\n PLAYER_SAFE_SEARCH_PATHS = 1 # ignored if search depth < 2\\n PLAYER_SAFE_SEARCH_DEPTH = 2\\n OPP_ISOL_MOVES_WEIGHT = 100.0\\n PLAYER_SAFE_MOVES_WEIGHT = 300.0\\n KT_WEIGHT = 50.0\\n LATE_CENTRALITY_WEIGHT = 80.0\\n KT_PROGRESS_MEASURED_TO = 30.0\\n\\n\\n return custom_score_generator(game, player, progress, use_eval_dict=USE_EVAL_DICT, use_transformations=USE_TRANSFORMATIONS, get_stats=GET_STATS,\\n # opening_book_weight=OPENING_BOOK_WEIGHT,\\n kt_weight=KT_WEIGHT, kt_progress_measured_to=KT_PROGRESS_MEASURED_TO,\\n late_centrality_weight=LATE_CENTRALITY_WEIGHT,\\n player_safe_moves_weight=PLAYER_SAFE_MOVES_WEIGHT,\\n player_safe_search_depth=PLAYER_SAFE_SEARCH_DEPTH,\\n player_safe_search_paths=PLAYER_SAFE_SEARCH_PATHS,\\n opp_isol_moves_weight=OPP_ISOL_MOVES_WEIGHT,\\n opp_isol_search_depth=OPP_ISOL_SEARCH_DEPTH,\\n opp_isol_search_paths=OPP_ISOL_SEARCH_PATHS)\",\n \"def make_move(self, time_limit, players_score):\\n \\n start_time = time.time()\\n d = 1 \\n \\n reach_the_end = False\\n best_direction = None\\n chosen_state = None\\n \\n time_limit = (2 * self.game_time * float(self.player_turns - self.turns + 1)) / ((self.player_turns + 1) * self.player_turns)\\n time_limit += self.spaire_time\\n\\n if time_limit >= 5:\\n TIME_ESTIMATION = 0.9 \\n else:\\n TIME_ESTIMATION = 0.85\\n\\n while not reach_the_end: \\n \\n iter_time_limit = TIME_ESTIMATION * ( time_limit - (time.time() - start_time) )\\n \\n state = State(get_directions(),self.board,self.locations,self.fruits_on_board_dict,PLAYER,players_score,self.penalty_score,self.fruits_ttl,self.turns)\\n\\n try:\\n _, best_direction, reach_the_end,chosen_state = self.alphabeta.search(state,d,True,iter_time_limit,alpha=float('-inf'), beta=float('inf'))\\n d += 1\\n except Exception as e:\\n self.spaire_time = time_limit - (time.time() - start_time)\\n break\\n \\n # Set new location \\n if best_direction == None:\\n best_direction = self.get_random_move() \\n self.set_player_location(best_direction)\\n \\n self.turns += 1\\n return best_direction\",\n \"def minimax(self, game, depth, maximizing_player=True):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise Timeout()\\n\\n if game.get_legal_moves():\\n scores = [(self.minvalue(game.forecast_move(move), depth), move) for move in game.get_legal_moves()]\\n else:\\n return (self.score(game, self), (-1,-1)) \\n\\n return max(scores)\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def MaxValue(gameState, currentDepth, agentNumber):\\n \\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n \\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n #print 'depth ',currentDepth\\n \\n largestValue = float(\\\"-inf\\\")\\n bestAction = Directions.NORTH\\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for pacman ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\\n if(successorValue > largestValue):\\n largestValue = successorValue\\n bestAction = action\\n return (largestValue, bestAction)\\n \\n def MinValue(gameState, currentDepth, agentNumber):\\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n \\n #print 'depth ',currentDepth\\n \\n smallestValue = float(\\\"inf\\\")\\n bestAction = Directions.NORTH \\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for ghost ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\\n if nextAgentNumber is 0:\\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\\n else:\\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\\n if(successorValue < smallestValue):\\n smallestValue = successorValue\\n bestAction = action\\n return (smallestValue, bestAction)\\n\\n result = MaxValue(gameState, 0, 0)\\n resultActionToTake = result[1]\\n #print 'Minimax value for depth ', self.depth,' ',result[0]\\n #import time\\n #time.sleep(1000000)\\n return resultActionToTake\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n possible_actions = actions(board)\\n if player(board) == X:\\n max_utility = -math.inf\\n for action in possible_actions:\\n action_val = min_val(result(board, action))\\n if action_val > max_utility:\\n max_utility = action_val\\n optimal_action = action\\n else:\\n min_utility = math.inf\\n for action in possible_actions:\\n action_val = max_val(result(board, action))\\n if action_val < min_utility:\\n min_utility = action_val\\n optimal_action = action\\n return optimal_action\",\n \"def minimax(board):\\n if terminal(board):\\n return None\\n if player(board)==X:\\n value, move = max_value(board)\\n return move\\n if player(board)==O:\\n value, move = min_value(board)\\n return move\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n # Mark this move as explored\\n self.visited[self.currentState] = True\\n self.visited_states.append(self.currentState.state)\\n\\n # Get move to make\\n movables = self.gm.getMovables()\\n # print(\\\"EXPLORING GAME STATE \\\" + str(self.gm.getGameState()) + \\\"---------------------------------------------------------\\\")\\n to_move = self.currentState.nextChildToVisit # movables index\\n # print(\\\"depth \\\", self.currentState.depth)\\n\\n # Return if done\\n if self.currentState.state == self.victoryCondition:\\n # print(\\\"DONE\\\")\\n return True\\n\\n # If current state has no children, make children\\n if not self.currentState.children:\\n for movable_statement in movables:\\n # Make the move\\n # print(\\\"implementing move \\\", movable_statement)\\n self.gm.makeMove(movable_statement)\\n\\n # Create a new state with this move made\\n new_state = self.gm.getGameState()\\n # print (\\\"new state \\\", new_state)\\n\\n # If the new state hasn't been visited and isn't in the queue then add it as a child and to the queue\\n if (new_state not in self.visited_states):\\n new_gs = GameState(new_state, self.currentState.depth + 1, movable_statement)\\n new_gs.parent = self.currentState\\n self.currentState.children.append(new_gs)\\n self.currentState.nextChildToVisit = to_move + 1\\n self.visited[new_gs] = True\\n self.visited_states.append(new_state)\\n self.gs_queue.append(new_gs)\\n\\n self.gm.reverseMove(movable_statement)\\n\\n # Return false if no more to explore\\n if not self.gs_queue:\\n return False\\n\\n # Revert to state at when current and next start to change\\n root_curr = self.currentState\\n self.currentState = self.gs_queue.popleft()\\n root_new = self.currentState\\n\\n # Backtrack to when current node and new node start to diverge\\n if root_new.depth == root_curr.depth:\\n while root_curr.state != root_new.state:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n root_new = root_new.parent\\n else:\\n while root_curr.requiredMovable:\\n self.gm.reverseMove(root_curr.requiredMovable)\\n root_curr = root_curr.parent\\n\\n # Return game master to state that we are exploring\\n # Find path between root and current state\\n path = []\\n currNode = self.currentState\\n while currNode != root_curr:\\n path.append(currNode.requiredMovable)\\n currNode = currNode.parent\\n\\n # Created backwards path, now make moves from root to current state\\n path.reverse()\\n for movable_statement in path:\\n self.gm.makeMove(movable_statement)\\n\\n return False\",\n \"def expectimax_move(game, method='score'):\\n\\n if method == 'score':\\n def val(g):\\n return g[1]\\n elif method == 'empty':\\n val = empty_squares\\n elif method == 'gradient':\\n val = gradient_value\\n else:\\n print('Invalid method given to expectimax function')\\n exit(1)\\n\\n _, move = expectimax(game, 2, val)\\n return move\",\n \"def minimax(board):\\n if (terminal(board)):\\n return None\\n if (player(board) == X):\\n best_so_far = -2\\n else:\\n best_so_far = 2\\n best_move = ()\\n for move in actions(board):\\n new_board = [row[:] for row in board]\\n res = recursion(result(new_board, move))\\n if (player(board) == X):\\n if (res > best_so_far):\\n best_so_far = res\\n best_move = move\\n if (res == 1):\\n break\\n else:\\n if (res < best_so_far):\\n best_so_far = res\\n best_move = move\\n if (res == -1):\\n break\\n \\n return best_move\",\n \"def _find_move(self, current, ply, difficulty_level, player):\\n\\n #check the score of this state\\n node_score = current.get_score()\\n #if this state is a win for either side, or if we're at the end of our difficulty depth level\\n if ply == difficulty_level or node_score > 100000000 or node_score < -100000000: #base case\\n return node_score * (difficulty_level+1-ply) #NOTE: I'm not sure if this is paranoid, but I want to make sure it doesn't multiply by 0 if we hit a win condition at the end of our search\\n\\n #recursive\\n else:\\n options = []\\n #we're either player one (Min) or player two (Max)\\n\\n #for a column at c in the rack\\n for c in range(WIDTH):\\n\\n #simulate a move in that column, making an attempt State\\n attempt = current.simul_move(c, player)\\n\\n if attempt is not None: #if this produced a move\\n if player == 1: next_player = 2\\n else: next_player = 1\\n\\n #recurse down this attempted move\\n attempt_score = self._find_move(attempt, ply+1, difficulty_level, next_player)\\n #add the results of each column move into options\\n options.append(attempt_score)\\n if len(options) == 0: return 0\\n #based on whether we're the current player or not, max (if we are) or min (if we aren't) and pass back the result\\n if player == self.player_id: return max(options)\\n else: return min(options)\",\n \"def Pwin(state):\\n # Assumes opponent also plays with optimal strategy\\n p, me, you, pending = state\\n if me + pending >= goal:\\n return 1\\n elif you >= goal:\\n return 0\\n else:\\n return max(Q_pig(state, action, Pwin) for action in pig_actions(state))\",\n \"def mm_move(board, player):\\n result = board.check_win() # get result of the current board\\n if result == None:\\n move_list = board.get_empty_squares() # get the tree branches and possible next moves\\n best = (None, (-1, -1))\\n for step in move_list:\\n bd_clone = board.clone()\\n bd_clone.move(step[0], step[1], player) #make a move on a cloned board\\n next_player = provided.switch_player(player)\\n next_score = mm_move(bd_clone, next_player) #make a recursive call to mm_move() pasing the cloned board and the 'other' player\\n if player == 3: #if it is oppo O--min\\n if best[0] == None or (next_score[0] < best[0]):\\n best = (next_score[0], step)\\n #print best\\n elif player ==2: #if it is X--max\\n if best[0] == None or (next_score[0] > best[0]):\\n best = (next_score[0], step)\\n return best\\n else:\\n return SCORES[result], (-1, -1)\",\n \"def minimax_minimize_play(self, game, legal_moves, depth):\\n lowest_score, selected_move = (float('inf'), (-1, -1))\\n for move in legal_moves:\\n score, _ = self.minimax(game.forecast_move(move), depth - 1)\\n lowest_score, selected_move = min((lowest_score, selected_move), (score, move))\\n return (lowest_score, selected_move)\",\n \"def getMove(self, grid):\\n# global prune\\n# prune = 0\\n def Terminal(stateTup):\\n \\\"\\\"\\\"\\n Checks if the node is a terminal node\\n Returns eval(state) if it is terminal\\n \\\"\\\"\\\"\\n state = stateTup[0]\\n maxDepth = self.depthLimit\\n if stateTup[1] == maxDepth:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n elif len(stateTup[0].getAvailableMoves()) == 0:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n\\n def Eval(state):\\n \\\"\\\"\\\"\\n This is the eval function which combines many heuristics and assigns\\n weights to each of them\\n Returns a single value\\n \\\"\\\"\\\"\\n\\n# H1 = htest2(state)\\n# return H1\\n H2 = h1(state)*monotonic(state)\\n return H2\\n\\n\\n def h1(state):\\n Max = state.getMaxTile()\\n left = len(state.getAvailableCells())/16\\n if state.getCellValue([0,0]) == Max:\\n v = 1\\n else:\\n v= 0.3\\n Max = Max/1024\\n return Max*left*v\\n\\n def mono(state):\\n mon = 0\\n# for i in range(4):\\n# row = 0\\n# for j in range(3):\\n# if state.map[i][j] > state.map[i][j+1]:\\n# row+=1\\n# if row == 4:\\n# mon += 1\\n# for i in range(4):\\n# column = 0\\n# for j in range(3):\\n# if state.map[j][i] > state.map[j+1][i]:\\n# column +=1\\n# if column == 4:\\n# mon +=1\\n#\\n#\\n# return mon/8\\n for i in range(4):\\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\\n mon+=1\\n\\n return mon/8\\n\\n def monotonic(state):\\n cellvals = {}\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n for i in Path1:\\n cellvals[i] = state.getCellValue(i)\\n mon = 0\\n for i in range(4):\\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\\n mon +=1\\n for j in range(4):\\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\\n mon+=1\\n return mon/8\\n\\n\\n\\n def htest2(state):\\n score1 = 0\\n score2 = 0\\n r = 0.5\\n\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\\n valDict = {}\\n for n in range(16):\\n valDict[Path1[n]] = state.getCellValue(Path1[n])\\n for n in range(16):\\n if n%3 == 0:\\n self.emergency()\\n cell1 = valDict.get(Path1[n])\\n cell2 = valDict.get(Path2[n])\\n score1 += (cell1) * (r**n)\\n score2 += (cell2) * (r**n)\\n return max(score1,score2)\\n\\n\\n def Maximize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n maxChild , maxUtility = None,-999999999\\n state = stateTup[0]\\n Map = self.dict.get(str(state.map))\\n if Map == None:\\n children = []\\n for M in range(4):\\n g = state.clone()\\n if g.move(M):\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Minimize(childTup,A,B)[1]\\n if utility > maxUtility:\\n maxChild , maxUtility = child , utility\\n if maxUtility >= B:\\n# global prune\\n# prune +=1\\n break\\n if maxUtility > A:\\n A = maxUtility\\n\\n return (maxChild,maxUtility)\\n\\n\\n def Minimize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n minChild , minUtility = None,999999999\\n state = stateTup[0]\\n Map= self.dict.get(str(state.map))\\n if Map == None:\\n cells= state.getAvailableCells()\\n children = []\\n tiles = [2,4]\\n for i in cells:\\n for j in tiles:\\n g = state.clone()\\n g.insertTile(i,j)\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Maximize(childTup,A,B)[1]\\n if utility < minUtility:\\n minChild , minUtility = child , utility\\n if minUtility <= A:\\n# global prune\\n# prune +=1\\n break\\n if minUtility < B:\\n B = minUtility\\n\\n return (minChild,minUtility)\\n\\n\\n\\n def decision(grid):\\n \\\"\\\"\\\"\\n Decision function which returns the move which led to the state\\n \\\"\\\"\\\"\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\\n\\n self.dict = {}\\n self.h = {}\\n self.prevTime = time.clock()\\n self.depthLimit = 1\\n self.mL = []\\n self.over = False\\n while self.over == False:\\n self.depthLimit +=1\\n try :\\n self.mL.append(decision(grid))\\n\\n except KeyError:\\n# print(self.depthLimit)\\n return self.mL[-1]\\n except IndexError:\\n return random.randint(0,3)\\n self.Alarm(time.clock())\\n return self.mL[-1]\",\n \"def play(self):\\r\\n state = copy.deepcopy(self.initial_state)\\r\\n # calculating the best move value and action for the given state\\r\\n best_action = self.minimax_decision(state)\\r\\n\\r\\n # To handle the case where there are no possible moves from the initial state\\r\\n if best_action[1] not in [(9, 9, 9), (6, 6), (5, 5)]:\\r\\n # Making the best move corresponding to the initial state\\r\\n state = copy.deepcopy(self.initial_state)\\r\\n expected_state = self.result(state, best_action[1])\\r\\n\\r\\n # Printing the board state resulting from the best move.\\r\\n print '{}'.format(self.convert_matrix_rastor(expected_state))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70844316","0.7019589","0.6996672","0.6943626","0.69175905","0.6854551","0.68362564","0.6793055","0.6789411","0.6709212","0.66958034","0.66800773","0.6658891","0.6658891","0.6573327","0.6429762","0.6422315","0.6422285","0.64213127","0.6387401","0.63860327","0.6373411","0.63706344","0.63647956","0.6333815","0.63234615","0.6314759","0.63134664","0.63128126","0.63008577","0.6273822","0.6272342","0.62714165","0.62688625","0.62593997","0.6255909","0.62331164","0.6231638","0.6230815","0.6226575","0.61805","0.6170884","0.6169786","0.61670494","0.61613655","0.61588293","0.61558247","0.61519027","0.61462736","0.6126214","0.6119759","0.6104037","0.6102021","0.6101598","0.60982734","0.609681","0.6087089","0.60863745","0.6067105","0.6055537","0.6053564","0.6053415","0.6053093","0.60518","0.6028914","0.6024813","0.6024424","0.60218453","0.60185695","0.6012497","0.60077226","0.6007698","0.60072947","0.60032946","0.59985435","0.59972936","0.5993816","0.5988225","0.598797","0.5986904","0.598173","0.59737176","0.59709686","0.5967291","0.59631765","0.59534836","0.5948891","0.594607","0.5939084","0.59228927","0.5921835","0.59209704","0.5915416","0.5900876","0.589416","0.5880192","0.5875459","0.58721334","0.5869819","0.5869436","0.58653593"],"string":"[\n \"0.70844316\",\n \"0.7019589\",\n \"0.6996672\",\n \"0.6943626\",\n \"0.69175905\",\n \"0.6854551\",\n \"0.68362564\",\n \"0.6793055\",\n \"0.6789411\",\n \"0.6709212\",\n \"0.66958034\",\n \"0.66800773\",\n \"0.6658891\",\n \"0.6658891\",\n \"0.6573327\",\n \"0.6429762\",\n \"0.6422315\",\n \"0.6422285\",\n \"0.64213127\",\n \"0.6387401\",\n \"0.63860327\",\n \"0.6373411\",\n \"0.63706344\",\n \"0.63647956\",\n \"0.6333815\",\n \"0.63234615\",\n \"0.6314759\",\n \"0.63134664\",\n \"0.63128126\",\n \"0.63008577\",\n \"0.6273822\",\n \"0.6272342\",\n \"0.62714165\",\n \"0.62688625\",\n \"0.62593997\",\n \"0.6255909\",\n \"0.62331164\",\n \"0.6231638\",\n \"0.6230815\",\n \"0.6226575\",\n \"0.61805\",\n \"0.6170884\",\n \"0.6169786\",\n \"0.61670494\",\n \"0.61613655\",\n \"0.61588293\",\n \"0.61558247\",\n \"0.61519027\",\n \"0.61462736\",\n \"0.6126214\",\n \"0.6119759\",\n \"0.6104037\",\n \"0.6102021\",\n \"0.6101598\",\n \"0.60982734\",\n \"0.609681\",\n \"0.6087089\",\n \"0.60863745\",\n \"0.6067105\",\n \"0.6055537\",\n \"0.6053564\",\n \"0.6053415\",\n \"0.6053093\",\n \"0.60518\",\n \"0.6028914\",\n \"0.6024813\",\n \"0.6024424\",\n \"0.60218453\",\n \"0.60185695\",\n \"0.6012497\",\n \"0.60077226\",\n \"0.6007698\",\n \"0.60072947\",\n \"0.60032946\",\n \"0.59985435\",\n \"0.59972936\",\n \"0.5993816\",\n \"0.5988225\",\n \"0.598797\",\n \"0.5986904\",\n \"0.598173\",\n \"0.59737176\",\n \"0.59709686\",\n \"0.5967291\",\n \"0.59631765\",\n \"0.59534836\",\n \"0.5948891\",\n \"0.594607\",\n \"0.5939084\",\n \"0.59228927\",\n \"0.5921835\",\n \"0.59209704\",\n \"0.5915416\",\n \"0.5900876\",\n \"0.589416\",\n \"0.5880192\",\n \"0.5875459\",\n \"0.58721334\",\n \"0.5869819\",\n \"0.5869436\",\n \"0.58653593\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9295,"cells":{"query":{"kind":"string","value":"Summary This function encapsulates the routine to generate backprojected and cortical views for the magnocellular pathway retinal ganglion cells"},"document":{"kind":"string","value":"def showNonOpponency(C,theta):\n GI = retina.gauss_norm_img(x, y, dcoeff[i], dloc[i], imsize=imgsize,rgb=False)\n # Sample using the other recepetive field, note there is no temporal response with still images\n S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True)\n #backproject the imagevectors\n ncentreV,nsurrV = rgc.nonopponency(C,S,theta)\n ninverse = retina.inverse(ncentreV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n ninv_crop = retina.crop(ninverse,x,y,dloc[i])\n ninverse2 = retina.inverse(nsurrV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n ninv_crop2 = retina.crop(ninverse2,x,y,dloc[i])\n # place descriptive text onto generated images\n cv2.putText(ninv_crop,\"R+G + \",(xx,yy), font, 1,(255,255,255),2)\n cv2.putText(ninv_crop2,\"R+G - \",(xx,yy), font, 1,(255,255,255),2)\n merged = np.concatenate((ninv_crop, ninv_crop2),axis=1)\n \n # create cortical maps of the imagevectors\n lposnon, rposnon = cortex.cort_img(ncentreV, L, L_loc, R, R_loc, cort_size, G)\n lnegnon, rnegnon = cortex.cort_img(nsurrV, L, L_loc, R, R_loc, cort_size, G)\n pos_cort_img = np.concatenate((np.rot90(lposnon),np.rot90(rposnon,k=3)),axis=1)\n neg_cort_img = np.concatenate((np.rot90(lnegnon),np.rot90(rnegnon,k=3)),axis=1)\n mergecort = np.concatenate((pos_cort_img,neg_cort_img),axis=1)\n return merged, mergecort"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def view_marginals_cristobal(rep=0, epoch=300, zoom=False):\n samples_path = paths.eICU_synthetic_dir + 'samples_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\n samples = np.load(samples_path)\n labels_path = paths.eICU_synthetic_dir + 'labels_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\n labels = np.load(labels_path)\n real_path = paths.eICU_task_data\n raw_real_train = np.load(real_path).item()['X_train'].reshape(-1, 16, 4)\n real_test = np.load(real_path).item()['X_test'].reshape(-1, 16, 4)\n real_vali = np.load(real_path).item()['X_vali'].reshape(-1, 16, 4)\n # discard vali, test\n real, scaled_vali, scaled_test = scale_data(raw_real_train, real_vali, real_test)\n real = raw_real_train\n view_marginals_raw(raw_real_train, label='raw_real_train')\n view_marginals_raw(real, label='real_train')\n view_marginals_raw(samples, label='synthetic')\n\n variables = ['sao2', 'heartrate', 'respiration', 'systemicmean']\n\n # get the scaling factors\n scaling_factors = {'a': np.zeros(shape=(16, 4)), 'b': np.zeros(shape=(16, 4))}\n ranges = []\n for var in range(4):\n var_min = 100\n var_max = 0\n for timestep in range(16):\n min_val = np.min([np.min(raw_real_train[:, timestep, var]), np.min(real_vali[:, timestep, var])])\n max_val = np.max([np.max(raw_real_train[:, timestep, var]), np.max(real_vali[:, timestep, var])])\n if min_val < var_min:\n var_min = min_val\n if max_val > var_max:\n var_max = max_val\n a = (max_val - min_val)/2\n b = (max_val + min_val)/2\n scaling_factors['a'][timestep, var] = a\n scaling_factors['b'][timestep, var] = b\n ranges.append([var_min, var_max])\n\n # now, scale the synthetic data manually\n samples_scaled = np.zeros_like(samples)\n for var in range(4):\n for timestep in range(16):\n samples_scaled[:, timestep, var] = samples[:, timestep, var]*scaling_factors['a'][timestep, var] + scaling_factors['b'][timestep, var]\n\n if zoom:\n # use modes, skip for now\n modes = False\n if modes:\n # get rough region of interest, then zoom in on it afterwards!\n num_gradations = 5\n gradations = np.linspace(-1, 1, num_gradations)\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\n lower = 0\n real_grid = np.zeros(shape=(16, num_gradations, 4))\n for (i, cutoff) in enumerate(gradations):\n # take the mean over samples\n real_frac = ((real > lower) & (real <= cutoff)).mean(axis=0)\n lower = cutoff\n real_grid[:, i, :] = real_frac\n time_averaged_grid = np.mean(real_grid, axis=0)\n # get the most populated part of the grid for each variable\n grid_modes = np.argmax(time_averaged_grid, axis=0)\n lower = 0\n ranges = []\n for i in grid_modes:\n lower = gradations[i-1]\n upper = gradations[i]\n ranges.append([lower, upper])\n else:\n # hand-crafted ranges\n ranges = [[88, 100], [30, 130], [7, 60], [35, 135]]\n\n num_gradations = 25\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\n grid = np.zeros(shape=(16, num_gradations, 4))\n real_grid = np.zeros(shape=(16, num_gradations, 4))\n assert samples.shape[-1] == 4\n for var in range(4):\n # allow for a different range per variable (if zoom)\n low = ranges[var][0]\n high = ranges[var][1]\n gradations = np.linspace(low, high, num_gradations)\n for (i, cutoff) in enumerate(gradations):\n # take the mean over samples\n frac = ((samples_scaled[:, :, var] > low) & (samples_scaled[:, :, var] <= cutoff)).mean(axis=0)\n real_frac = ((real[:, :, var] > low) & (real[:, :, var] <= cutoff)).mean(axis=0)\n low = cutoff\n grid[:, i, var] = frac\n real_grid[:, i, var] = real_frac\n\n # now plot this as an image\n fig, axarr = plt.subplots(nrows=4, ncols=2, sharey='row', sharex=True)\n axarr[0, 0].imshow(grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[1, 0].imshow(grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[2, 0].imshow(grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[3, 0].imshow(grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[0, 1].imshow(real_grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[1, 1].imshow(real_grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[2, 1].imshow(real_grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[3, 1].imshow(real_grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\n\n axarr[0, 0].set_title(\"synthetic\")\n axarr[0, 1].set_title(\"real\")\n for var in range(4):\n low, high = ranges[var]\n labels = np.linspace(low, high, num_gradations)[1::4]\n labels = np.round(labels, 0)\n axarr[var, 0].set_yticklabels(labels)\n axarr[var, 0].set_yticks(np.arange(num_gradations)[1::4])\n axarr[var, 0].set_ylabel(variables[var])\n for ax in axarr[var, :]:\n ax.yaxis.set_ticks_position('none')\n ax.xaxis.set_ticks_position('none')\n ax.set_adjustable('box-forced')\n ax.spines['top'].set_visible(False)\n ax.spines['bottom'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\n\n axarr[-1, 0].set_xticks(np.arange(16)[::2])\n axarr[-1, 1].set_xticks(np.arange(16)[::2])\n\n if zoom:\n plt.suptitle('(zoomed)')\n\n plt.tight_layout(pad=0.0, w_pad=-5.0, h_pad=0.1)\n plt.savefig(\"./experiments/eval/eICU_cristobal_marginals_r\" + str(rep) + \"_epoch\" + str(epoch) + \".png\")\n\n # now make the histograms\n fig, axarr = plt.subplots(nrows=1, ncols=4)\n axarr[0].set_ylabel(\"density\")\n axarr[0].hist(real[:, :, 0].flatten(), normed=True, color='black', alpha=0.8, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='real')\n axarr[1].hist(real[:, :, 1].flatten(), normed=True, color='black', alpha=0.8, range=ranges[1], bins=50)\n axarr[2].hist(real[:, :, 2].flatten(), normed=True, color='black', alpha=0.8, range=ranges[2], bins=50)\n axarr[3].hist(real[:, :, 3].flatten(), normed=True, color='black', alpha=0.8, range=ranges[3], bins=50)\n axarr[0].hist(samples_scaled[:, :, 0].flatten(), normed=True, alpha=0.6, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='synthetic')\n axarr[0].legend()\n axarr[1].hist(samples_scaled[:, :, 1].flatten(), normed=True, alpha=0.6, range=ranges[1], bins=50)\n axarr[2].hist(samples_scaled[:, :, 2].flatten(), normed=True, alpha=0.6, range=ranges[2], bins=50)\n axarr[3].hist(samples_scaled[:, :, 3].flatten(), normed=True, alpha=0.6, range=ranges[3], bins=50)\n for (var, ax) in enumerate(axarr):\n ax.set_xlabel(variables[var])\n ax.yaxis.set_ticks_position('none')\n ax.xaxis.set_ticks_position('none')\n ax.spines['top'].set_visible(False)\n ax.spines['bottom'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\n\n plt.gcf().subplots_adjust(bottom=0.2)\n fig.set_size_inches(10, 3)\n plt.savefig(\"./experiments/eval/eICU_cristobal_hist_r\" + str(rep) + \"_epoch\" + str(epoch) + \".png\")\n\n return True","def generate_overview_tiles(self):\n\n gdal.SetConfigOption(\"GDAL_PAM_ENABLED\", \"NO\")\n\n print \"Generating Overview Tiles:\"\n\n if self.options.profile == 'garmin': # no overview tiles for 'garmin'\n return\n # Usage of existing tiles: from 4 underlying tiles generate one as overview.\n\n tcount = 0\n zcount = 0\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\n tcount += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\n zcount+=1\n if self.options.resume:\n count_tiles=tcount\n zcount+=1\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\n count_tiles += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\n i_count = self.tile_exists(0, 0, 0,1)\n if i_count == count_tiles:\n if self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; all-tiles [\",zcount,\"] zoom-levels with tiles[\",count_tiles,\"]\"\n return\n ti = 0\n\n # querysize = tilesize * 2\n\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\n i_x_column_count=((tmaxx-tminx)+1)\n i_y_column_count=((tmaxy-tminy)+1)\n if self.options.verbose:\n # tx in range(tminx, tmaxx+1) tminx[ 140798 ] tmaxx[ 140872 ] ; ((tmaxx-tmaxy)+1) x_tiles[ -35331 ]\n print \"\\ttz=[\",tz,\"] : tx in range(tminx, tmaxx+1) tminx[\",tminx,\"] tmaxx[\",tmaxx,\"] ; ((tmaxx-tminx)+1) x_tiles[\",i_x_column_count,\"]\"\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 176204 ] tminy[ 176126 ] ; ((tmaxy-tminy)) y_tiles[ 78 ]\n print \"\\ttz=[\",tz,\"] :ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\",tmaxy,\"] tminy[\",tminy,\"] ; ((tmaxy-tminy)) y_tiles[\",i_y_column_count,\"]\"\n if self.options.resume:\n i_count = self.tile_exists(0, 0, tz,2)\n print \"\\tTile generation skipped because of --??? ; x/y-tiles of z[\",tz,\"] x/y_tiles[\",tcount,\"] i_count[\",i_count,\"]\"\n if i_count == tcount:\n if self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; x/y-tiles of z[\",tz,\"] x/y_tiles[\",tcount,\"]\"\n break\n for tx in range(tminx, tmaxx+1):\n tmaxy_work=tmaxy\n if self.options.resume:\n i_count = self.tile_exists(tx, 0, tz,3)\n print \"\\tTile generation skipped because of --??? ; z =\",tz,\" ; y-tiles of x[\",tx,\"] y_tiles[\",i_y_column_count,\"] i_count[\",i_count,\"]\"\n if i_count == i_y_column_count:\n if self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; z =\",tz,\" ; y-tiles of x[\",tx,\"] y_tiles[\",i_y_column_count,\"]\"\n break\n else:\n if i_count > 0:\n # this assums the rows are compleate, which may NOT be true 18-140798-176204.jpg\n tmaxy_work-=i_count\n if self.options.verbose:\n print \"\\tTile generation skipped to tmaxy[\",tmaxy_work,\"] because of --resume ; z =\",tz,\" ; y-tiles of x[\",tx,\"] y_tiles[\",i_y_column_count,\"]\"\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\n ty_osm=self.flip_y(tz,ty_tms)\n ty=ty_tms\n if self.options.tms_osm:\n ty=ty_osm\n if self.stopped:\n if self.options.mbtiles:\n if self.mbtiles_db:\n self.mbtiles_db.close_db()\n self.mbtiles_db=None\n break\n\n ti += 1\n\n if self.options.resume:\n exists = self.tile_exists(tx, ty, tz,0)\n if exists and self.options.verbose:\n print \"\\tTile generation skipped because of --resume\"\n else:\n exists = False\n\n if not exists:\n if self.options.verbose:\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\n try:\n self.write_overview_tile(tx, ty, tz,self.options.tms_osm)\n except ImageOutputException, e:\n self.error(\"'%d/%d/%d': %s\" % (tz, tx, ty, e.message))\n\n if not self.options.verbose or self.is_subprocess:\n self.progressbar( ti / float(tcount) )\n if self.options.mbtiles:\n if self.mbtiles_db:\n self.mbtiles_db.close_db()\n self.mbtiles_db=None","def main():\n\n cages = [\n \"AABCCD\",\n \"EFBCGD\",\n \"EFFHGI\",\n \"EJJHGI\",\n \"EKJHGL\",\n \"KKJLLL\",\n ]\n\n peaks = [\n (0, 1),\n (0, 2),\n (1, 3),\n (1, 4),\n (1, 5),\n (2, 1),\n (2, 3),\n (3, 0),\n (3, 5),\n (4, 2),\n (5, 1),\n (5, 4),\n ]\n\n extract = {\n \"A\": (5, 2),\n \"B\": (0, 3),\n \"C\": (3, 2),\n \"D\": (1, 4),\n \"E\": (0, 1),\n \"F\": (1, 5),\n \"G\": (4, 2),\n \"H\": (3, 5),\n \"I\": (1, 0),\n \"J\": (5, 5),\n \"K\": (3, 4),\n \"L\": (5, 1),\n \"M\": (0, 5),\n \"N\": (4, 4),\n }\n\n def answer(sg):\n solved_grid = sg.solved_grid()\n s = \"\"\n s += chr(64 + solved_grid[extract[\"A\"]] + solved_grid[extract[\"B\"]])\n s += chr(64 + solved_grid[extract[\"C\"]] + solved_grid[extract[\"D\"]])\n s += chr(64 + solved_grid[extract[\"E\"]] + solved_grid[extract[\"F\"]] + solved_grid[extract[\"G\"]])\n s += chr(64 + solved_grid[extract[\"H\"]] + solved_grid[extract[\"I\"]])\n s += chr(64 + solved_grid[extract[\"J\"]] + solved_grid[extract[\"K\"]] + solved_grid[extract[\"L\"]])\n s += chr(64 + solved_grid[extract[\"M\"]] + solved_grid[extract[\"N\"]])\n return s\n\n sym = grilops.make_number_range_symbol_set(1, 6)\n lattice = grilops.get_square_lattice(6)\n sg = grilops.SymbolGrid(lattice, sym)\n\n add_sudoku_constraints(sg)\n\n # Constrain regions to match the cages and be rooted at the peaks.\n cage_label_to_region_id = {}\n for py, px in peaks:\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\n\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\n for y, x in lattice.points:\n sg.solver.add(\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\n\n # Within each region, a parent cell must have a greater value than a child\n # cell, so that the values increase as you approach the root cell (the peak).\n for p in lattice.points:\n for n in sg.edge_sharing_neighbors(p):\n sg.solver.add(Implies(\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\n n.symbol > sg.grid[p]\n ))\n\n if sg.solve():\n sg.print()\n print()\n print(answer(sg))\n while not sg.is_unique():\n print()\n print(\"Alternate solution\")\n sg.print()\n print()\n print(answer(sg))\n else:\n print(\"No solution\")","def gen_obs_grid(self):\n\n topX, topY, botX, botY = self.get_view_exts()\n\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\n\n # for i in range(self.agent_dir + 1):\n # grid = grid.rotate_left()\n\n # Process occluders and visibility\n # Note that this incurs some performance cost\n if not self.see_through_walls:\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\n self.agent_view_size // 2))\n else:\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\n\n # Make it so the agent sees what it's carrying\n # We do this by placing the carried object at the agent's position\n # in the agent's partially observable view\n agent_pos = grid.width // 2, grid.height // 2\n if self.carrying:\n grid.set(*agent_pos, self.carrying)\n else:\n grid.set(*agent_pos, None)\n\n return grid, vis_mask","def main():\n dpi = 1\n dpi = 2\n width = int(360)\n height = int(130)\n mywidth = int(width*dpi)\n myheight = int(height*dpi)\n FWHM = 7.5 # degrees\n FWHM = 10.0 # degrees\n FWHM = 5.0 # degrees\n FWHM = 3.0 # degrees\n FWHM = 1.0 # degrees\n weight = 1.\n\n nargs = len(sys.argv)\n if nargs < 2:\n print('GR: GRid Observations of integrated intensity produced by the T Command')\n print('GR produces fits images for each of the horns used for the observations.')\n print('For observations at the same coordinates, the ratios of intensities are also produced.')\n print('The FITS format files require header information, which is copied from the')\n print('Cold Load File provided by the user')\n print('GR RA|GAL <cold file name> <savefile1> [<savefile2> ... <savefileN>]')\n print(\"\")\n print('Glen Langston, National Science Foundation -- 20 May 12')\n exit()\n\n gridtype = sys.argv[1]\n gridtype = gridtype.upper()\n print('Grid Type: ', gridtype)\n\n # enable having ra going from 24 to 0 hours == 360 to 0 degrees\n xsign = 1.\n xoffset = 0.\n if gridtype == 'RA':\n xmin = 0.\n xmax = 360.\n ymin = -40.\n ymax = 90.\n maptype = 'RA'\n elif gridtype == '-RA':\n xmin = 0.\n xmax = 360.\n ymin = -40.\n ymax = 90.\n xsign = -1.\n xoffset = 360. # when x = 360. should be at zero.\n maptype = 'RA'\n elif gridtype == '-EL':\n xmin = 0.\n xmax = 360.\n ymin = 0.\n ymax = 90.\n xsign = -1.\n xoffset = 360. # when x = 360. should be at zero.\n maptype = 'AZEL'\n elif gridtype == 'RA0':\n xmin = 0.\n xmax = 360.\n ymin = -41.\n ymax = 89.\n xsign = -1.\n xoffset = 180. # when x = 360. should be at zero.\n gridtype = 'RA'\n elif gridtype == 'GAL':\n xmin = -180.\n xmax = 180.\n ymin = -90.\n ymax = 90.\n maptype = 'GAL'\n\n if gridtype != 'RA' and gridtype != 'GAL' and gridtype != '-RA' and gridtype != \"RA0\":\n print('Error parsing grid type: ', gridtype)\n print('1st argument should be either RA, -RA or GAL')\n exit()\n\n rs = radioastronomy.Spectrum()\n\n if doRatio: \n #create the grid with map parameters\n grid1 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid2 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid3 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid4 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n # put each telescope in a different grid\n grids = [grid1, grid2, grid3, grid4]\n\n gridall = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n \n\n projection = \"-AIT\"\n# coldfile \n coldfile = sys.argv[2]\n# get telescope geographic location etc\n print(\"Reading Observing parameters from: %s\" % (coldfile))\n rs.read_spec_ast(coldfile)\n print(\"Observer: %s \" % (rs.observer))\n\n# first read through all data and find hot load\n names = sys.argv[3:]\n names = sorted(names)\n\n firsttime = \"\"\n lasttime = \"\"\n count = 0\n # setup grid indicies so that cpuIndex goes to the correct grid\n # This assumes telescopes 2,3,4,5 are being used] \n gridIndex = [0,0,0,1,2,3]\n # for all save Files to Grid\n for filename in names:\n print(\"File: %s\" % (filename))\n f = open(filename)\n\n date = \"Unknown\"\n while date != \"\":\n date, time, cpuIndex, telaz, telel, tSys, tRx, tRms, tint, KperC, tSourcemax, velSource, dV, tVSum, tVSumRms, tSumKmSec, dTSumKmSec, gainFactor = gainfactor.readSaveValues( f)\n dlen = len(date)\n if dlen < 1:\n break\n if date[0] == \"#\":\n continue\n # else not a comment process the line\n count = count + 1\n isodate = \"20\"+date+\"T\"+time\n# print(\"DateTime: %s\" % (isodate))\n rs.utc = datetime.datetime.strptime(isodate,\"%Y-%m-%dT%H:%M:%S\")\n# print(\"Utc: %s\" % (rs.utc))\n rs.telaz = telaz\n rs.telel = telel\n rs.azel2radec()\n\n ra = rs.ra\n dec = rs.dec\n lon = rs.gallon\n lat = rs.gallat\n tsum = tSumKmSec\n tsdv = dTSumKmSec\n tmax = tSourcemax\n vave = tVSum\n vsdv = tVSumRms\n if firsttime == \"\":\n firsttime = date\n else:\n lasttime = date\n\n# if vave > -100. and vave < 100:\n# mygrid.convolve( lon, lat, vave, 1.)\n iGrid = gridIndex[cpuIndex]\n gainCorr = telescopefactors[iGrid]\n tsum = tsum * gainCorr\n if gridtype == 'RA':\n if doRatio:\n grids[iGrid].convolve(ra, dec, tsum, weight)\n gridall.convolve( ra, dec, tsum, weight)\n elif gridtype == '-RA':\n x = (ra*xsign) + xoffset\n if doRatio:\n grids[iGrid].convolve(x, dec, tsum, weight)\n gridall.convolve( x, dec, tsum, weight)\n elif gridtype == 'RA0':\n x = (ra*xsign) + xoffset\n if x < 0:\n x = x + xmax\n elif x > xmax:\n x = x - xmax\n if doRatio:\n grids[iGrid].convolve(x, dec, tsum, weight)\n gridall.convolve( x, dec, tsum, weight)\n else:\n if doRatio:\n grids[iGrid].convolve(lon, lat, tsum, weight)\n gridall.convolve( lon, lat, tsum, weight)\n\n if count == 0:\n print('Convolving Coordinates: ', ra, dec, lon, lat)\n print('Convolving Intensities: ', tsum, tsdv, vave, vsdv)\n print('Convolvign Parameters : ', n, time)\n count = count + 1\n # end reading all lines in save file\n f.close()\n\n # normalize each of the gridded images\n if doRatio:\n grids[0].normalize()\n grids[1].normalize()\n grids[2].normalize()\n grids[3].normalize()\n gridall.normalize()\n# mygrid.check()\n# zmin = -1000.\n# zmax = 3000.\n# limit grid intensities for plotting\n# mygrid.set_ij( 0, 0, zmax, 1.)\n# mygrid.set_ij( 1, 1, zmin, 1.)\n# mygrid.limit(zmin, zmax)\n\n subplots = False\n\n if subplots:\n fig, ax = plt.subplots(figsize=(myheight, mywidth), dpi=dpi)\n\n if gridtype == 'RA':\n cax = fig.add_axes([-180, 180], [-90, 90])\n else:\n cax = fig.add_axes([0, 24], [-90, 90])\n\n cbar = fig.colorbar(cax, ticks=[zmin, zmax], orientation='horizontal')\n cbar.ax.set_yticklabels([str(zmin), str(zmax)])\n\n ax.set_title(\"Citizen Science: Horn observations of our Galaxy\")\n else:\n#y_ticks = ymin + (ymax-ymin)*ticks/myheight\n\n ticks = np.arange(0, mywidth, 30*dpi)\n x_ticks = xmin + ((xmax-xmin)*ticks/mywidth)\n\n plt.imshow(gridall.image, interpolation='nearest', cmap=plt.get_cmap('jet'))\n\n if firsttime != lasttime:\n plt.title(\"Citizen Science: Observing our Galaxy: %s to %s\" % (firsttime, lasttime))\n else:\n plt.title(\"Citizen Science: Observing our Galaxy: %s\" % (firsttime))\n if gridtype == 'RA':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = ticks/(mywidth/24)\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == '-RA':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = 24 - (ticks/(mywidth/24))\n labels[0] = 0\n labels[0] = 24\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == '-EL':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Elevation (degrees)\")\n labels = 24 - (ticks/(mywidth/24))\n labels[0] = 0\n labels[0] = 24\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == 'RA0': # put 0 hours in middle of plot\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = 12 - (ticks/(mywidth/24))\n nlabels = len(labels)\n for iii in range(nlabels):\n if labels[iii] < 0:\n labels[iii] = 24 + labels[iii]\n if labels[iii] == 24:\n labels[iii] = 0\n yticks = np.arange(0, myheight, 15*dpi)\n else:\n yticks = np.arange(0, myheight, 30*dpi)\n ticks = np.arange(0, mywidth, 30*dpi)\n x_ticks = xmin + (xmax-xmin)*ticks/mywidth\n labels = x_ticks\n plt.xlabel(\"Galactic Longitude (degrees)\")\n plt.ylabel(\"Galactic Latitude (degrees)\")\n # wnat an integer list of labels\n# slabels = str(labels)\n print(ticks, labels)\n y_ticks = ymax - (ymax-ymin)*yticks/myheight\n plt.yticks(yticks, y_ticks)\n plt.xticks(ticks, labels, rotation='horizontal')\n plt.colorbar()\n\n crval2 = (xmin + xmax)/2.\n crval1 = (ymin + ymax)/2.\n cdelt1 = (-1./float(dpi)) - .001\n cdelt2 = (1./float(dpi)) + .001\n if doRatio:\n# now show eacsh of the images\n for iGrid in range(4):\n imagetemp = copy.deepcopy(grids[iGrid].image)\n imagetemp2 = copy.deepcopy(grids[iGrid].image)\n kkk = myheight - 1\n for jjj in range(myheight):\n imagetemp[:][kkk] = imagetemp2[:][jjj]\n kkk = kkk - 1\n grids[iGrid].image = imagetemp\n writeFitsImage( rs, iGrid+2, grids[iGrid], projection)\n\n # put each telescope in a different grid\n ratio1 = copy.deepcopy(grid1)\n ratio2 = copy.deepcopy(grid1)\n ratio3 = copy.deepcopy(grid1)\n gratios = [ratio1, ratio2, ratio3]\n ratios = np.zeros(3)\n rmss = np.zeros(3)\n\n jGrid = 3\n for iGrid in range(3):\n print(\"Gain Ratios for Telescopes T%d and T%d\" % (iGrid+2, jGrid+2))\n ratio, rms, aratio = gridratio(grids[iGrid], grids[jGrid])\n ratios[iGrid] = ratio\n rmss[iGrid] = rms\n writeFitsImage( rs, iGrid+2, aratio, projection)\n \n writeFitsImage( rs, 0, gridall, projection)\n plt.show()","def refl_analysis(self,dials_model):\n Z = self.refl_table\n indices = Z['miller_index']\n expts = ExperimentListFactory.from_json_file(dials_model,\n check_format=False)\n self.dials_model=expts[0]\n CRYS = self.dials_model.crystal\n UC = CRYS.get_unit_cell()\n strong_resolutions = UC.d(indices)\n order = flex.sort_permutation(strong_resolutions, reverse=True)\n Z[\"spots_order\"] = order\n self.spots_pixels = flex.size_t()\n spots_offset = flex.int(len(order),-1)\n spots_size = flex.int(len(order),-1)\n\n P = panels = Z['panel']\n S = shoeboxes = Z['shoebox']\n N_visited = 0; N_bad = 0\n for oidx in range(len(order)): #loop through the shoeboxes in correct order\n sidx = order[oidx] # index into the Miller indices\n ipanel = P[sidx]\n slow_size = 254\n fast_size = 254\n panel_size=slow_size*fast_size\n bbox = S[sidx].bbox\n first_position = spots_offset[sidx] = self.spots_pixels.size()\n for islow in range(max(0,bbox[2]-3), min(slow_size,bbox[3]+3)):\n for ifast in range(max(0,bbox[0]-3), min(fast_size,bbox[1]+3)):\n value = self.trusted_mask[ipanel][islow*slow_size + ifast]\n N_visited += 1\n if value: self.spots_pixels.append(ipanel*panel_size+islow*slow_size+ifast)\n else: N_bad+=1\n spot_size = spots_size[sidx] = self.spots_pixels.size() - first_position\n Z[\"spots_offset\"] = spots_offset\n Z[\"spots_size\"] = spots_size\n print (N_visited,\"pixels were visited in the %d shoeboxes (with borders)\"%len(order))\n print (N_bad,\"of these were bad pixels, leaving %d in target\"%(len(self.spots_pixels)))","def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n hspc=(max_x-min_x)/x_divisions\n vspc=(max_y-min_y)/y_divisions\n\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%.1f\" % hval)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%.1f\" % vval)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def compute_plan_with_gaddpg(self, state, ef_pose, vis=False):\n joints = get_joints(self.joint_listener)\n gaddpg_grasps_from_simulate_view(self.agent, state, cfg.RL_MAX_STEP, ef_pose)\n print('finish simulate views')\n # can use remaining timesteps to replan. Set vis to visualize collision and traj\n self.expert_plan, self.standoff_idx = self.planner.expert_plan(cfg.RL_MAX_STEP, joints, ef_pose, state[0][0], vis=vis)\n print('expert plan', self.expert_plan.shape)\n print('standoff idx', self.standoff_idx)","def drought_veg_index_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.8},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n\n # NCDC Climate Divisions\n climo_divs = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\n 'params': {'LAYERS': 'show:1'}},\n legend_title='Climate Divisions',\n layer_options={'visible':False,'opacity':0.8},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n ##### WMS Layers - Ryan\n vdri_legend = MVLegendImageClass(value='VegDRI Cat',\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_VDRI_EMODIS_1') \n vegdri = MVLayer(\n source='ImageWMS',\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\n 'params': {'LAYERS': 'DROUGHT_VDRI_EMODIS_1'},\n 'serverType': 'geoserver'},\n layer_options={'visible':True,'opacity':0.5},\n legend_title='VegDRI',\n legend_classes=[vdri_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n # historical layers https://edcintl.cr.usgs.gov/geoserver/qdrivegdriemodis/wms?', 'params': {'LAYERS': 'qdrivegdriemodis_pd_1-sevenday-53-2017_mm_data'\n\n qdri_legend = MVLegendImageClass(value='QuickDRI Cat',\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_QDRI_EMODIS_1') \n quickdri = MVLayer(\n source='ImageWMS',\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\n 'params': {'LAYERS': 'DROUGHT_QDRI_EMODIS_1'},\n 'serverType': 'geoserver'},\n layer_options={'visible':False,'opacity':0.5},\n legend_title='QuickDRI',\n legend_classes=[qdri_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n # historical layers: https://edcintl.cr.usgs.gov/geoserver/qdriquickdriraster/wms?', 'params': {'LAYERS': 'qdriquickdriraster_pd_1-sevenday-53-2017_mm_data' \n \n # Land Cover REST layer\n #https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer\n NLCD = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer',\n 'params': {'LAYERS': 'show6'}},\n layer_options={'visible':False,'opacity':0.5},\n legend_title='NLCD',\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # Define map view options\n drought_veg_index_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\n layers=[tiger_boundaries,climo_divs,vegdri,quickdri,NLCD,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_veg_index_map_view_options':drought_veg_index_map_view_options,\n }\n\n return render(request, 'co_drought/drought_veg_index.html', context)","def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\n\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\n \n \n for i in np.arange(0,SHP[0],1):\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\n \n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\n \n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\n\n # normalise lateral flow so that -ve= flow out of cells towards edges\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\n # fluxes if not normalised in this way.\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\n\n # nabla is the inverted delta operator used to denote the divergence \n # of a vector field, here applied to hydrological flow in m3/d \n # calculated as dx/dt + dy/dt + dz/dt\n\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\n \n # divergence gives net in/outflow in m3/t\n # cells/m3 = cells/mL *1000\n\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\n\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \n\n Cells[Cells<0] = 0\n \n CellColumnTot = Cells.sum(axis=1)\n \n\n return Cells, CellColumnTot","def gpt2_1w (station, dmjd,dlat,dlon,hell,it):\n\n# need to find diffpod and difflon\n if (dlon < 0):\n plon = (dlon + 2*np.pi)*180/np.pi;\n else:\n plon = dlon*180/np.pi;\n# transform to polar distance in degrees\n ppod = (-dlat + np.pi/2)*180/np.pi; \n\n# % find the index (line in the grid file) of the nearest point\n# \t % changed for the 1 degree grid (GP)\n ipod = np.floor(ppod+1); \n ilon = np.floor(plon+1);\n \n# normalized (to one) differences, can be positive or negative\n#\t% changed for the 1 degree grid (GP)\n diffpod = (ppod - (ipod - 0.5));\n difflon = (plon - (ilon - 0.5));\n\n\n# change the reference epoch to January 1 2000\n print('Modified Julian Day', dmjd)\n dmjd1 = dmjd-51544.5 \n\n pi2 = 2*np.pi\n pi4 = 4*np.pi\n\n# mean gravity in m/s**2\n gm = 9.80665;\n# molar mass of dry air in kg/mol\n dMtr = 28.965E-3 \n# dMtr = 28.965*10^-3 \n# universal gas constant in J/K/mol\n Rg = 8.3143 \n\n# factors for amplitudes, i.e. whether you want time varying\n if (it==1):\n print('>>>> no refraction time variation ')\n cosfy = 0; coshy = 0; sinfy = 0; sinhy = 0;\n else: \n cosfy = np.cos(pi2*dmjd1/365.25)\n coshy = np.cos(pi4*dmjd1/365.25) \n sinfy = np.sin(pi2*dmjd1/365.25) \n sinhy = np.sin(pi4*dmjd1/365.25) \n cossin = np.matrix([1, cosfy, sinfy, coshy, sinhy])\n# initialization of new vectors\n p = 0; T = 0; dT = 0; Tm = 0; e = 0; ah = 0; aw = 0; la = 0; undu = 0;\n undul = np.zeros(4)\n Ql = np.zeros(4)\n dTl = np.zeros(4)\n Tl = np.zeros(4)\n pl = np.zeros(4)\n ahl = np.zeros(4)\n awl = np.zeros(4)\n lal = np.zeros(4)\n Tml = np.zeros(4)\n el = np.zeros(4)\n#\n pgrid, Tgrid, Qgrid, dTgrid, u, Hs, ahgrid, awgrid, lagrid, Tmgrid = read_4by5(station,dlat,dlon,hell)\n#\n for l in [0,1,2,3]:\n KL = l #silly to have this as a variable like this \n# transforming ellipsoidal height to orthometric height:\n# Hortho = -N + Hell\n undul[l] = u[KL] \n hgt = hell-undul[l] \n# pressure, temperature at the height of the grid\n T0 = Tgrid[KL,0] + Tgrid[KL,1]*cosfy + Tgrid[KL,2]*sinfy + Tgrid[KL,3]*coshy + Tgrid[KL,4]*sinhy;\n tg = float(Tgrid[KL,:] *cossin.T)\n# print(T0,tg)\n\n p0 = pgrid[KL,0] + pgrid[KL,1]*cosfy + pgrid[KL,2]*sinfy + pgrid[KL,3]*coshy + pgrid[KL,4]*sinhy;\n \n# humidity \n Ql[l] = Qgrid[KL,0] + Qgrid[KL,1]*cosfy + Qgrid[KL,2]*sinfy + Qgrid[KL,3]*coshy + Qgrid[KL,4]*sinhy;\n \n# reduction = stationheight - gridheight\n Hs1 = Hs[KL]\n redh = hgt - Hs1;\n\n# lapse rate of the temperature in degree / m\n dTl[l] = dTgrid[KL,0] + dTgrid[KL,1]*cosfy + dTgrid[KL,2]*sinfy + dTgrid[KL,3]*coshy + dTgrid[KL,4]*sinhy;\n \n# temperature reduction to station height\n Tl[l] = T0 + dTl[l]*redh - 273.15;\n\n# virtual temperature\n Tv = T0*(1+0.6077*Ql[l]) \n c = gm*dMtr/(Rg*Tv) \n \n# pressure in hPa\n pl[l] = (p0*np.exp(-c*redh))/100 \n \n# hydrostatic coefficient ah\n ahl[l] = ahgrid[KL,0] + ahgrid[KL,1]*cosfy + ahgrid[KL,2]*sinfy + ahgrid[KL,3]*coshy + ahgrid[KL,4]*sinhy;\n \n# wet coefficient aw\n awl[l] = awgrid[KL,0] + awgrid[KL,1]*cosfy + awgrid[KL,2]*sinfy + awgrid[KL,3]*coshy + awgrid[KL,4]*sinhy;\n\t\t\t\t\t \n# water vapor decrease factor la - added by GP\n lal[l] = lagrid[KL,0] + lagrid[KL,1]*cosfy + lagrid[KL,2]*sinfy + lagrid[KL,3]*coshy + lagrid[KL,4]*sinhy;\n\t\t\t\t\t \n# mean temperature of the water vapor Tm - added by GP\n Tml[l] = Tmgrid[KL,0] + Tmgrid[KL,1]*cosfy + Tmgrid[KL,2]*sinfy + Tmgrid[KL,3]*coshy + Tmgrid[KL,4]*sinhy;\n\t\t\t\t\t \t\t \n# water vapor pressure in hPa - changed by GP\n e0 = Ql[l]*p0/(0.622+0.378*Ql[l])/100; # % on the grid\n aa = (100*pl[l]/p0)\n bb = lal[l]+1\n el[l] = e0*np.power(aa,bb) # % on the station height - (14) Askne and Nordius, 1987\n \n dnpod1 = np.abs(diffpod); # % distance nearer point\n dnpod2 = 1 - dnpod1; # % distance to distant point\n dnlon1 = np.abs(difflon);\n dnlon2 = 1 - dnlon1;\n \n# pressure\n R1 = dnpod2*pl[0]+dnpod1*pl[1];\n R2 = dnpod2*pl[2]+dnpod1*pl[3];\n p = dnlon2*R1+dnlon1*R2;\n \n# temperature\n R1 = dnpod2*Tl[0]+dnpod1*Tl[1];\n R2 = dnpod2*Tl[2]+dnpod1*Tl[3];\n T = dnlon2*R1+dnlon1*R2;\n \n# temperature in degree per km\n R1 = dnpod2*dTl[0]+dnpod1*dTl[1];\n R2 = dnpod2*dTl[2]+dnpod1*dTl[3];\n dT = (dnlon2*R1+dnlon1*R2)*1000;\n \n# water vapor pressure in hPa - changed by GP\n R1 = dnpod2*el[0]+dnpod1*el[1];\n R2 = dnpod2*el[2]+dnpod1*el[3];\n e = dnlon2*R1+dnlon1*R2;\n \n# hydrostatic\n R1 = dnpod2*ahl[0]+dnpod1*ahl[1];\n R2 = dnpod2*ahl[2]+dnpod1*ahl[3];\n ah = dnlon2*R1+dnlon1*R2;\n \n# wet\n R1 = dnpod2*awl[0]+dnpod1*awl[1];\n R2 = dnpod2*awl[2]+dnpod1*awl[3];\n aw = dnlon2*R1+dnlon1*R2;\n \n# undulation\n R1 = dnpod2*undul[0]+dnpod1*undul[1];\n R2 = dnpod2*undul[2]+dnpod1*undul[3];\n undu = dnlon2*R1+dnlon1*R2;\n\n# water vapor decrease factor la - added by GP\n R1 = dnpod2*lal[0]+dnpod1*lal[1];\n R2 = dnpod2*lal[2]+dnpod1*lal[3];\n la = dnlon2*R1+dnlon1*R2;\n\t\t\n# mean temperature of the water vapor Tm - added by GP\n R1 = dnpod2*Tml[0]+dnpod1*Tml[1];\n R2 = dnpod2*Tml[2]+dnpod1*Tml[3];\n Tm = dnlon2*R1+dnlon1*R2; \n\n return p, T, dT,Tm,e,ah,aw,la,undu","def GetCoastGrids(LandMask):\n \n \"\"\"\n Define a coastline map. This map will be set to 1 on all coast cells.\n \"\"\"\n \n \n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\n \n \"\"\"\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \n \"\"\"\n \n for i in range(LandMask.shape[0]-1):\n for j in range(LandMask.shape[1]-1):\n \n\n \"\"\"\n We have nine if statements, four for the corners, four for the sides and one for the middle\n of the landmask. \n \"\"\"\n\n if i == 0 and j == 0: #upper left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n \n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1, j] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i+1,j+1] = 1\n \n \n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j-1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j-1] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i-1,j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i-1,j] = 1 \n CoastlineMap[i-1, j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i-1, j] = 1\n CoastlineMap[i-1,j-1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n \n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j+1] = 1\n CoastlineMap[i+1,j+1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n else:\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1 #middle\n CoastlineMap[i+1,j] = 1#lowermiddle\n CoastlineMap[i-1,j] = 1#uppermiddle\n \n CoastlineMap[i+1, j-1] = 1\n CoastlineMap[i-1, j-1] = 1\n CoastlineMap[i, j-1] =1\n \n CoastlineMap[i+1, j+1] = 1\n CoastlineMap[i-1, j+1] = 1\n CoastlineMap[i, j+1] = 1\n \n \n \n \"\"\"\n Here we substract the landmaks from the coastline mask, resulting in only\n the coastline. \n \"\"\"\n \n \n Coastgrids = CoastlineMap - LandMask\n \n return Coastgrids, CoastlineMap","def visitspec(load,plate,mjd,fiber,gridfile='apg_rvsynthgrid',apstar=False) :\n grid = fits.open(os.environ['APOGEE_DIR']+'/data/synthgrid/'+gridfile+'.fits')\n if gridfile == 'apg_rvsynthgrid' : hdu=1\n elif gridfile == 'apg_rvsynthgrid_v2': hdu=0\n elif apstar : hdu=2\n else : hdu=1\n gridspec=grid[hdu].data\n gridwave = 10.**spectra.fits2vector(grid[hdu].header,2)\n griderr = np.ones(gridspec.shape[0])\n #for ispec in range(gridspec.shape[1]) :\n # cont = norm.cont(gridspec[:,ispec],griderr)\n # gridspec[:,ispec] /= cont\n\n data = load.apVisit(plate,mjd,fiber)\n\n # compare with DR14 \n comp(a,b,domatch=False,out='plots/dr14all')\n grid.append(['dr14all_1.png',''])\n xtit.append('all stars: DR14 (dotted) and test DR16 (solid)')\n\n comp(a,b,domatch=True,out='plots/dr14match')\n grid.append(['dr14match_1.png','dr14match_2.png'])\n xtit.append('same stars: DR14 (dotted) and test DR16 (solid)')\n # set bad pixels to nan\n shape=data[1].data.shape\n spec = copy.copy(data[1].data).flatten()\n specerr = copy.copy(data[2].data)\n specwave=data[4].data\n pixmask=bitmask.PixelBitMask()\n bd = np.where( ((data[3].data & pixmask.badval()) > 0) | \n ((data[3].data & pixmask.getval('SIG_SKYLINE')) > 0) ) [0]\n spec[bd] = np.nan\n spec = spec.reshape(shape)\n\n # continuum normalize and sample to grid\n outspec = np.full(len(gridwave),np.nan)\n if not apstar :\n # apVisit wavelengths are reversed\n spec=np.flip(spec)\n specwave=np.flip(specwave)\n specerr=np.flip(specerr)\n for ichip in range(3) :\n cont = norm.cont(spec[ichip,:],specerr[ichip,:])\n spec[ichip,:] /= cont\n gd=np.where(np.isfinite(spec[ichip,:]))[0]\n ip= interpolate.InterpolatedUnivariateSpline(specwave[ichip,gd],spec[ichip,gd],k=3)\n out = ip(gridwave)\n gd = np.where( (gridwave > specwave[ichip,0]) & (gridwave < specwave[ichip,-1]) )[0]\n outspec[gd] = out[gd]\n plt.plot(specwave[ichip,:],spec[ichip,:])\n plt.plot(gridwave[gd],out[gd])\n plt.show()\n\n for ispec in range(gridspec.shape[1]) :\n print(ispec)\n bd=np.where(np.isnan(outspec))\n outspec[bd]=1.\n out=correlate(outspec,gridspec[:,ispec])\n pdb.set_trace()","def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n # Round to nearest integer space\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n for hval in numpy.arange(min_x,\n max_x+x_spacing/100.0,\n x_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%d\" % int(hval+0.5))\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,\n max_y+y_spacing/100.0,\n y_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%d\" % int(vval+0.5))\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def DegViewshed (FLOOR, HEIGHT):\n\n #Select Record\n arcpy.SelectLayerByAttribute_management(PointsFL,\"NEW_SELECTION\",SQL)\n \n #Set Observer Height (OffSETA)\n arcpy.CalculateField_management(PointsFL,\"OFFSETA\",HEIGHT,\"PYTHON_9.3\")\n \n #perform viewshed analysis\n arcpy.SetProgressorLabel(\"Performing Viewshed Analysis for point \"+str(value))\n outViewshed = IntermediateFiles+\"\\\\vs_\"+str(FLOOR)+\"_\"+str(value).split(\".\")[0]\n arcpy.Viewshed_3d(outCon,PointsFL,outViewshed)\n\n #convert viewshed to polygon\n arcpy.SetProgressorLabel(\"Converting viewshed\"+str(value)+\" on floor \"+str(FLOOR)+\" to polygon.\")\n OutPoly = IntermediateFiles+\"\\\\\"+os.path.basename(outViewshed).split(\".\")[0]+\"_poly.shp\"\n arcpy.RasterToPolygon_conversion(outViewshed,OutPoly)\n\n #Intersect viewshed polygon with buffer clip\n #This will allow the viewshed poly to inherit attribute fields needed for later analysis\n FinalView = Final_Floor_Viewsheds+\"\\\\FinalViewshed_\"+str(FLOOR)+\"_\"+str(value)+\".shp\"\n arcpy.Intersect_analysis([BufferClip,OutPoly],FinalView)\n \n #Select features in viewshed polygon with Gridcode = 1\n #If no records with grid = 1 exist, scriptwill skip to setting viewshed in degrees to 0\n \n #Convert viewshed polygon to layer\n ViewshedLayer = outName(FinalView,\"lyr\")\n arcpy.MakeFeatureLayer_management(FinalView,ViewshedLayer)\n\n #Select records with gridcode = 1\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\"NEW_SELECTION\",\"GRIDCODE =\"+str(1)+\"\") \n\n #Get count of the # of records selected in viewshed poly layer\n VsLyrCount = int(arcpy.GetCount_management(ViewshedLayer).getOutput(0))\n \n NoView = SummaryTables+\"\\\\summary_\"+str(FLOOR)+\"_\"+str(value)+\".dbf\"\n YesView = SummaryTables+\"\\\\summary_\"+str(FLOOR)+\"_\"+str(value)+\".dbf\"\n StatsField0 = [[\"GRIDCODE\",\"SUM\"]]\n CaseField0 = [\"ID\",\"SPOT\",FloorField] \n StatsField1 = [[\"LENGTH\",\"SUM\"]]\n CaseField1 = [\"GRIDCODE\",\"ID\",\"SPOT\",FloorField]\n VsArcLengths = ArcLengths+\"\\\\ArcLength_\"+str(FLOOR)+\"_\"+str(value)+\".shp\"\n \n if VsLyrCount == 0: #no viewable areas exist\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\"CLEAR_SELECTION\")\n arcpy.SetProgressorLabel(\"Calculating viewshed statistics for parcel \"+str(value))\n arcpy.Statistics_analysis(ViewshedLayer,NoView, StatsField0,CaseField0)\n\n #Add field to summary table to hold viewshed value of 0\n #Add field to note which floor viewshed corresponds to\n arcpy.AddField_management(NoView, \"FLR_RAN\",\"SHORT\")\n arcpy.AddField_management(NoView, \"VIEW_\"+Year,\"DOUBLE\")\n arcpy.AddField_management(NoView,\"OFFSETA\",\"SHORT\")\n arcpy.CalculateField_management(NoView,\"FLR_RAN\",FLOOR)\n arcpy.CalculateField_management(NoView,\"VIEW_\"+Year,0)\n arcpy.CalculateField_management(NoView,\"OFFSETA\",HEIGHT)\n\n else: #Calculate viewshed, in degrees, for selected records\n arcpy.SetProgressorLabel(\"Getting arc length for parcel\"+str(value)+\" at the \"+str(FLOOR)+\" floor.\")\n arcpy.Intersect_analysis([BufferLine,ViewshedLayer],VsArcLengths,\"\",10,\"LINE\")#Intersect with any line within 10 ft. \n arcpy.AddField_management(VsArcLengths, \"Length\",\"DOUBLE\")\n arcpy.CalculateField_management(VsArcLengths,\"Length\",\"!SHAPE.length@miles!\",\"PYTHON_9.3\")\n arcpy.Statistics_analysis(VsArcLengths,YesView,StatsField1,CaseField1)\n\n #Add fields to output summary table\n arcpy.AddField_management(YesView,\"FLR_RAN\",\"SHORT\")\n arcpy.AddField_management(YesView,\"VIEW_\"+Year,\"DOUBLE\")\n arcpy.AddField_management(YesView,\"OFFSETA\",\"SHORT\")\n arcpy.CalculateField_management(YesView,\"FLR_RAN\",FLOOR)\n arcpy.CalculateField_management(YesView,\"OFFSETA\",HEIGHT)\n arcpy.CalculateField_management(YesView,\"VIEW_\"+Year,\"((!SUM_LENGTH!/3.14)*180)\",\"PYTHON_9.3\")\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\"CLEAR_SELECTION\")","def gaddpg_grasps_from_simulate_view(gaddpg, state, time, ef_pose):\n n = 30\n mask = get_target_mask(state[0][0])\n point_state = state[0][0][:, mask]\n\n # hand to base\n point_state = se3_transform_pc(ef_pose, point_state)\n print('target point shape', point_state.shape)\n # target center is in base coordinate now\n target_center = point_state.mean(1)[:3]\n print('target center', target_center)\n\n # set up gaddpg\n img_state = state[0][1]\n gaddpg.policy.eval()\n gaddpg.state_feature_extractor.eval()\n\n # sample view (simulated hand) in base\n view_poses = np.array(sample_ef_view_transform(n, 0.2, 0.5, target_center, linspace=True, anchor=True))\n\n # base to view (simulated hand)\n inv_view_poses = se3_inverse_batch(view_poses)\n transform_view_points = np.matmul(inv_view_poses[:,:3,:3], point_state[:3]) + inv_view_poses[:,:3,[3]]\n \n # gaddpg generate grasps\n point_state_batch = torch.from_numpy(transform_view_points).cuda().float()\n time = torch.ones(len(point_state_batch) ).float().cuda() * 10. # time\n point_state_batch = torch.cat((point_state_batch, torch.zeros_like(point_state_batch)[:, [0]]), dim=1)\n policy_feat = gaddpg.extract_feature(img_state, point_state_batch, value=False, time_batch=time) \n _,_,_,gaddpg_aux = gaddpg.policy.sample(policy_feat)\n \n # compose with ef poses \n gaddpg_aux = gaddpg_aux.detach().cpu().numpy()\n unpacked_poses = [unpack_pose_rot_first(pose) for pose in gaddpg_aux]\n goal_pose_ws = np.matmul(view_poses, np.array(unpacked_poses)) # grasp to ef\n planner_cfg.external_grasps = goal_pose_ws\n\n # show_grasps(view_poses, 'grasps')\n # planner_cfg.external_grasps = view_poses\n # planner_cfg.external_grasps = np.concatenate((goal_pose_ws, view_poses), axis=0) # also visualize view\n planner_cfg.use_external_grasp = True","def galex(band='fuv', ra_ctr=None, dec_ctr=None, size_deg=None, index=None, name=None, pgcname=None, model_bg=True, weight_ims=True, convert_mjysr=True, desired_pix_scale=GALEX_PIX_AS, imtype='intbgsub', wttype='rrhr'):\n ttype = 'galex'\n data_dir = os.path.join(_TOP_DIR, ttype, 'sorted_tiles')\n problem_file = os.path.join(_WORK_DIR, 'problem_galaxies_{}.txt'.format(band))\n numbers_file = os.path.join(_WORK_DIR, 'gal_reproj_info_{}.txt'.format(band))\n\n galaxy_mosaic_file = os.path.join(_MOSAIC_DIR, '_'.join([pgcname, band]).upper() + '.FITS')\n\n if not os.path.exists(galaxy_mosaic_file):\n start_time = time.time()\n print pgcname, band.upper()\n\n # READ THE INDEX FILE (IF NOT PASSED IN)\n if index is None:\n indexfile = os.path.join(_INDEX_DIR, 'galex_index_file.fits')\n ext = 1\n index, hdr = astropy.io.fits.getdata(indexfile, ext, header=True)\n\n # CALCULATE TILE OVERLAP\n tile_overlaps = calc_tile_overlap(ra_ctr, dec_ctr, pad=size_deg,\n min_ra=index['MIN_RA'],\n max_ra=index['MAX_RA'],\n min_dec=index['MIN_DEC'],\n max_dec=index['MAX_DEC'])\n\n # FIND OVERLAPPING TILES WITH RIGHT BAND\n # index file set up such that index['fuv'] = 1 where fuv and\n # index['nuv'] = 1 where nuv\n ind = np.where((index[band]) & tile_overlaps)\n\n\n # MAKE SURE THERE ARE OVERLAPPING TILES\n ct_overlap = len(ind[0])\n if ct_overlap == 0:\n with open(problem_file, 'a') as myfile:\n myfile.write(pgcname + ': ' + 'No overlapping tiles\\n')\n return\n\n pix_scale = desired_pix_scale / 3600. # 1.5 arbitrary: how should I set it?\n\n try:\n # CREATE NEW TEMP DIRECTORY TO STORE TEMPORARY FILES\n gal_dir = os.path.join(_WORK_DIR, '_'.join([pgcname, band]).upper())\n os.makedirs(gal_dir)\n\n # MAKE HEADER AND EXTENDED HEADER AND WRITE TO FILE\n gal_hdr = GalaxyHeader(pgcname, gal_dir, ra_ctr, dec_ctr, size_deg, pix_scale, factor=3)\n\n\n # GATHER THE INPUT FILES\n input_dir = os.path.join(gal_dir, 'input')\n if not os.path.exists(input_dir):\n os.makedirs(input_dir)\n nfiles = get_input(index, ind, data_dir, input_dir, hdr=gal_hdr)\n im_dir, wt_dir = input_dir, input_dir\n\n # WRITE TABLE OF INPUT IMAGE INFORMATION\n input_table = os.path.join(im_dir, 'input.tbl')\n montage.mImgtbl(im_dir, input_table, corners=True)\n \n if convert_mjysr:\n converted_dir = os.path.join(gal_dir, 'converted')\n if not os.path.exists(converted_dir):\n os.makedirs(converted_dir)\n convert_to_flux_input(im_dir, converted_dir, band, desired_pix_scale, imtype=imtype)\n im_dir = converted_dir\n\n\n # MASK IMAGES\n masked_dir = os.path.join(gal_dir, 'masked')\n im_masked_dir = os.path.join(masked_dir, imtype)\n wt_masked_dir = os.path.join(masked_dir, wttype)\n for outdir in [masked_dir, im_masked_dir, wt_masked_dir]:\n os.makedirs(outdir)\n\n mask_images(im_dir, wt_dir, im_masked_dir, wt_masked_dir, imtype=imtype, wttype=wttype)\n im_dir = im_masked_dir\n wt_dir = wt_masked_dir\n\n\n # REPROJECT IMAGES WITH EXTENDED HEADER\n reprojected_dir = os.path.join(gal_dir, 'reprojected')\n reproj_im_dir = os.path.join(reprojected_dir, imtype)\n reproj_wt_dir = os.path.join(reprojected_dir, wttype)\n for outdir in [reprojected_dir, reproj_im_dir, reproj_wt_dir]:\n os.makedirs(outdir)\n\n reproject_images(gal_hdr.hdrfile_ext, im_dir, reproj_im_dir, imtype)\n reproject_images(gal_hdr.hdrfile_ext, wt_dir, reproj_wt_dir, wttype)\n im_dir = reproj_im_dir\n wt_dir = reproj_wt_dir\n\n\n # MODEL THE BACKGROUND IN THE IMAGE FILES WITH THE EXTENDED HEADER\n if model_bg:\n bg_model_dir = os.path.join(gal_dir, 'background_model')\n diff_dir = os.path.join(bg_model_dir, 'differences')\n corr_dir = os.path.join(bg_model_dir, 'corrected')\n for outdir in [bg_model_dir, diff_dir, corr_dir]:\n os.makedirs(outdir)\n bg_model(im_dir, bg_model_dir, diff_dir, corr_dir, gal_hdr.hdrfile_ext, im_type=imtype, level_only=False)\n im_dir = os.path.join(corr_dir, imtype)\n\n\n # WEIGHT IMAGES\n if weight_ims:\n weight_dir = os.path.join(gal_dir, 'weighted')\n im_weight_dir = os.path.join(weight_dir, imtype)\n wt_weight_dir = os.path.join(weight_dir, wttype)\n for outdir in [weight_dir, im_weight_dir, wt_weight_dir]:\n os.makedirs(outdir)\n\n weight_images(im_dir, wt_dir, weight_dir, im_weight_dir, wt_weight_dir, imtype=imtype, wttype=wttype)\n im_dir = im_weight_dir\n wt_dir = wt_weight_dir\n\n\n # CREATE THE METADATA TABLES NEEDED FOR COADDITION\n weight_table = create_table(wt_dir, dir_type=wttype)\n weighted_table = create_table(im_dir, dir_type=imtype)\n\n\n # COADD THE REPROJECTED, WEIGHTED IMAGES AND THE WEIGHT IMAGES WITH THE REGULAR HEADER FILE\n penultimate_dir = os.path.join(gal_dir, 'large_mosaic')\n final_dir = os.path.join(gal_dir, 'mosaic')\n for outdir in [penultimate_dir, final_dir]:\n os.makedirs(outdir)\n \n coadd(gal_hdr.hdrfile, penultimate_dir, im_dir, output=imtype, add_type='mean')\n coadd(gal_hdr.hdrfile, penultimate_dir, wt_dir, output=wttype, add_type='mean')\n\n\n # DIVIDE OUT THE WEIGHTS AND CONVERT TO MJY/SR\n imagefile, wtfile = finish_weight(penultimate_dir, imtype=imtype, wttype=wttype)\n \n\n # COPY IMAGE AND WEIGHTS MOSAIC TO FINAL DIRECTORY\n outfile = os.path.join(final_dir, 'final_mosaic.fits')\n shutil.copy(imagefile, outfile)\n shutil.copy(wtfile, os.path.join(final_dir, '{}_mosaic.fits'.format(wttype)))\n\n\n # COPY MOSAIC FILES TO CUTOUTS DIRECTORY\n mosaic_file = os.path.join(final_dir, 'final_mosaic.fits')\n weight_file = os.path.join(final_dir, '{}_mosaic.fits'.format(wttype))\n\n newsuffs = ['.FITS', '_weight.FITS']\n oldfiles = [mosaic_file, weight_file]\n newfiles = ['_'.join([pgcname, band]).upper() + s for s in newsuffs]\n\n for files in zip(oldfiles, newfiles):\n shutil.copy(files[0], os.path.join(_MOSAIC_DIR, files[1]))\n\n\n # REMOVE TEMP GALAXY DIRECTORY AND EXTRA FILES\n shutil.rmtree(gal_dir, ignore_errors=True)\n\n\n # NOTE TIME TO FINISH\n stop_time = time.time()\n total_time = (stop_time - start_time) / 60.\n\n\n # WRITE OUT THE NUMBER OF TILES THAT OVERLAP THE GIVEN GALAXY\n out_arr = [pgcname, band.upper(), nfiles, np.around(total_time, 2)]\n with open(numbers_file, 'a') as nfile:\n nfile.write('{0: >10}'.format(out_arr[0]))\n nfile.write('{0: >6}'.format(out_arr[1]))\n nfile.write('{0: >6}'.format(out_arr[2]))\n nfile.write('{0: >6}'.format(out_arr[3]) + '\\n')\n\n\n # SOMETHING WENT WRONG -- WRITE ERROR TO FILE\n except Exception as inst:\n me = sys.exc_info()[0]\n with open(problem_file, 'a') as myfile:\n myfile.write(pgcname + ': ' + str(me) + ': '+str(inst)+'\\n')\n shutil.rmtree(gal_dir, ignore_errors=True)\n\n return","def main(ngrains=100,sigma=15.,c2a=1.6235,mu=0.,\n prc='cst',isc=False,tilt_1=0.,\n tilts_about_ax1=0.,tilts_about_ax2=0.):\n if isc:\n h = mmm()\n else:\n h=np.array([np.identity(3)])\n gr = []\n for i in range(ngrains):\n dth = random.uniform(-180., 180.)\n if prc=='cst': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=0) # Basal//ND\n elif prc=='ext': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=1) # Basal//ED\n else:\n raise IOError('Unexpected option')\n for j in range(len(h)):\n temp = np.dot(g,h[j].T)\n\n ## tilts_about_ax1\n if abs(tilts_about_ax1)>0:\n g_tilt = rd_rot(tilts_about_ax1)\n temp = np.dot(temp,g_tilt.T)\n ## tilts_about_ax2?\n elif abs(tilts_about_ax2)>0:\n g_tilt = td_rot(tilts_about_ax2)\n temp = np.dot(temp,g_tilt.T)\n elif abs(tilts_about_ax2)>0 and abs(tilts_about_ax2)>0:\n raise IOError('One tilt at a time is allowed.')\n\n phi1,phi,phi2 = euler(a=temp, echo=False)\n gr.append([phi1,phi,phi2,1./ngrains])\n\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\n mypf.pf_new(poles=[[0,0,0,2],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\n return np.array(gr)","def ggpl_house():\n\n\t# .lines ogni riga ha due coppie di x/y che costituiscono un segmento\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/muri_esterni.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\texternalWalls = MKPOL([verts,cells,None])\n\tfloor = SOLIDIFY(externalWalls)\n\tfloor = S([1,2,3])([.04,.04,.04])(floor)\n\texternalWalls = S([1,2,3])([.04,.04,.04])(externalWalls)\n\texternalWalls = OFFSET([.2,.2,4])(externalWalls)\n\theightWalls = SIZE([3])(externalWalls)[0]\n\tthicknessWalls = SIZE([2])(externalWalls)[0]\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/muri_interni.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\tinternalWalls = MKPOL([verts,cells,None])\n\tinternalWalls = S([1,2,3])([.04,.04,.04])(internalWalls)\n\tinternalWalls = OFFSET([.2,.2,4])(internalWalls)\n\twalls = STRUCT([externalWalls, internalWalls])\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/porte.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\tdoors = MKPOL([verts,cells,None])\n\tdoors = SOLIDIFY(doors)\n\tdoors = S([1,2,3])([.04,.04,.04])(doors)\n\tdoors = OFFSET([.2,.2,3])(doors)\n\twalls = DIFFERENCE([walls, doors])\n\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/finestre.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\twindows = MKPOL([verts,cells,None])\n\twindows = SOLIDIFY(windows)\n\twindows = S([1,2,3])([.04,.04,.04])(windows)\n\twindows = OFFSET([.2,.2,2])(windows)\n\theightWindows = SIZE([3])(windows)[0]\n\twindows = T(3)((heightWalls-heightWindows)/2.)(windows)\n\twalls = DIFFERENCE([walls, windows])\n\n\tfloor = TEXTURE(\"texture/floor.jpg\")(floor)\n\twalls = TEXTURE(\"texture/wall.jpg\")(walls)\n\thome = STRUCT([floor, walls])\n\treturn home","def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\n pg = placement_grid\n rg12 = routing_grid_m1m2\n pfix = objectname_pfix\n\n # placement\n imbl0 = laygen.relplace(name=\"I\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\n refi=imbl0\n if not m_dmy==0:\n imdmyl0 = laygen.relplace(name=\"I\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyl0\n else:\n imdmyl0 = None\n im0 = laygen.relplace(name=\"I\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\n refi=im0\n if not m_dmy==0:\n imdmyr0 = laygen.relplace(name=\"I\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\n refi=imdmyr0\n else:\n imdmyr0 = None\n imbr0 = laygen.relplace(name=\"I\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\n md=im0.elements[:, 0]\n #route\n #gate\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\n #drain\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\n for _md in md:\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\n #source\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\n for _md in md:\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\n #dmy\n if m_dmy>=2:\n mdmyl=imdmyl0.elements[:, 0]\n mdmyr=imdmyr0.elements[:, 0]\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\n for _mdmyl in mdmyl:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\n for _mdmyr in mdmyr:\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]","def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\n # assigning cost of changing from one leg to another based on the distance to the desired pose\n cost_ChangeLeg = 1\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\n if dz_final < 1:\n cost_ChangeLeg = 10\n elif dz_final < 2:\n cost_ChangeLeg = 20\n else:\n cost_ChangeLeg = 10\n\n # assigning weight for cost of predicted repositioning and cost of robot motion\n w_cost_reposition = 40\n w_cost_motion = 10\n\n # finding object's leg cordinates\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\n\n # initialization (initializeing cost to infinity)\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\n cost_legchange = [0, 0, 0, 0]\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\n cost_manipulation = [0, 0, 0, 0]\n cost_motion = [0, 0, 0, 0]\n force = [0, 0, 0, 0]\n path = [[[], []], [[], []], [[], []], [[], []]]\n planned_path_w = [[],[],[],[]]\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\n command = [[], [], [], []]\n des = [[], [], [], [], []]\n PAM_goal = state()\n\n # find the nominal trajectory for manipulation\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\n\n # itterate through each leg to find the leg with minimum cost\n for leg in range(4):\n phi_linear = theta\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\n \t# find the cost and required force for manipulation for the leg\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\n \t# adding cost of changing leg\n if leg != current_leg:\n cost_legchange[leg] = cost_ChangeLeg\n # adding cost of PAM motion to PAM goal pose\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\n if cost_PAM[leg][push_pull]!= float(\"inf\"):\n PAM_s_sim = copy.deepcopy(PAM_s)\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n # adding cost of predicted re-positionings\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\n # print(n_transition)\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\n else:\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\n\n if min(cost) < float(\"inf\"):\n \t[min_index, min_value] = [np.argmin(cost), min(cost)]\n \t# Finding the grasping goal pose based on the selected plan\n \tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\n \tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\n \tPAM_goal = state()\n \tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\n \tobject_path_planned = Path()\n \tobject_path_planned.header.frame_id = 'frame_0'\n \tfor i in range(len(planned_path_w[min_index])):\n \t\tpose = PoseStamped()\n \t\tpose.pose.position.x = planned_path_w[min_index][i][0]\n \t\tpose.pose.position.y = planned_path_w[min_index][i][1]\n \t\tpose.pose.position.z = 0\n \t\tobject_path_planned.poses.append(pose)\n\n \tPAM_path_planned = Path()\n \tPAM_path_planned.header.frame_id = 'frame_0'\n \tif min_index != current_leg:\n \t\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\n \t\t\tpose = PoseStamped()\n \t\t\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\n \t\t\tPAM_path_planned.poses.append(pose)\n else:\n \tmin_index = 5\n \tmin_value = float(\"inf\")\n if 0 < min_index and min_index <= 4:\n force_d = force[min_index][0]\n else:\n force_d = [0,0,0]\n\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned","def main():\n\n # Log messages to stdout\n logging.basicConfig(\n level=logging.DEBUG,\n format=\"%(asctime)s [%(levelname)s] %(message)s\",\n stream=sys.stdout,\n )\n\n # Load the sample dataset: the US states and their corresponding population number.\n # (data from https://www.census.gov/)\n us_states_path = os.path.join(os.getcwd(), \"sample_data\", \"cb_2018_us_state_5m.shp\")\n us_pop_path = os.path.join(os.getcwd(), \"sample_data\", \"nst-est2019-01.xlsx\")\n us_states = gpd.read_file(us_states_path)\n us_inhab = pd.read_excel(us_pop_path, skiprows=3, engine=\"openpyxl\").add_prefix(\n \"pop_\"\n )\n # Tidy up rows and column names\n us_inhab.rename(columns={us_inhab.columns[0]: \"NAME\"}, inplace=True)\n us_inhab.NAME = us_inhab.NAME.str.replace(\".\", \"\")\n # Join population numbers and us state geometries.\n us_states = us_states.merge(us_inhab, on=\"NAME\").reset_index()\n # Inspect the data\n print(us_states.info())\n\n # Initialize a circle style cartogram for inhabitants per state in 2019.\n circle_cg = CircleCartogram(\n gdf=us_states,\n size_column=\"pop_2019\",\n mode=2,\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\n )\n square_cg = SquareCartogram(\n gdf=us_states,\n size_column=\"pop_2019\",\n mode=1,\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\n )\n square2_cg = SquareCartogram(\n gdf=us_states,\n size_column=\"pop_2019\",\n mode=4,\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\n )\n\n # Calculate the cartogram geometries.\n circle_cg.calculate()\n square_cg.calculate()\n square2_cg.calculate()\n\n # Plot both the original map and the cartogram side by side.\n gdfs = [us_states, circle_cg.gdf, square_cg.gdf, square2_cg.gdf]\n m = Map(\n gdfs=gdfs,\n title=\"Population per US State in 2019\",\n column=\"pop_2019\",\n labels=\"STUSPS\",\n )\n m.ax[0][0].set_xlim(-150, -60)\n m.plot()\n plt.show()","def generate_base_tiles(self):\n\n gdal.SetConfigOption(\"GDAL_PAM_ENABLED\", \"NO\")\n\n print \"Generating Base Tiles:\"\n if self.options.verbose:\n #mx, my = self.out_gt[0], self.out_gt[3] # OriginX, OriginY\n #px, py = self.mercator.MetersToPixels( mx, my, self.tmaxz)\n #print \"Pixel coordinates:\", px, py, (mx, my)\n print\n print \"Tiles generated from the max zoom level:\"\n print \"----------------------------------------\"\n print\n\n\n # Set the bounds\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\n querysize = self.querysize\n\n # Just the center tile\n #tminx = tminx+ (tmaxx - tminx)/2\n #tminy = tminy+ (tmaxy - tminy)/2\n #tmaxx = tminx\n #tmaxy = tminy\n\n #print tminx, tminy, tmaxx, tmaxy\n tcount = (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\n #print tcount\n ti = 0\n i_y_column_count=((tmaxy-tminy)+1)\n ds = self.out_ds\n tz = self.tmaxz\n if self.options.verbose:\n # tx in range(tminx, tmaxx+1) tminx[ 281596 ] tmaxx[ 281744 ] ; ((tmaxx-tmaxy)+1) x_tiles[ 23393 ]\n print \"\\ttz=[\",tz,\"] : tx in range(tminx, tmaxx+1) tminx[\",tminx,\"] tmaxx[\",tmaxx,\"] ; ((tmaxx-tmaxy)+1) x_tiles[\",tcount,\"]\"\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 352409 ] tminy[ 352253 ] ; ((tmaxy-tminy)) y_tiles[ 157 ] 352409-(352253-1)\n print \"\\ttz=[\",tz,\"] : ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\",tmaxy,\"] tminy[\",tminy,\"] ; ((tmaxy-tminy+1)) y_tiles[\",i_y_column_count,\"]\"\n if self.options.resume:\n i_count = self.tile_exists(0, 0, tz,2)\n if i_count == tcount:\n if self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; x/y-tiles of z[\",tz,\"] y_tiles[\",tcount,\"]\"\n return\n for tx in range(tminx, tmaxx+1):\n tmaxy_work=tmaxy\n if self.options.resume:\n i_count = self.tile_exists(tx, 0, tz,3)\n if i_count == i_y_column_count:\n if self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; z =\",tz,\" ; y-tiles of x[\",tx,\"] y_tiles[\",i_y_column_count,\"]\"\n break\n else:\n if i_count > 0:\n # this assums the rows are compleate, which may NOT be true\n tmaxy_work-=i_count\n if self.options.verbose:\n print \"\\tTile generation skipped to tmaxy[\",tmaxy_work,\"] because of --resume ; z =\",tz,\" ; y-tiles of x[\",tx,\"] y_tiles[\",i_y_column_count,\"]\"\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\n ty_osm=self.flip_y(tz,ty_tms)\n ty=ty_tms\n if self.options.tms_osm:\n ty=ty_osm\n if self.stopped:\n if self.options.mbtiles:\n if self.mbtiles_db:\n self.mbtiles_db.close_db()\n break\n ti += 1\n\n if self.options.resume:\n exists = self.tile_exists(tx, ty, tz,0)\n if exists and self.options.verbose:\n print \"\\tTile generation skipped because of --resume ; z =\",tz,\" ; x =\",tx,\" ; y_tms =\",ty_tms, \"; y_osm =\",ty_osm\n else:\n exists = False\n\n if not exists:\n if self.options.verbose:\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\n # Don't scale up by nearest neighbour, better change the querysize\n # to the native resolution (and return smaller query tile) for scaling\n if self.options.profile in ('mercator','geodetic'):\n if self.options.profile == 'mercator':\n # Tile bounds in EPSG:900913\n b = self.mercator.TileBounds(tx, ty_tms, tz)\n elif self.options.profile == 'geodetic':\n b = self.geodetic.TileBounds(tx, ty_tms, tz)\n\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1])\n nativesize = wb[0]+wb[2] # Pixel size in the raster covering query geo extent\n if self.options.verbose:\n print \"\\tNative Extent (querysize\",nativesize,\"): \", rb, wb\n\n querysize = self.querysize\n # Tile bounds in raster coordinates for ReadRaster query\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1], querysize=querysize)\n\n rx, ry, rxsize, rysize = rb\n wx, wy, wxsize, wysize = wb\n else: # 'raster' or 'gearth' or 'garmin' profile:\n tsize = int(self.tsize[tz]) # tilesize in raster coordinates for actual zoom\n xsize = self.out_ds.RasterXSize # size of the raster in pixels\n ysize = self.out_ds.RasterYSize\n if tz >= self.nativezoom:\n querysize = self.tilesize # int(2**(self.nativezoom-tz) * self.tilesize)\n\n rx = (tx) * tsize\n rxsize = 0\n if tx == tmaxx:\n rxsize = xsize % tsize\n if rxsize == 0:\n rxsize = tsize\n\n rysize = 0\n if ty_tms == tmaxy:\n rysize = ysize % tsize\n if rysize == 0:\n rysize = tsize\n ry = ysize - (ty_tms * tsize) - rysize\n\n wx, wy = 0, 0\n\n wxsize, wysize = int(rxsize/float(tsize) * querysize), int(rysize/float(tsize) * querysize)\n if wysize != querysize:\n wy = querysize - wysize\n xyzzy = Xyzzy(querysize, rx, ry, rxsize, rysize, wx, wy, wxsize, wysize)\n try:\n if self.options.verbose:\n print ti,'/',tcount,' total ; z =',tz,' ; x =',tx,' ; y_tms =',ty_tms,' ; y_osm =',ty_osm\n print \"\\tReadRaster Extent: \", (rx, ry, rxsize, rysize), (wx, wy, wxsize, wysize)\n self.write_base_tile(tx, ty, tz, xyzzy)\n except ImageOutputException, e:\n self.error(\"'%d/%d/%d': %s\" % (tz, tx, ty, e.message))\n\n if not self.options.verbose or self.is_subprocess:\n self.progressbar( ti / float(tcount) )\n if self.options.mbtiles:\n if self.mbtiles_db:\n self.mbtiles_db.close_db()\n self.mbtiles_db=None","def make_NM08_grid(work_dir, log_base, max_range):\n base_name = 'NM08'\n dat = fdata.fdata(work_dir=work_dir)\n dat.files.root = base_name\n pad_1 = [1500., 1500.]\n # Symmetric grid in x-y\n base = log_base\n dx = pad_1[0]\n x1 = dx ** (1 - base) * np.linspace(0, dx, max_range) ** base\n X = np.sort(list(pad_1[0] - x1) + list(pad_1[0] + x1)[1:] + [pad_1[0]])\n # If no. z nodes > 100, temperature_gradient will not like it...\n surface_deps = np.linspace(350, -750, 4)\n cap_grid = np.linspace(-750, -1200, 4)\n perm_zone = np.linspace(-1200., -2100., 30)\n lower_reservoir = np.linspace(-2100, -3100, 10)\n Z = np.sort(list(surface_deps) + list(cap_grid) + list(perm_zone)\n + list(lower_reservoir))\n dat.grid.make('{}_GRID.inp'.format(base_name), x=X, y=X, z=Z,\n full_connectivity=True)\n grid_dims = [3000., 3000.] # 5x7x5 km grid\n # Geology time\n dat.new_zone(1, 'suface_units', rect=[[-0.1, -0.1, 350 + 0.1],\n [grid_dims[0] + 0.1,\n grid_dims[1] + 0.1,\n -750 - 0.1]],\n permeability=[1.e-15, 1.e-15, 1.e-15], porosity=0.1,\n density=2477, specific_heat=800., conductivity=2.2)\n dat.new_zone(2, 'clay_cap', rect=[[-0.1, -0.1, -750],\n [grid_dims[0] + 0.1,\n grid_dims[1] + 0.1,\n -1200 - 0.1]],\n permeability=1.e-18, porosity=0.01, density=2500,\n specific_heat=1200., conductivity=2.2)\n return dat","def CalculatePaths(self):\n agrid = self.agrid \n self.apath = array([0 for y in range(self.T)], dtype=float)\n self.cpath = array([0 for y in range(self.T)], dtype=float)\n self.npath = array([0 for y in range(self.T)], dtype=float)\n # generate each generation's asset, consumption and labor supply forward\n for y in range(self.T-1): # y = 0, 1,..., 58\n self.apath[y+1] = max(0,interp1d(agrid, self.a[y], kind='cubic')(self.apath[y]))\n if y >= self.W:\n self.cpath[y], self.npath[y] = (1+self.r)*self.apath[y] + self.b - self.apath[y+1], 0\n else:\n self.cpath[y], self.npath[y] = self.solve(self.apath[y], self.apath[y+1])\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\n # the oldest generation's consumption and labor supply\n self.cpath[self.T-1], self.npath[self.T-1] = (1+self.r)*self.apath[self.T-1]+self.b, 0\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])","def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\tlabels = ['no APMB', 'APMB']\n\tdeep = {}\n\tuzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795 # Why?\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\n\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n\n #this is just printing stuff for easier terminal reading\n if h_agent is not None:\n hstr = \"Specialized Human\"\n else:\n hstr = \"Random Human\"\n if coagent is not None:\n coagenthelp = True\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\n else:\n coagenthelp = False\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\n\n liRewards = []\n liRewardsPenalized = []\n actionsctli =[]\n heatmap = np.zeros((7, 7))\n for i in range(episodes):\n grid.reset()\n actionct = 0\n misstepct = 0\n heatmap[0,0] += 1\n while (not grid.isEnd) and (grid.numSteps <=200):\n state = grid.state\n width = grid.getBoardDim()[0]\n state_ind = state[1]*(width+1)+state[0]\n\n if 'disjoint' in mode:\n actions = [0, 1, 2, 3]\n else:\n #'up','right','down','left','upri','dori','dole','uple'\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n #if we have a special human agent use it, if not use random human\n if h_agent is None:\n action = np.random.choice(actions, 1)[0]\n h_action = action\n else:\n action = h_agent.get_action(state_ind)\n h_action = action\n if coagenthelp:\n q_vals = coagent.get_q_values(state_ind)\n best_action = coagent.get_action(state_ind)\n best_q = q_vals[best_action]\n min_q = min(q_vals)\n human_q = q_vals[action]\n\n #closest actions dictionary\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\n #value = action index if radial\n #key = actual action index\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\n #actions in order of circle\n a_radial = [0,4,1,5,2,6,3,7]\n #co-pilot action choices\n #override to optimal if suboptimal action selected\n if \"override\" in mode:\n #random percent to decide when to help if wrong action taken\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\n actionct += 1\n action = best_action\n #select best closest action if human action q-value is negative\n elif mode == \"q-neg\" and human_q < 0:\n actionct += 1\n a_li = closest_a[action]\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\n #Shared Autonomy\n #select better closest action if difference between best q and human q is past some threshold\n elif mode == \"q-diff\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\n actionct += 1\n for i in range(1,5):\n radial_a = a_dist_ind[action]\n ccw_ra = (radial_a - i) % len(actions)\n ccw_a = a_radial[ccw_ra]\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = ccw_a\n break\n cw_ra = (radial_a + i) % len(actions)\n cw_a = a_radial[cw_ra]\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = cw_a\n break\n #take the potentiallny new action\n grid.step(action)\n\n if h_agent is not None:\n heatmap[grid.state[1],grid.state[0]] += 1\n\n #add metrics to their respective lists\n liRewards.append(grid.reward)\n liRewardsPenalized.append(grid.reward-actionct)\n actionsctli.append(actionct)\n #convert lists to numpy arrays\n rewards = np.array(liRewards)\n rewards_penalized = np.array(liRewardsPenalized)\n actionsctli = np.array(actionsctli)\n #print some metrics if we want to\n if verbose:\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\n if h_agent is not None:\n plt.figure()\n print(heatmap)\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\n plt.savefig('two.png')\n\n return rewards, actionsctli, rewards_penalized","def _get_observations(self):\n food = np.array(self.game.state.data.food.data)\n walls = np.array(self.game.state.data.layout.walls.data)\n map_shape = walls.shape\n capsules = self.game.state.data.capsules\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\n\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\n self.game.state.data.agentStates[1:]))\n gosts_scared = list(\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\n\n \"\"\"\n 0: empty,\n 1: wall,\n 2: food,\n 3: capsules,\n 4: ghost,\n 5: scared ghost,\n 6: pacman\n \"\"\"\n\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\n\n def select(l):\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\n\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\n\n def pos_to_relative_pos(pos):\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\n return None\n else:\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\n\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\n\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\n if (g_relative_pos is not None):\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\n ] = 5 if gosts_scared[i] else 4\n\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\n\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\n\n obs[0, 0] = 2 if np.any(\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\n obs[obs.shape[0]-1,\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\n\n obs[0, obs.shape[1] -\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\n\n # print(np.transpose(obs)[::-1, :])\n\n return obs","def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\n tmpl_out_path, null_charges=False, growing_mode=\"SoftcoreLike\"):\n lambda_to_reduce = float(step/(total_steps+1))\n templ_ini = TemplateImpact(template_initial_path)\n \n for bond in templ_ini.list_of_bonds:\n key, bond_cont = bond\n templ_grw = TemplateImpact(template_grown_path)\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \n template_grown=templ_grw,\n hydrogen_to_replace=hydrogen_to_replace)\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\n set_linker_bond(templ_grw)\n if growing_mode == \"SoftcoreLike\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\n null_charges=null_charges)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \n null_charges=null_charges)\n \n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"AllLinear\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\n null_charges=False)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"SpreadHcharge\":\n if step > 1:\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n else:\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n else:\n raise ValueError(\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\")\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\n [atom.pdb_atom_name for atom in core_atoms_grown]","def main():\n # https://github.com/caelan/pddlstream/blob/master/examples/motion/run.py\n # TODO: 3D work and CSpace\n # TODO: visualize just the tool frame of an end effector\n\n np.set_printoptions(precision=3)\n parser = argparse.ArgumentParser()\n parser.add_argument('-a', '--algorithm', default='rrt_connect',\n help='The algorithm seed to use.')\n parser.add_argument('-d', '--draw', action='store_true',\n help='When enabled, draws the roadmap')\n parser.add_argument('-r', '--restarts', default=0, type=int,\n help='The number of restarts.')\n parser.add_argument('-s', '--smooth', action='store_true',\n help='When enabled, smooths paths.')\n parser.add_argument('-t', '--time', default=1., type=float,\n help='The maximum runtime.')\n args = parser.parse_args()\n\n #########################\n\n obstacles = [\n create_box(center=(.35, .75), extents=(.25, .25)),\n create_box(center=(.75, .35), extents=(.225, .225)),\n create_box(center=(.5, .5), extents=(.225, .225)),\n ]\n\n # TODO: alternate sampling from a mix of regions\n regions = {\n 'env': create_box(center=(.5, .5), extents=(1., 1.)),\n 'green': create_box(center=(.8, .8), extents=(.1, .1)),\n }\n\n start = np.array([0., 0.])\n goal = 'green'\n if isinstance(goal, str) and (goal in regions):\n goal = get_box_center(regions[goal])\n else:\n goal = np.array([1., 1.])\n\n title = args.algorithm\n if args.smooth:\n title += '+shortcut'\n viewer = draw_environment(obstacles, regions, title=title)\n\n #########################\n\n #connected_test, roadmap = get_connected_test(obstacles)\n distance_fn = get_distance_fn(weights=[1, 1]) # distance_fn\n\n # samples = list(islice(region_gen('env'), 100))\n with profiler(field='cumtime'): # cumtime | tottime\n # TODO: cost bound & best cost\n for _ in range(args.restarts+1):\n start_time = time.time()\n collision_fn, cfree = get_collision_fn(obstacles)\n sample_fn, samples = get_sample_fn(regions['env'], obstacles=[]) # obstacles\n extend_fn, roadmap = get_extend_fn(obstacles=obstacles) # obstacles | []\n\n if args.algorithm == 'prm':\n path = prm(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\n num_samples=200)\n elif args.algorithm == 'lazy_prm':\n path = lazy_prm(start, goal, sample_fn, extend_fn, collision_fn,\n num_samples=200, max_time=args.time)[0]\n elif args.algorithm == 'rrt':\n path = rrt(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\n iterations=INF, max_time=args.time)\n elif args.algorithm == 'rrt_connect':\n path = rrt_connect(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\n max_time=args.time)\n elif args.algorithm == 'birrt':\n path = birrt(start, goal, distance_fn=distance_fn, sample_fn=sample_fn,\n extend_fn=extend_fn, collision_fn=collision_fn,\n max_time=args.time, smooth=100)\n elif args.algorithm == 'rrt_star':\n path = rrt_star(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\n radius=1, max_iterations=INF, max_time=args.time)\n elif args.algorithm == 'lattice':\n path = lattice(start, goal, extend_fn, collision_fn, distance_fn=distance_fn)\n else:\n raise NotImplementedError(args.algorithm)\n paths = [] if path is None else [path]\n\n #paths = random_restarts(rrt_connect, start, goal, distance_fn=distance_fn, sample_fn=sample_fn,\n # extend_fn=extend_fn, collision_fn=collision_fn, restarts=INF,\n # max_time=args.time, max_solutions=INF, smooth=100) #, smooth=1000, **kwargs)\n\n # paths = exhaustively_select_portfolio(paths, k=2)\n # print(score_portfolio(paths))\n\n #########################\n\n if args.draw:\n # roadmap = samples = cfree = []\n add_roadmap(viewer, roadmap, color='black')\n add_points(viewer, samples, color='red', radius=2)\n #add_points(viewer, cfree, color='blue', radius=2)\n\n print('Solutions ({}): {} | Time: {:.3f}'.format(len(paths), [(len(path), round(compute_path_cost(\n path, distance_fn), 3)) for path in paths], elapsed_time(start_time)))\n for path in paths:\n add_path(viewer, path, color='green')\n\n if args.smooth:\n for path in paths:\n extend_fn, roadmap = get_extend_fn(obstacles=obstacles) # obstacles | []\n smoothed = smooth_path(path, extend_fn, collision_fn, iterations=INF, max_time=args.time)\n print('Smoothed distance_fn: {:.3f}'.format(compute_path_cost(smoothed, distance_fn)))\n add_path(viewer, smoothed, color='red')\n user_input('Finish?')","def generate_aima_grid():\n\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\n\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\n\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\n\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\n\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\n\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\n\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\n\n print('\\n***** aima grid world *****\\n')\n print('Transition matrix:', transitions.shape)\n print('Reward matrix:', rewards.shape)\n\n return transitions, rewards","def example_3():\n\n # maze = klyubin_world()\n maze = mazeworld.door_world()\n emptymaze = MazeWorld(maze.height, maze.width)\n # maze = mazeworld.tunnel_world()\n n_step = 3\n start = time.time()\n initpos = np.random.randint(maze.dims[0], size=2)\n initpos = [1,4]\n s = maze._cell_to_index(initpos)\n T = emptymaze.compute_model()\n B = maze.compute_model()\n E = maze.compute_empowerment(n_step = n_step).reshape(-1)\n n_s, n_a, _ = T.shape\n agent = EmpowermentMaximiser(alpha=0.1, gamma=0.9, T = T, n_step=n_step, n_samples=1000, det=1.)\n steps = int(10000) \n visited = np.zeros(maze.dims)\n tau = np.zeros(steps)\n D_emp = np.zeros(steps)\n D_mod = n_s*n_a*np.ones(steps)\n for t in range(steps):\n # append data for plotting \n tau[t] = agent.tau\n D_emp[t] = np.mean((E - agent.E)**2)\n D_mod[t] = D_mod[t] - np.sum(np.argmax(agent.T, axis=0) == np.argmax(B, axis=0))\n a = agent.act(s)\n pos = maze._index_to_cell(s)\n visited[pos[0],pos[1]] += 1\n s_ = maze.act(s,list(maze.actions.keys())[a])\n agent.update(s,a,s_)\n s = s_\n print(\"elapsed seconds: %0.3f\" % (time.time() - start) )\n plt.figure(1)\n plt.title(\"value map\")\n Vmap = np.max(agent.Q, axis=1).reshape(*maze.dims)\n maze.plot(colorMap= Vmap )\n plt.figure(2)\n plt.title(\"subjective empowerment\")\n maze.plot(colorMap= agent.E.reshape(*maze.dims))\n plt.figure(3)\n plt.title(\"tau\")\n plt.plot(tau)\n plt.figure(4)\n plt.scatter(agent.E, visited.reshape(n_s))\n plt.xlabel('true empowerment')\n plt.ylabel('visit frequency')\n plt.figure(5)\n plt.title(\"visited\")\n maze.plot(colorMap=visited.reshape(*maze.dims))\n fig, ax1 = plt.subplots()\n red = 'tab:red'\n ax1.set_xlabel('time')\n ax1.set_ylabel('MSE of empowerment map', color=red)\n ax1.plot(D_emp, color=red)\n ax1.tick_params(axis='y', labelcolor=red)\n ax2 = ax1.twinx() \n ax2.set_ylabel('Model disagreement', color='tab:blue') \n ax2.plot(D_mod, color='tab:blue')\n ax2.tick_params(axis='y', labelcolor='tab:blue')\n plt.show()","def createStabilizedView():\n global cc\n y = b.createNode('StartStabilized')\n dd = b.createNode('Dot', '', False)\n de = b.createNode('Dot', '', False)\n w = b.createNode('EndStabilized')\n if cc:\n y = gV(y)\n w = gX(w)\n y['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\n w['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\n w.connectInput(2, y)\n stabilizedPrecompNode___connectPrecompNodes(y, w)\n cd = 250\n df = 250\n ez = 50\n eA = 7\n cP(dd)\n de.setSelected(True)\n eB = b.nodes.BackdropNode(xpos=y.xpos() + cd / 2, bdwidth=cd * 1.5, ypos=y.ypos() - ez, bdheight=df + 2 * ez,\n tile_color=int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16),\n note_font_color=4294967040, note_font_size=36, name='MochaImport+')\n eB['label'].setValue('Stabilized View+')\n dd.setXpos(y.xpos() + cd)\n dd.setYpos(y.ypos() + eA)\n de.setXpos(y.xpos() + cd)\n de.setYpos(y.ypos() + df + eA)\n w.setXpos(y.xpos())\n w.setYpos(y.ypos() + df)\n eB['help'].setValue(\n \"\\n<h2>Basic Usage of Stabilized View Rig</h2>\\n<ol>\\n<li>From the MochaImport+ menu, create the stabilized view rig consisting of the StartStabilized node, the EndStabilized node, and the Stabilized View Backdrop.</li>\\n<li>Load your mocha tracking data in the StartStabilized node.\\n</li><li>Do arbitrary manipulations in the Stabilized View by inserting new nodes inside the backdrop. All changes you do there in a stabilized setting will also be visible in your original perspective after the EndStabilized node.</li>\\n</ol>\\n\\n<h2>Lens Distortion</h2>\\n<p>If you've used the mocha Lens module to analyze the lens distortion of your clip, you need to do the following things to get an undistorted stabilized view and reapply the lens distortion to the final result:\\n</p><ul>\\n<li>make sure the mocha corner pin data you load into the StartStabilized node is exported from mocha Pro with the option 'Remove lens distortion'</li>\\n<li>as UndistMap input of the StartStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'undistort'.</li>\\n<li>as DistMap input of the EndStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'distort'.</li>\\n</ul>\".replace(\n '\\n', '').replace('\\r', ''))","def vision(image):\n vis_map = resize(image, alpha, beta)\n print(\"Resized map from the blue mask\")\n\n world = rotate(vis_map)\n\n plt.figure()\n plt.imshow(world[:, :, ::-1])\n plt.show()\n object_grid, occupancy_grid = detect_object(world)\n print(\"Result of the red mask\")\n plt.figure()\n plt.imshow(occupancy_grid)\n plt.show()\n return object_grid, occupancy_grid, world","def __init__(self, gameState, costFn = lambda x: 1, goal=(1,1), start=None, warn=True, visualize=True):\n self.goal=(1,1)\n self.goals=[]\n self.walls = gameState.getWalls()\n self.startState = gameState.getPacmanPosition()\n if start != None: self.startState = start\n\n n=0\n try:\n for j in range(1, 40):\n n=j\n x=gameState.hasWall(1, j)\n except:\n n=n\n m=0\n try:\n for i in range(1, 40):\n m=i\n x=gameState.hasWall(i, 1)\n except:\n m=m\n print('maze dimension: ',m,'x',n)\n\n for i in range(1,m):\n for j in range(1,n):\n if (gameState.hasFood(i,j)):\n if(gameState.getNumFood()==1):\n self.goal=(i,j)\n else:\n x=(i,j)\n self.goals.append(x)\n\n #print('goals',self.getFoodPositions())\n self.costFn = costFn\n self.visualize = visualize\n #x=getFoodPosition(gameState)\n #print(\"food positions: \" )\n print(\"[R12] Initial position of pacman is \"+str(gameState.getPacmanPosition()))\n print(\"[R10] Number of foods is \"+str(gameState.getNumFood()))\n if(gameState.getNumFood()>1):\n print(\"[R10] Final goal positions are \", self.goals)\n else:\n print(\"[R10] Final goal position is \"+str(self.goals))\n print(\"[R11] Ghost Positions is/are \"+str(gameState.getGhostPositions()))\n print(\"[R15] has the game food? \"+str(gameState.hasFood(*goal)))\n if warn and (gameState.getNumFood() != 1 or not gameState.hasFood(*goal)):\n print('Warning: this does not look like a regular search maze')\n\n # For display purposes\n self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE","def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def generate_all_locations(grid, shape):","def write_ROMS_grid(grd, visc_factor, diff_factor, filename='roms_grd.nc'):\n\n Mm, Lm = grd.hgrid.x_rho.shape\n\n \n # Write ROMS grid to file\n nc = netCDF.Dataset(filename, 'w', format='NETCDF4')\n nc.Description = 'ROMS grid'\n nc.Author = 'Trond Kristiansen'\n nc.Created = datetime.now().isoformat()\n nc.type = 'ROMS grid file'\n\n nc.createDimension('xi_rho', Lm)\n nc.createDimension('xi_u', Lm-1)\n nc.createDimension('xi_v', Lm)\n nc.createDimension('xi_psi', Lm-1)\n \n nc.createDimension('eta_rho', Mm)\n nc.createDimension('eta_u', Mm)\n nc.createDimension('eta_v', Mm-1)\n nc.createDimension('eta_psi', Mm-1)\n\n nc.createDimension('xi_vert', Lm+1)\n nc.createDimension('eta_vert', Mm+1)\n\n nc.createDimension('bath', None)\n\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\n N, = grd.vgrid.s_rho.shape\n nc.createDimension('s_rho', N)\n nc.createDimension('s_w', N+1)\n\n def write_nc_var(var, name, dimensions, long_name=None, units=None):\n nc.createVariable(name, 'f8', dimensions)\n if long_name is not None:\n nc.variables[name].long_name = long_name\n if units is not None:\n nc.variables[name].units = units\n nc.variables[name][:] = var\n print ' ... wrote ', name\n\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\n write_nc_var(grd.vgrid.theta_s, 'theta_s', (), 'S-coordinate surface control parameter')\n write_nc_var(grd.vgrid.theta_b, 'theta_b', (), 'S-coordinate bottom control parameter')\n write_nc_var(grd.vgrid.Tcline, 'Tcline', (), 'S-coordinate surface/bottom layer width', 'meter')\n write_nc_var(grd.vgrid.hc, 'hc', (), 'S-coordinate parameter, critical depth', 'meter')\n write_nc_var(grd.vgrid.s_rho, 's_rho', ('s_rho'), 'S-coordinate at RHO-points')\n write_nc_var(grd.vgrid.s_w, 's_w', ('s_w'), 'S-coordinate at W-points')\n write_nc_var(grd.vgrid.Cs_r, 'Cs_r', ('s_rho'), 'S-coordinate stretching curves at RHO-points')\n write_nc_var(grd.vgrid.Cs_w, 'Cs_w', ('s_w'), 'S-coordinate stretching curves at W-points')\n\n write_nc_var(grd.vgrid.h, 'h', ('eta_rho', 'xi_rho'), 'bathymetry at RHO-points', 'meter')\n #ensure that we have a bath dependancy for hraw\n if len(grd.vgrid.hraw.shape) == 2:\n hraw = np.zeros((1, grd.vgrid.hraw.shape[0], grd.vgrid.hraw.shape[1]))\n hraw[0,:] = grd.vgrid.hraw\n else:\n hraw = grd.vgrid.hraw\n write_nc_var(hraw, 'hraw', ('bath', 'eta_rho', 'xi_rho'), 'raw bathymetry at RHO-points', 'meter')\n write_nc_var(grd.hgrid.f, 'f', ('eta_rho', 'xi_rho'), 'Coriolis parameter at RHO-points', 'second-1')\n write_nc_var(1./grd.hgrid.dx, 'pm', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in XI', 'meter-1')\n write_nc_var(1./grd.hgrid.dy, 'pn', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in ETA', 'meter-1')\n write_nc_var(grd.hgrid.dmde, 'dmde', ('eta_rho', 'xi_rho'), 'XI derivative of inverse metric factor pn', 'meter')\n write_nc_var(grd.hgrid.dndx, 'dndx', ('eta_rho', 'xi_rho'), 'ETA derivative of inverse metric factor pm', 'meter')\n write_nc_var(grd.hgrid.xl, 'xl', (), 'domain length in the XI-direction', 'meter')\n write_nc_var(grd.hgrid.el, 'el', (), 'domain length in the ETA-direction', 'meter')\n\n write_nc_var(grd.hgrid.x_rho, 'x_rho', ('eta_rho', 'xi_rho'), 'x location of RHO-points', 'meter')\n write_nc_var(grd.hgrid.y_rho, 'y_rho', ('eta_rho', 'xi_rho'), 'y location of RHO-points', 'meter')\n write_nc_var(grd.hgrid.x_u, 'x_u', ('eta_u', 'xi_u'), 'x location of U-points', 'meter')\n write_nc_var(grd.hgrid.y_u, 'y_u', ('eta_u', 'xi_u'), 'y location of U-points', 'meter')\n write_nc_var(grd.hgrid.x_v, 'x_v', ('eta_v', 'xi_v'), 'x location of V-points', 'meter')\n write_nc_var(grd.hgrid.y_v, 'y_v', ('eta_v', 'xi_v'), 'y location of V-points', 'meter')\n write_nc_var(grd.hgrid.x_psi, 'x_psi', ('eta_psi', 'xi_psi'), 'x location of PSI-points', 'meter')\n write_nc_var(grd.hgrid.y_psi, 'y_psi', ('eta_psi', 'xi_psi'), 'y location of PSI-points', 'meter')\n write_nc_var(grd.hgrid.x_vert, 'x_vert', ('eta_vert', 'xi_vert'), 'x location of cell verticies', 'meter')\n write_nc_var(grd.hgrid.y_vert, 'y_vert', ('eta_vert', 'xi_vert'), 'y location of cell verticies', 'meter')\n\n if hasattr(grd.hgrid, 'lon_rho'):\n write_nc_var(grd.hgrid.lon_rho, 'lon_rho', ('eta_rho', 'xi_rho'), 'longitude of RHO-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_rho, 'lat_rho', ('eta_rho', 'xi_rho'), 'latitude of RHO-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_u, 'lon_u', ('eta_u', 'xi_u'), 'longitude of U-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_u, 'lat_u', ('eta_u', 'xi_u'), 'latitude of U-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_v, 'lon_v', ('eta_v', 'xi_v'), 'longitude of V-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_v, 'lat_v', ('eta_v', 'xi_v'), 'latitude of V-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_psi, 'lon_psi', ('eta_psi', 'xi_psi'), 'longitude of PSI-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_psi, 'lat_psi', ('eta_psi', 'xi_psi'), 'latitude of PSI-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_vert, 'lon_vert', ('eta_vert', 'xi_vert'), 'longitude of cell verticies', 'degree_east')\n write_nc_var(grd.hgrid.lat_vert, 'lat_vert', ('eta_vert', 'xi_vert'), 'latitude of cell verticies', 'degree_north')\n\n nc.createVariable('spherical', 'c')\n nc.variables['spherical'].long_name = 'Grid type logical switch'\n nc.variables['spherical'][:] = grd.hgrid.spherical\n print ' ... wrote ', 'spherical'\n\n write_nc_var(grd.hgrid.angle_rho, 'angle', ('eta_rho', 'xi_rho'), 'angle between XI-axis and EAST', 'radians')\n\n write_nc_var(grd.hgrid.mask_rho, 'mask_rho', ('eta_rho', 'xi_rho'), 'mask on RHO-points')\n write_nc_var(grd.hgrid.mask_u, 'mask_u', ('eta_u', 'xi_u'), 'mask on U-points')\n write_nc_var(grd.hgrid.mask_v, 'mask_v', ('eta_v', 'xi_v'), 'mask on V-points')\n write_nc_var(grd.hgrid.mask_psi, 'mask_psi', ('eta_psi', 'xi_psi'), 'mask on psi-points')\n\n if visc_factor != None:\n write_nc_var(visc_factor, 'visc_factor', ('eta_rho', 'xi_rho'), 'horizontal viscosity sponge factor')\n if diff_factor != None:\n write_nc_var(diff_factor, 'diff_factor', ('eta_rho', 'xi_rho'), 'horizontal diffusivity sponge factor')\n \n nc.close()","def visualize(self):\n self.octree.updateInnerOccupancy()\n print(\"Start Octomap Visualization\")\n\n # define parameters\n data = imgviz.data.arc2017()\n camera_info = data['camera_info']\n K = np.array(camera_info['K']).reshape(3, 3)\n width=camera_info['width']\n height=camera_info['height']\n\n # get free and occupied grid\n occupied, _ = self.octree.extractPointCloud()\n #frontier = self.gen_frontier()\n \n print(\"load point cloud\")\n window = pyglet.window.Window(\n width=int(1280), height=int(960)\n )\n\n @window.event\n def on_key_press(symbol, modifiers):\n if modifiers == 0:\n if symbol == pyglet.window.key.Q:\n window.on_close()\n\n gui = glooey.Gui(window)\n hbox = glooey.HBox()\n hbox.set_padding(5)\n\n camera = trimesh.scene.Camera(\n resolution=(width, height), focal=(K[0, 0], K[1, 1])\n )\n\n # initial camera pose\n camera_transform = np.array(\n [\n [1, 0, 0, 0],\n [0, -1, 0, 0],\n [0, 0, -1, -5],\n [0.0, 0.0, 0.0, 1.0],\n ],\n )\n\n \n\n occupied_geom = trimesh.voxel.ops.multibox(\n occupied, pitch=self.resolution, colors=[0.0, 0.0, 0.0, 0.5]\n )\n\n # frontier_geom = trimesh.voxel.ops.multibox(\n # frontier, pitch=self.resolution, colors=[1.0, 0, 0, 0.5]\n # )\n scene = trimesh.Scene(camera=camera, geometry=[occupied_geom])#, frontier_geom])\n scene.camera_transform = camera_transform\n hbox.add(self.labeled_scene_widget(scene, label='octomap'))\n\n\n gui.add(hbox)\n pyglet.app.run()","def make_land_agents_2016(self):\r\n # add non-gtgp\r\n for hh_row in agents: # from excel_import\r\n hh_id = return_values(hh_row, 'hh_id')\r\n self.total_rice = return_values(hh_row, 'non_gtgp_rice_mu')\r\n if self.total_rice in ['-3', '-4', -3, None]:\r\n self.total_rice = 0\r\n self.total_dry = return_values(hh_row, 'non_gtgp_dry_mu')\r\n if self.total_dry in ['-3', '-4', -3, None]:\r\n self.total_dry = 0\r\n self.gtgp_rice = return_values(hh_row, 'gtgp_rice_mu')\r\n if self.gtgp_rice in ['-3', '-4', -3, None]:\r\n self.total_rice = 0\r\n self.gtgp_dry = return_values(hh_row, 'gtgp_dry_mu')\r\n if self.gtgp_dry in ['-3', '-4', -3, None]:\r\n self.gtgp_dry = 0\r\n\r\n landposlist = self.determine_landpos(hh_row, 'non_gtgp_latitude', 'non_gtgp_longitude')\r\n self.age_1 = return_values(hh_row, 'age')[0]\r\n self.gender_1 = return_values(hh_row, 'gender')[0]\r\n self.education_1 = return_values(hh_row, 'education')[0]\r\n\r\n for landpos in landposlist:\r\n try:\r\n self.pre_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n\r\n try:\r\n self.non_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n self.land_time = return_values(hh_row, 'non_gtgp_travel_time')[landposlist.index(landpos)]\r\n try:\r\n self.plant_type = return_values(hh_row, 'non_gtgp_plant_type')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n try:\r\n self.land_type = return_values(hh_row, 'non_gtgp_land_type')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n self.hh_size = len(return_values(hh_row, 'age'))\r\n self.gtgp_enrolled = 0\r\n lp = LandParcelAgent(hh_row, self, hh_id, hh_row, landpos, self.gtgp_enrolled,\r\n self.age_1, self.gender_1, self.education_1,\r\n self.gtgp_dry, self.gtgp_rice, self.total_dry, self.total_rice,\r\n self.land_type, self.land_time, self.plant_type, self.non_gtgp_output,\r\n self.pre_gtgp_output)\r\n self.space.place_agent(lp, landpos)\r\n self.schedule.add(lp)\r\n if self.gtgp_enrolled == 0 and landpos not in nongtgplist and landpos not in gtgplist:\r\n nongtgplist.append(landpos)\r\n # except:\r\n # pass\r\n\r\n # add gtgp\r\n for hh_row in agents: # from excel_import\r\n hh_id = return_values(hh_row, 'hh_id')\r\n self.total_rice = return_values(hh_row, 'non_gtgp_rice_mu')\r\n if self.total_rice in ['-3', '-4', -3, None]:\r\n self.total_rice = 0\r\n self.total_dry = return_values(hh_row, 'non_gtgp_dry_mu')\r\n if self.total_dry in ['-3', '-4', -3, None]:\r\n self.total_dry = 0\r\n self.gtgp_rice = return_values(hh_row, 'gtgp_rice_mu')\r\n if self.gtgp_rice in ['-3', '-4', -3, None]:\r\n self.total_rice = 0\r\n self.gtgp_dry = return_values(hh_row, 'gtgp_dry_mu')\r\n if self.gtgp_dry in ['-3', '-4', -3, None]:\r\n self.gtgp_dry = 0\r\n landposlist = self.determine_landpos(hh_row, 'gtgp_latitude', 'gtgp_longitude')\r\n self.age_1 = return_values(hh_row, 'age')[0]\r\n self.gender_1 = return_values(hh_row, 'gender')[0]\r\n self.education_1 = return_values(hh_row, 'education')[0]\r\n for landpos in landposlist:\r\n try:\r\n self.pre_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n try:\r\n self.non_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n try:\r\n self.land_time = return_values(hh_row, 'gtgp_travel_time')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n try:\r\n self.plant_type = return_values(hh_row, 'pre_gtgp_plant_type')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n try:\r\n self.land_type = return_values(hh_row, 'pre_gtgp_land_type')[landposlist.index(landpos)]\r\n except:\r\n pass\r\n self.hh_size = len(return_values(hh_row, 'age'))\r\n self.gtgp_enrolled = 1\r\n\r\n lp_gtgp = LandParcelAgent(hh_id, self, hh_id, hh_row, landpos, self.gtgp_enrolled,\r\n self.age_1, self.gender_1, self.education_1,\r\n self.gtgp_dry, self.gtgp_rice, self.total_dry, self.total_rice,\r\n self.land_type, self.land_time, self.plant_type, self.non_gtgp_output,\r\n self.pre_gtgp_output)\r\n self.space.place_agent(lp_gtgp, landpos)\r\n self.schedule.add(lp_gtgp)\r\n if self.gtgp_enrolled == 1 and landpos not in gtgplist and landpos in nongtgplist:\r\n gtgplist.append(landpos)","def abstract(res):\n o = r'\\begin{center}'\n #o += r'\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\n #o += r'\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\n o += r'\\begin{tikzpicture}' + '\\n'\n o += r'\\draw[blue!40!white] (0,0) rectangle (6,4); \\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\n'\n for i in range(res[7]):\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\n o += r'\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\n'\n o += r'\\end{tikzpicture}\\end{center}' + '\\n'\n\n o += r'\\begin{tabular}{|l|l|}' + '\\n' + r'\\hline' + '\\n'\n o += r'Election name& \\texttt{\"%s\"}\\\\'%res[1]\n o += r'Box number& \\texttt{%s}\\\\'%res[2]\n o += r'State& \\texttt{%s}\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\n o += r'Registration end& \\textit{%s}\\\\'%res[3]\n o += r'Vote closing& \\textit{%s}\\\\'%res[4]\n o += r'Casted/registered& $%s/%s$\\\\'%(res[7],res[6]) +'\\n'\n o += r'\\hline\\end{tabular}' + '\\n'\n o += r'\\quad' + '\\n'\n o += r'\\begin{tabular}{|l|l|}\\hline'\n l = res[8].items()\n l.sort(key = operator.itemgetter(1),reverse=True)\n n = 0\n for x in l:\n o += r'%s & %s\\\\'%(r'\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\texttt{%s}'%x[0],x[1]) \n if n == 0:\n o += r'\\hline' + '\\n'\n n += 1\n o += r'\\hline\\end{tabular}' + '\\n'\n\n\n #o += r'\\item The designer\\textquoteright s digital signature of this document (the source file \\texttt{oeu.py}) is: \\tiny $$\\verb!%s!$$ \\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\n'\n\n return r'\\begin{abstract}' + abstract.__doc__ + r'\\end{abstract}' + o","def drought_ag_risk_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.2},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n ##### WMS Layers - Ryan\n usdm_legend = MVLegendImageClass(value='Drought Category',\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\n usdm_current = MVLayer(\n source='ImageWMS',\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\n layer_options={'visible':False,'opacity':0.25},\n legend_title='USDM',\n legend_classes=[usdm_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\n vuln_legend = MVLegendImageClass(value='Risk Score',\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\n ag_vuln_kml = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/CO_Ag_vuln_score_2018.kml'},\n layer_options={'visible':True,'opacity':0.75},\n legend_title='Ag Risk Score',\n feature_selection=True,\n legend_classes=[vuln_legend],\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\n \n # Define GeoJSON layer\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\n with open(como_cocorahs) as f:\n data = json.load(f)\n \n # the section below is grouping data by 'scalebar' drought condition\n # this is a work around for displaying each drought report classification with a unique colored icon\n data_sd = {}; data_md ={}; data_ml={}\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\n for element in data['features']:\n if 'Severely Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_sd[u'features'].append(element)\n if 'Moderately Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_md[u'features'].append(element)\n if 'Mildly Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_ml[u'features'].append(element)\n \n cocojson_sevdry = MVLayer(\n source='GeoJSON',\n options=data_sd,\n legend_title='CoCoRaHS Condition Monitor',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_moddry = MVLayer(\n source='GeoJSON',\n options=data_md,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_mildry = MVLayer(\n source='GeoJSON',\n options=data_ml,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n \n # Define map view options\n drought_ag_risk_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,ag_vuln_kml,usdm_current,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_ag_risk_map_view_options':drought_ag_risk_map_view_options,\n }\n\n return render(request, 'co_drought/drought_ag_risk.html', context)","def global_analysis(tomo, b_th, c=18):\n\n ## Thesholding and Volume analysis\n if c == 6:\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\n elif c == 18:\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\n elif c == 26:\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\n else:\n raise ValueError\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\n lut = np.zeros(shape=num_lbls+1, dtype=int)\n\n ## COUNTING REGIONS METHODS\n # import time\n # hold_t = time.time()\n # for lbl in range(1, num_lbls + 1):\n # ids = tomo == lbl\n # feat_sz = len(ids)\n # tomo_out[ids] = feat_sz\n # # print('[1]:', lbl, 'of', num_lbls)\n # print time.time() - hold_t\n\n ## COUNTING PIXELS METHOD\n ## Count loop\n # cont, total = 0, np.prod(tomo.shape)\n # import time\n # hold_t = time.time()\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n lut[id] += 1\n # cont += 1\n # print('[1]:', cont, 'of', total)\n #\n ## Write loop\n # cont, total = 0, np.prod(tomo.shape)\n\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n if id > 0:\n tomo_out[x, y, z] = lut[id]\n # cont += 1\n # print('[1]:', cont, 'of', total)\n # print time.time() - hold_t\n\n return tomo_out","def _regr_basic():","def localization_full(Gint, focal_genes, \n num_reps = 200,\n method = 'LCC', \n print_counter = False,\n label = 'focal genes',\n line_height = 0.1,\n legend_loc = 'upper left'):\n \n numedges_list, numedges_rand, LCC_list, LCC_rand = localization(Gint, focal_genes, num_reps, \n sample_frac = 1, \n method = method, \n plot = False,\n print_counter = print_counter)\n if method == 'numedges':\n analysis_list = numedges_list\n analysis_rand = numedges_rand\n title = 'number of edges'\n else:\n analysis_list = LCC_list\n analysis_rand = LCC_rand\n title = 'largest connected component'\n\n # plot distributions for non-sampled case\n fig, ax = plt.subplots(figsize = (12, 7))\n sns.set_style('white') \n plt.vlines(np.mean(analysis_list), ymin = 0, ymax = line_height, color = 'r', lw = 2, label = label)\n sns.kdeplot(analysis_rand, ax = ax, color = 'k', lw = 2, alpha = 0.5, shade = True, label = 'random')\n plt.legend(loc = legend_loc, fontsize = 12)\n plt.ylabel('frequency', fontsize = 16)\n plt.xlabel(title, fontsize = 16)\n\n # print the z-score and fdr\n analysis_z = (np.mean(analysis_list) - np.mean(analysis_rand))/float(np.std(analysis_rand))\n\n print(1 - ndtr(analysis_z))\n\n plt.title('permutation p = ' + str(1 - ndtr(analysis_z)))\n \n return numedges_list, numedges_rand, LCC_list, LCC_rand","def create_grids(self):\n \n par = self.par\n\n # a. retirement\n \n # pre-decision states\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\n \n # post-decision states\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\n \n # b. working: state space (m,n,k) \n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\n\n par.Nn = par.Nm\n par.n_max = par.m_max + par.n_add\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\n\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\n\n # c. working: w interpolant (and wa and wb and wq)\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\n par.a_max = par.m_max + par.a_add\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\n \n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\n par.b_max = par.n_max + par.b_add\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\n \n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\n \n # d. working: egm (seperate grids for each segment)\n \n if par.solmethod == 'G2EGM':\n\n # i. dcon\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\n \n # ii. acon\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\n par.a_acon = np.zeros(par.grid_b_acon.shape)\n par.b_acon = par.grid_b_acon\n\n # iii. con\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\n \n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\n\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\n par.a_con = np.zeros(par.c_con.shape)\n par.d_con = np.zeros(par.c_con.shape)\n \n elif par.solmethod == 'NEGM':\n\n par.grid_l = par.grid_m\n\n # e. shocks\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\n\n if par.Neta > 1:\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\n else:\n par.eta = np.ones(1)\n par.w_eta = np.ones(1)\n\n # f. timings\n par.time_work = np.zeros(par.T)\n par.time_w = np.zeros(par.T)\n par.time_egm = np.zeros(par.T)\n par.time_vfi = np.zeros(par.T)","def registerInitialState(self, gameState):\r\n \r\n '''\r\n Make sure you do not delete the following line. If you would like to\r\n use Manhattan distances instead of maze distances in order to save\r\n on initialization time, please take a look at\r\n CaptureAgent.registerInitialState in captureAgents.py.\r\n '''\r\n CaptureAgent.registerInitialState(self, gameState)\r\n \r\n \r\n self.teamMates = []\r\n for mate in self.getTeam(gameState):\r\n if mate is not self.index:\r\n self.teamMates.append(mate)\r\n \r\n def getSuccessors(walls, state):\r\n successors = []\r\n for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:\r\n x,y = state\r\n dx, dy = Actions.directionToVector(action)\r\n nextx, nexty = int(x + dx), int(y + dy)\r\n if not walls[nextx][nexty]:\r\n nextState = (nextx, nexty)\r\n cost = 1\r\n successors.append( ( nextState, action, cost) )\r\n return successors\r\n \r\n \r\n \r\n class o0State:\r\n def __init__(self, pos, node = None):\r\n self.pos = pos\r\n self.node = node\r\n self.deadEndDepth = 0.0\r\n self.successors = {}\r\n self.successorsByNodePos = {}\r\n def isDeadEndNode(self):\r\n if self.node is None:\r\n return False\r\n noneDeadEndCount = 0\r\n for successor in self.successors.values():\r\n if not successor.isDeadEnd:\r\n noneDeadEndCount += 1\r\n return noneDeadEndCount is 1\r\n class o0Node:\r\n def __init__(self, pos):\r\n self.pos = pos\r\n self.isDeadEnd = False\r\n class o0Successor:\r\n def __init__(self, direction, nextPos, nextNodePos = None):\r\n self.direction = direction\r\n self.nextPos = nextPos\r\n self.nextNodePos = nextNodePos\r\n self.isDeadEnd = False\r\n\r\n class o0PathMap:\r\n def __init__(self, gameState):\r\n #print 'init pathMap'\r\n walls = gameState.getWalls()\r\n positions = walls.asList(False)\r\n self.states = {}\r\n self.nodes = {}\r\n for pos in positions:\r\n self.states[pos] = o0State(pos)\r\n for successor in getSuccessors(walls,pos):\r\n self.states[pos].successors[successor[1]] = o0Successor(successor[1],successor[0])\r\n successorCount = len(self.states[pos].successors)\r\n if successorCount is not 2:\r\n node = o0Node(pos)\r\n self.nodes[pos] = node\r\n self.states[pos].node = node\r\n \r\n def connectNode(node):\r\n for nodeSuccessor in self.states[node.pos].successors.values():\r\n if nodeSuccessor.nextNodePos is None:\r\n forwardSuccessors = [nodeSuccessor]\r\n backwardSuccessors = []\r\n previousPos = node.pos\r\n currentPos = nodeSuccessor.nextPos\r\n while currentPos not in self.nodes.keys():\r\n #print node.pos\r\n #print currentPos\r\n if len(self.states[currentPos].successors) is not 2:\r\n print 'not a path'\r\n for successor in self.states[currentPos].successors.values():\r\n #print successor.nextPos\r\n if successor.nextPos[0] is previousPos[0] and successor.nextPos[1] is previousPos[1]:\r\n backwardSuccessors.append(successor)\r\n else:\r\n forwardSuccessors.append(successor)\r\n previousPos = currentPos\r\n currentPos = forwardSuccessors[len(forwardSuccessors) - 1].nextPos\r\n for successor in self.states[currentPos].successors.values():\r\n if successor.nextPos is previousPos:\r\n backwardSuccessors.append(successor)\r\n \r\n for successor in forwardSuccessors:\r\n successor.nextNodePos = currentPos\r\n for successor in backwardSuccessors:\r\n successor.nextNodePos = node.pos\r\n \r\n #connectNode(self.nodes.values()[0])\r\n #connectNode(self.nodes.values()[1])\r\n #connectNode(self.nodes.values()[2])\r\n #connectNode(self.nodes.values()[3])\r\n #connectNode(self.nodes.values()[4])\r\n #connectNode(self.nodes.values()[5])\r\n \r\n for node in self.nodes.values():\r\n connectNode(node)#'''\r\n for state in self.states.values():\r\n for successor in self.states[state.pos].successors.values():\r\n self.states[state.pos].successorsByNodePos[successor.nextNodePos] = successor\r\n \r\n updatedNodes = self.nodes.values()\r\n while(len(updatedNodes) is not 0):\r\n nodePool = updatedNodes\r\n updatedNodes = []\r\n for node in nodePool:\r\n if self.states[node.pos].isDeadEndNode():\r\n self.nodes[node.pos].isDeadEnd = True\r\n for successor in self.states[node.pos].successors.values():\r\n self.states[successor.nextNodePos].successorsByNodePos[node.pos].isDeadEnd = True\r\n updatedNodes.append(self.states[successor.nextNodePos])\r\n \r\n #node.isDeadEnd = self.states[node.pos].isDeadEndNode()#'''\r\n \r\n '''\r\n for node in self.nodes.values():\r\n if self.states[node.pos].isDeadEndNode():\r\n node.isDeadEnd = True#'''\r\n \r\n deadEndNodes = {}\r\n noneDeadEndNodes = {}\r\n for node in self.nodes.values():\r\n if not node.isDeadEnd:\r\n noneDeadEndNodes[node.pos] = node\r\n else:\r\n deadEndNodes[node.pos] = node\r\n \r\n for node in deadEndNodes.values():#\r\n actions = breadthFirstSearch(AnyTargetSearchProblem(gameState,noneDeadEndNodes.keys(),node.pos))\r\n nodeConnectedTo = self.nodes[performActions(node.pos, actions)] \r\n actions = reverseActions(actions)\r\n pos = nodeConnectedTo.pos\r\n deadEndDepth = 0.0\r\n for action in actions:\r\n pos = performActions(pos,[action])\r\n deadEndDepth += 1.0\r\n self.states[pos].deadEndDepth = deadEndDepth\r\n def willDie(self, position, distance, scaredTime = 0):#distance from our agent to closest enemy\r\n deadEndDepth = self.states[position].deadEndDepth\r\n if deadEndDepth >= distance - deadEndDepth and deadEndDepth >= scaredTime:\r\n return True\r\n return False\r\n def isDeadEnd(self, position):\r\n return self.states[position].deadEndDepth >= 0.5\r\n #def getAllStatesInDeadEnd(self, anyState):\r\n \r\n\r\n global pathMap\r\n if pathMap is None:\r\n pathMap = o0PathMap(gameState)\r\n self.pathMap = pathMap\r\n targets[self.index] = None\r\n global lastEattenFoodAreDefendingPos\r\n lastEattenFoodAreDefendingPos = None \r\n global totalFood\r\n totalFood = len(self.getFood(gameState).asList())\r\n global leftFood\r\n leftFood = totalFood\r\n #self.debugDraw(pathMap.deadEndNodes.keys(),[1,0,0])\r\n #self.debugDraw(pathMap.nodes.keys(),[0,1,0])\r\n \r\n global pathMapDebugMode\r\n if pathMapDebugMode:\r\n for state in self.pathMap.states.values():\r\n deadEndColor = 0.3 + state.deadEndDepth * 0.1\r\n if deadEndColor>1.0:\r\n deadEndColor = 1.0\r\n if state.deadEndDepth == 0:\r\n deadEndColor = 0.0\r\n \r\n nodeColor = 0.0\r\n if state.node is not None:\r\n nodeColor = 0.5\r\n self.debugDraw(state.pos,[deadEndColor,0,0])\r\n\r\n self.curryFoodScore = 0.8\r\n \r\n \r\n \r\n global defenseWall\r\n global defensePositions\r\n if len(defenseWall) is 0:\r\n foods = self.getFoodYouAreDefending(gameState)\r\n for capsule in self.getCapsulesYouAreDefending(gameState):\r\n foods[capsule[0]][capsule[1]] = True\r\n defenseWall = actionsToPositions((0,0), aStarSearch(DefenseSearchProblem(gameState, foods, self.index),nullHeuristic))\r\n defensePositions = getPositionsNeededToDefense(gameState)\r\n global defenseWallDebugMode\r\n if defenseWallDebugMode is True:\r\n self.debugDraw(defenseWall,[0,0.5,0])\r\n self.debugDraw(defensePositions,[0.5,0,0])\r\n \r\n global agentInDeadEnd\r\n agentInDeadEnd[self.index] = False","def drawCell(self,land,uland,vland,marked):\n from math import sqrt, pow\n #--Tranlate grid point (u,v) to pixel point\n if not self.changed: self.edit()\n #--u/v max/min are grid range of visible map. \n #--wcell is bit width of cell. 512 is bit width of visible map.\n (umin,umax,vmin,vmax,wcell,wmap) = (-28,27,-27,28,9,512)\n if not ((umin <= uland <= umax) and (vmin <= vland <= vmax)):\n return\n #--x0,y0 is bitmap coordinates of top left of cell in visible map.\n (x0,y0) = (4 + wcell*(uland-umin), 4 + wcell*(vmax-vland))\n #--Default to deep\n mapc = [Fmap.DEEP]*(9*9)\n heights = land and land.getHeights()\n if heights:\n #--Land heights are in 65*65 array, starting from bottom left. \n #--Coordinate conversion. Subtract one extra from height array because it's edge to edge.\n converter = [(65-2)*px/(wcell-1) for px in range(wcell)]\n for yc in range(wcell):\n ycoff = wcell*yc\n yhoff = (65-1-converter[yc])*65\n for xc in range(wcell):\n height = heights[converter[xc]+yhoff]\n if height >= 0: #--Land\n (r0,g0,b0,r1,g1,b1,scale) = (66,48,33,32,23,16,sqrt(height/3000.0))\n scale = int(scale*10)/10.0 #--Make boundaries sharper.\n r = chr(max(0,int(r0 - r1*scale)) & ~1)\n else: #--Sea\n #--Scale color from shallow to deep color.\n (r0,g0,b0,r1,g1,b1,scale) = (37,55,50,12,19,17,-height/2048.0)\n r = chr(max(0,int(r0 - r1*scale)) | 1)\n g = chr(max(0,int(g0 - g1*scale)))\n b = chr(max(0,int(b0 - b1*scale)))\n mapc[xc+ycoff] = r+g+b\n #--Draw it\n mapd = self.mapd\n for yc in range(wcell):\n ycoff = wcell*yc\n ymoff = wmap*(y0+yc)\n for xc in range(wcell):\n cOld = mapd[x0+xc+ymoff]\n cNew = mapc[xc+ycoff]\n rOld = ord(cOld[0])\n #--New or old is sea.\n if (ord(cNew[0]) & 1) or ((rOld & 1) and\n (-2 < (1.467742*rOld - ord(cOld[1])) < 2) and\n (-2 < (1.338710*rOld - ord(cOld[2])) < 2)):\n mapd[x0+xc+ymoff] = cNew\n if marked:\n self.drawBorder(Fmap.MARKED,x0+2,y0+2,x0+7,y0+7,1)\n pass","def decision(grid):\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()","def add_building_output_locations(self,dictionary, start,end,step): \n \"\"\"\n Given a dictionary of building footprints and associated nodes,element and sides, add the values \n to the netcdf grid file.\n \n The nodes, elements and sides associated with each footprint correspond to the there index in the RiCOM grid file\n \n Dictionary format:\n {id1: {'nodes': [n1, n2,...nn] }, {'elements': [e1,e2,...,en] },{'sides': [s1,s2,...,sn]}, id2: {}, id3 {}, ...., idn {} } \n \n idn = the id of the building footprint that the node, elements and sides belong to\n \n \"\"\"\n \n if (dictionary != {}):\n maxNodes = 0\n maxElements = 0\n maxSides = 0\n nodesAll = []\n elementsAll = []\n sidesAll = []\n id = []\n perimeter = []\n type = []\n for row in dictionary.iteritems(): \n id.append(row[0]) \n n = row[1]['nodes'] \n e = row[1]['elements']\n s = row[1]['sides']\n perimeter.append(row[1]['perimeter'])\n \n if row[1]['type'] == \"BUILDINGS_AS_HOLES\":\n typeNUM = 1\n elif row[1]['type'] == \"BUILDINGS_GRIDDED\":\n typeNUM = 2\n\n elif row[1]['type'] == \"BUILDINGS_AS_POINTS\":\n typeNUM = 3\n else:\n typeNUM = 0\n type.append(typeNUM)\n \n nodesAll.extend(n)\n elementsAll.extend(e)\n sidesAll.extend(s)\n if maxNodes < len(n): maxNodes = len(n)\n if maxElements < len(e): maxElements = len(e)\n if maxSides < len(s): maxSides = len(s)\n \n \n #remove repeated elements, sides and nodes\n nodesAll = list(set(nodesAll))\n elementsAll = list(set(elementsAll))\n sidesAll = list(set(sidesAll))\n \n print \"# elements = %s\" % len(elementsAll)\n print \"# sides = %s\" % len(sidesAll)\n print \"# nodes = %s\" % len(nodesAll)\n\n \n #initialise arrays for entry into netcdf file\n nodes = zeros((len(dictionary),maxNodes))\n elements = zeros((len(dictionary),maxElements))\n sides = zeros((len(dictionary),maxSides)) \n \n i = 0\n for row in dictionary.iteritems(): \n nodes[i,0:(len(row[1]['nodes']))] = row[1]['nodes']\n elements[i,0:(len(row[1]['elements']))] = row[1]['elements']\n sides[i,0:(len(row[1]['sides']))] = row[1]['sides']\n i+=1 \n \n #create dimensions\n try: self.buildings.createDimension('max_number_nodes',maxNodes)\n except Exception, e: print \"WARNING: %s\" % e\n try: self.buildings.createDimension('max_number_elements',maxElements)\n except Exception, e: print \"WARNING: %s\" % e\n try: self.buildings.createDimension('max_number_sides',maxSides)\n except Exception, e: print \"WARNING: %s\" % e\n try: self.buildings.createDimension('number_of_buildings',len(dictionary))\n except Exception, e: print \"WARNING: %s\" % e \n try: self.building_nodes.createDimension('number_of_nodes',len(nodesAll))\n except Exception, e: print \"WARNING: %s\" % e\n try: self.building_elements.createDimension('number_of_elements',len(elementsAll))\n except Exception, e: print \"WARNING: %s\" % e\n try: self.building_sides.createDimension('number_of_sides',len(sidesAll))\n except Exception, e: print \"WARNING: %s\" % e\n \n \n #create variables\n try: building_id = self.buildings.createVariable(varname = 'building_id',datatype = 'i', dimensions=('number_of_buildings',)) \n except Exception, e:\n building_id = self.buildings.variables['building_id']\n print \"WARNING: %s\" % e\n \n try: building_wkt = self.buildings.createVariable(varname = 'building_wkt',datatype = str, dimensions=('number_of_buildings',)) \n except Exception, e:\n building_wkt = self.buildings.variables['building_wkt'] \n print \"WARNING: %s\" % e\n\n try: building_perimeter = self.buildings.createVariable(varname = 'building_perimeter',datatype = 'd', dimensions=('number_of_buildings',)) \n except Exception, e:\n building_perimeter = self.buildings.variables['building_perimeter'] \n print \"WARNING: %s\" % e\n\n\n try: building_type = self.buildings.createVariable(varname = 'building_type',datatype = 'i', dimensions=('number_of_buildings',)) \n except Exception, e:\n building_type = self.buildings.variables['building_type'] \n print \"WARNING: %s\" % e\n\n try: building_nodes = self.buildings.createVariable(varname = 'building_nodes',datatype = 'i', dimensions=('number_of_buildings','max_number_nodes',)) \n except Exception, e:\n building_nodes = self.buildings.variables['building_nodes'] \n print \"WARNING: %s\" % e\n \n try: building_elements = self.buildings.createVariable(varname = 'building_elements',datatype = 'i', dimensions=('number_of_buildings','max_number_elements',)) \n except Exception, e:\n building_elements = self.buildings.variables['building_elements']\n print \"WARNING: %s\" % e\n \n try: building_sides = self.buildings.createVariable(varname = 'building_sides',datatype = 'i', dimensions=('number_of_buildings','max_number_sides',)) \n except Exception, e:\n building_sides = self.buildings.variables['building_sides']\n print \"WARNING: %s\" % e\n \n building_nodes[:] = nodes\n building_elements[:] = elements\n building_sides[:] = sides\n building_id[:] = array(id) \n building_perimeter[:] = array(perimeter)\n building_type[:] = array(type)\n #Set the attributes\n self.building_nodes.start = start\n self.building_nodes.finish = end\n self.building_nodes.step = step\n self.building_elements.start = start\n self.building_elements.finish = end\n self.building_elements.step = step\n self.building_sides.start = start\n self.building_sides.finish = end\n self.building_sides.step = step\n \n #assign the data\n output_ids = {'nodes': [], 'elements': [], 'sides': []}\n try: output_ids['nodes'] = self.building_nodes.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_nodes',))\n except Exception, e:\n output_ids['nodes'] = self.building_nodes.variables['id']\n print \"WARNING: %s\" % e\n try: output_ids['elements'] = self.building_elements.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_elements',))\n except Exception, e:\n output_ids['elements'] = self.building_elements.variables['id']\n print \"WARNING: %s\" % e\n try: output_ids['sides'] = self.building_sides.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_sides',))\n except Exception, e:\n output_ids['sides'] = self.building_sides.variables['id']\n print \"WARNING: %s\" % e\n \n \n output_ids['nodes'][:] = array(nodesAll)\n output_ids['elements'][:] = array(elementsAll)\n output_ids['sides'][:] = array(sidesAll)\n \n \n self.buildingsAdded = True\n else:\n #create dimensions\n try: self.buildings.createDimension('number_of_buildings',0)\n except Exception, e: print \"WARNING: %s\" % e \n try: self.building_nodes.createDimension('number_of_nodes',0)\n except Exception, e: print \"WARNING: %s\" % e\n try: self.building_elements.createDimension('number_of_elements',0)\n except Exception, e: print \"WARNING: %s\" % e\n try: self.building_sides.createDimension('number_of_sides',0)\n except Exception, e: print \"WARNING: %s\" % e \n self.buildingsAdded = True","def pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\n def compute_avec(vec,aaa,bbb,grd):\n\n avec=np.empty(grd.np0,)\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\n avec[grd.vp1] = vec[grd.vp1]\n\n return avec,\n if name_grd is not None:\n if os.path.isfile(name_grd):\n with open(name_grd, 'rb') as f:\n grd = pickle.load(f)\n else:\n grd = Grid(lon,lat)\n with open(name_grd, 'wb') as f:\n pickle.dump(grd, f)\n f.close()\n else:\n grd = Grid(lon,lat)\n\n ny,nx,=np.shape(hg)\n g=grd.g\n\n\n x=hg[grd.indi,grd.indj]\n q1d=q[grd.indi,grd.indj]\n\n aaa=g/grd.f01d\n bbb=-g*grd.f01d/c**2\n ccc=+q1d\n\n aaa[grd.vp1]=0\n bbb[grd.vp1]=1\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\n\n vec=+x\n\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n p=-gg\n\n for itr in range(nitr-1):\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n tmp=np.dot(p,avec)\n\n if tmp!=0. : s=-np.dot(p,gg)/tmp\n else: s=1.\n\n a1=np.dot(gg,gg)\n x=x+s*p\n vec=+x\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n a2=np.dot(gg,gg)\n\n if a1!=0: beta=a2/a1\n else: beta=1.\n\n p=-gg+beta*p\n\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n val1=-np.dot(p,gg)\n val2=np.dot(p,avec)\n if (val2==0.):\n s=1.\n else:\n s=val1/val2\n\n a1=np.dot(gg,gg)\n x=x+s*p\n\n # back to 2D\n h=np.empty((ny,nx))\n h[:,:]=np.NAN\n h[grd.indi,grd.indj]=x[:]\n\n\n return h","def __init__(self, folder):\n print \"folder passed is \", folder\n self.folder = folder\n self.geometry = gf.geometry(self.folder)\n self.elements = gf.dictionary_set()\n self.area = np.zeros(shape = (8))\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\n *self.geometry.properties['span_width']/2))\n self.F = np.zeros(shape = (8, 8))\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\n self.geometry.properties['tra_sidewall_out'],\n self.geometry.properties['tra_cover_in'],\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\n self.geometry.properties['emi_sidewall_out'],\n self.geometry.properties['emi_cover_in'],\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\n if ((self.tr + self.em).any() > 1.0):\n print \"error in optical properties\"\n self.T = np.zeros(shape = (2,10))\n self.RH = np.zeros(shape = (2,10))\n # 8 inside,9 outside \n self.qcond = np.zeros(shape = (2,8))\n self.qconv = np.zeros(shape = (2,8))\n self.qrad = np.zeros(shape = (2,8))\n self.j = np.zeros(shape = (2,8))\n self.g = np.zeros(shape = (2,8))\n self.alpha = np.zeros(shape = (2,8))\n deltaT = 300\n RH_in = 0.6\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\n 278,\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\n self.geometry.properties['sky_temp'])\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\n self.geometry.properties['wind_speed'],\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\n self.geometry.properties['rho'],self.geometry.properties['cp'],\n self.Vol,self.geometry.properties['degree_window'],deltaT)","def test_for_grader():\n test_map1 = np.array([\n [1, 1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 1, 0, 0, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\n [1, 0, 0, 0, 1, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1, 1]])\n x_spacing1 = 1\n y_spacing1 = 1\n start1 = np.array([[1.5], [1.5], [0]])\n goal1 = np.array([[7.5], [1], [0]])\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\n s = 0\n for i in range(len(path1)-1):\n s += np.sqrt((path1[i][0]-path1[i+1][0])**2 + (path1[i][1]-path1[i+1][1])**2)\n print(\"Path 1 length:\")\n print(s)\n\n\n test_map2 = np.array([\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n start2 = np.array([[0.4], [0.4], [1.5707963267948966]])\n goal2 = np.array([[0.4], [1.8], [-1.5707963267948966]])\n x_spacing2 = 0.2\n y_spacing2 = 0.2\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\n s = 0\n for i in range(len(path2)-1):\n s += np.sqrt((path2[i][0]-path2[i+1][0])**2 + (path2[i][1]-path2[i+1][1])**2)\n print(\"Path 2 length:\")\n print(s)","def generate_trivial_tours(self):\n self.routes = []\n for c in range(1, self.vrpdata.NumCust+1):\n self.routes.append(VRP_Route([c]))\n return self.get_objective()","def workflow(save_dir):\n year = 2016\n month_series = range(1, 13)\n total_potential_biomass_multiplier = 48.8\n total_standing_biomass_multiplier = 45.25\n biomass_jitter = 3.\n diet_sufficiency_multiplier = 0.28\n diet_sufficiency_jitter = 0.01\n avg_animal_density = 0.0175\n animal_density_jitter = 0.005\n\n # twelve months of precipitation rasters covering the study area\n precip_basename_list = [\n 'chirps-v2.0.{}.{:02d}.tif'.format(year, month) for month in\n month_series]\n\n # reclassify 0 to NoData in CHIRPS rasters\n output_precip_dir = os.path.join(save_dir, 'precip')\n if not os.path.exists(output_precip_dir):\n os.makedirs(output_precip_dir)\n for bn in precip_basename_list:\n base_raster = os.path.join(PRECIP_DIR, bn)\n target_raster = os.path.join(output_precip_dir, bn)\n pygeoprocessing.raster_calculator(\n [(base_raster, 1)], zero_to_nodata, target_raster,\n gdal.GDT_Float32, _IC_NODATA)\n\n # generate outputs\n for month in month_series:\n precip_raster = os.path.join(\n output_precip_dir, 'chirps-v2.0.{}.{:02d}.tif'.format(year, month))\n\n total_potential_biomass_path = os.path.join(\n save_dir, 'potential_biomass_{}_{:02d}.tif'.format(year, month))\n pygeoprocessing.raster_calculator(\n [(precip_raster, 1)] + [(path, 'raw') for path in [\n total_potential_biomass_multiplier,\n biomass_jitter]],\n precip_to_correlated_output, total_potential_biomass_path,\n gdal.GDT_Float32, _IC_NODATA)\n\n total_standing_biomass_path = os.path.join(\n save_dir, 'standing_biomass_{}_{:02d}.tif'.format(year, month))\n pygeoprocessing.raster_calculator(\n [(precip_raster, 1)] + [(path, 'raw') for path in [\n total_standing_biomass_multiplier,\n biomass_jitter]],\n precip_to_correlated_output, total_standing_biomass_path,\n gdal.GDT_Float32, _IC_NODATA)\n\n diet_sufficiency_path = os.path.join(\n save_dir, 'diet_sufficiency_{}_{:02d}.tif'.format(year, month))\n pygeoprocessing.raster_calculator(\n [(precip_raster, 1)] + [(path, 'raw') for path in [\n diet_sufficiency_multiplier,\n diet_sufficiency_jitter]],\n precip_to_correlated_output, diet_sufficiency_path,\n gdal.GDT_Float32, _IC_NODATA)\n\n animal_density_path = os.path.join(\n save_dir, 'animal_density_{}_{:02d}.tif'.format(year, month))\n pygeoprocessing.raster_calculator(\n [(precip_raster, 1)] + [(path, 'raw') for path in [\n avg_animal_density,\n animal_density_jitter]],\n precip_to_animal_density, animal_density_path,\n gdal.GDT_Float32, _IC_NODATA)","def getMove(self, grid):\n# global prune\n# prune = 0\n def Terminal(stateTup):\n \"\"\"\n Checks if the node is a terminal node\n Returns eval(state) if it is terminal\n \"\"\"\n state = stateTup[0]\n maxDepth = self.depthLimit\n if stateTup[1] == maxDepth:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n elif len(stateTup[0].getAvailableMoves()) == 0:\n val = self.h.get(str(state.map))\n if val == None:\n Val = Eval(state)\n self.h[str(state.map)] = Val\n return Val\n else:\n return val\n\n def Eval(state):\n \"\"\"\n This is the eval function which combines many heuristics and assigns\n weights to each of them\n Returns a single value\n \"\"\"\n\n# H1 = htest2(state)\n# return H1\n H2 = h1(state)*monotonic(state)\n return H2\n\n\n def h1(state):\n Max = state.getMaxTile()\n left = len(state.getAvailableCells())/16\n if state.getCellValue([0,0]) == Max:\n v = 1\n else:\n v= 0.3\n Max = Max/1024\n return Max*left*v\n\n def mono(state):\n mon = 0\n# for i in range(4):\n# row = 0\n# for j in range(3):\n# if state.map[i][j] > state.map[i][j+1]:\n# row+=1\n# if row == 4:\n# mon += 1\n# for i in range(4):\n# column = 0\n# for j in range(3):\n# if state.map[j][i] > state.map[j+1][i]:\n# column +=1\n# if column == 4:\n# mon +=1\n#\n#\n# return mon/8\n for i in range(4):\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\n mon+=1\n\n return mon/8\n\n def monotonic(state):\n cellvals = {}\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n for i in Path1:\n cellvals[i] = state.getCellValue(i)\n mon = 0\n for i in range(4):\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\n mon +=1\n for j in range(4):\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\n mon+=1\n return mon/8\n\n\n\n def htest2(state):\n score1 = 0\n score2 = 0\n r = 0.5\n\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\n valDict = {}\n for n in range(16):\n valDict[Path1[n]] = state.getCellValue(Path1[n])\n for n in range(16):\n if n%3 == 0:\n self.emergency()\n cell1 = valDict.get(Path1[n])\n cell2 = valDict.get(Path2[n])\n score1 += (cell1) * (r**n)\n score2 += (cell2) * (r**n)\n return max(score1,score2)\n\n\n def Maximize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n maxChild , maxUtility = None,-999999999\n state = stateTup[0]\n Map = self.dict.get(str(state.map))\n if Map == None:\n children = []\n for M in range(4):\n g = state.clone()\n if g.move(M):\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Minimize(childTup,A,B)[1]\n if utility > maxUtility:\n maxChild , maxUtility = child , utility\n if maxUtility >= B:\n# global prune\n# prune +=1\n break\n if maxUtility > A:\n A = maxUtility\n\n return (maxChild,maxUtility)\n\n\n def Minimize(stateTup,A,B):\n \"\"\"\n Returns a tuple of state,eval(state)\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\n and beta\n \"\"\"\n self.emergency()\n t = Terminal(stateTup)\n if t != None:\n return (None, t)\n\n minChild , minUtility = None,999999999\n state = stateTup[0]\n Map= self.dict.get(str(state.map))\n if Map == None:\n cells= state.getAvailableCells()\n children = []\n tiles = [2,4]\n for i in cells:\n for j in tiles:\n g = state.clone()\n g.insertTile(i,j)\n children.append(g)\n self.dict[str(state.map)] = children\n else:\n children = Map\n for child in children:\n childTup = (child,stateTup[1]+1)\n utility = Maximize(childTup,A,B)[1]\n if utility < minUtility:\n minChild , minUtility = child , utility\n if minUtility <= A:\n# global prune\n# prune +=1\n break\n if minUtility < B:\n B = minUtility\n\n return (minChild,minUtility)\n\n\n\n def decision(grid):\n \"\"\"\n Decision function which returns the move which led to the state\n \"\"\"\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()\n\n self.dict = {}\n self.h = {}\n self.prevTime = time.clock()\n self.depthLimit = 1\n self.mL = []\n self.over = False\n while self.over == False:\n self.depthLimit +=1\n try :\n self.mL.append(decision(grid))\n\n except KeyError:\n# print(self.depthLimit)\n return self.mL[-1]\n except IndexError:\n return random.randint(0,3)\n self.Alarm(time.clock())\n return self.mL[-1]","def connect_cells(dfte,vari):\n # Create the variabel cell for mother, grand mother and grand grand mother\n if 'g_parent_cell' not in dfte.columns:\n dfte = rl.genalogy(dfte,'parent_cell') #Create genealogy\n if 'g_g_parent_cell' not in dfte.columns:\n dfte = rl.genalogy(dfte,'g_parent_cell')\n if 'g_g_g_parent_cell' not in dfte.columns:\n dfte = rl.genalogy(dfte,'g_g_parent_cell')\n #give unique index to all cells\n dfte['uid'] = dfte['cell']+dfte['time_sec'].apply(lambda x: str(x))\n vac=[];sc=[];uid = []\n # Create a vecotor for the variable of interest of cell,mother,grand mother and grand grand mother and an unique identifier of it\n for c,idx in enumerate(dfte['cell'].unique()):\n dau = dfte.loc[dfte['cell']==idx]\n pc = dau['parent_cell'].iloc[0]\n mum = dfte.loc[dfte['cell']==pc]\n gpc = dau['g_parent_cell'].iloc[0]\n gmum = dfte.loc[dfte['cell']==gpc]\n ggpc = dau['g_g_parent_cell'].iloc[0]\n ggmum = dfte.loc[dfte['cell']==ggpc]\n gggpc = dau['g_g_g_parent_cell'].iloc[0]\n gggmum = dfte.loc[dfte['cell']==gggpc]\n fte = lambda x: x[['{}'.format(vari),'uid']].values\n tmp = np.vstack([fte(gggmum),fte(ggmum),fte(gmum),fte(mum),fte(dau)])\n vac.append(tmp[:,0])\n uid.append(tmp[:,1])\n sc.append(['super_cell_{}'.format(c)]*len(tmp))\n return pd.DataFrame({'super_cell':np.hstack(sc),'uid':np.hstack(uid),'{}'.format(vari):np.hstack(vac)})","def drought_prec_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.8},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # Previous 7-day precip from USGS (not working) \n prec7_legend = MVLegendImageClass(value='7-day Precip Total',\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP7') \n precip7day = MVLayer(\n source='ImageWMS',\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\n 'params': {'LAYERS': 'PRECIP_RD7'},\n 'serverType': 'geoserver'},\n layer_options={'visible':True,'opacity':0.5},\n legend_title='Prev 7-day Precip',\n legend_classes=[prec7_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # NWS Precip analysis data \n nws_prec7 = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Forecasts_Guidance_Warnings/rfc_dly_qpe/MapServer',\n 'params': {'LAYERS': 'show:15'}},\n legend_title='7-day % of Norm',\n layer_options={'visible':False,'opacity':0.6},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n ##### USGS WMS Precip Layers\n precip30_legend = MVLegendImageClass(value='Previous 30-day Precip',\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP30') \n precip30 = MVLayer(\n source='ImageWMS',\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\n 'params': {'LAYERS': 'PRECIP_TP30'},\n 'serverType': 'geoserver'},\n layer_options={'visible':True,'opacity':0.4},\n legend_title='30-day Total Precip',\n legend_classes=[precip30_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n\n # NEXRAD Radar reflectivity \n nexrad_legend = MVLegendImageClass(value='Base Reflectivity',\n image_url='https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?version=1.1.1&service=WMS&request=GetLegendGraphic&layer=nexrad-n0q-900913&format=image/png&STYLE=default') \n nexrad = MVLayer(\n source='ImageWMS',\n options={'url': 'https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?',\n 'params': {'LAYERS': 'nexrad-n0q-900913'}},\n layer_options={'visible':True,'opacity':0.5},\n legend_title='NEXRAD',\n legend_classes=[nexrad_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # NOAA NOHRSC snow products\n snodas_swe = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Observations/NOHRSC_Snow_Analysis/MapServer',\n 'params': {'LAYERS': 'show:7'}},\n legend_title='SNODAS Model SWE',\n layer_options={'visible':True,'opacity':0.7},\n legend_classes=[\n MVLegendClass('polygon', '0.04', fill='rgba(144,175,180,0.7)'),\n MVLegendClass('polygon', '0.20', fill='rgba(128,165,192,0.7)'),\n MVLegendClass('polygon', '0.39', fill='rgba(95,126,181,0.7)'),\n MVLegendClass('polygon', '0.78', fill='rgba(69,73,171,0.7)'),\n MVLegendClass('polygon', '2.00', fill='rgba(71,46,167,0.7)'),\n MVLegendClass('polygon', '3.90', fill='rgba(79,20,144,0.7)'),\n MVLegendClass('polygon', '5.90', fill='rgba(135,33,164,0.7)'),\n MVLegendClass('polygon', '9.80', fill='rgba(155,53,148,0.7)'),\n MVLegendClass('polygon', '20', fill='rgba(189,88,154,0.7)'),\n MVLegendClass('polygon', '30', fill='rgba(189,115,144,0.7)'),\n MVLegendClass('polygon', '39', fill='rgba(195,142,150,0.7)'),\n MVLegendClass('polygon', '79', fill='rgba(179,158,153,0.7)')],\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # Coloado CDSS snowpack data (requires token --- expires)\n snodas_cdss = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.colorado.gov/oit/rest/services/DNR_CWCB/SNODAS/MapServer',\n 'params': {'LAYERS': 'show:0','TOKEN':'4HhtbZGoUS6eXs7G93BmoyFjDnjQNfNC_pWr3N-FbLI.'}},\n legend_title='SNODAS Mean',\n layer_options={'visible':False,'opacity':0.5},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # testing homemand kml image dispaly for SNODAS % daily median SWE (kml not working - kmz contains png with data??) \n snodas_kml_med = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/20180322_multyear_perc_med.kmz'},\n layer_options={'visible':False,'opacity':0.5},\n legend_title='SNODAS SWE % of Median',\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # Define map view options\n drought_prec_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'FullScreen', 'ScaleLine', 'WMSLegend',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\n layers=[tiger_boundaries,snodas_swe,precip30,nexrad,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_prec_map_view_options':drought_prec_map_view_options,\n }\n\n return render(request, 'co_drought/drought_prec.html', context)","def drawValidationNeedles(self): \n #productive #onButton\n profprint()\n # reset report table\n # print \"Draw manually segmented needles...\"\n #self.table =None\n #self.row=0\n self.initTableView()\n self.deleteEvaluationNeedlesFromTable()\n while slicer.util.getNodes('manual-seg*') != {}:\n nodes = slicer.util.getNodes('manual-seg*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)\n \n if self.tableValueCtrPt==[[]]:\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\n nbNode=modelNodes.GetNumberOfItems()\n for nthNode in range(nbNode):\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\n if modelNode.GetAttribute(\"ValidationNeedle\") == \"1\":\n needleNumber = int(modelNode.GetAttribute(\"NeedleNumber\"))\n needleStep = int(modelNode.GetAttribute(\"NeedleStep\"))\n coord=[0,0,0]\n modelNode.GetFiducialCoordinates(coord)\n self.tableValueCtrPt[needleNumber][needleStep]=coord\n print needleNumber,needleStep,coord\n # print self.tableValueCtrPt[needleNumber][needleStep]\n\n for i in range(len(self.tableValueCtrPt)):\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\n colorVar = random.randrange(50,100,1)/float(100)\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\n self.addNeedleToScene(controlPoints,i,'Validation')\n else:\n # print i\n pass","def drawObturatorNeedles(self):\n #productive\n profprint()\n widget = slicer.modules.NeedleFinderWidget\n realNeedleLength = widget.realNeedleLength.value\n\n # reset report table\n self.table =None\n self.row=0\n self.initTableView()\n while slicer.util.getNodes('obturator-seg*') != {}:\n nodes = slicer.util.getNodes('obturator-seg*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)\n \n if self.obtuNeedleValueCtrPt==[[[]]]:\n self.obtuNeedleValueCtrPt = [[[999,999,999] for i in range(10)] for j in range(10)]\n if self.obtuNeedlePt==[[[]]]:\n self.obtuNeedlePt = [[[999,999,999] for i in range(10)] for j in range(10)]\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\n nbNode=modelNodes.GetNumberOfItems()\n for nthNode in range(nbNode):\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\n if modelNode.GetAttribute(\"ObturatorNeedle\") == \"1\":\n needleNumber = int(modelNode.GetAttribute(\"NeedleNumber\"))\n needleStep = int(modelNode.GetAttribute(\"NeedleStep\"))\n coord=[0,0,0]\n modelNode.GetFiducialCoordinates(coord)\n if needleNumber==0:\n self.obtuNeedleValueCtrPt[needleNumber][needleStep]=coord\n \n for i in range(0,len(self.obtuNeedleValueCtrPt)):\n\n sign = cmp(self.obtuNeedleValueCtrPt[0][0][2],self.obtuNeedleValueCtrPt[0][1][2])\n if (i==0 and sign <=-1 ):\n AA = self.obtuNeedleValueCtrPt[0][0][2]\n BB = self.obtuNeedleValueCtrPt[0][1][2]\n self.obtuNeedleValueCtrPt[0][0][2] = BB\n self.obtuNeedleValueCtrPt[0][1][2] = AA\n\n # As we give the tip of the obturator needles, we only want to g in the increasing z direction.\n\n Vx = self.obtuNeedleValueCtrPt[0][1][0] - self.obtuNeedleValueCtrPt[0][0][0]\n Vy = self.obtuNeedleValueCtrPt[0][1][1] - self.obtuNeedleValueCtrPt[0][0][1]\n Vz = self.obtuNeedleValueCtrPt[0][1][2] - self.obtuNeedleValueCtrPt[0][0][2]\n\n L= float(Vx**2 + Vy**2 + Vz**2)**0.5\n\n E = self.obtuNeedleValueCtrPt[i][0]\n Ex = E[0] + realNeedleLength*Vx/L\n Ey = E[1] + realNeedleLength*Vy/L\n Ez = E[2] + realNeedleLength*Vz/L\n self.obtuNeedlePt[i][1] = [Ex,Ey,Ez]\n self.obtuNeedlePt[i][0] = [E[0],E[1],E[2]]\n #print needleNumber,needleStep,coord\n\n for i in range(len(self.obtuNeedlePt)):\n if self.obtuNeedlePt[i][0][0]!=999:\n colorVar = random.randrange(50,100,1)/(100)\n controlPointsUnsorted = [val for val in self.obtuNeedlePt[i] if val !=[999,999,999]]\n controlPoints=controlPointsUnsorted\n #controlPoins = self.obtuNeedlePt[i]\n if ((i==0 and len(controlPoints)>=1) or i>=1) :\n self.addNeedleToScene(controlPoints,i,'Obturator')","def genGrid(nTot,gDict):\n \n # Generate nTot-by-8 array, and dump to disk.\n grid = np.empty([nTot,8])\n \n # Initialize Simulation ID (SID) to keep track of the number of propagations.\n SID = 1\n\n # The grid array is filled in the order: MA, AOP, RAAN, INC, ECC, SMA, MJD.\n \n # Get deltas\n for key in gDict:\n if gDict[key]['points'] > 1:\n gDict[key]['delta'] = (gDict[key]['end'] - gDict[key]['start']) / (gDict[key]['points'] - 1)\n else:\n gDict[key]['delta'] = 0.\n \n # Here's the Big Nested Loop.\n for i0 in range(0, gDict['MJD']['points']):\n MJD = gDict['MJD']['start'] + i0 * gDict['MJD']['delta']\n\n for i1 in range(0, gDict['SMA']['points']):\n SMA = gDict['SMA']['start'] + i1 * gDict['SMA']['delta']\n\n for i2 in range(0, gDict['ECC']['points']):\n ECC = gDict['ECC']['start'] + i2 * gDict['ECC']['delta']\n\n for i3 in range(0, gDict['INC']['points']):\n INC = gDict['INC']['start'] + i3 * gDict['INC']['delta']\n\n for i4 in range(0, gDict['RAAN']['points']):\n RAAN = gDict['RAAN']['start'] + i4 * gDict['RAAN']['delta']\n\n for i5 in range(0, gDict['AOP']['points']):\n AOP = gDict['AOP']['start'] + i5 * gDict['AOP']['delta']\n\n for i6 in range(0, gDict['MA']['points']):\n MA = gDict['MA']['start'] + i6 * gDict['MA']['delta']\n \n grid[SID - 1,:] = [SID,MJD,SMA,ECC,INC,RAAN,AOP,MA]\n SID = SID + 1\n\n return grid","def __init__(self, \n nd = 2, \n goal = np.array([1.0,1.0]),\n state_bound = [[0,1],[0,1]],\n nA = 4,\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\n<<<<<<< HEAD:archive-code/puddleworld.py\n ngrid = [10.0,10.0],\n maxStep = 40):\n ngrid = [40, 40]\n x_vec = np.linspace(0,1,ngrid[0])\n y_vec = np.linspace(0,1,ngrid[1])\n for x in x_vec:\n for y in y_vec:\n if ~self.inPuddle([x,y]):\n puddle.append([x,y])\n # puddle is a closed loop \n outpuddlepts = np.asarray(puddle)\n \"\"\"\n\n\n # Horizontal wing of puddle consists of \n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\n # (xchi,ychi) is the center points (h ==> horizantal)\n # x, y = state[0], state[1]\n xch1, ych1 = 0.3, 0.7\n xch2, ych2 = 0.65, ych1\n radius = 0.1\n\n\n #Vertical wing of puddle consists of \n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\n # where (xcvi,ycvi) is the center points (v ==> vertical)\n xcv1 = 0.45; ycv1=0.4;\n xcv2 = xcv1; ycv2 = 0.8;\n\n # % 2) two half-circle at end edges of rectangle\n \n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n puddle.append([xcv1-radius,ych1-radius])\n \n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n \n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n \n puddle.append([xcv1-radius,ych1+radius])\n\n\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1-radius,y])\n \n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1+radius,y])\n \"\"\"\n for y in np.arrange():\n puddle.append([])\n \n for y in np.arrange():\n puddle.append([])\n \"\"\"\n\n # HALF CIRCLES\n ngridTheta = 10\n thetaVec = np.linspace(0,pi,ngridTheta)\n\n for t in thetaVec:\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\n\n for t in thetaVec:\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\n\n \n outpuddlepts = np.asarray(puddle)\n return outpuddlepts","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if rooms==[]: return\n xcord=len(rooms)\n ycord=len(rooms[0])\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\n gatenum=1\n while indexstack != []:\n newindex=[]\n for item in indexstack:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=gatenum\n newindex.append((xpoint,ypoint))\n indexstack=newindex\n gatenum+=1\n ''''\n for item in index_0:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=1\n index_1.append((xpoint,ypoint))\n for item in index_1:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=2\n index_2.append((xpoint,ypoint))\n for item in index_2:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=3\n index_3.append((xpoint,ypoint))\n for item in index_3:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=4\n #index_3.append((xpoint,ypoint))'''","def get_problem():\n\n #User Defined Terrain Elevation\n #def terr( x_pos, y_pos ):\n #Defines terrain elevation [m] as a function of x and y positions [m]\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\n # return elev\n\n #User Defined Tunnel Cost\n #def tunnel(depth):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #depth below the ground.\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\n # return TunnelCost\n\n #def bridge(height):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #heigh above the ground.\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\n # return BridgeCost\n\n # Rename this and/or move to optim package?\n problem = beluga.optim.Problem('surftest_noinc')\n\n #Define independent variables\n problem.independent('t', 's')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','m') \\\n .state('y','V*sin(hdg)','m') \\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\n .state('hdg','cmax/V*sin(hdgA)','rad')\n\n # Define controls\n #problem.control('thrA','rad') \\\n # .control('hdgA','rad')\n problem.control('hdgA','rad')\n\n # Define Cost Functional\n problem.cost['path'] = Expression('1','s')\n\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\n\n #+ \\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\n\n #Define constraints\n problem.constraints().initial('x-x_0','m') \\\n .initial('y-y_0','m') \\\n .initial('V-V_0','m/s') \\\n .initial('hdg-hdg_0','rad') \\\n .terminal('x-x_f','m') \\\n .terminal('y-y_f','m')\n #.terminal('V-V_f','m/s')\n #.initial('hdg-hdg_0','rad') \\\n\n #Define constants\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\n problem.constant('eps',10,'m/s^2') #Error constant\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\n problem.constant('thrA',0,'rad')\n\n #Unit scaling\n problem.scale.unit('m','x') \\\n .unit('s','x/V') \\\n .unit('rad',1) \\\n .unit('USD',1)\n\n #Configure solver\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\n\n #Initial Guess\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\n\n #Add Continuation Steps\n problem.steps.add_step().num_cases(10) \\\n .terminal('x', 10) \\\n .terminal('y', 0)\n\n problem.steps.add_step().num_cases(10) \\\n .const('eps', 0.2)\n\n #problem.steps.add_step().num_cases(10) \\\n # .terminal('y', 2*pi*1000) \\\n # .terminal('z', 0.0) \\\n # .terminal('inc', 0.0)\n #^ City B\n return problem","def climb_tree():\n global UP_TREE\n westdesc = \"\"\n eastdesc = \"\"\n northdesc = \"\"\n southdesc = \"\"\n UP_TREE = True\n westinvalid = False\n eastinvalid = False\n northinvalid = False\n southinvalid = False\n\n\n printmessage(\"You climb the large tree to get a look at your surroundings.\", 5, MAGENTA, 2)\n\n if ZERO_BASE_PLYR_POS in range(0, 10):\n northinvalid = True\n if ZERO_BASE_PLYR_POS in range(90, 100):\n southinvalid = True\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\n eastinvalid = True\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\n westinvalid = True\n \n if not westinvalid: \n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\n if HAS_COMPASS: \n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \"Y\"\n if westpos == 10: # Water\n westdesc = TREE_VIEWS[2]\n else:\n westdesc = TREE_VIEWS[1]\n\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\n if westpos == 1:\n westdesc = TREE_VIEWS[3]\n elif westpos == 2:\n westdesc = TREE_VIEWS[4]\n else:\n westdesc = TREE_VIEWS[5]\n\n if not eastinvalid:\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \"Y\"\n if eastpos == 10: # Water\n eastdesc = TREE_VIEWS[2]\n else:\n eastdesc = TREE_VIEWS[1]\n\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\n if eastpos == 1:\n eastdesc = TREE_VIEWS[3]\n elif eastpos == 2:\n eastdesc = TREE_VIEWS[4]\n else:\n eastdesc = TREE_VIEWS[6]\n\n\n if not northinvalid:\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \"Y\"\n if northpos == 10: # Water\n northdesc = TREE_VIEWS[2]\n else:\n northdesc = TREE_VIEWS[1]\n\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\n if northpos == 1: # bear\n northdesc = TREE_VIEWS[3]\n elif northpos == 2: # grizzly\n northdesc = TREE_VIEWS[4]\n else:\n northdesc = TREE_VIEWS[7]\n\n\n if not southinvalid:\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \"Y\"\n if southpos == 10: # Water\n southdesc = TREE_VIEWS[2]\n else:\n southdesc = TREE_VIEWS[1]\n\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\n if southpos == 1: # bear\n southdesc = TREE_VIEWS[3]\n elif southpos == 2: # grizzly\n southdesc = TREE_VIEWS[4]\n else:\n southdesc = TREE_VIEWS[8]\n\n clear_messages(0)\n printmessage(\"West: \" + westdesc, 2, GREEN, 0)\n printmessage(\"East: \" + eastdesc, 3, YELLOW, 0)\n printmessage(\"North: \" + northdesc, 4, CYAN, 0)\n printmessage(\"South: \" + southdesc, 5, MAGENTA, 0)\n #show_movement(True, 10)\n update_player_on_map()\n pause_for_keypress()\n clear_messages(0)","def new_bragg(cls,\n DESCRIPTOR=\"Graphite\",\n H_MILLER_INDEX=0,\n K_MILLER_INDEX=0,\n L_MILLER_INDEX=2,\n TEMPERATURE_FACTOR=1.0,\n E_MIN=5000.0,\n E_MAX=15000.0,\n E_STEP=100.0,\n SHADOW_FILE=\"bragg.dat\"):\n # retrieve physical constants needed\n codata = scipy.constants.codata.physical_constants\n codata_e2_mc2, tmp1, tmp2 = codata[\"classical electron radius\"]\n # or, hard-code them\n # In [179]: print(\"codata_e2_mc2 = %20.11e \\n\" % codata_e2_mc2 )\n # codata_e2_mc2 = 2.81794032500e-15\n\n fileout = SHADOW_FILE\n descriptor = DESCRIPTOR\n\n hh = int(H_MILLER_INDEX)\n kk = int(K_MILLER_INDEX)\n ll = int(L_MILLER_INDEX)\n\n temper = float(TEMPERATURE_FACTOR)\n\n emin = float(E_MIN)\n emax = float(E_MAX)\n estep = float(E_STEP)\n\n #\n # end input section, start calculations\n #\n\n f = open(fileout, 'wt')\n\n cryst = xraylib.Crystal_GetCrystal(descriptor)\n volume = cryst['volume']\n\n #test crystal data - not needed\n itest = 1\n if itest:\n if (cryst == None):\n sys.exit(1)\n print (\" Unit cell dimensions are %f %f %f\" % (cryst['a'],cryst['b'],cryst['c']))\n print (\" Unit cell angles are %f %f %f\" % (cryst['alpha'],cryst['beta'],cryst['gamma']))\n print (\" Unit cell volume is %f A^3\" % volume )\n print (\" Atoms at:\")\n print (\" Z fraction X Y Z\")\n for i in range(cryst['n_atom']):\n atom = cryst['atom'][i]\n print (\" %3i %f %f %f %f\" % (atom['Zatom'], atom['fraction'], atom['x'], atom['y'], atom['z']) )\n print (\" \")\n\n volume = volume*1e-8*1e-8*1e-8 # in cm^3\n #flag Graphite Struecture\n f.write( \"%i \" % 5)\n #1/V*electronRadius\n f.write( \"%e \" % ((1e0/volume)*(codata_e2_mc2*1e2)) )\n #dspacing\n dspacing = xraylib.Crystal_dSpacing(cryst, hh, kk, ll)\n f.write( \"%e \" % (dspacing*1e-8) )\n f.write( \"\\n\")\n #Z's\n atom = cryst['atom']\n f.write( \"%i \" % atom[0][\"Zatom\"] )\n f.write( \"%i \" % -1 )\n f.write( \"%e \" % temper ) # temperature parameter\n f.write( \"\\n\")\n\n ga = (1e0+0j) + cmath.exp(1j*cmath.pi*(hh+kk)) \\\n + cmath.exp(1j*cmath.pi*(hh+ll)) \\\n + cmath.exp(1j*cmath.pi*(kk+ll))\n # gb = ga * cmath.exp(1j*cmath.pi*0.5*(hh+kk+ll))\n ga_bar = ga.conjugate()\n # gb_bar = gb.conjugate()\n\n\n f.write( \"(%20.11e,%20.11e ) \\n\" % (ga.real, ga.imag) )\n f.write( \"(%20.11e,%20.11e ) \\n\" % (ga_bar.real, ga_bar.imag) )\n f.write( \"(%20.11e,%20.11e ) \\n\" % (0.0, 0.0) )\n f.write( \"(%20.11e,%20.11e ) \\n\" % (0.0, 0.0) )\n\n zetas = [atom[0][\"Zatom\"]]\n for zeta in zetas:\n xx01 = 1e0/2e0/dspacing\n xx00 = xx01-0.1\n xx02 = xx01+0.1\n yy00= xraylib.FF_Rayl(int(zeta),xx00)\n yy01= xraylib.FF_Rayl(int(zeta),xx01)\n yy02= xraylib.FF_Rayl(int(zeta),xx02)\n xx = numpy.array([xx00,xx01,xx02])\n yy = numpy.array([yy00,yy01,yy02])\n fit = numpy.polyfit(xx,yy,2)\n #print \"zeta: \",zeta\n #print \"z,xx,YY: \",zeta,xx,yy\n #print \"fit: \",fit[::-1] # reversed coeffs\n #print \"fit-tuple: \",(tuple(fit[::-1].tolist())) # reversed coeffs\n #print(\"fit-tuple: %e %e %e \\n\" % (tuple(fit[::-1].tolist())) ) # reversed coeffs\n f.write(\"%e %e %e \\n\" % (tuple(fit[::-1].tolist())) ) # reversed coeffs\n\n f.write(\"%e %e %e \\n\" % (0.0, 0.0, 0.0)) # reversed coeffs\n\n\n npoint = int( (emax - emin)/estep + 1 )\n f.write( (\"%i \\n\") % npoint)\n for i in range(npoint):\n energy = (emin+estep*i)\n f1a = xraylib.Fi(int(zetas[0]),energy*1e-3)\n f2a = xraylib.Fii(int(zetas[0]),energy*1e-3)\n # f1b = xraylib.Fi(int(zetas[1]),energy*1e-3)\n # f2b = xraylib.Fii(int(zetas[1]),energy*1e-3)\n out = numpy.array([energy,f1a,abs(f2a),1.0, 0.0])\n f.write( (\"%20.11e %20.11e %20.11e \\n %20.11e %20.11e \\n\") % ( tuple(out.tolist()) ) )\n\n f.close()\n print(\"File written to disk: %s\" % fileout)","def robotGridSummaryDict(self):\n rgd = self.robotGridDict(incRobotDict=False)\n robotDict = {}\n for rid, robot in self.robotDict.items():\n r = {}\n # print(\"rid\", robot.id, robot.alpha, robot.beta)\n r[\"id\"] = robot.id\n r[\"nDecollide\"] = robot.nDecollide\n r[\"lastStepNum\"] = robot.lastStepNum\n r[\"assignedTargetID\"] = robot.assignedTargetID\n r[\"hasApogee\"] = robot.hasApogee\n r[\"hasBoss\"] = robot.hasBoss\n r[\"xPos\"] = robot.xPos\n r[\"yPos\"] = robot.yPos\n r[\"alpha\"] = robot.alpha\n r[\"beta\"] = robot.beta\n r[\"destinationAlpha\"] = robot.destinationAlpha\n r[\"desstinationBeta\"] = robot.destinationBeta\n r[\"angStep\"] = robot.angStep\n r[\"collisionBuffer\"] = robot.collisionBuffer\n\n # convert from numpy arrays to lists\n r[\"metFiberPos\"] = list(robot.metFiberPos)\n r[\"bossFiberPos\"] = list(robot.bossFiberPos)\n r[\"apFiberPos\"] = list(robot.apFiberPos)\n r[\"roughAlphaX\"] = robot.roughAlphaX[-1][-1]\n r[\"roughAlphaY\"] = robot.roughAlphaY[-1][-1]\n r[\"roughBetaX\"] = robot.roughBetaX[-1][-1]\n r[\"roughBetaY\"] = robot.roughBetaY[-1][-1]\n # find the step at which this\n # guy found its target\n # otv = np.array(robot.onTargetVec)\n # print(\"otargvec\", otv)\n # r[\"onTargetVec\"] = robot.onTargetVec[-1]\n # # find last False (after which must be true)\n # # +1 because step numbers start from 1 and indices start from 0\n # whereFalse = np.argwhere(otv==False).flatten()\n # if not whereFalse:\n # # empty list started on target? thats crazy\n # lastFalse = 0\n # else:\n # lastFalse = int(whereFalse[-1] + 1)\n # if lastFalse == len(otv):\n # # last step was false robot never got there\n # r[\"stepConverged\"] = str(-1 )# -1 incicates never got to target\n # else:\n # r[\"stepConverged\"] = str(lastFalse)\n robotDict[robot.id] = r\n\n rgd[\"robotDict\"] = robotDict\n return rgd","def casdetude_genetics():\n file_path = PROJECT_PATH + \"/geographycal_data/Monterusciello/MontEdo_buildings\"\n router = Router(building_file=file_path)\n\n router.design_aqueduct(0)\n\n router.write2epanet(router.acqueduct, PROJECT_PATH + \"/Monterusciello_solution/Monterusciello_acqueduct\",\n diam=False)\n\n read_epanet = graphIO.graph_reader(router.acqueduct)\n read_epanet.read_epanet(PROJECT_PATH + \"/geographycal_data/SolvedNet/MonteSolution\")\n kpi_calculator(router.acqueduct)\n\n minimal = router.design_minimal_aqueduct(router.acqueduct, \"Q*H\")\n router.write2epanet(minimal, PROJECT_PATH + \"/Monterusciello_solution/Monterusciello_acqueduct\", diam=False)","def generate_maze(self):\r\n # reset the grid before generation\r\n self.initialize_grid()\r\n\r\n # choose the first cell to put in the visited list\r\n # see Step 1 of the algorithm.\r\n current = self.unvisited.pop(random.randint(0,len(self.unvisited)-1))\r\n self.visited.append(current)\r\n self.cut(current)\r\n\r\n # loop until all cells have been visited\r\n while len(self.unvisited) > 0:\r\n # choose a random cell to start the walk (Step 2)\r\n first = self.unvisited[random.randint(0,len(self.unvisited)-1)]\r\n current = first\r\n # loop until the random walk reaches a visited cell\r\n while True:\r\n # choose direction to walk (Step 3)\r\n dirNum = random.randint(0,3)\r\n # check if direction is valid. If not, choose new direction\r\n while not self.is_valid_direction(current,dirNum):\r\n dirNum = random.randint(0,3)\r\n # save the cell and direction in the path\r\n self.path[current] = dirNum\r\n # get the next cell in that direction\r\n current = self.get_next_cell(current,dirNum,2)\r\n if (current in self.visited): # visited cell is reached (Step 5)\r\n break\r\n\r\n current = first # go to start of path\r\n # loop until the end of path is reached\r\n while True:\r\n # add cell to visited and cut into the maze\r\n self.visited.append(current)\r\n self.unvisited.remove(current) # (Step 6.b)\r\n self.cut(current)\r\n\r\n # follow the direction to next cell (Step 6.a)\r\n dirNum = self.path[current]\r\n crossed = self.get_next_cell(current,dirNum,1)\r\n self.cut(crossed) # cut crossed edge\r\n\r\n current = self.get_next_cell(current,dirNum,2)\r\n if (current in self.visited): # end of path is reached\r\n self.path = dict() # clear the path\r\n break\r\n \r\n self.generated = True","def drought_index_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.8},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n\n # NCDC Climate Divisions\n climo_divs = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\n 'params': {'LAYERS': 'show:1'}},\n legend_title='Climate Divisions',\n layer_options={'visible':False,'opacity':0.8},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n ##### WMS Layers - Ryan\n usdm_legend = MVLegendImageClass(value='Drought Category',\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\n usdm_current = MVLayer(\n source='ImageWMS',\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\n layer_options={'visible':False,'opacity':0.3},\n legend_title='USDM',\n legend_classes=[usdm_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n usdm_kml = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/usdm_current.kml'},\n layer_options={'visible':True,'opacity':0.5},\n legend_title='USDM',\n feature_selection=False,\n legend_classes=[usdm_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # ESI Data from USDA\n esi_1 = MVLayer(\n source='ImageWMS',\n options={'url': 'https://hrsl.ba.ars.usda.gov/wms.esi.2012?',\n 'params': {'LAYERS': 'ESI_current_1month', 'VERSION':'1.1.3', 'CRS':'EPSG:4326'}},\n layer_options={'visible':False,'opacity':0.5},\n legend_title='ESI - 1 month',\n legend_extent=[-126, 24.5, -66.2, 49])\n\n # Define SWSI KML Layer\n swsi_legend = MVLegendImageClass(value='',\n image_url='/static/tethys_gizmos/data/swsi_legend.PNG')\n SWSI_kml = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/SWSI_2018Current.kml'},\n legend_title='SWSI',\n layer_options={'visible':True,'opacity':0.7},\n feature_selection=True,\n legend_classes=[swsi_legend],\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\n \n # NCDC/NIDIS precip index\n ncdc_pindex = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:1'}},\n legend_title='Precipitation Index',\n layer_options={'visible':False,'opacity':0.7},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # NCDC/NIDIS palmer drought severity index\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\n ncdc_pdsi = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:2','layerDefs':'{\"2\":\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\"}'}},\n legend_title='PDSI',\n layer_options={'visible':False,'opacity':0.7},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # NCDC/NIDIS palmer drought severity index\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\n ncdc_palmz = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:8','layerDefs':'{\"8\":\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\"}'}},\n legend_title='Palmer Z',\n layer_options={'visible':False,'opacity':0.7},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # NCDC/NIDIS standardized precip index\n ncdc_spi_1 = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:11','layerDefs':'{\"11\":\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\"}'}},\n legend_title='SPI (1-month)',\n layer_options={'visible':False,'opacity':0.6},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # NCDC/NIDIS standardized precip index\n ncdc_spi_3 = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:13','layerDefs':'{\"13\":\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\"}'}},\n legend_title='SPI (3-month)',\n layer_options={'visible':False,'opacity':0.6},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # NCDC/NIDIS standardized precip index\n ncdc_spi_6 = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\n 'params': {'LAYERS': 'show:14','layerDefs':'{\"14\":\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\"}'}},\n legend_title='SPI (6-month)',\n layer_options={'visible':False,'opacity':0.6},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n \n # Define map view options\n drought_index_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\n layers=[tiger_boundaries,climo_divs,ncdc_pdsi,ncdc_palmz,ncdc_spi_1,ncdc_spi_3,ncdc_spi_6,SWSI_kml,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_index_map_view_options':drought_index_map_view_options,\n }\n\n return render(request, 'co_drought/drought_index.html', context)","def ShowOneContourBKG(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt):\n \n figname='contourBKG_{}_{}.pdf'.format(all_filt[index],index)\n \n plt.figure(figsize=(15,6))\n spec_index_min=100 # cut the left border\n spec_index_max=1900 # cut the right border\n star_halfwidth=70\n \n YMIN=-100\n YMAX=100\n \n figfilename=os.path.join(dir_top_img,figname) \n \n #center is approximately the one on the original raw image (may be changed)\n #x0=int(all_pointing[index][0])\n x0=int(thex0[index])\n \n \n # Extract the image \n full_image=np.copy(all_images[index])\n \n # refine center in X,Y\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\n \n profile_X=np.sum(star_region_X,axis=0)\n profile_Y=np.sum(star_region_X,axis=1)\n\n NX=profile_X.shape[0]\n NY=profile_Y.shape[0]\n \n X_=np.arange(NX)\n Y_=np.arange(NY)\n \n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\n \n x0=int(avX+x0-star_halfwidth)\n \n \n # find the center in Y on the spectrum\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\n y0=np.where(yprofile==yprofile.max())[0][0]\n\n # cut the image in vertical and normalise by exposition time\n reduc_image=full_image[y0+YMIN:y0+YMAX,x0:spec_index_max]/all_expo[index] \n reduc_image[:,0:100]=0 # erase central star\n \n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\n \n # calibration in wavelength\n #grating_name=all_filt[index].replace('dia ','')\n grating_name=get_disperser_filtname(all_filt[index])\n \n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\n \n #if grating_name=='Ron200':\n # holo = Hologram('Ron400',verbose=True)\n #else: \n # holo = Hologram(grating_name,verbose=True)\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\n #if grating_name=='Ron200':\n # lambdas=lambdas*2.\n \n\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \n T=np.transpose(reduc_image)\n \n \n cs=plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\n #C = plt.contour(X, Y, reduc_image ,10, colors='white', linewidth=.01,origin='lower')\n \n cbar = plt.colorbar(cs) \n \n for line in LINES:\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\n plt.text(line['lambda'],YMAX*0.8,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\n \n \n \n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\n plt.title(all_titles[index])\n plt.grid(color='white', ls='solid')\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\n plt.xlabel('$\\lambda$ (nm)')\n plt.ylabel('pixels')\n plt.ylim(YMIN,YMAX)\n plt.xlim(0.,1200.)\n plt.savefig(figfilename)","def challenge2(self):\n # Let's try an octree-type approach\n # For each grid cube we should be able to find whether a nanobot:\n # 1) is not in range (is outside grid cube and not in range of nearest face)\n # 2) is in range of whole cube (all 8 corners are in range)\n # 3) is in range of part of the cube (i.e. not 1 or 2)\n # Root node: figure out extent of whole space\n mins = []\n maxs = []\n for axis in range(3):\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n\n for count in range(len(self.nanobots), 0, -1):\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\n if results and results[0].count >= count:\n break\n\n print(f\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\")\n\n # Find result coord closest to origin\n closest_dist = np.iinfo(np.int32).max\n best_coord = None\n for result in results:\n for corner in itertools.product(*zip(result.mins, result.maxs)):\n d = manhattan_dist(corner, (0, 0, 0))\n if d < closest_dist:\n closest_dist = d\n best_coord = corner\n\n print(f\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\")","def __init__(self,start,goal,theta_s,clearance,radius,rpm1,rpm2):\r\n #clearance = 5\r\n #radius = 10\r\n self.padding = clearance + radius\r\n self.ground_truth={}\r\n\r\n self.obstacle=[]\r\n self.rpm1=rpm1\r\n self.rpm2=rpm2\r\n self.expanded=[]\r\n\r\n self.parent=[]\r\n self.parent_orignal_data={}\r\n \r\n self.start=start\r\n #print(self.start)\r\n self.theta=theta_s\r\n self.theta_diff=30\r\n self.n=int(self.theta)\r\n self.frontier={}\r\n self.frontier[self.start[0],self.start[1],self.n]=0\r\n self.start_score=self.string(self.start[0],self.start[1],self.n)\r\n self.frontier_string=[]\r\n self.cost_togo={}\r\n self.cost_togo[self.start_score,self.n]=0\r\n self.parent_orignal_data[self.start_score]=None\r\n self.cost={}\r\n #self.cost=0\r\n self.goal=goal\r\n self.cost[self.start_score,self.n]=self.cost_togo[self.start_score,self.n]+self.h(self.start[0],self.start[1],self.theta)\r\n #self.cost[self.start_score,self.n]=self.cost_togo[self.start_score,self.n]+self.h(self.start[0],self.start[1])\r\n self.data_with_string={}\r\n self.data_with_string[self.start_score]=self.start\r\n self.current_score=\"00\"\r\n self.i=1\r\n self.theta_diff=30\r\n #self.cost={}\r\n #self.cost[self.start_score]=0\r\n self.dt=0.2\r\n self.threshold=1\r\n self.maximum_size=999\r\n self.parent_pos=(self.start[1],self.maximum_size-self.start[0])\r\n self.image_p=np.zeros([int(floor((self.maximum_size+1))),int(floor((self.maximum_size+1))),(360)])\r\n self.action_rpm=[[0,rpm1],[rpm1,0],[rpm1,rpm1],[0,rpm2],[rpm2,0],[rpm2,rpm2],[rpm1,rpm2],[rpm2,rpm1]]\r\n self.action_index={}","def magnetic_reynolds(uu, param, grid, aa=list(), bb=list(), jj=list(),\n nghost=3, lmix=True):\n if len(bb) ==0 and len(aa) ==0 and len(jj) ==0:\n print('magnetic_reynolds WARNING: no aa, bb nor jj provided\\n'+\n 'aa or bb must be provided or aa for only hyper resistivity') \n #resistive force\n lres, lhyper3 = False, False\n for iresi in param.iresistivity:\n iresi = str.strip(iresi,'\\n')\n if 'hyper' not in iresi and len(iresi) > 0:\n lres = True\n if 'hyper3' in iresi:\n lhyper3 = True\n fresi = np.zeros_like(uu)\n if lres:\n if lhyper3:\n lhyper3 = lhyper3==lmix\n if len(jj) == 0:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: calculating jj without aa\\n',\n 'provide aa or jj directly for accurate boundary values')\n jj = curl(bb,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n else:\n jj = curl2(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n for j in range(0,3):\n jj[j, :nghost,:,:] = jj[j,-2*nghost:-nghost,:,:]\n jj[j,-nghost:,:,:] = jj[j, nghost: 2*nghost,:,:]\n jj[j,:, :nghost,:] = jj[j,:,-2*nghost:-nghost,:]\n jj[j,:,-nghost:,:] = jj[j,:, nghost: 2*nghost,:]\n jj[j,:,:, :nghost] = jj[j,:,:,-2*nghost:-nghost]\n jj[j,:,:,-nghost:] = jj[j,:,:, nghost: 2*nghost]\n fresi = fresi + param.eta*param.mu0*jj\n for iresi in param.iresistivity:\n iresi = str.strip(iresi,'\\n')\n if 'eta-const' not in iresi and 'hyper' not in iresi\\\n and len(iresi) > 0:\n print('magnetic_reynolds WARNING: '+iresi+' not implemented\\n'+\n 'terms may be missing from the standard resistive forces')\n if lhyper3:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: no aa provided\\n'+\n 'aa must be provided for hyper resistivity')\n return 1\n else:\n del6a = np.zeros_like(aa)\n for j in range(0,3):\n del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz)\n del6a[j, :nghost,:,:] = del6a[j,-2*nghost:-nghost,:,:]\n del6a[j,-nghost:,:,:] = del6a[j, nghost: 2*nghost,:,:]\n del6a[j,:, :nghost,:] = del6a[j,:,-2*nghost:-nghost,:]\n del6a[j,:,-nghost:,:] = del6a[j,:, nghost: 2*nghost,:]\n del6a[j,:,:, :nghost] = del6a[j,:,:,-2*nghost:-nghost]\n del6a[j,:,:,-nghost:] = del6a[j,:,:, nghost: 2*nghost]\n #del6 for non-cartesian tba\n #del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y,\n # coordinate_system=param.coord_system)\n #effective at l > 5 grid.dx? \n fresi = fresi + param.eta_hyper3*del6a\n del(del6a)\n fresi2 = np.sqrt(dot2(fresi))\n del(fresi)\n #advective force\n if len(bb) == 0:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: calculating uu x bb without bb\\n',\n 'provide aa or bb directly to proceed')\n return 1\n else:\n bb = curl(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n for j in range(0,3):\n bb[j, :nghost,:,:] = bb[j,-2*nghost:-nghost,:,:]\n bb[j,-nghost:,:,:] = bb[j, nghost: 2*nghost,:,:]\n bb[j,:, :nghost,:] = bb[j,:,-2*nghost:-nghost,:]\n bb[j,:,-nghost:,:] = bb[j,:, nghost: 2*nghost,:]\n bb[j,:,:, :nghost] = bb[j,:,:,-2*nghost:-nghost]\n bb[j,:,:,-nghost:] = bb[j,:,:, nghost: 2*nghost]\n advec = cross(uu,bb)\n advec2 = np.sqrt(dot2(advec))\n del(advec)\n #avoid division by zero\n if fresi2.max() > 0:\n fresi2[np.where(fresi2==0)] = fresi2[np.where(fresi2>0)].min()\n Rm = advec2/fresi2\n #set minimum floor to exclude zero-valued Rm \n if Rm.max() > 0:\n Rm[np.where(Rm==0)] = Rm[np.where(Rm>0)].min()\n else:\n print('Rm undefined')\n else:\n Rm = advec2\n print('Rm undefined')\n return Rm","def do_stuff(self):\n self.create_tourism_raster()","def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\r\n \r\n nI_agg = len(list(set(indices['ind'][agg_level])))\r\n nP_agg = len(list(set(indices['prod'][agg_level])))\r\n nW_agg = len(list(set(indices['vadd'][agg_level])))\r\n nM_agg = len(list(set(indices['imp'][agg_level])))\r\n nY_agg = len(list(set(indices['fd'][agg_level])))\r\n nR_agg = len(list(set(indices['exog'][agg_level])))\r\n\r\n nI_rcot = len(list(set(indices['ind'][rect_level])))\r\n nP_rcot = len(list(set(indices['prod'][rect_level])))\r\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\r\n nM_rcot = len(list(set(indices['imp'][rect_level])))\r\n nY_rcot = len(list(set(indices['fd'][rect_level])))\r\n nR_rcot = len(list(set(indices['exog'][rect_level])))\r\n\r\n \r\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\r\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n \r\n indInd = indices_agg['ind']\r\n prodInd = indices_agg['prod']\r\n vaddInd = indices_agg['vadd']\r\n impInd = indices_agg['imp']\r\n fdInd = indices_agg['fd']\r\n exogInd = indices_agg['exog']\r\n\r\n zInd = prodInd.append(indInd)\r\n zInd = zInd.swaplevel(0,1)\r\n \r\n\r\n for l in range(nL):\r\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\r\n\r\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n ZR_0[l] = Z.values\r\n WR_0[l] = W.values\r\n MR_0[l] = M.values\r\n YR_0[l] = Y.values\r\n \r\n AR_0[l] = A.values\r\n wR_0[l] = w.values\r\n mR_0[l] = m.values\r\n\r\n \r\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n\r\n ML_RCOT_0 = {\r\n 'Z' : ZR_0,\r\n 'W' : WR_0,\r\n 'M' : MR_0,\r\n 'Y' : YR_0,\r\n 'R' : RR_0,\r\n }\r\n\r\n ML_RCOT_coeff_0 = {\r\n 'A' : AR_0,\r\n 'w' : wR_0,\r\n 'm' : mR_0,\r\n 'Y' : YR_0,\r\n 'B' : BR_0,\r\n }\r\n\r\n \r\n indices_RCOT = {\r\n 'prod/ind' : zInd,\r\n 'vadd' : vaddInd,\r\n 'imp' : impInd,\r\n 'fd' : fdInd,\r\n 'exog' : exogInd,\r\n 'headers' : indices['headers']\r\n }\r\n \r\n \r\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)","def __init__(self,height,width): \r\n self.width = 2*(width//2) + 1 # Make width odd\r\n self.height = 2*(height//2) + 1 # Make height odd\r\n\r\n # grid of cells\r\n self.grid = [[0 for j in range(self.width)] for i in range(self.height)]\r\n\r\n # declare instance variable\r\n self.visited = [] # visited cells\r\n self.unvisited = [] # unvisited cells\r\n self.path = dict() # random walk path\r\n\r\n # valid directions in random walk\r\n self.directions = [(0,1),(1,0),(0,-1),(-1,0)]\r\n\r\n # indicates whether a maze is generated\r\n self.generated = False\r\n\r\n # shortest solution\r\n self.solution = []\r\n self.showSolution = False\r\n self.start = (0,0)\r\n self.end = (self.height-1,self.width-1)","def grass_drass():","def update_visualization(self):\n rpos = self.sim.getAgentPosition(self.robot_num)\n rvel = self.sim.getAgentVelocity(self.robot_num)\n rrad = self.sim.getAgentRadius(self.robot_num)\n v_pref = self.sim.getAgentMaxSpeed(self.robot_num)\n theta = math.atan2(rvel[1], rvel[0])\n return_str = \"\"\n return_str += str(self.sim.getGlobalTime()) + \" \"\n return_str += \"(\" + str(rpos[0]) + \",\" + str(rpos[1]) + \") \"\n return_str += \"(\" + str(rvel[0]) + \",\" + str(rvel[1]) + \") \"\n return_str += str(rrad) + \" \"\n return_str += str(self.headings[self.robot_num]) + \" \"\n return_str += (\"(\" + str(self.overall_robot_goal[0])\n + \",\" + str(self.overall_robot_goal[1]) + \") \")\n return_str += str(v_pref) + \" \"\n return_str += str(theta) + \" \"\n if not self.single:\n for agent in self.agents:\n if agent != self.robot_num: # We already wrote out the robot\n pos = self.sim.getAgentPosition(agent)\n vel = self.sim.getAgentVelocity(agent)\n rad = self.sim.getAgentRadius(agent)\n return_str += \"(\" + str(pos[0]) + \",\" + str(pos[1]) + \") \"\n return_str += \"(\" + str(vel[0]) + \",\" + str(vel[1]) + \") \"\n return_str += str(rad) + \" \"\n return_str += str(self.headings[agent]) + \" \"\n for obs in self.obstacles:\n if len(obs) > 1:\n # Polygonal obstacle\n o = Polygon(obs)\n p = Point(rpos)\n p1, p2 = nearest_points(o, p)\n return_str += \"(\" + str(p1.x) + \",\" + str(p1.y) + \") \"\n return_str += \"(0,0) \"\n return_str += str(self.obs_width) + \" \"\n return_str += str(self.headings[self.robot_num]) + \" \"\n else:\n # Point obstacle\n return_str += \\\n \"(\" + str(obs[0][0]) + \",\" +str(obs[0][1]) + \") \"\n return_str += \"(0,0) \"\n return_str += str(self.obs_width) + \" \"\n return_str += str(self.headings[self.robot_num]) + \" \"\n return_str += \"\\n\"\n if self.file is not None:\n self.file.write(return_str)\n return return_str","def test():\n test_map1 = np.array([\n [1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n x_spacing1 = 0.13\n y_spacing1 = 0.2\n start1 = np.array([[0.3], [0.3], [0]])\n goal1 = np.array([[0.6], [1], [0]])\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\n true_path1 = np.array([\n [ 0.3 , 0.3 ],\n [ 0.325, 0.3 ],\n [ 0.325, 0.5 ],\n [ 0.325, 0.7 ],\n [ 0.455, 0.7 ],\n [ 0.455, 0.9 ],\n [ 0.585, 0.9 ],\n [ 0.600, 1.0 ]\n ])\n if np.array_equal(path1,true_path1):\n print(\"Path 1 passes\")\n\n test_map2 = np.array([\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n start2 = np.array([[0.5], [1.0], [1.5707963267948966]])\n goal2 = np.array([[1.1], [0.9], [-1.5707963267948966]])\n x_spacing2 = 0.2\n y_spacing2 = 0.2\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\n true_path2 = np.array([[ 0.5, 1.0],\n [ 0.5, 1.1],\n [ 0.5, 1.3],\n [ 0.5, 1.5],\n [ 0.7, 1.5],\n [ 0.9, 1.5],\n [ 1.1, 1.5],\n [ 1.1, 1.3],\n [ 1.1, 1.1],\n [ 1.1, 0.9]])\n if np.array_equal(path2,true_path2):\n print(\"Path 2 passes\")","def make_montage_sagittal(overlay, underlay, png_name, cbar_name):\n import matplotlib\n import commands\n import os\n import numpy as np\n matplotlib.rcParams.update({'font.size': 5})\n ###\n try:\n from mpl_toolkits.axes_grid1 import ImageGrid\n except:\n from mpl_toolkits.axes_grid import ImageGrid\n import matplotlib.cm as cm\n import matplotlib.pyplot as plt\n import matplotlib.colors as col\n import nibabel as nb\n def determine_start_and_end(data, direction, percent):\n x, y, z = data.shape\n xx1 = 0\n xx2 = x - 1\n zz1 = 0\n zz2 = z - 1\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\n thresh = percent * float(total_non_zero_voxels)\n start = None\n end = None\n if 'axial' in direction:\n while(zz2 > 0):\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\n if float(d) > thresh:\n break\n zz2 -= 1\n while(zz1 < zz2):\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\n if float(d) > thresh:\n break\n zz1 += 1\n start = zz1\n end = zz2\n else:\n while(xx2 > 0):\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx2 -= 1\n while(xx1 < xx2):\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx1 += 1\n start = xx1\n end = xx2\n return start, end\n def get_spacing(across, down, dimension):\n space = 10\n prod = (across*down*space)\n if prod > dimension:\n while(across*down*space) > dimension:\n space -= 1\n else:\n while(across*down*space) < dimension:\n space += 1\n return space\n\n Y = nb.load(underlay).get_data()\n X = nb.load(overlay).get_data()\n X = X.astype(np.float16)\n Y = Y.astype(np.float16)\n\n\n if 'skull_vis' in png_name:\n X[X < 20.0] = 0.0\n if 'skull_vis' in png_name or 't1_edge_on_mean_func_in_t1' in png_name or 'MNI_edge_on_mean_func_mni' in png_name:\n max_ = np.nanmax(np.abs(X.flatten()))\n X[X != 0.0] = max_\n print '^^', np.unique(X)\n\n x1, x2 = determine_start_and_end(Y, 'sagittal', 0.0001)\n spacing = get_spacing(6, 3, x2 - x1)\n x, y, z = Y.shape\n fig = plt.figure(1)\n max_ = np.max(np.abs(Y))\n\n if ('snr' in png_name) or ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\"single\", cbar_pad=0.5, direction=\"row\")\n else:\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\"None\", direction=\"row\")\n\n xx = x1\n for i in range(6*3):\n\n if xx >= x2:\n break\n\n im = grid[i].imshow(np.rot90(Y[xx, :, :]), cmap=cm.Greys_r)\n grid[i].get_xaxis().set_visible(False)\n grid[i].get_yaxis().set_visible(False)\n xx += spacing\n\n x, y, z = X.shape\n X[X == 0.0] = np.nan\n max_ = np.nanmax(np.abs(X.flatten()))\n print '~~', max_\n xx = x1\n for i in range(6*3):\n\n\n if xx >= x2:\n break\n im = None\n if cbar_name is 'red_to_blue':\n\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_) ###\n elif cbar_name is 'green':\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_)\n else:\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=- max_, vmax=max_)\n xx += spacing\n cbar = grid.cbar_axes[0].colorbar(im)\n\n if 'snr' in png_name:\n cbar.ax.set_yticks(drange(0, max_))\n\n elif ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\n cbar.ax.set_yticks(drange(-max_, max_))\n\n\n plt.show()\n plt.axis(\"off\")\n png_name = os.path.join(os.getcwd(), png_name)\n plt.savefig(png_name, dpi=300, bbox_inches='tight')\n plt.close()\n matplotlib.rcdefaults()\n\n return png_name","def drought_rec_risk_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.2},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n ##### WMS Layers - Ryan\n usdm_legend = MVLegendImageClass(value='Drought Category',\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\n usdm_current = MVLayer(\n source='ImageWMS',\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\n layer_options={'visible':False,'opacity':0.25},\n legend_title='USDM',\n legend_classes=[usdm_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\n vuln_legend = MVLegendImageClass(value='Risk Score',\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\n rec_vuln_kml = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/CO_Rec_vuln_score_2018.kml'},\n layer_options={'visible':True,'opacity':0.75},\n legend_title='Recreation Risk Score',\n feature_selection=True,\n legend_classes=[vuln_legend],\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\n \n # Define GeoJSON layer\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\n with open(como_cocorahs) as f:\n data = json.load(f)\n \n # the section below is grouping data by 'scalebar' drought condition\n # this is a work around for displaying each drought report classification with a unique colored icon\n data_sd = {}; data_md ={}; data_ml={}\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\n for element in data['features']:\n if 'Severely Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_sd[u'features'].append(element)\n if 'Moderately Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_md[u'features'].append(element)\n if 'Mildly Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_ml[u'features'].append(element)\n \n cocojson_sevdry = MVLayer(\n source='GeoJSON',\n options=data_sd,\n legend_title='CoCoRaHS Condition Monitor',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_moddry = MVLayer(\n source='GeoJSON',\n options=data_md,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_mildry = MVLayer(\n source='GeoJSON',\n options=data_ml,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n \n # Define map view options\n drought_rec_risk_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,rec_vuln_kml,usdm_current,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_rec_risk_map_view_options':drought_rec_risk_map_view_options,\n }\n\n return render(request, 'co_drought/drought_rec_risk.html', context)","def jacking_calculations(dictionary, view):\n f_list = []\n s_list = []\n corners = ['Left Front', 'Right Front', 'Left Rear', 'Right Rear']\n for corner in corners:\n # Establishing Instant Center Left Front\n ic_direction, ic_point = plane_intersection_line(\n plane_equation(dictionary[corner]['Upper Fore'],\n dictionary[corner]['Upper Aft'],\n dictionary[corner]['Upper Out']),\n plane_equation(dictionary[corner]['Lower Fore'],\n dictionary[corner]['Lower Aft'],\n dictionary[corner]['Lower Out']),\n dictionary[corner]['Upper Fore'],\n dictionary[corner]['Lower Fore'])\n axis = plot_line(ic_direction, ic_point, np.linspace(0, 2, 2))\n # Establishing Side View Instant Center\n ic_xz = three_d_vector_plane_intersection((axis[0][0], axis[1][0], axis[2][0]),\n (axis[0][1], axis[1][1], axis[2][1]),\n dictionary[corner]['Wheel Center'],\n np.add(np.array(dictionary[corner]\n ['Wheel Center']), np.array([1, 0, 0])),\n np.add(np.array(dictionary[corner]\n ['Wheel Center']), np.array([0, 0, 1])))\n # Establishing Front View Instant Center\n ic_yz = three_d_vector_plane_intersection((axis[0][0], axis[1][0], axis[2][0]),\n (axis[0][1], axis[1][1], axis[2][1]),\n dictionary[corner]['Wheel Center'],\n np.add(np.array(dictionary[corner]\n ['Wheel Center']), np.array([0, 1, 0])),\n np.add(np.array(dictionary[corner]\n ['Wheel Center']), np.array([0, 0, 1])))\n # Establishing Jacking Height\n y_val = dictionary['Performance Figures']['Center of Gravity'][1]\n cg_plane_points = [[1, y_val, 1], [-1, y_val, 4], [-3, y_val, 6]]\n wheel_center_ground = [(dictionary[corner]['Wheel Center'][0]),\n (dictionary[corner]['Wheel Center'][1]), 0]\n np.array(wheel_center_ground)\n jacking_height = three_d_vector_plane_intersection(wheel_center_ground,\n ic_yz, cg_plane_points[0], cg_plane_points[1],\n cg_plane_points[2])\n # Establishing Jacking Coefficient\n wc_jh = np.subtract(jacking_height, wheel_center_ground)\n jacking_coeff = -abs(wc_jh[2] / wc_jh[1])\n # Establishing Pitch Coefficient\n wc_icxz = np.subtract(ic_xz, dictionary[corner]['Wheel Center'])\n wc_cg = np.subtract(dictionary['Performance Figures']['Center of Gravity'],\n dictionary[corner]['Wheel Center'])\n pitch_coeff = (wc_icxz[2] / wc_icxz[0]) / (wc_cg[2] / wc_cg[0])\n if view == 'Front':\n f_list.append(jacking_coeff)\n elif view == 'Side':\n s_list.append(pitch_coeff)\n else:\n print 'Wtf, you want an isometric or something?'\n return\n if view == 'Front':\n return f_list\n elif view == 'Side':\n return s_list\n else:\n print 'view does not equal Front or Side'\n return","def main():\n font = {'family' : 'normal',\n 'weight' : 'normal',\n 'size' : 18}\n\n matplotlib.rc('font', **font)\n\n ###Plot overviews\n\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full.png\",\n# show_shells=False,title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n \n plot_overview(plotname=\"../paper/figs/12co_nroonly_peak_full_shells.png\", show_shells=True,\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\n title=r\"\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\n )\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_mom0_cometary.png\",\n # show_shells=False, title=r\"Combined Integrated $^{12}$CO\",\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000,\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(plotname=\"12co_nroonly_mom0_cometary.png\", show_shells=False,\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000, title=r\"NRO Integrated $^{12}$CO\",\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full_shells.png\",\n # show_shells=True, shells_highlight=shells_score3, title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # return\n\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\n\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\n\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\n\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\n\n planck_herschel_file = '../catalogs/planck_herschel.fits'\n\n region_file = '../shell_candidates/AllShells.reg'\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\n\n obaf_file = 'stars_obaf.txt'\n yso_file = \"../catalogs/spitzer_orion.fit\"\n\n obaf = ascii.read(obaf_file)\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\"b'\") for sp in obaf['SP_TYPE']])\n yso = fits.open(yso_file)[1].data\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\n\n # for nshell in range(19,43):\n # shell = shell_list[nshell-1]\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n # #Check whether shell is in each mips image coverage.\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\n \n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\n # hdu = mips_l1641_hdu\n # else:\n # hdu = mips_onc_hdu\n\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\n\n\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\n\n spec_cube = SpectralCube.read(cube_file)\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\n vel_grid = spec_cube.spectral_axis\n pad_factor = 1.5\n\n #plot_overview(show_shells=True)\n #plot_overview(plotname=\"12co_nro_peak.png\", show_shells=False)\n #plot_overview(cube=\"/Volumes/Untitled/13co_pix_2.cm.fits\", plotname=\"13co_combined_peak.png\", show_shells=False)\n #return\n #channel_vmax = [12.9, 14]\n for nshell in range(17,18):\n shell = shell_list[nshell-1]\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\n #print(l1641_xy)\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\n ir_hdu = ir_l1641_hdu\n else:\n ir_hdu = ir_onc_hdu\n\n #Extract sub_cube around shell.\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\n (abs(dec_grid - dec) < radius * pad_factor)\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n\n #Integrate between vmin and vmax.\n mom0_hdu = sub_cube.moment0().hdu\n\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\n # (abs(dec_grid - dec) < radius)\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\n\n #Calculate contour levels.\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\n #print(\"sigma: {}\".format(sigma))\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\n #print(\"delta_vel: {}\".format(delta_vel))\n mom0_sigma = sigma * delta_vel\n #print(mom0_sigma) \n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\n\n #Get source coordinates.\n\n\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \"12CO\", shell.vmin.value, shell.vmax.value),\n # return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\n # cbar_label=\"Counts\", cmap='inferno',\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\n # source_labels=[obaf_label, yso_label], dpi=300\n # )\n\n #cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n \n \n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\n # vmin=None, vmax=None, max_chans=12,\n # #cbar_label=\"Counts\",\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\n\n # angle = 90*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\n # width=7.5*u.arcsec, angle=angle,\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\n # stretch='linear', auto_scale=True, dpi=900.)\n \n\n\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\n\n\n #movie(test=False, labels=False) \n\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n # region_file = '../nro_maps/SouthShells.reg'\n # N = 2 # Number of shell candidates to plot\n # shell_list = get_shells(region_file=region_file)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # #cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n\n # for n in range(1,2):\n # shell = shell_list[n]\n # for deg in np.linspace(0, 180, 13):\n # angle = deg*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\n # width=7.5*u.arcsec, angle=105*u.deg,\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\n # stretch='linear', auto_scale=True)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\n\n # cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')","def SimpleLatLongGrid(min_x,min_y,max_x,max_y,hdeg,hmin,hsec,vdeg,vmin,vsec,\n color=(0.5,1.0,0.5,1.0),xoff=-0.18,yoff=1.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n x_spacing=float(hdeg)+(float(hmin)+(float(hsec)/60.0))/60.0\n y_spacing=float(vdeg)+(float(vmin)+(float(vsec)/60.0))/60.0\n\n\n # Round to nearest integer space\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n for hval in numpy.arange(min_x,\n max_x+x_spacing/100.0,\n x_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n hstr=GetLatLongString(hval,'longitude')\n pshp.set_property('position',hstr)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,\n max_y+y_spacing/100.0,\n y_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n vstr=GetLatLongString(vval,'latitude')\n pshp.set_property('position',vstr)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True)\n\n return layer","def run_phaseg(locus_file, gam_file, vg_file, canu_alignments, true_haps):\n\trecombrate=1.26\n\tmax_coverage = 15\n\tall_heterozygous = False\n\tdistrust_genotypes = True\n\twith ExitStack() as stack:\n\t\tnode_seq_list, edge_connections = vg_graph_reader(vg_file)\n\t\tall_reads, alleles_per_pos, locus_branch_mapping = vg_reader(locus_file, gam_file, canu_alignments)\n\t\tall_positions = sorted(all_reads.get_positions())\n\t\tall_components = find_components(all_positions, all_reads)\n\t\tblocks = defaultdict(list)\n\t\tprint(\"all_components\")\n\t\tfor position, block_id in all_components.items():\n\t\t\tblocks[block_id].append(locus_branch_mapping[position][0][0][0])\n\t\tfor k,v in blocks.items():\n\t\t\tprint(k,v)\n\t\tprint(\"all_components\")\n\t\t\n\n\t\t#print(all_reads)\n\t\tselected_indices = readselection(all_reads, max_coverage)\n\t\tselected_reads = all_reads.subset(selected_indices)\n\n\t\t#selected_reads = slice_reads(all_reads, max_coverage)\n\t\t#print('positions from all reads')\n\t\t#print(len(all_reads.get_positions()))\n\t\tprint(\"reads after read-selection\")\n\t\tprint(len(selected_reads))\n\t\tprint(\"positions covered by atleast one read after read selection\")\n\t\tprint(len(selected_reads.get_positions()))\n\n\t\taccessible_positions = sorted(selected_reads.get_positions())\n\t\t\n\t\tprint(\"readset after read_selection\")\n\t\t#for read in selected_reads:\n\t\t\t#print(read.name)\n\t\tpedigree = Pedigree(NumericSampleIds())\n\t\t# compute the number of alleles at each position.\n\t\talleles_per_accessible_pos =[]\n\t\tgenotype_likelihoods = []\n\t\tfor pos in accessible_positions:\n\t\t\tif pos in alleles_per_pos:\n\t\t\t\tn_alleles = alleles_per_pos[pos] \n\t\t\t\tpossible_genotypes = n_alleles + ncr(n_alleles, 2)\n\t\t\t\tgenotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\n\t\t# random input of genotypes, since distrust_genotypes is always ON.\n\t\tpedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\n\t\trecombination_costs = uniform_recombination_map(recombrate, accessible_positions)\n\t\t# Finally, run phasing algorithm\n\t\t#print(selected_reads)\n\t\tdp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\n\t\tsuperreads_list, transmission_vector = dp_table.get_super_reads()\n\n\t\tcost = dp_table.get_optimal_cost()\n\t\tprint(superreads_list[0])\n\t\t#print(cost)\n\t\tread_partitions = dp_table.get_optimal_partitioning()\n\t\t#print(read_partitions)\n\t\t\n\t\t## To generate the connected components and corresponding haplotypes.\n\t\tprint(\"in components\")\n\t\tf = open('whole_genome' + '.predicted_read_partionting.pred', 'w')\n\t\toverall_components = find_components(accessible_positions, selected_reads)\n\t\t\n\t\tread_partitions_dict ={}\n\t\tfor read, haplotype in zip(selected_reads, read_partitions):\n\t\t\tphaseset = overall_components[read[0].position] + 1\n\t\t\tprint(read.name, phaseset, haplotype, file=f)\n\t\t\tread_partitions_dict[read.name] = haplotype\n\t\t#phaset is blockid\n\n\t\tn_phased_blocks = len(set(overall_components.values()))\n\t\tall_phased_blocks = len(set(all_components.values()))\n\t\tprint('No. of phased blocks: %d', n_phased_blocks)\n\t\tlargest_component = find_largest_component(overall_components)\n\t\tprint('No. of blocks from all the reads: %d', all_phased_blocks)\n\t\tlargest_component_all_reads = find_largest_component(all_components)\n\t\tif len(largest_component) > 0:\n\t\t\tprint('Largest component contains %d variants',len(largest_component))\n\t\tif len(largest_component_all_reads) > 0:\n\t\t\tprint('Largest component contains %d variants',len(largest_component_all_reads))\n\t\t\n\t\t\n\t\t### To generate contig sequences\n\t\tsample = 0\n\t\tsuperreads, components = dict(), dict()\n\t\tsuperreads[sample] = superreads_list[0]\n\t\tcomponents[sample] = overall_components\n\t\t#generate_hap_contigs_based_on_canu(superreads_list[0], components[sample], node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\n\t\t#generate_hap_contigs(superreads_list[0], overall_components, node_seq_list, locus_branch_mapping, edge_connections)\n\t\t\n\t\tnodes_in_bubbles =[]\n\t\twith stream.open(str(locus_file), \"rb\") as istream:\n\t\t\tfor data in istream:\n\t\t\t\tl = vg_pb2.SnarlTraversal()\n\t\t\t\tl.ParseFromString(data)\n\t\t\t\tfor i in range(0,len(l.visits)):\n\t\t\t\t\tnodes_in_bubbles.append(l.visits[i].node_id)\n\t\t\t\t#nodes_in_bubbles.append(l.snarl.end.node_id)\n\t\t\t\t#nodes_in_bubbles.append(l.snarl.start.node_id)\n\t\tedge_connections_tmp = defaultdict(list)\n\t\twith stream.open(str(vg_file), \"rb\") as istream:\n\t\t\tfor data in istream:\n\t\t\t\tl = vg_pb2.Graph()\n\t\t\t\tl.ParseFromString(data)\n\t\t\t\tfor j in range(len(l.edge)):\n\t\t\t\t\tfrom_edge = getattr(l.edge[j], \"from\")\n\t\t\t\t\t#if from_edge not in nodes_in_bubbles and l.edge[j].to not in nodes_in_bubbles:\n\t\t\t\t\tedge_connections_tmp[str(from_edge)].append(str(l.edge[j].to))\n\t\t\t\t\tedge_connections_tmp[str(l.edge[j].to)].append(str(from_edge))\n\n\n\t\t#generate_hap_contigs_based_on_canu(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\n\t\t#generate_hap_contigs_avgRL(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, edge_connections_tmp, gam_file, read_partitions_dict, nodes_in_bubbles)\n\t\t\n\t\t# evaluation partition all the reads based on one iteration\n\t\t#print('partition all the reads based on haplotypes from one iteration')\n\t\t# Check here if you wanna do all reads or selected reads only\n\t\t#haplotag(superreads_list[0], selected_reads, overall_components, 1)\n\t\t\n\t\t#compute_read_partitioning_accuracy(\"true_partioning\")\n\n\n\n\t\t##generate_hap_contigs(superreads, components, node_seq_list, locus_branch_mapping, edge_connections)\n\t\t\n\t\t##For phasing accuracy, read true haps and generate corresponding superreads\n\t\t#all_reads_true, alleles_per_pos_true, locus_branch_mapping_true = vg_reader(locus_file, true_haps)\n\t\t# Finally, run phasing algorithm for true haplotypes\n\t\t#dp_table_true = PedigreeDPTable(all_reads_true, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\n\t\t#superreads_list_true, transmission_vector_true = dp_table_true.get_super_reads()\n\t\t# to compute the phasing accuracy\n\t\t#true_haps = ReadSet()\n\t\t#for read in all_reads_true:\n\t\t\t#tmp_read = Read(read.name, 0, 0, 0)\n\t\t\t#for variant in read:\n\t\t\t\t#if variant.position in accessible_positions:\n\t\t\t\t\t#tmp_read.add_variant(variant.position, variant.allele, [10])\n\t\t\t#true_haps.add(tmp_read)\n\t\t#compare(superreads_list[0], true_haps, overall_components)\n\t\t## To perform iterative whatshap phasing\n\t\t#remaining_reads =[]\n\t\t#for read in all_reads:\n\t\t\t#remaining_reads.append(read.name)\n\t\t#prev_superreads = superreads_list[0]\n\t\t#for read in selected_reads:\n\t\t\t#remaining_reads.remove(read.name)\n\t\t#while len(remaining_reads)>0:\n\t\t\t#print('iteration')\n\t\t\t#iterative_reaset = ReadSet()\n\t\t\t#for read in all_reads:\n\t\t\t\t#if read.name in remaining_reads:\n\t\t\t\t\t#iterative_reaset.add(read)\n\n\t\t\t\t\n\t\t\t#selected_indices = readselection(iterative_reaset, max_coverage)\n\t\t\t#selected_reads = iterative_reaset.subset(selected_indices)\n\t\t\t#for read in prev_superreads:\n\t\t\t\t#selected_reads.add(read)\n\t\t\t\t#remaining_reads.append(read.name)\n\t\t\t#accessible_positions = sorted(selected_reads.get_positions())\n\t\t\t#selected_reads.sort()\n\t\t\t#pedigree = Pedigree(NumericSampleIds())\n\t\t\t## compute the number of alleles at each position.\n\t\t\t#alleles_per_accessible_pos =[]\n\t\t\t#genotype_likelihoods = []\n\t\t\t#for pos in accessible_positions:\n\t\t\t\t#if pos in alleles_per_pos:\n\t\t\t\t\t#n_alleles = alleles_per_pos[pos] \n\t\t\t\t\t#possible_genotypes = n_alleles + ncr(n_alleles, 2)\n\t\t\t\t\t#genotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\n\t\t\t## random input of genotypes, since distrust_genotypes is always ON.\n\t\t\t#pedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\n\t\t\t#recombination_costs = uniform_recombination_map(recombrate, accessible_positions)\n\t\t\t## Finally, run phasing algorithm\n\t\t\t##print(selected_reads)\n\t\t\t#dp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\n\t\t\t#superreads_list, transmission_vector = dp_table.get_super_reads()\n\t\t\t#for read in selected_reads:\n\t\t\t\t#remaining_reads.remove(read.name)\n\t\t\t#prev_superreads = superreads_list[0]\n\t\t\t\n\t\t#print('I am final')\n\t\t#accessible_positions = sorted(all_reads.get_positions())\n\t\t#overall_components = find_components(accessible_positions, all_reads)\n\t\t#haplotag(superreads_list[0], all_reads, overall_components, \"all_iter\")\n\t\t#compare(superreads_list[0], superreads_list_true[0], overall_components)\n\t\t#print(superreads_list[0])\n\t\t\n\t\t#iterative whatshap for sparse matrices where we fix the phasing for variants at each iteration that reach max coverage.","def main():\n test_file = 'lib/pbk411.tsp'\n limit = 1000\n milestones = [10, 25, 100, 500, 1000]\n\n lx, ly = parse_data(test_file)\n algo = Genalgo(lx, ly)\n current = 0\n\n for i in range(0, limit):\n algo.evolve_new_pop(i)\n if i == milestones[current]:\n cities, distance = get_best(algo)\n cities.append(cities[0])\n make_plot_solved(lx, ly, cities)\n save_plot('solved-' + str(milestones[current]) + '.png')\n print(str(milestones[current]) + ': ' + str(distance))\n current += 1\n\n _, best_tuple = algo.get_best_tours(algo.tours)\n best = algo.tours[best_tuple[0]]\n cities = best.cities\n cities.append(best.cities[0])\n print('Best: ' + str(best.get_cost()))\n\n make_plot_original(lx, ly)\n save_plot('original.png')\n make_plot_solved(lx, ly, cities)\n save_plot('solved.png')","def create_matrices(maze, reward, penalty_s, penalty_l, prob):\n \n r, c = np.shape(maze)\n states = r*c\n p = prob\n q = (1 - prob)*0.5\n \n # Create reward matrix\n path = maze*penalty_s\n walls = (1 - maze)*penalty_l\n combined = path + walls\n \n combined[-1, -1] = reward\n \n R = np.reshape(combined, states)\n \n # Create transition matrix\n T_up = np.zeros((states, states))\n T_left = np.zeros((states, states))\n T_right = np.zeros((states, states))\n T_down = np.zeros((states, states))\n \n wall_ind = np.where(R == penalty_l)[0]\n\n for i in range(states):\n # Up\n if (i - c) < 0 or (i - c) in wall_ind :\n T_up[i, i] += p\n else:\n T_up[i, i - c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i+1] += q\n \n # Down\n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_down[i, i] += p\n else:\n T_down[i, i + c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i+1] += q\n \n # Left\n if i%c == 0 or (i - 1) in wall_ind:\n T_left[i, i] += p\n else:\n T_left[i, i-1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i + c] += q\n \n # Right\n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_right[i, i] += p\n else:\n T_right[i, i+1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i + c] += q\n \n T = [T_up, T_left, T_right, T_down] \n \n return T, R","def visualize_reconstruction(maps_filename, timecourses_filename, data_filename, out_filename, mask_nib, hgap=20, vgap=20, nsamples=10):\n\n\tmaps = np.load(maps_filename)\n\ttimecourses = np.load(timecourses_filename)\n\tsubject_data = np.load(data_filename)\n\n\t(nframes, nvoxels) = subject_data.shape\n\n\trecon = timecourses.dot(maps)\n\n\tsamples = range(0, 1028, int(math.ceil(nframes / float(nsamples))))\n\n\t# draw the maps and timecourses into temporary files\n\tdata_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(nsamples)]\n\trecon_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(nsamples)]\n\n\tfor i in range(nsamples):\n\t\tplot_map(subject_data[samples[i],:], mask_nib, data_image_files[i])\n\t\tplot_map(recon[samples[i],:], mask_nib, recon_image_files[i])\n\n\tdata_images = [Image.open(fname) for fname in data_image_files]\n\trecon_images = [Image.open(fname) for fname in recon_image_files]\n\n\tim_width = data_images[0].size[0]\n\tim_height = data_images[0].size[1]\n\n\tresult_width = 2*im_width + hgap \n\tresult_height = nsamples * (im_height + vgap)\n\n\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\n\ty = 0\n\tfor (recon_image, data_image) in zip(recon_images, data_images):\n\t\tresult.paste(im=recon_image, box=(0, y))\n\t\tresult.paste(im=data_image, box=(im_width+hgap, y))\n\t\ty += im_height + vgap\n\n\tresult.save(out_filename)\n\n\tfor i in range(nsamples):\n\t\tos.remove(data_image_files[i])\n\t\tos.remove(recon_image_files[i])","def swipeBase (self) :\n grid = self.grid\n\n #we start by putting every tile up\n for columnNbr in range(4) :\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\n\n for lineNbr in range(4) :\n counter = 0\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\n counter += 1\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\n for remainingLine in range (lineNbr, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n #now we do the additions\n for lineNbr in range(3) :\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\n grid[lineNbr, columnNbr] *= 2\n for remainingLine in range (lineNbr+1, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n return (grid)","def print_solution(data, manager, routing, assignment):\n\n html_name = './app/templates/res.html'\n depot_latlon = str2ll(depot)\n gmap = gmplot.GoogleMapPlotter(depot_latlon[0], depot_latlon[1], 15, api)\n\n total_distance = 0\n total_load = 0\n\n routes = []\n for vehicle_id in range(data['num_vehicles']):\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n\n route = []\n while not routing.IsEnd(index):\n node_index = manager.IndexToNode(index)\n route_load += data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\n\n route.append(node_index)\n previous_index = index\n index = assignment.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n route.append(0)\n\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\n route_load)\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n print(plan_output)\n\n total_distance += route_distance\n total_load += route_load\n routes.append([route, route_distance, route_load])\n \n # coordinates = []\n # for i in range(len(route)-1):\n # src = data['addresses'][route[i]]\n # dst = data['addresses'][route[i+1]]\n \n # latlon = str2ll(src)\n # if route[i] == 0:\n # color = 'pink'\n # else:\n # color = colors[vehicle_id%len(colors)]\n\n # gmap.marker(latlon[0], latlon[1], color)\n \n # now = datetime.now()\n # directions_result = gmaps.directions(src,\n # dst,\n # mode=\"driving\",\n # departure_time=now)[0]\n \n # polyline = directions_result['overview_polyline']['points']\n # coordinates = np.asarray(decode_polyline(polyline))\n # gmap.plot(coordinates[:, 0], coordinates[:, 1], colors[vehicle_id%len(colors)], edge_width=2)\n \n\n \n # if gmap is not None:\n # #save plot as html\n # gmap.draw(html_name)\n\n print('Total distance of all routes: {}m'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))\n\n return routes\n\n #draw html for this","def _plot_pr2(gc_val_lst: list, at_val_lst: list, g3_val_lst: list, a3_val_lst: list, organism_name: str | None = None,\n save_image: bool = False, folder_path: str = 'Report', gene_analysis: bool = True):\n N = len(gc_val_lst)\n gc_arr = np.array(gc_val_lst)\n g3_arr = np.array(g3_val_lst)\n at_arr = np.array(at_val_lst)\n a3_arr = np.array(a3_val_lst)\n x = g3_arr / gc_arr\n y = a3_arr / at_arr\n # [[x_val], [y_val]]\n ag_lst = [[], []]\n ag_count = 0\n tg_lst = [[], []]\n tg_count = 0\n tc_lst = [[], []]\n tc_count = 0\n ac_lst = [[], []]\n ac_count = 0\n no_bias = [[], []]\n no_bias_count = 0\n for x_val, y_val in zip(x, y):\n if x_val > 0.5 and y_val > 0.5:\n ag_lst[0].append(x_val)\n ag_lst[1].append(y_val)\n ag_count += 1\n elif x_val > 0.5 > y_val:\n tg_lst[0].append(x_val)\n tg_lst[1].append(y_val)\n tg_count += 1\n elif x_val < 0.5 and y_val < 0.5:\n tc_lst[0].append(x_val)\n tc_lst[1].append(y_val)\n tc_count += 1\n elif x_val < 0.5 < y_val:\n ac_lst[0].append(x_val)\n ac_lst[1].append(y_val)\n ac_count += 1\n else:\n no_bias[0].append(x_val)\n no_bias[1].append(y_val)\n no_bias_count += 1\n fig, ax = plt.subplots(figsize=(9, 5.25))\n ax.scatter(ag_lst[0], ag_lst[1], s=5, label='AG', alpha=0.5, zorder=2)\n ax.scatter(tg_lst[0], tg_lst[1], s=5, label='TG', alpha=0.5, zorder=2)\n ax.scatter(tc_lst[0], tc_lst[1], s=5, label='TC', alpha=0.5, zorder=2)\n ax.scatter(ac_lst[0], ac_lst[1], s=5, label='AC', alpha=0.5, zorder=2)\n ax.scatter(no_bias[0], no_bias[1], s=5, label=f'No Bias', alpha=0.5, zorder=3)\n ax.grid(True, linestyle=':')\n ax.legend()\n ax.text(0.6, 0.95, 'AG')\n ax.text(0.4, 0.95, 'AC')\n ax.text(0.6, 0.05, 'TG')\n ax.text(0.4, 0.05, 'TC')\n ax.text(0, 0, f'AG: {ag_count}\\nTG: {tg_count}\\nTC: {tc_count}\\nAC: {ac_count}\\nNo Bias: {no_bias_count}',\n transform=ax.transAxes)\n plt.xlim([0, 1])\n plt.ylim([0, 1])\n plt.axvline(0.5, color='grey', zorder=1)\n plt.axhline(0.5, color='grey', zorder=1)\n plt.xlabel(r\"$G_3/GC_3$ Values\")\n plt.ylabel(r\"$A_3/AT_3$ Values\")\n suptitle = r'Parity Rule 2 plot' if organism_name is None else f\"Parity Rule 2 plot for {organism_name}\"\n plt.suptitle(suptitle, fontsize=16)\n title = f'Total genes: {N}' if gene_analysis else f'Total genome: {N}'\n plt.title(title, fontsize=12)\n if save_image:\n make_dir(folder_path)\n name = 'PR2_plot.png' if organism_name is None else f\"PR2_plot_{organism_name}.png\"\n file_name = join(folder_path, name)\n if is_file_writeable(file_name):\n plt.savefig(file_name, dpi=500)\n print(f'Saved file can be found as {abspath(file_name)}')\n plt.show()\n plt.close()","def examineMaze(self, gameState):\n w = self.walls.width\n h = self.walls.height\n walls = self.walls.deepCopy()\n food1 = self.getFoodYouAreDefending(gameState)\n food2 = self.getFood(gameState)\n\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\n for x in range(w):\n for y in range(h):\n if walls[x][y]:\n walls[x][y] = 0\n elif food1[x][y]:\n walls[x][y] = 2\n elif food2[x][y]:\n walls[x][y] = 2\n else:\n walls[x][y] = 1\n\n roomsDisplay = []\n # Detect doors and spaces. Spaces are now negative\n for x in range(w):\n for y in range(h):\n if walls[x][y] > 0:\n exitsNum = 0\n if walls[x][y - 1] != 0:\n exitsNum += 1\n if walls[x][y + 1] != 0:\n exitsNum += 1\n if walls[x - 1][y] != 0:\n exitsNum += 1\n if walls[x + 1][y] != 0:\n exitsNum += 1\n if exitsNum == 1 or exitsNum == 2:\n walls[x][y] = -1 * walls[x][y]\n roomsDisplay.append((x, y))\n elif exitsNum == 0:\n # We erase unaccessible cells\n walls[x][y] = 0\n else:\n # These are doors or big rooms, we leave them positive\n pass\n\n # Create roomsGraph: every room has a number, some cells and some doors\n roomsGraph = []\n doorsGraph = []\n for x in range(1, w - 1):\n for y in range(1, h - 1):\n if walls[x][y] < 0:\n spacesNum = 0\n if walls[x][y - 1] < 0:\n spacesNum += 1\n if walls[x][y + 1] < 0:\n spacesNum += 1\n if walls[x - 1][y] < 0:\n spacesNum += 1\n if walls[x + 1][y] < 0:\n spacesNum += 1\n if spacesNum < 2:\n endOfPath = False\n graphNode = {\"path\": [], \"doors\": [], \"food\": 0, \"isBig\": False}\n auxx = x\n auxy = y\n while not endOfPath:\n graphNode[\"path\"].append((x, y))\n graphNode[\"food\"] += -walls[x][y] - 1\n walls[x][y] = 0\n xx = x\n yy = y\n if walls[x][y - 1] < 0:\n yy = y - 1\n elif walls[x][y + 1] < 0:\n yy = y + 1\n elif walls[x - 1][y] < 0:\n xx = x - 1\n elif walls[x + 1][y] < 0:\n xx = x + 1\n else:\n endOfPath = True\n if walls[x][y - 1] > 0:\n if [(x, y - 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y - 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y - 1), []]))\n if walls[x][y + 1] > 0:\n if [(x, y + 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y + 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y + 1), []]))\n if walls[x - 1][y] > 0:\n if [(x - 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x - 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x - 1, y), []]))\n if walls[x + 1][y] > 0:\n if [(x + 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x + 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x + 1, y), []]))\n x = xx\n y = yy\n roomsGraph.append(graphNode)\n x = auxx\n y = auxy\n\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\n for j, door in enumerate(doorsGraph):\n for i, room in enumerate(roomsGraph):\n for aDoor in room[\"doors\"]:\n if aDoor == j:\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\n (x, y) = doorsGraph[j][0]\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\n adjacentDoors = []\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\n for p in adjacentCells:\n # Skip if wall\n if self.walls[p[0]][p[1]]:\n continue\n # Skip if door\n isRoom = False\n for room in doorsGraph[j][1]:\n if p in roomsGraph[room][\"path\"]:\n isRoom = True\n break\n if not isRoom:\n # Add if existing door\n doorFound = False\n for i, neighborDoor in enumerate(doorsGraph):\n if neighborDoor[0] == p:\n adjacentDoors.append(i)\n doorFound = True\n break\n # Create if non existing door and add\n if not doorFound:\n adjacentDoors.append(len(doorsGraph))\n doorsGraph.append([p, []])\n doorsGraph[j].append(adjacentDoors)\n\n # Create doorsDistance: maps what doors can be accessed from other doors\n roomsMapper = {}\n doorsMapper = {}\n isRoom = util.Counter()\n for i, door in enumerate(doorsGraph):\n doorsMapper[door[0]] = i\n isRoom[door[0]] = 0\n for i, room in enumerate(roomsGraph):\n for p in room[\"path\"]:\n roomsMapper[p] = i\n isRoom[p] = 1\n\n # Create self variables\n self.doorsGraph = doorsGraph\n self.roomsGraph = roomsGraph\n self.roomsMapper = roomsMapper\n self.doorsMapper = doorsMapper\n self.isRoom = isRoom\n\n # # Find dead ends (rooms with only one door)\n # deadRooms = {}\n # deadDoors = {}\n # # deaderDoors = {}\n # # deaderRooms = {}\n # for i, room in enumerate(roomsGraph):\n # if len(room[\"doors\"]) == 1:\n # deadRooms[i] = room[\"doors\"][0]\n # deadDoors[room[\"doors\"][0]] = 1\n # numdR = 0\n # aliveR = -1\n # for adjRoom in doorsGraph[room[\"doors\"][0]][1]:\n # if adjRoom not in deadRooms:\n # numdR += 1\n # aliveR = adjRoom\n # if numdR + len(doorsGraph[room[\"doors\"][0]][2]) == 1:\n # if aliveR >= 0:\n # deaderRooms[aliveR] = room[\"doors\"][0]\n # for adjDoor in roomsGraph[aliveR][\"doors\"]:\n # if adjDoor == room[\"doors\"][0]:\n # continue\n # deaderDoors[adjDoor] = 1.0\n # else:\n # deaderDoors[doorsGraph[room[\"doors\"][0]][2][0]] = 1.0\n\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deaderRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deaderDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, room in enumerate(roomsGraph):\n # numAliveDoors = 0\n # aliveDoor = 0\n # deadDoor = []\n # for door in room[\"doors\"]:\n # if door not in deadDoors:\n # numAliveDoors += 1\n # aliveDoor = door\n # else:\n # deadDoor.append(door)\n # if numAliveDoors == 1:\n # aliveRoom = 0\n # aliveNeighborDoor = 0\n # for door in deadDoor:\n # # aliveNeighborDoor += len(doorsGraph[door][2])\n # for neighborRoom in doorsGraph[door][1]:\n # if neighborRoom not in deadRooms:\n # aliveRoom += 1\n # if aliveRoom == len(deadDoor):\n # deadRooms[i] = aliveDoor\n # deadDoors[aliveDoor] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\n # for p in room[\"path\"]:\n # roomsCounter[1][p] = 1\n # for p in deadDoor:\n # roomsCounter[2][doorsGraph[p][0]] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, door in enumerate(doorsGraph):\n # if i not in deadDoors:\n # numOpenRooms = 0\n # openRoom = 0\n # for j, room in enumerate(door[1]):\n # if room not in deadRooms:\n # numOpenRooms += 1\n # openRoom = j\n # if numOpenRooms + len(door[2]) == 1:\n # for room in door[1]:\n # if room != openRoom:\n # deadRooms[room] = i\n # deadDoors[j] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][door[0]] = 1\n # for rr in door[1]:\n # print rr\n # if rr in deadRooms:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[1][p] = 1\n # else:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[3][p] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[1][(6, 9)] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deadRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deadDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # Show every room\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n for room in roomsGraph:\n for p in room[\"path\"]:\n if len(room[\"doors\"]) > 1:\n roomsCounter[0][p] = 0.4\n else:\n roomsCounter[2][p] = 0.4\n # Show every door\n for door in doorsGraph:\n roomsCounter[1][door[0]] = 0.4\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\n self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")","def drawmaze(self):\n win=GraphWin(\"Perfect Maze\",600,600) \n win.setBackground(\"White\")\n scale=600/self.N #Used to generalize the size difference for the input of larger numbers. The background resolution/ grid size, N\n\n x1=scale\n y1=0\n x2=scale\n y2=scale\n\n ##VERTICAL LINES ####\n for i in range(self.N,0,-1):\n for j in range(1,self.N):\n if self.East[j][i]: #If East is true, draw a line.\n \n line=Line(Point(x1,y1),Point(x2,y2)) #lines | |\n line.setFill(\"red\")\n line.draw(win)\n x1+=scale #Increment causes |->|\n x2+=scale #Increment causes |->|\n y1+=scale #Used to draw two more\n y2+=scale #of the same spaced lines further down.\n x1=scale #Reset\n x2=scale #Reset\n\n\n ##HORIZONTAL LINES##\n x1=0\n y1=scale\n x2=scale\n y2=scale\n\n\n for i in range(self.N,1,-1):\n for j in range(1,self.N+1):\n if self.South[j][i]: #If South is true, draw a line.\n \n line=Line(Point(x1,y1),Point(x2,y2))\n line.setFill(\"red\")\n line.draw(win)\n x1+=scale\n x2+=scale\n y1+=scale\n y2+=scale\n x1=0\n x2=scale\n\n const=scale//5 #Very useful const which helps in placing circles on grid.\n x=scale//2\n y=600-scale//2\n #radius=(scale-(4*scale//self.N))/2\n radius=scale//2-(const)\n start=Point(x,y) #START POINT HERE \n circ=Circle(start,radius)\n circ.setFill(\"Red\")\n label=Text(start,\"Start\")\n label.setFill(\"Black\")\n circ.draw(win)\n label.draw(win)\n #print(self.CurrentCell)\n #Using the current cell from the finished algorithm(last place visited), a circle can be placed at that point.\n endpointx=(self.CurrentCell[0]-1)*scale +scale//2 ####MAKING END POINT X\n endpointy=600-(self.CurrentCell[1]-1)*scale-scale//2 ####MAKING END POINT Y\n endpoint=Point(endpointx,endpointy)\n circ2=Circle(endpoint,radius)\n circ2.setFill(\"White\")\n label2=Text(endpoint,\"End\")\n circ2.draw(win)\n label2.draw(win)\n \n ###############CREATE KEY########################\n \n \n keypointx=(self.MazeKey[0]-1)*scale +scale//2 ####MAKING END POINT X\n keypointy=600-(self.MazeKey[1]-1)*scale-scale//2 ####MAKING END POINT Y\n keypoint=Point(keypointx,keypointy)\n circ3=Circle(keypoint,radius)\n circ3.setFill(\"Blue\")\n label3=Text(keypoint,\"Key\")\n circ3.draw(win)\n label3.draw(win)\n pathcol=\"Yellow\"\n##\n\n \n for i in range(1,len(self.EntirePath)): \n pathpointx=(self.EntirePath[i][0]-1)*scale +scale//2 ####MAKING END POINT X\n pathpointy=600-(self.EntirePath[i][1]-1)*scale-scale//2 ####MAKING END POINT Y\n pathpoint=Point(pathpointx,pathpointy)\n drawpath=Circle(pathpoint,radius)\n drawpath.setFill(pathcol)\n if self.EntirePath[i]==self.KeyPath[-1]:\n pathcol=\"Violet\"\n label4=Text(keypoint,\"Key\")\n label4.draw(win) \n drawpath.draw(win)\n drawpath.setWidth(1)\n sleep(0.1)\n \n #drawpath.draw(win)\n \n label5=Text(endpoint,\"Maze Solved \")\n label5.draw(win)\n circ4=Circle(start,radius)\n circ4.setFill(\"Red\")\n circ4.draw(win) \n label6=Text(start,\"Start \")\n label6.draw(win)","def makeOverviewPage(orbit_list, mtpConstants, paths, occultationObservationDict, nadirObservationDict):\n mtpNumber = mtpConstants[\"mtpNumber\"]\n obsTypeNames = {\"ingress\":\"irIngressLow\", \"egress\":\"irEgressLow\"}\n\n \n #loop through once to find list of all orders measured\n ordersAll = []\n for orbit in orbit_list:\n occultationObsTypes = [occultationType for occultationType in orbit[\"allowedObservationTypes\"][:] if occultationType in [\"ingress\", \"egress\"]] \n for occultationObsType in occultationObsTypes:\n if occultationObsType in orbit.keys():\n obsTypeName = obsTypeNames[occultationObsType]\n \n orders = orbit[\"finalOrbitPlan\"][obsTypeName+\"Orders\"]\n if 0 in orders: #remove darks\n orders.remove(0)\n if \"COP#\" in \"%s\" %orders[0]: #remove manual COP selection\n orders = []\n ordersAll.extend(orders)\n uniqueOccultationOrders = sorted(list(set(ordersAll)))\n \n #loop through again to plot each order on a single graph\n for chosenOrder in uniqueOccultationOrders:\n title = \"Solar occultations for diffraction order %s\" %(chosenOrder)\n fig = plt.figure(figsize=(FIG_X, FIG_Y))\n ax = fig.add_subplot(111, projection=\"mollweide\")\n ax.grid(True)\n plt.title(title)\n \n lonsAll = [] #pre-make list of all observing points of this order, otherwise colourbar scale will be incorrect\n latsAll = []\n altsAll = []\n for orbit in orbit_list:\n occultationObsTypes = [occultationType for occultationType in orbit[\"allowedObservationTypes\"][:] if occultationType in [\"ingress\", \"egress\"]] \n for occultationObsType in occultationObsTypes:\n if occultationObsType in orbit.keys():\n obsTypeName = obsTypeNames[occultationObsType]\n \n orders = orbit[\"finalOrbitPlan\"][obsTypeName+\"Orders\"]\n if chosenOrder in orders:\n occultation = orbit[occultationObsType]\n \n #if lats/lons/alts not yet in orbitList, find and write to list\n if \"alts\" not in occultation.keys():\n #just plot the half of the occultation closest to the surface, not the high altitude bits\n #ignore merged or grazing occs at this point\n if occultationObsType == \"ingress\":\n ets = np.arange(occultation[\"etMidpoint\"], occultation[\"etEnd\"], OCCULTATION_SEARCH_STEP_SIZE)\n elif occultationObsType == \"egress\":\n ets = np.arange(occultation[\"etStart\"], occultation[\"etMidpoint\"], OCCULTATION_SEARCH_STEP_SIZE)\n lonsLatsLsts = np.asfarray([getLonLatLst(et) for et in ets])\n occultation[\"lons\"] = lonsLatsLsts[:, 0]\n occultation[\"lats\"] = lonsLatsLsts[:, 1]\n occultation[\"alts\"] = np.asfarray([getTangentAltitude(et) for et in ets])\n \n #else take lats/lons/alts from orbitList if already exists\n lonsAll.extend(occultation[\"lons\"])\n latsAll.extend(occultation[\"lats\"])\n altsAll.extend(occultation[\"alts\"])\n \n plot1 = ax.scatter(np.asfarray(lonsAll)/sp.dpr(), np.asfarray(latsAll)/sp.dpr(), \\\n c=np.asfarray(altsAll), cmap=plt.cm.jet, marker='o', linewidth=0)\n \n cbar = fig.colorbar(plot1, fraction=0.046, pad=0.04)\n cbar.set_label(\"Tangent Point Altitude (km)\", rotation=270, labelpad=20)\n fig.tight_layout()\n plt.savefig(os.path.join(paths[\"IMG_MTP_PATH\"], \"occultations_mtp%03d_order%i_altitude.png\" %(mtpNumber, chosenOrder)))\n plt.close()\n \n \n \n \"\"\"plot nadir orders\"\"\"\n #find all orders measured\n ordersAll = []\n for orbit in orbit_list:\n if \"dayside\" in orbit[\"irMeasuredObsTypes\"]:\n orders = orbit[\"finalOrbitPlan\"][\"irDaysideOrders\"]\n if 0 in orders: #remove darks\n orders.remove(0)\n if \"COP#\" in \"%s\" %orders[0]: #remove manual COP selection\n orders = []\n ordersAll.extend(orders)\n uniqueNadirOrders = sorted(list(set(ordersAll)))\n \n #plot each order\n for chosenOrder in uniqueNadirOrders:\n title = \"Dayside nadirs for diffraction order %s\" %(chosenOrder)\n fig = plt.figure(figsize=(FIG_X, FIG_Y))\n ax = fig.add_subplot(111, projection=\"mollweide\")\n ax.grid(True)\n plt.title(title)\n \n lonsAll = [] #pre-make list of all observing points of this order, otherwise colourbar scale will be incorrect\n latsAll = []\n anglesAll = []\n for orbit in orbit_list:\n if \"dayside\" in orbit[\"irMeasuredObsTypes\"]:\n orders = orbit[\"finalOrbitPlan\"][\"irDaysideOrders\"]\n if chosenOrder in orders:\n nadir = orbit[\"dayside\"]\n \n #if lats/lons/incidence angles not yet in orbitList, find and write to list\n if \"incidences\" not in nadir.keys():\n# print(orbit[\"orbitNumber\"])\n #nadir start/end times have been modified to fit thermal room\n realStartTime = nadir[\"obsStart\"] + PRECOOLING_TIME + INITIALISATION_TIME\n realEndTime = nadir[\"obsEnd\"]\n ets = np.arange(realStartTime, realEndTime, NADIR_SEARCH_STEP_SIZE)\n lonsLatsIncidencesLsts = np.asfarray([getLonLatIncidenceLst(et) for et in ets])\n nadir[\"lons\"] = lonsLatsIncidencesLsts[:, 0]\n nadir[\"lats\"] = lonsLatsIncidencesLsts[:, 1]\n nadir[\"incidences\"] = lonsLatsIncidencesLsts[:, 2]\n #else take lats/lons/incidence angles from orbitList if already exists\n lonsAll.extend(nadir[\"lons\"])\n latsAll.extend(nadir[\"lats\"])\n anglesAll.extend(nadir[\"incidences\"])\n \n plot1 = ax.scatter(np.asfarray(lonsAll)/sp.dpr(), np.asfarray(latsAll)/sp.dpr(), \\\n c=np.asfarray(anglesAll), cmap=plt.cm.jet, marker='o', linewidth=0)\n \n cbar = fig.colorbar(plot1, fraction=0.046, pad=0.04)\n cbar.set_label(\"Incidence Angle (degrees)\", rotation=270, labelpad=20)\n fig.tight_layout()\n plt.savefig(os.path.join(paths[\"IMG_MTP_PATH\"], \"dayside_nadirs_mtp%03d_order%i_incidence_angle.png\" %(mtpNumber, chosenOrder)))\n plt.close()\n\n \"\"\"write mtp overview page\"\"\"\n h = r\"\"\n h += r\"<h1>MTP%03d Overview</h1>\" %(mtpNumber)\n h += r\"<h2>Geometry</h2>\"+\"\\n\"\n \n imagename = \"mtp%03d_occultation_duration.png\" %(mtpNumber)\n h += r\"<img src='%s'>\" %imagename\n imagename = \"mtp%03d_occultation_lat.png\" %(mtpNumber)\n h += r\"<img src='%s'>\" %imagename\n imagename = \"mtp%03d_nadir_minimum_incidence_angle.png\" %(mtpNumber)\n h += r\"<img src='%s'>\" %imagename\n \n h += r\"<p>UVIS typically operates on all dayside nadirs and all occultations</p>\"+\"\\n\"\n \n h += r\"<h2>Solar Occultations</h2>\"+\"\\n\"\n \n h += r\"Solar occultation diffraction orders measured this MTP: \"+\"\\n\"\n for chosenOrder in sorted(uniqueOccultationOrders):\n h += \"%i, \" %chosenOrder\n h += r\"<br>\"+\"\\n\"\n \n for chosenOrder in sorted(uniqueOccultationOrders):\n h += \"<h3>Solar occultations for diffraction order %i</h3>\" %chosenOrder\n imagename = \"img/occultations_mtp%03d_order%i_altitude.png\" %(mtpNumber, chosenOrder)\n h += r\"<img src='%s'>\" %imagename\n \n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n h += r\"<h2>Dayside Nadirs</h2>\"+\"\\n\"\n \n h += r\"Dayside nadir diffraction orders measured this MTP: \"+\"\\n\"\n for chosenOrder in sorted(uniqueNadirOrders):\n h += \"%i, \" %chosenOrder\n h += r\"<br>\"+\"\\n\"\n \n for chosenOrder in sorted(uniqueNadirOrders):\n h += \"<h3>Dayside nadirs for diffraction order %i</h3>\" %chosenOrder\n imagename = \"img/dayside_nadirs_mtp%03d_order%i_incidence_angle.png\" %(mtpNumber, chosenOrder)\n h += r\"<img src='%s'>\" %imagename\n \n \n \n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n# h += r\"<h2>SO/LNO Observation Plan</h2>\"+\"\\n\"\n \n \n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n h += r\"<h2>SO/LNO Observation Dictionaries</h2>\"+\"\\n\"\n h += r\"<h3>Solar Occultation</h3>\"+\"\\n\"\n headers = [\"Name\", \"Diffraction Order 1\", \"Diffraction Order 2\", \"Diffraction Order 3\", \"Diffraction Order 4\", \"Diffraction Order 5\", \"Diffraction Order 6\", \"Integration Time\", \"Rhythm\", \"Detector Height\"]\n h += r\"<table border=1>\"+\"\\n\"\n h += r\"<tr>\"+\"\\n\"\n for header in headers:\n h += r\"<th>%s</th>\" %header\n h += r\"</tr>\"+\"\\n\"\n for key in sorted(occultationObservationDict.keys()):\n orders, integrationTime, rhythm, detectorRows, channelCode = getObsParameters(key, occultationObservationDict)\n \n h += r\"<tr>\"+\"\\n\"\n h += r\"<td>%s</td>\" %(key)\n if \"COP\" in orders:\n h += r\"<td>%s (manual mode)</td>\" %(orders)\n for order in range(5):\n h += r\"<td>-</td>\"+\"\\n\"\n else: \n for order in orders:\n h += r\"<td>%s</td>\" %(order)\n for order in range(6-len(orders)):\n h += r\"<td>-</td>\"+\"\\n\"\n \n h += r\"<td>%i</td>\" %(integrationTime)\n h += r\"<td>%i</td>\" %(rhythm)\n h += r\"<td>%i</td>\" %(detectorRows)\n h += r\"</tr>\"+\"\\n\"\n h += r\"</table>\"+\"\\n\"\n \n \n h += r\"<h3>Nadir/Limb</h3>\"+\"\\n\"\n headers = [\"Name\", \"Diffraction Order 1\", \"Diffraction Order 2\", \"Diffraction Order 3\", \"Diffraction Order 4\", \"Diffraction Order 5\", \"Diffraction Order 6\", \"Integration Time\", \"Rhythm\", \"Detector Height\"]\n h += r\"<table border=1>\"+\"\\n\"\n h += r\"<tr>\"+\"\\n\"\n for header in headers:\n h += r\"<th>%s</th>\" %header\n h += r\"</tr>\"\n for key in sorted(nadirObservationDict.keys()):\n orders, integrationTime, rhythm, detectorRows, channelCode = getObsParameters(key, nadirObservationDict)\n \n h += r\"<tr>\"+\"\\n\"\n h += r\"<td>%s</td>\" %(key)\n if \"COP\" in orders:\n h += r\"<td>%s (manual mode)</td>\" %(orders)\n for order in range(5):\n h += r\"<td>-</td>\"+\"\\n\"\n else: \n for order in orders:\n h += r\"<td>%s</td>\" %(order)\n for order in range(6-len(orders)):\n h += r\"<td>-</td>\"+\"\\n\"\n \n h += r\"<td>%i</td>\" %(integrationTime)\n h += r\"<td>%i</td>\" %(rhythm)\n h += r\"<td>%i</td>\" %(detectorRows)\n h += r\"</tr>\"+\"\\n\"\n h += r\"</table>\"+\"\\n\"\n \n \n \n \n h += r\"<br>\"+\"\\n\"\n h += r\"<br>\"+\"\\n\"\n h += r\"<p>Page last modified: %s</p>\" %(datetime.now().strftime('%a, %d %b %Y %H:%M:%S')) +\"\\n\"\n \n with open(os.path.join(paths[\"HTML_MTP_PATH\"], \"nomad_mtp%03d_overview.html\" %(mtpNumber)), 'w') as f:\n f.write(h)","def create_path(self):\n\n partials = []\n partials.append({})\n #print self.trip_id\n\n #this variable is true if we have not yet recorded the first edge of a path\n first_edge = True\n #this variable is false until we hit the midpoint\n hit_midpoint = False\n\n first_lasts = []\n first_lasts.append([0,0])\n matrices = []\n matrices.append([np.zeros((self.graph.rows,self.graph.cols)),0])\n edge_sets = []\n edge_sets.append([0 for i in range(self.graph.num_edges)])\n cur_line = self.line_num\n good_graphs = []\n good_graphs.append(True)\n nodes_visited = []\n nodes_visited.append([])\n #normalized = dg.normalize(self.graph.lines[cur_line])\n normalized = normalize_simple(self.graph.lines[cur_line])\n matrices_index = 0\n prev_coords = (-1,-1)\n while normalized[0] == self.trip_id:\n lat = normalized[1]\n lon = normalized[2]\n coords = self.graph.gps_to_coords(lat,lon)\n node = self.graph.coords_to_node(coords[0],coords[1])\n\n if prev_coords == (-1,-1) and coords[0] != -1:\n first_lasts[matrices_index][0] = node\n\n if coords[0] == -1 and prev_coords[0] != -1:\n prev_node = self.graph.coords_to_node(prev_coords[0],prev_coords[1])\n first_lasts[matrices_index][1] = prev_node\n\n if prev_coords != (-1,-1) and coords[0] != -1 and coords != prev_coords:\n edge_num = self.graph.edge_num(prev_coords[0],prev_coords[1],coords[0],coords[1])\n if edge_num == -1:\n good_graphs[matrices_index] = False\n else:\n edge_sets[matrices_index][edge_num] = 1\n if edge_num in partials[matrices_index] and partials[matrices_index][edge_num] == 0:\n del partials[matrices_index][edge_num]\n if not hit_midpoint:\n if first_edge:\n above = (prev_coords[0]-1,prev_coords[1])\n below = (prev_coords[0]+1,prev_coords[1])\n left = (prev_coords[0],prev_coords[1]-1)\n right = (prev_coords[0],prev_coords[1]+1)\n for next_coords in (above,below,left,right):\n other_edge = self.graph.edge_num(prev_coords[0],prev_coords[1],next_coords[0],next_coords[1])\n if other_edge != -1:\n partials[matrices_index][other_edge] = 0\n first_edge = False\n if self.graph.coords_to_node(prev_coords[0],prev_coords[1]) == self.midpoint:\n hit_midpoint = True\n partials[matrices_index][edge_num] = 1\n if self.graph.coords_to_node(coords[0],coords[1]) == self.midpoint:\n hit_midpoint = True\n\n\n\n if coords[0] == -1:\n matrices.append([np.zeros((self.graph.rows,self.graph.cols)),0])\n first_lasts.append([0,0])\n edge_sets.append([0 for i in range(self.graph.num_edges)])\n good_graphs.append(True)\n nodes_visited.append([])\n matrices_index += 1\n partials.append({})\n hit_midpoint = False\n first_edge = True\n \n elif coords[0] < self.graph.rows and coords[1] < self.graph.cols and not matrices[matrices_index][0][coords[0]][coords[1]]:\n matrices[matrices_index][1] += 1\n matrices[matrices_index][0][coords[0]][coords[1]] = 1\n nodes_visited[matrices_index].append(coords)\n\n prev_coords = coords\n\n cur_line += 1\n if cur_line == len(self.graph.lines):\n break\n #normalized = dg.normalize(self.graph.lines[cur_line])\n normalized = normalize_simple(self.graph.lines[cur_line])\n\n prev_node = self.graph.coords_to_node(prev_coords[0],prev_coords[1])\n first_lasts[matrices_index][1] = prev_node\n self.next_line = cur_line\n best_index = 0\n best_score = 0\n for matrix_index in range(len(matrices)):\n if matrices[matrix_index][1] > best_score:\n best_score = matrices[matrix_index][1]\n best_index = matrix_index\n\n for coords in nodes_visited[best_index]:\n self.graph.node_visit(self.trip_id,coords)\n \n\n if self.trip_id not in self.graph.trip_id2line_num:\n #if first_lasts[best_index] == [28,5]:\n # print \"a to b: %d\" % self.trip_id\n self.graph.first_last2trip_ids[tuple(first_lasts[best_index])].append(self.trip_id)\n\n return matrices[best_index][0],edge_sets[best_index],good_graphs[best_index],partials[best_index]","def test(indices_to_visit = None):\n ##0 Chicago\n ##1 New York City\n ##2 Los Angeles\n ##3 Minneapolis\n ##4 Denver\n ##5 Dallas\n ##6 Seattle\n ##7 Boston\n ##8 San Francisco\n ##9 St. Louis\n ##10 Houston\n ##11 Phoenix\n ##12 Salt Lake City\n ##13 Miami\n ##14 Atlanta\n ##15 Kansas City\n home_index = 15 # Kansas city\n # 15x15 matrix with main diagonal consisting of 0s and to which data is mirrored along\n # (values are derived from external resource and multiplied by 1000 for higher accuracy)\n matrix = np.array([[0.0, 1148413.3550047704, 2813453.6297408855, 572861.4368351421, 1483440.7452179305, 1296355.2188721865, 2801269.1215845253, 1370943.3069385102, 2996683.256068982, 422589.4697157836, 1515737.0196676727, 2343639.7107855356, 2031500.319603397, 1913900.3015914203, 946854.1020487415, 665894.0336505901],\n [1148413.3550047704, 0.0, 3949451.153672887, 1642119.4792808082, 2628946.6435325537, 2212019.1209020815, 3882177.952930788, 306997.0343229422, 4144977.810718553, 1408454.3261387087, 2286054.8575902223, 3455343.3108375454, 3179102.5335818897, 1754834.3710577146, 1202616.154562711, 1766599.1336905772],\n [2813453.6297408855, 3949451.153672887, 0.0, 2455296.3791196346, 1339227.410707824, 1998182.1420783552, 1545364.434045008, 4184394.186016967, 559978.4273194656, 2560790.9591738936, 2212581.51715849, 575975.8749662543, 933602.6426595236, 3767490.41517038, 3120118.850020503, 2186473.1552241463],\n [572861.4368351421, 1642119.4792808082, 2455296.3791196346, 0.0, 1127312.7583590776, 1390159.7734006236, 2249169.1308160927, 1811513.5290266906, 2554165.8167895717, 750916.7305340832, 1701189.1538312144, 2062079.2399570548, 1590460.9488364782, 2434801.332310659, 1462408.5353501518, 662752.1291133759],\n [1483440.7452179305, 2628946.6435325537, 1339227.410707824, 1127312.7583590776, 0.0, 1067257.7993323756, 1646308.7967673023, 2852307.4164419994, 1530510.2790658756, 1283707.511393525, 1414308.8805983758, 943721.1931707633, 598728.757362067, 2779561.192116527, 1952618.0544916363, 899656.1020173575],\n [1296355.2188721865, 2212019.1209020815, 1998182.1420783552, 1390159.7734006236, 1067257.7993323756, 0.0, 2709804.112590561, 2500314.4507069485, 2390841.4329337194, 882457.80942383, 361482.7025425731, 1427995.4150203674, 1610768.421819668, 1788903.6065106322, 1161480.3557326929, 730446.8613086065],\n [2801269.1215845253, 3882177.952930788, 1545364.434045008, 2249169.1308160927, 1646308.7967673023, 2709804.112590561, 0.0, 4018059.834330202, 1093104.7332788548, 2778905.575804111, 3046648.362755992, 1794989.6453295103, 1129464.5539648102, 4404737.747850686, 3516794.375197078, 2427457.036285458],\n [1370943.3069385102, 306997.0343229422, 4184394.186016967, 1811513.5290266906, 2852307.4164419994, 2500314.4507069485, 4018059.834330202, 0.0, 4350710.853063807, 1673216.4080939887, 2586942.3262796295, 3706392.097841614, 3382851.415271485, 2022974.6418062754, 1509585.60107986, 2015770.1390589625],\n [2996683.256068982, 4144977.810718553, 559978.4273194656, 2554165.8167895717, 1530510.2790658756, 2390841.4329337194, 1093104.7332788548, 4350710.853063807, 0.0, 2812916.3098878833, 2650547.941880299, 1053620.7288649315, 967859.8344376946, 4179636.203479384, 3448359.745690545, 2428862.4239271535],\n [422589.4697157836, 1408454.3261387087, 2560790.9591738936, 750916.7305340832, 1283707.511393525, 882457.80942383, 2778905.575804111, 1673216.4080939887, 2812916.3098878833, 0.0, 1093601.4408876144, 2050115.5214378452, 1872971.1741522516, 1708236.6189296674, 752855.8488125347, 384122.2000072272],\n [1515737.0196676727, 2286054.8575902223, 2212581.51715849, 1701189.1538312144, 1414308.8805983758, 361482.7025425731, 3046648.362755992, 2586942.3262796295, 2650547.941880299, 1093601.4408876144, 0.0, 1636770.4499809493, 1932616.2801687205, 1559260.024532222, 1130480.278513877, 1039856.4844335921],\n [2343639.7107855356, 3455343.3108375454, 575975.8749662543, 2062079.2399570548, 943721.1931707633, 1427995.4150203674, 1794989.6453295103, 3706392.097841614, 1053620.7288649315, 2050115.5214378452, 1636770.4499809493, 0.0, 812548.5062332726, 3191662.5092484164, 2564665.4531581327, 1690942.142157212],\n [2031500.319603397, 3179102.5335818897, 933602.6426595236, 1590460.9488364782, 598728.757362067, 1610768.421819668, 1129464.5539648102, 3382851.415271485, 967859.8344376946, 1872971.1741522516, 1932616.2801687205, 812548.5062332726, 0.0, 3364908.7076308434, 2551338.215149899, 1490589.7393085626],\n [1913900.3015914203, 1754834.3710577146, 3767490.41517038, 2434801.332310659, 2779561.192116527, 1788903.6065106322, 4404737.747850686, 2022974.6418062754, 4179636.203479384, 1708236.6189296674, 1559260.024532222, 3191662.5092484164, 3364908.7076308434, 0.0, 973244.7750437199, 2000112.4162614697],\n [946854.1020487415, 1202616.154562711, 3120118.850020503, 1462408.5353501518, 1952618.0544916363, 1161480.3557326929, 3516794.375197078, 1509585.60107986, 3448359.745690545, 752855.8488125347, 1130480.278513877, 2564665.4531581327, 2551338.215149899, 973244.7750437199, 0.0, 1089830.6426635552],\n [665894.0336505901, 1766599.1336905772, 2186473.1552241463, 662752.1291133759, 899656.1020173575, 730446.8613086065, 2427457.036285458, 2015770.1390589625, 2428862.4239271535, 384122.2000072272, 1039856.4844335921, 1690942.142157212, 1490589.7393085626, 2000112.4162614697, 1089830.6426635552, 0.0]])\n\n solver = FacilityOrderSolver(matrix, home_index)\n \n return solver.solve(indices_to_visit)","def drought_env_risk_map(request):\n \n view_center = [-105.2, 39.0]\n view_options = MVView(\n projection='EPSG:4326',\n center=view_center,\n zoom=7.0,\n maxZoom=12,\n minZoom=5\n )\n\n # TIGER state/county mapserver\n tiger_boundaries = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\n legend_title='States & Counties',\n layer_options={'visible':True,'opacity':0.2},\n legend_extent=[-112, 36.3, -98.5, 41.66]) \n \n ##### WMS Layers - Ryan\n usdm_legend = MVLegendImageClass(value='Drought Category',\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\n usdm_current = MVLayer(\n source='ImageWMS',\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\n layer_options={'visible':False,'opacity':0.25},\n legend_title='USDM',\n legend_classes=[usdm_legend],\n legend_extent=[-126, 24.5, -66.2, 49])\n \n # USGS Rest server for HUC watersheds \n watersheds = MVLayer(\n source='TileArcGISRest',\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\n legend_title='HUC Watersheds',\n layer_options={'visible':False,'opacity':0.4},\n legend_extent=[-112, 36.3, -98.5, 41.66])\n \n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\n vuln_legend = MVLegendImageClass(value='Risk Score',\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\n environ_vuln_kml = MVLayer(\n source='KML',\n options={'url': '/static/tethys_gizmos/data/CO_Environ_vuln_score_2018.kml'},\n layer_options={'visible':True,'opacity':0.75},\n legend_title='Environ Risk Score',\n feature_selection=True,\n legend_classes=[vuln_legend],\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\n \n # Define GeoJSON layer\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\n with open(como_cocorahs) as f:\n data = json.load(f)\n \n # the section below is grouping data by 'scalebar' drought condition\n # this is a work around for displaying each drought report classification with a unique colored icon\n data_sd = {}; data_md ={}; data_ml={}\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\n for element in data['features']:\n if 'Severely Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_sd[u'features'].append(element)\n if 'Moderately Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_md[u'features'].append(element)\n if 'Mildly Dry' in element['properties']['scalebar']:\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\"%Y-%m-%d\")\n if rdate >= week20:\n data_ml[u'features'].append(element)\n \n cocojson_sevdry = MVLayer(\n source='GeoJSON',\n options=data_sd,\n legend_title='CoCoRaHS Condition Monitor',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_moddry = MVLayer(\n source='GeoJSON',\n options=data_md,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n cocojson_mildry = MVLayer(\n source='GeoJSON',\n options=data_ml,\n legend_title='',\n legend_extent=[-112, 36.3, -98.5, 41.66],\n feature_selection=False,\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\n\n \n # Define map view options\n drought_env_risk_map_view_options = MapView(\n height='100%',\n width='100%',\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\n {'MousePosition': {'projection': 'EPSG:4326'}},\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,environ_vuln_kml,usdm_current,watersheds],\n view=view_options,\n basemap='OpenStreetMap',\n legend=True\n )\n\n context = {\n 'drought_env_risk_map_view_options':drought_env_risk_map_view_options,\n }\n\n return render(request, 'co_drought/drought_env_risk.html', context)","def main(\n num_sampled=[3, 3],\n max_depth=2,\n num_iters=1000,\n do_graph=False,\n # These are for checking stats on smaller data\n subsample=False,\n plot=False,\n # Generates a random matrix for comparison\n random=False,\n # Visualise the connection matrix\n vis_connect=False,\n subsample_vis=False,\n # Generate final graphs\n final=False,\n # Analyse\n analyse=False,\n only_exp=False,\n # Which regions are considered here\n # A_name, B_name = \"MOp\", \"SSP-ll\"\n A_name=\"VISp\",\n B_name=\"VISl\",\n desired_depth=1,\n desired_samples=79,\n):\n np.random.seed(42)\n\n if random:\n AB, BA, AA, BB = gen_random_matrix(150, 50, 0, 0.04, 0, 0.0)\n matrix_vis(AB, BA, AA, BB, 10, name=\"test_vis.png\")\n\n os.makedirs(os.path.dirname(pickle_loc), exist_ok=True)\n convert_mouse_data(A_name, B_name)\n to_use = [True, True, True, True]\n mc, args_dict = load_matrix_data(to_use, A_name, B_name)\n print(\"{} - {}, {} - {}\".format(A_name, B_name, mc.num_a, mc.num_b))\n\n result = {}\n result[\"matrix_stats\"] = print_args_dict(args_dict, out=False)\n\n if only_exp:\n mpf_res = mpf_connectome(mc, num_sampled, max_depth, args_dict)\n mpf_val = [\n mpf_res[\"expected\"],\n mpf_res[\"expected\"] / num_sampled[1],\n \"{}_{}\".format(A_name, B_name),\n \"Statistical estimation\",\n ]\n if do_graph:\n print(\"Converting matrix\")\n gc.collect()\n mc.create_connections()\n print(\"Finished conversion\")\n graph = mc.graph\n to_write = [mc.num_a, mc.num_b]\n del mc\n gc.collect()\n reverse_graph = reverse(graph)\n graph_res = graph_connectome(\n num_sampled,\n max_depth,\n graph=graph,\n reverse_graph=reverse_graph,\n to_write=to_write,\n num_iters=num_iters,\n )\n to_add = np.mean(graph_res[\"full_results\"][\"Connections\"].values)\n graph_val = [\n to_add,\n to_add / num_sampled[1],\n \"{}_{}\".format(A_name, B_name),\n \"Statistical estimation\",\n ]\n return mpf_val, graph_val\n return mpf_val, None\n\n # Convert to a pickle\n # if not os.path.isfile(pickle_loc):\n # print(\"Converting matrix\")\n # gc.collect()\n # mc.create_connections()\n # print(\"Finished conversion\")\n # graph = mc.graph\n # to_write = [mc.num_a, mc.num_b]\n # del mc\n # gc.collect()\n\n # handle_pickle(graph, \"graph.pickle\", \"w\")\n # handle_pickle(reverse(graph), \"r_graph.pickle\", \"w\")\n # handle_pickle(to_write, \"graph_size.pickle\", \"w\")\n\n if vis_connect:\n if subsample_vis:\n print(\"Plotting subsampled matrix vis\")\n new_mc = mc.subsample(int(mc.num_a / 10), int(mc.num_b / 10))\n matrix_vis(\n new_mc.ab,\n new_mc.ba,\n new_mc.aa,\n new_mc.bb,\n 15,\n name=\"mc_mat_vis_sub10.pdf\",\n )\n else:\n o_name = \"mc_mat_vis_{}_to_{}.pdf\".format(A_name, B_name)\n print(\"Plotting full matrix vis\")\n matrix_vis(mc.ab, mc.ba, mc.aa, mc.bb, 150, name=o_name)\n print(\"done vis\")\n\n print(mc, print_args_dict(args_dict, out=False))\n\n result = None\n if subsample:\n result = check_stats(mc, 1000, 1, 20000, 1, plot)\n if final:\n result = {}\n\n # For different depths and number of samples\n for depth in range(1, 4):\n for ns in range(1, num_sampled[0] + 1):\n ns_2 = [ns] * 2\n mpf_res = mpf_connectome(mc, ns_2, depth, args_dict)\n result[\"mpf_{}_{}\".format(depth, ns)] = mpf_res\n\n # Save this for plotting\n cols = [\"Number of samples\", \"Proportion of connections\", \"Max distance\"]\n depth_name = [None, \"Direct synapse\", \"Two synapses\", \"Three synapses\"]\n vals = []\n for depth in range(1, 4):\n for ns in range(1, num_sampled[0] + 1):\n this = result[\"mpf_{}_{}\".format(depth, ns)]\n val = [ns, this[\"expected\"] / ns, depth_name[depth]]\n vals.append(val)\n df = pd.DataFrame(vals, columns=cols)\n os.makedirs(os.path.join(here, \"..\", \"results\"), exist_ok=True)\n df.to_csv(\n os.path.join(\n here, \"..\", \"results\", \"{}_to_{}_depth.csv\".format(A_name, B_name)\n ),\n index=False,\n )\n\n cols = [\"Number of sampled connected neurons\", \"Probability\"]\n total_pmf = result[\"mpf_{}_{}\".format(desired_depth, desired_samples)][\"total\"]\n vals = []\n for k, v in total_pmf.items():\n vals.append([k, float(v)])\n df = pd.DataFrame(vals, columns=cols)\n df.to_csv(\n os.path.join(\n here,\n \"..\",\n \"results\",\n \"{}_to_{}_pmf_{}_{}.csv\".format(\n A_name, B_name, desired_depth, desired_samples\n ),\n ),\n index=False,\n )\n if analyse:\n result = {}\n result[\"matrix_stats\"] = args_dict\n\n mpf_res = mpf_connectome(\n mc,\n num_sampled,\n max_depth,\n args_dict,\n clt_start=30,\n sr=None,\n mean_estimate=True,\n )\n result[\"mean\"] = mpf_res\n\n vals = []\n cols = [\"Number of connected neurons\", \"Probability\", \"Calculation\"]\n for k, v in mpf_res[\"total\"].items():\n vals.append([k, float(v), \"Mean estimation\"])\n\n mpf_res = mpf_connectome(mc, num_sampled, max_depth, args_dict, clt_start=30)\n result[\"mpf\"] = mpf_res\n\n for k, v in mpf_res[\"total\"].items():\n vals.append([k, float(v), \"Statistical estimation\"])\n\n if do_graph:\n print(\"Converting matrix\")\n gc.collect()\n mc.create_connections()\n print(\"Finished conversion\")\n graph = mc.graph\n to_write = [mc.num_a, mc.num_b]\n del mc\n gc.collect()\n reverse_graph = reverse(graph)\n\n graph_res = graph_connectome(\n num_sampled,\n max_depth,\n graph=graph,\n reverse_graph=reverse_graph,\n to_write=to_write,\n num_iters=num_iters,\n )\n\n result[\"difference\"] = (\n dist_difference(mpf_res[\"total\"], graph_res[\"dist\"]),\n )\n result[\"graph\"] = graph_res\n\n for k, v in graph_res[\"dist\"].items():\n vals.append([k, float(v), \"Monte Carlo simulation\"])\n\n df = pd.DataFrame(vals, columns=cols)\n df.to_csv(\n os.path.join(\n here,\n \"..\",\n \"results\",\n \"{}_to_{}_pmf_final_{}_{}.csv\".format(\n A_name, B_name, max_depth, num_sampled[0]\n ),\n ),\n index=False,\n )\n\n if result is not None:\n with open(os.path.join(here, \"..\", \"results\", \"mouse.txt\"), \"w\") as f:\n pprint(result, width=120, stream=f)\n\n return result","def __init__(self,\r\n ox=0.0, oy=0.0, oz=0.0,\r\n dx=1.0, dy=1.0, dz=1.0,\r\n nx=200, ny=200, nz=10,\r\n gtype='points', gname='image',\r\n periodicity=False):\r\n\r\n self.ox = ox\r\n self.oy = oy\r\n self.oz = oz\r\n self.dx = dx\r\n self.dy = dy\r\n self.dz = dz\r\n self.nx = nx\r\n self.ny = ny\r\n self.nz = nz\r\n self.gtype = gtype\r\n self.gname = gname\r\n self.periodicity = periodicity\r\n\r\n if self.gtype == 'points':\r\n self.points = self.nx*self.ny*self.nz\r\n elif self.gtype == 'cells':\r\n self.cells = (self.nx-1 if self.nx> 1 else 1)*(self.ny-1 if self.ny> 1 else 1)*(self.nz-1 if self.nz> 1 else 1)\r\n\r\n # Compute the size of the grid\r\n self._lx = None #self.dx * self.nx - self.ox\r\n self._ly = None #self.dy * self.ny - self.oy\r\n self._lz = None #self.dz * self.nz - self.oz\r","def go_or_grow(lgca):\n relevant = lgca.cell_density[lgca.nonborder] > 0\n coords = [a[relevant] for a in lgca.nonborder]\n n_m = lgca.nodes[..., :lgca.velocitychannels].sum(-1)\n n_r = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\n M1 = np.minimum(n_m, lgca.restchannels - n_r)\n M2 = np.minimum(n_r, lgca.velocitychannels - n_m)\n for coord in zip(*coords):\n # node = lgca.nodes[coord]\n n = lgca.cell_density[coord]\n\n n_mxy = n_m[coord]\n n_rxy = n_r[coord]\n\n rho = n / lgca.K\n j_1 = npr.binomial(M1[coord], tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\n j_2 = npr.binomial(M2[coord], 1 - tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\n n_mxy += j_2 - j_1\n n_rxy += j_1 - j_2\n n_mxy -= npr.binomial(n_mxy * np.heaviside(n_mxy, 0), lgca.r_d)\n n_rxy -= npr.binomial(n_rxy * np.heaviside(n_rxy, 0), lgca.r_d)\n M = min([n_rxy, lgca.restchannels - n_rxy])\n n_rxy += npr.binomial(M * np.heaviside(M, 0), lgca.r_b)\n\n v_channels = [1] * n_mxy + [0] * (lgca.velocitychannels - n_mxy)\n v_channels = npr.permutation(v_channels)\n r_channels = np.zeros(lgca.restchannels)\n r_channels[:n_rxy] = 1\n node = np.hstack((v_channels, r_channels))\n lgca.nodes[coord] = node"],"string":"[\n \"def view_marginals_cristobal(rep=0, epoch=300, zoom=False):\\n samples_path = paths.eICU_synthetic_dir + 'samples_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\\n samples = np.load(samples_path)\\n labels_path = paths.eICU_synthetic_dir + 'labels_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\\n labels = np.load(labels_path)\\n real_path = paths.eICU_task_data\\n raw_real_train = np.load(real_path).item()['X_train'].reshape(-1, 16, 4)\\n real_test = np.load(real_path).item()['X_test'].reshape(-1, 16, 4)\\n real_vali = np.load(real_path).item()['X_vali'].reshape(-1, 16, 4)\\n # discard vali, test\\n real, scaled_vali, scaled_test = scale_data(raw_real_train, real_vali, real_test)\\n real = raw_real_train\\n view_marginals_raw(raw_real_train, label='raw_real_train')\\n view_marginals_raw(real, label='real_train')\\n view_marginals_raw(samples, label='synthetic')\\n\\n variables = ['sao2', 'heartrate', 'respiration', 'systemicmean']\\n\\n # get the scaling factors\\n scaling_factors = {'a': np.zeros(shape=(16, 4)), 'b': np.zeros(shape=(16, 4))}\\n ranges = []\\n for var in range(4):\\n var_min = 100\\n var_max = 0\\n for timestep in range(16):\\n min_val = np.min([np.min(raw_real_train[:, timestep, var]), np.min(real_vali[:, timestep, var])])\\n max_val = np.max([np.max(raw_real_train[:, timestep, var]), np.max(real_vali[:, timestep, var])])\\n if min_val < var_min:\\n var_min = min_val\\n if max_val > var_max:\\n var_max = max_val\\n a = (max_val - min_val)/2\\n b = (max_val + min_val)/2\\n scaling_factors['a'][timestep, var] = a\\n scaling_factors['b'][timestep, var] = b\\n ranges.append([var_min, var_max])\\n\\n # now, scale the synthetic data manually\\n samples_scaled = np.zeros_like(samples)\\n for var in range(4):\\n for timestep in range(16):\\n samples_scaled[:, timestep, var] = samples[:, timestep, var]*scaling_factors['a'][timestep, var] + scaling_factors['b'][timestep, var]\\n\\n if zoom:\\n # use modes, skip for now\\n modes = False\\n if modes:\\n # get rough region of interest, then zoom in on it afterwards!\\n num_gradations = 5\\n gradations = np.linspace(-1, 1, num_gradations)\\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\\n lower = 0\\n real_grid = np.zeros(shape=(16, num_gradations, 4))\\n for (i, cutoff) in enumerate(gradations):\\n # take the mean over samples\\n real_frac = ((real > lower) & (real <= cutoff)).mean(axis=0)\\n lower = cutoff\\n real_grid[:, i, :] = real_frac\\n time_averaged_grid = np.mean(real_grid, axis=0)\\n # get the most populated part of the grid for each variable\\n grid_modes = np.argmax(time_averaged_grid, axis=0)\\n lower = 0\\n ranges = []\\n for i in grid_modes:\\n lower = gradations[i-1]\\n upper = gradations[i]\\n ranges.append([lower, upper])\\n else:\\n # hand-crafted ranges\\n ranges = [[88, 100], [30, 130], [7, 60], [35, 135]]\\n\\n num_gradations = 25\\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\\n grid = np.zeros(shape=(16, num_gradations, 4))\\n real_grid = np.zeros(shape=(16, num_gradations, 4))\\n assert samples.shape[-1] == 4\\n for var in range(4):\\n # allow for a different range per variable (if zoom)\\n low = ranges[var][0]\\n high = ranges[var][1]\\n gradations = np.linspace(low, high, num_gradations)\\n for (i, cutoff) in enumerate(gradations):\\n # take the mean over samples\\n frac = ((samples_scaled[:, :, var] > low) & (samples_scaled[:, :, var] <= cutoff)).mean(axis=0)\\n real_frac = ((real[:, :, var] > low) & (real[:, :, var] <= cutoff)).mean(axis=0)\\n low = cutoff\\n grid[:, i, var] = frac\\n real_grid[:, i, var] = real_frac\\n\\n # now plot this as an image\\n fig, axarr = plt.subplots(nrows=4, ncols=2, sharey='row', sharex=True)\\n axarr[0, 0].imshow(grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[1, 0].imshow(grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[2, 0].imshow(grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[3, 0].imshow(grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[0, 1].imshow(real_grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[1, 1].imshow(real_grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[2, 1].imshow(real_grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[3, 1].imshow(real_grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\\n\\n axarr[0, 0].set_title(\\\"synthetic\\\")\\n axarr[0, 1].set_title(\\\"real\\\")\\n for var in range(4):\\n low, high = ranges[var]\\n labels = np.linspace(low, high, num_gradations)[1::4]\\n labels = np.round(labels, 0)\\n axarr[var, 0].set_yticklabels(labels)\\n axarr[var, 0].set_yticks(np.arange(num_gradations)[1::4])\\n axarr[var, 0].set_ylabel(variables[var])\\n for ax in axarr[var, :]:\\n ax.yaxis.set_ticks_position('none')\\n ax.xaxis.set_ticks_position('none')\\n ax.set_adjustable('box-forced')\\n ax.spines['top'].set_visible(False)\\n ax.spines['bottom'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.spines['left'].set_visible(False)\\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\\n\\n axarr[-1, 0].set_xticks(np.arange(16)[::2])\\n axarr[-1, 1].set_xticks(np.arange(16)[::2])\\n\\n if zoom:\\n plt.suptitle('(zoomed)')\\n\\n plt.tight_layout(pad=0.0, w_pad=-5.0, h_pad=0.1)\\n plt.savefig(\\\"./experiments/eval/eICU_cristobal_marginals_r\\\" + str(rep) + \\\"_epoch\\\" + str(epoch) + \\\".png\\\")\\n\\n # now make the histograms\\n fig, axarr = plt.subplots(nrows=1, ncols=4)\\n axarr[0].set_ylabel(\\\"density\\\")\\n axarr[0].hist(real[:, :, 0].flatten(), normed=True, color='black', alpha=0.8, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='real')\\n axarr[1].hist(real[:, :, 1].flatten(), normed=True, color='black', alpha=0.8, range=ranges[1], bins=50)\\n axarr[2].hist(real[:, :, 2].flatten(), normed=True, color='black', alpha=0.8, range=ranges[2], bins=50)\\n axarr[3].hist(real[:, :, 3].flatten(), normed=True, color='black', alpha=0.8, range=ranges[3], bins=50)\\n axarr[0].hist(samples_scaled[:, :, 0].flatten(), normed=True, alpha=0.6, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='synthetic')\\n axarr[0].legend()\\n axarr[1].hist(samples_scaled[:, :, 1].flatten(), normed=True, alpha=0.6, range=ranges[1], bins=50)\\n axarr[2].hist(samples_scaled[:, :, 2].flatten(), normed=True, alpha=0.6, range=ranges[2], bins=50)\\n axarr[3].hist(samples_scaled[:, :, 3].flatten(), normed=True, alpha=0.6, range=ranges[3], bins=50)\\n for (var, ax) in enumerate(axarr):\\n ax.set_xlabel(variables[var])\\n ax.yaxis.set_ticks_position('none')\\n ax.xaxis.set_ticks_position('none')\\n ax.spines['top'].set_visible(False)\\n ax.spines['bottom'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.spines['left'].set_visible(False)\\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\\n\\n plt.gcf().subplots_adjust(bottom=0.2)\\n fig.set_size_inches(10, 3)\\n plt.savefig(\\\"./experiments/eval/eICU_cristobal_hist_r\\\" + str(rep) + \\\"_epoch\\\" + str(epoch) + \\\".png\\\")\\n\\n return True\",\n \"def generate_overview_tiles(self):\\n\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"NO\\\")\\n\\n print \\\"Generating Overview Tiles:\\\"\\n\\n if self.options.profile == 'garmin': # no overview tiles for 'garmin'\\n return\\n # Usage of existing tiles: from 4 underlying tiles generate one as overview.\\n\\n tcount = 0\\n zcount = 0\\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\\n tcount += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n zcount+=1\\n if self.options.resume:\\n count_tiles=tcount\\n zcount+=1\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\\n count_tiles += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n i_count = self.tile_exists(0, 0, 0,1)\\n if i_count == count_tiles:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; all-tiles [\\\",zcount,\\\"] zoom-levels with tiles[\\\",count_tiles,\\\"]\\\"\\n return\\n ti = 0\\n\\n # querysize = tilesize * 2\\n\\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\\n i_x_column_count=((tmaxx-tminx)+1)\\n i_y_column_count=((tmaxy-tminy)+1)\\n if self.options.verbose:\\n # tx in range(tminx, tmaxx+1) tminx[ 140798 ] tmaxx[ 140872 ] ; ((tmaxx-tmaxy)+1) x_tiles[ -35331 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : tx in range(tminx, tmaxx+1) tminx[\\\",tminx,\\\"] tmaxx[\\\",tmaxx,\\\"] ; ((tmaxx-tminx)+1) x_tiles[\\\",i_x_column_count,\\\"]\\\"\\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 176204 ] tminy[ 176126 ] ; ((tmaxy-tminy)) y_tiles[ 78 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] :ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\\\",tmaxy,\\\"] tminy[\\\",tminy,\\\"] ; ((tmaxy-tminy)) y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n if self.options.resume:\\n i_count = self.tile_exists(0, 0, tz,2)\\n print \\\"\\\\tTile generation skipped because of --??? ; x/y-tiles of z[\\\",tz,\\\"] x/y_tiles[\\\",tcount,\\\"] i_count[\\\",i_count,\\\"]\\\"\\n if i_count == tcount:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; x/y-tiles of z[\\\",tz,\\\"] x/y_tiles[\\\",tcount,\\\"]\\\"\\n break\\n for tx in range(tminx, tmaxx+1):\\n tmaxy_work=tmaxy\\n if self.options.resume:\\n i_count = self.tile_exists(tx, 0, tz,3)\\n print \\\"\\\\tTile generation skipped because of --??? ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"] i_count[\\\",i_count,\\\"]\\\"\\n if i_count == i_y_column_count:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n break\\n else:\\n if i_count > 0:\\n # this assums the rows are compleate, which may NOT be true 18-140798-176204.jpg\\n tmaxy_work-=i_count\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped to tmaxy[\\\",tmaxy_work,\\\"] because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\\n ty_osm=self.flip_y(tz,ty_tms)\\n ty=ty_tms\\n if self.options.tms_osm:\\n ty=ty_osm\\n if self.stopped:\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\\n break\\n\\n ti += 1\\n\\n if self.options.resume:\\n exists = self.tile_exists(tx, ty, tz,0)\\n if exists and self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume\\\"\\n else:\\n exists = False\\n\\n if not exists:\\n if self.options.verbose:\\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\\n try:\\n self.write_overview_tile(tx, ty, tz,self.options.tms_osm)\\n except ImageOutputException, e:\\n self.error(\\\"'%d/%d/%d': %s\\\" % (tz, tx, ty, e.message))\\n\\n if not self.options.verbose or self.is_subprocess:\\n self.progressbar( ti / float(tcount) )\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\",\n \"def main():\\n\\n cages = [\\n \\\"AABCCD\\\",\\n \\\"EFBCGD\\\",\\n \\\"EFFHGI\\\",\\n \\\"EJJHGI\\\",\\n \\\"EKJHGL\\\",\\n \\\"KKJLLL\\\",\\n ]\\n\\n peaks = [\\n (0, 1),\\n (0, 2),\\n (1, 3),\\n (1, 4),\\n (1, 5),\\n (2, 1),\\n (2, 3),\\n (3, 0),\\n (3, 5),\\n (4, 2),\\n (5, 1),\\n (5, 4),\\n ]\\n\\n extract = {\\n \\\"A\\\": (5, 2),\\n \\\"B\\\": (0, 3),\\n \\\"C\\\": (3, 2),\\n \\\"D\\\": (1, 4),\\n \\\"E\\\": (0, 1),\\n \\\"F\\\": (1, 5),\\n \\\"G\\\": (4, 2),\\n \\\"H\\\": (3, 5),\\n \\\"I\\\": (1, 0),\\n \\\"J\\\": (5, 5),\\n \\\"K\\\": (3, 4),\\n \\\"L\\\": (5, 1),\\n \\\"M\\\": (0, 5),\\n \\\"N\\\": (4, 4),\\n }\\n\\n def answer(sg):\\n solved_grid = sg.solved_grid()\\n s = \\\"\\\"\\n s += chr(64 + solved_grid[extract[\\\"A\\\"]] + solved_grid[extract[\\\"B\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"C\\\"]] + solved_grid[extract[\\\"D\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"E\\\"]] + solved_grid[extract[\\\"F\\\"]] + solved_grid[extract[\\\"G\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"H\\\"]] + solved_grid[extract[\\\"I\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"J\\\"]] + solved_grid[extract[\\\"K\\\"]] + solved_grid[extract[\\\"L\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"M\\\"]] + solved_grid[extract[\\\"N\\\"]])\\n return s\\n\\n sym = grilops.make_number_range_symbol_set(1, 6)\\n lattice = grilops.get_square_lattice(6)\\n sg = grilops.SymbolGrid(lattice, sym)\\n\\n add_sudoku_constraints(sg)\\n\\n # Constrain regions to match the cages and be rooted at the peaks.\\n cage_label_to_region_id = {}\\n for py, px in peaks:\\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\\n\\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\\n for y, x in lattice.points:\\n sg.solver.add(\\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\\n\\n # Within each region, a parent cell must have a greater value than a child\\n # cell, so that the values increase as you approach the root cell (the peak).\\n for p in lattice.points:\\n for n in sg.edge_sharing_neighbors(p):\\n sg.solver.add(Implies(\\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\\n n.symbol > sg.grid[p]\\n ))\\n\\n if sg.solve():\\n sg.print()\\n print()\\n print(answer(sg))\\n while not sg.is_unique():\\n print()\\n print(\\\"Alternate solution\\\")\\n sg.print()\\n print()\\n print(answer(sg))\\n else:\\n print(\\\"No solution\\\")\",\n \"def gen_obs_grid(self):\\n\\n topX, topY, botX, botY = self.get_view_exts()\\n\\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\\n\\n # for i in range(self.agent_dir + 1):\\n # grid = grid.rotate_left()\\n\\n # Process occluders and visibility\\n # Note that this incurs some performance cost\\n if not self.see_through_walls:\\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\\n self.agent_view_size // 2))\\n else:\\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\\n\\n # Make it so the agent sees what it's carrying\\n # We do this by placing the carried object at the agent's position\\n # in the agent's partially observable view\\n agent_pos = grid.width // 2, grid.height // 2\\n if self.carrying:\\n grid.set(*agent_pos, self.carrying)\\n else:\\n grid.set(*agent_pos, None)\\n\\n return grid, vis_mask\",\n \"def main():\\n dpi = 1\\n dpi = 2\\n width = int(360)\\n height = int(130)\\n mywidth = int(width*dpi)\\n myheight = int(height*dpi)\\n FWHM = 7.5 # degrees\\n FWHM = 10.0 # degrees\\n FWHM = 5.0 # degrees\\n FWHM = 3.0 # degrees\\n FWHM = 1.0 # degrees\\n weight = 1.\\n\\n nargs = len(sys.argv)\\n if nargs < 2:\\n print('GR: GRid Observations of integrated intensity produced by the T Command')\\n print('GR produces fits images for each of the horns used for the observations.')\\n print('For observations at the same coordinates, the ratios of intensities are also produced.')\\n print('The FITS format files require header information, which is copied from the')\\n print('Cold Load File provided by the user')\\n print('GR RA|GAL <cold file name> <savefile1> [<savefile2> ... <savefileN>]')\\n print(\\\"\\\")\\n print('Glen Langston, National Science Foundation -- 20 May 12')\\n exit()\\n\\n gridtype = sys.argv[1]\\n gridtype = gridtype.upper()\\n print('Grid Type: ', gridtype)\\n\\n # enable having ra going from 24 to 0 hours == 360 to 0 degrees\\n xsign = 1.\\n xoffset = 0.\\n if gridtype == 'RA':\\n xmin = 0.\\n xmax = 360.\\n ymin = -40.\\n ymax = 90.\\n maptype = 'RA'\\n elif gridtype == '-RA':\\n xmin = 0.\\n xmax = 360.\\n ymin = -40.\\n ymax = 90.\\n xsign = -1.\\n xoffset = 360. # when x = 360. should be at zero.\\n maptype = 'RA'\\n elif gridtype == '-EL':\\n xmin = 0.\\n xmax = 360.\\n ymin = 0.\\n ymax = 90.\\n xsign = -1.\\n xoffset = 360. # when x = 360. should be at zero.\\n maptype = 'AZEL'\\n elif gridtype == 'RA0':\\n xmin = 0.\\n xmax = 360.\\n ymin = -41.\\n ymax = 89.\\n xsign = -1.\\n xoffset = 180. # when x = 360. should be at zero.\\n gridtype = 'RA'\\n elif gridtype == 'GAL':\\n xmin = -180.\\n xmax = 180.\\n ymin = -90.\\n ymax = 90.\\n maptype = 'GAL'\\n\\n if gridtype != 'RA' and gridtype != 'GAL' and gridtype != '-RA' and gridtype != \\\"RA0\\\":\\n print('Error parsing grid type: ', gridtype)\\n print('1st argument should be either RA, -RA or GAL')\\n exit()\\n\\n rs = radioastronomy.Spectrum()\\n\\n if doRatio: \\n #create the grid with map parameters\\n grid1 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid2 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid3 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid4 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n # put each telescope in a different grid\\n grids = [grid1, grid2, grid3, grid4]\\n\\n gridall = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n \\n\\n projection = \\\"-AIT\\\"\\n# coldfile \\n coldfile = sys.argv[2]\\n# get telescope geographic location etc\\n print(\\\"Reading Observing parameters from: %s\\\" % (coldfile))\\n rs.read_spec_ast(coldfile)\\n print(\\\"Observer: %s \\\" % (rs.observer))\\n\\n# first read through all data and find hot load\\n names = sys.argv[3:]\\n names = sorted(names)\\n\\n firsttime = \\\"\\\"\\n lasttime = \\\"\\\"\\n count = 0\\n # setup grid indicies so that cpuIndex goes to the correct grid\\n # This assumes telescopes 2,3,4,5 are being used] \\n gridIndex = [0,0,0,1,2,3]\\n # for all save Files to Grid\\n for filename in names:\\n print(\\\"File: %s\\\" % (filename))\\n f = open(filename)\\n\\n date = \\\"Unknown\\\"\\n while date != \\\"\\\":\\n date, time, cpuIndex, telaz, telel, tSys, tRx, tRms, tint, KperC, tSourcemax, velSource, dV, tVSum, tVSumRms, tSumKmSec, dTSumKmSec, gainFactor = gainfactor.readSaveValues( f)\\n dlen = len(date)\\n if dlen < 1:\\n break\\n if date[0] == \\\"#\\\":\\n continue\\n # else not a comment process the line\\n count = count + 1\\n isodate = \\\"20\\\"+date+\\\"T\\\"+time\\n# print(\\\"DateTime: %s\\\" % (isodate))\\n rs.utc = datetime.datetime.strptime(isodate,\\\"%Y-%m-%dT%H:%M:%S\\\")\\n# print(\\\"Utc: %s\\\" % (rs.utc))\\n rs.telaz = telaz\\n rs.telel = telel\\n rs.azel2radec()\\n\\n ra = rs.ra\\n dec = rs.dec\\n lon = rs.gallon\\n lat = rs.gallat\\n tsum = tSumKmSec\\n tsdv = dTSumKmSec\\n tmax = tSourcemax\\n vave = tVSum\\n vsdv = tVSumRms\\n if firsttime == \\\"\\\":\\n firsttime = date\\n else:\\n lasttime = date\\n\\n# if vave > -100. and vave < 100:\\n# mygrid.convolve( lon, lat, vave, 1.)\\n iGrid = gridIndex[cpuIndex]\\n gainCorr = telescopefactors[iGrid]\\n tsum = tsum * gainCorr\\n if gridtype == 'RA':\\n if doRatio:\\n grids[iGrid].convolve(ra, dec, tsum, weight)\\n gridall.convolve( ra, dec, tsum, weight)\\n elif gridtype == '-RA':\\n x = (ra*xsign) + xoffset\\n if doRatio:\\n grids[iGrid].convolve(x, dec, tsum, weight)\\n gridall.convolve( x, dec, tsum, weight)\\n elif gridtype == 'RA0':\\n x = (ra*xsign) + xoffset\\n if x < 0:\\n x = x + xmax\\n elif x > xmax:\\n x = x - xmax\\n if doRatio:\\n grids[iGrid].convolve(x, dec, tsum, weight)\\n gridall.convolve( x, dec, tsum, weight)\\n else:\\n if doRatio:\\n grids[iGrid].convolve(lon, lat, tsum, weight)\\n gridall.convolve( lon, lat, tsum, weight)\\n\\n if count == 0:\\n print('Convolving Coordinates: ', ra, dec, lon, lat)\\n print('Convolving Intensities: ', tsum, tsdv, vave, vsdv)\\n print('Convolvign Parameters : ', n, time)\\n count = count + 1\\n # end reading all lines in save file\\n f.close()\\n\\n # normalize each of the gridded images\\n if doRatio:\\n grids[0].normalize()\\n grids[1].normalize()\\n grids[2].normalize()\\n grids[3].normalize()\\n gridall.normalize()\\n# mygrid.check()\\n# zmin = -1000.\\n# zmax = 3000.\\n# limit grid intensities for plotting\\n# mygrid.set_ij( 0, 0, zmax, 1.)\\n# mygrid.set_ij( 1, 1, zmin, 1.)\\n# mygrid.limit(zmin, zmax)\\n\\n subplots = False\\n\\n if subplots:\\n fig, ax = plt.subplots(figsize=(myheight, mywidth), dpi=dpi)\\n\\n if gridtype == 'RA':\\n cax = fig.add_axes([-180, 180], [-90, 90])\\n else:\\n cax = fig.add_axes([0, 24], [-90, 90])\\n\\n cbar = fig.colorbar(cax, ticks=[zmin, zmax], orientation='horizontal')\\n cbar.ax.set_yticklabels([str(zmin), str(zmax)])\\n\\n ax.set_title(\\\"Citizen Science: Horn observations of our Galaxy\\\")\\n else:\\n#y_ticks = ymin + (ymax-ymin)*ticks/myheight\\n\\n ticks = np.arange(0, mywidth, 30*dpi)\\n x_ticks = xmin + ((xmax-xmin)*ticks/mywidth)\\n\\n plt.imshow(gridall.image, interpolation='nearest', cmap=plt.get_cmap('jet'))\\n\\n if firsttime != lasttime:\\n plt.title(\\\"Citizen Science: Observing our Galaxy: %s to %s\\\" % (firsttime, lasttime))\\n else:\\n plt.title(\\\"Citizen Science: Observing our Galaxy: %s\\\" % (firsttime))\\n if gridtype == 'RA':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = ticks/(mywidth/24)\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == '-RA':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = 24 - (ticks/(mywidth/24))\\n labels[0] = 0\\n labels[0] = 24\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == '-EL':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Elevation (degrees)\\\")\\n labels = 24 - (ticks/(mywidth/24))\\n labels[0] = 0\\n labels[0] = 24\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == 'RA0': # put 0 hours in middle of plot\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = 12 - (ticks/(mywidth/24))\\n nlabels = len(labels)\\n for iii in range(nlabels):\\n if labels[iii] < 0:\\n labels[iii] = 24 + labels[iii]\\n if labels[iii] == 24:\\n labels[iii] = 0\\n yticks = np.arange(0, myheight, 15*dpi)\\n else:\\n yticks = np.arange(0, myheight, 30*dpi)\\n ticks = np.arange(0, mywidth, 30*dpi)\\n x_ticks = xmin + (xmax-xmin)*ticks/mywidth\\n labels = x_ticks\\n plt.xlabel(\\\"Galactic Longitude (degrees)\\\")\\n plt.ylabel(\\\"Galactic Latitude (degrees)\\\")\\n # wnat an integer list of labels\\n# slabels = str(labels)\\n print(ticks, labels)\\n y_ticks = ymax - (ymax-ymin)*yticks/myheight\\n plt.yticks(yticks, y_ticks)\\n plt.xticks(ticks, labels, rotation='horizontal')\\n plt.colorbar()\\n\\n crval2 = (xmin + xmax)/2.\\n crval1 = (ymin + ymax)/2.\\n cdelt1 = (-1./float(dpi)) - .001\\n cdelt2 = (1./float(dpi)) + .001\\n if doRatio:\\n# now show eacsh of the images\\n for iGrid in range(4):\\n imagetemp = copy.deepcopy(grids[iGrid].image)\\n imagetemp2 = copy.deepcopy(grids[iGrid].image)\\n kkk = myheight - 1\\n for jjj in range(myheight):\\n imagetemp[:][kkk] = imagetemp2[:][jjj]\\n kkk = kkk - 1\\n grids[iGrid].image = imagetemp\\n writeFitsImage( rs, iGrid+2, grids[iGrid], projection)\\n\\n # put each telescope in a different grid\\n ratio1 = copy.deepcopy(grid1)\\n ratio2 = copy.deepcopy(grid1)\\n ratio3 = copy.deepcopy(grid1)\\n gratios = [ratio1, ratio2, ratio3]\\n ratios = np.zeros(3)\\n rmss = np.zeros(3)\\n\\n jGrid = 3\\n for iGrid in range(3):\\n print(\\\"Gain Ratios for Telescopes T%d and T%d\\\" % (iGrid+2, jGrid+2))\\n ratio, rms, aratio = gridratio(grids[iGrid], grids[jGrid])\\n ratios[iGrid] = ratio\\n rmss[iGrid] = rms\\n writeFitsImage( rs, iGrid+2, aratio, projection)\\n \\n writeFitsImage( rs, 0, gridall, projection)\\n plt.show()\",\n \"def refl_analysis(self,dials_model):\\n Z = self.refl_table\\n indices = Z['miller_index']\\n expts = ExperimentListFactory.from_json_file(dials_model,\\n check_format=False)\\n self.dials_model=expts[0]\\n CRYS = self.dials_model.crystal\\n UC = CRYS.get_unit_cell()\\n strong_resolutions = UC.d(indices)\\n order = flex.sort_permutation(strong_resolutions, reverse=True)\\n Z[\\\"spots_order\\\"] = order\\n self.spots_pixels = flex.size_t()\\n spots_offset = flex.int(len(order),-1)\\n spots_size = flex.int(len(order),-1)\\n\\n P = panels = Z['panel']\\n S = shoeboxes = Z['shoebox']\\n N_visited = 0; N_bad = 0\\n for oidx in range(len(order)): #loop through the shoeboxes in correct order\\n sidx = order[oidx] # index into the Miller indices\\n ipanel = P[sidx]\\n slow_size = 254\\n fast_size = 254\\n panel_size=slow_size*fast_size\\n bbox = S[sidx].bbox\\n first_position = spots_offset[sidx] = self.spots_pixels.size()\\n for islow in range(max(0,bbox[2]-3), min(slow_size,bbox[3]+3)):\\n for ifast in range(max(0,bbox[0]-3), min(fast_size,bbox[1]+3)):\\n value = self.trusted_mask[ipanel][islow*slow_size + ifast]\\n N_visited += 1\\n if value: self.spots_pixels.append(ipanel*panel_size+islow*slow_size+ifast)\\n else: N_bad+=1\\n spot_size = spots_size[sidx] = self.spots_pixels.size() - first_position\\n Z[\\\"spots_offset\\\"] = spots_offset\\n Z[\\\"spots_size\\\"] = spots_size\\n print (N_visited,\\\"pixels were visited in the %d shoeboxes (with borders)\\\"%len(order))\\n print (N_bad,\\\"of these were bad pixels, leaving %d in target\\\"%(len(self.spots_pixels)))\",\n \"def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n hspc=(max_x-min_x)/x_divisions\\n vspc=(max_y-min_y)/y_divisions\\n\\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%.1f\\\" % hval)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%.1f\\\" % vval)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def compute_plan_with_gaddpg(self, state, ef_pose, vis=False):\\n joints = get_joints(self.joint_listener)\\n gaddpg_grasps_from_simulate_view(self.agent, state, cfg.RL_MAX_STEP, ef_pose)\\n print('finish simulate views')\\n # can use remaining timesteps to replan. Set vis to visualize collision and traj\\n self.expert_plan, self.standoff_idx = self.planner.expert_plan(cfg.RL_MAX_STEP, joints, ef_pose, state[0][0], vis=vis)\\n print('expert plan', self.expert_plan.shape)\\n print('standoff idx', self.standoff_idx)\",\n \"def drought_veg_index_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n\\n # NCDC Climate Divisions\\n climo_divs = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Climate Divisions',\\n layer_options={'visible':False,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### WMS Layers - Ryan\\n vdri_legend = MVLegendImageClass(value='VegDRI Cat',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_VDRI_EMODIS_1') \\n vegdri = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'DROUGHT_VDRI_EMODIS_1'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='VegDRI',\\n legend_classes=[vdri_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n # historical layers https://edcintl.cr.usgs.gov/geoserver/qdrivegdriemodis/wms?', 'params': {'LAYERS': 'qdrivegdriemodis_pd_1-sevenday-53-2017_mm_data'\\n\\n qdri_legend = MVLegendImageClass(value='QuickDRI Cat',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=DROUGHT_QDRI_EMODIS_1') \\n quickdri = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'DROUGHT_QDRI_EMODIS_1'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='QuickDRI',\\n legend_classes=[qdri_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n # historical layers: https://edcintl.cr.usgs.gov/geoserver/qdriquickdriraster/wms?', 'params': {'LAYERS': 'qdriquickdriraster_pd_1-sevenday-53-2017_mm_data' \\n \\n # Land Cover REST layer\\n #https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer\\n NLCD = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://www.mrlc.gov/arcgis/rest/services/LandCover/USGS_EROS_LandCover_NLCD/MapServer',\\n 'params': {'LAYERS': 'show6'}},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='NLCD',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # Define map view options\\n drought_veg_index_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,climo_divs,vegdri,quickdri,NLCD,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_veg_index_map_view_options':drought_veg_index_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_veg_index.html', context)\",\n \"def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\\n\\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\\n \\n \\n for i in np.arange(0,SHP[0],1):\\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\\n \\n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\\n \\n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\\n\\n # normalise lateral flow so that -ve= flow out of cells towards edges\\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\\n # fluxes if not normalised in this way.\\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\\n\\n # nabla is the inverted delta operator used to denote the divergence \\n # of a vector field, here applied to hydrological flow in m3/d \\n # calculated as dx/dt + dy/dt + dz/dt\\n\\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\\n \\n # divergence gives net in/outflow in m3/t\\n # cells/m3 = cells/mL *1000\\n\\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\\n\\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \\n\\n Cells[Cells<0] = 0\\n \\n CellColumnTot = Cells.sum(axis=1)\\n \\n\\n return Cells, CellColumnTot\",\n \"def gpt2_1w (station, dmjd,dlat,dlon,hell,it):\\n\\n# need to find diffpod and difflon\\n if (dlon < 0):\\n plon = (dlon + 2*np.pi)*180/np.pi;\\n else:\\n plon = dlon*180/np.pi;\\n# transform to polar distance in degrees\\n ppod = (-dlat + np.pi/2)*180/np.pi; \\n\\n# % find the index (line in the grid file) of the nearest point\\n# \\t % changed for the 1 degree grid (GP)\\n ipod = np.floor(ppod+1); \\n ilon = np.floor(plon+1);\\n \\n# normalized (to one) differences, can be positive or negative\\n#\\t% changed for the 1 degree grid (GP)\\n diffpod = (ppod - (ipod - 0.5));\\n difflon = (plon - (ilon - 0.5));\\n\\n\\n# change the reference epoch to January 1 2000\\n print('Modified Julian Day', dmjd)\\n dmjd1 = dmjd-51544.5 \\n\\n pi2 = 2*np.pi\\n pi4 = 4*np.pi\\n\\n# mean gravity in m/s**2\\n gm = 9.80665;\\n# molar mass of dry air in kg/mol\\n dMtr = 28.965E-3 \\n# dMtr = 28.965*10^-3 \\n# universal gas constant in J/K/mol\\n Rg = 8.3143 \\n\\n# factors for amplitudes, i.e. whether you want time varying\\n if (it==1):\\n print('>>>> no refraction time variation ')\\n cosfy = 0; coshy = 0; sinfy = 0; sinhy = 0;\\n else: \\n cosfy = np.cos(pi2*dmjd1/365.25)\\n coshy = np.cos(pi4*dmjd1/365.25) \\n sinfy = np.sin(pi2*dmjd1/365.25) \\n sinhy = np.sin(pi4*dmjd1/365.25) \\n cossin = np.matrix([1, cosfy, sinfy, coshy, sinhy])\\n# initialization of new vectors\\n p = 0; T = 0; dT = 0; Tm = 0; e = 0; ah = 0; aw = 0; la = 0; undu = 0;\\n undul = np.zeros(4)\\n Ql = np.zeros(4)\\n dTl = np.zeros(4)\\n Tl = np.zeros(4)\\n pl = np.zeros(4)\\n ahl = np.zeros(4)\\n awl = np.zeros(4)\\n lal = np.zeros(4)\\n Tml = np.zeros(4)\\n el = np.zeros(4)\\n#\\n pgrid, Tgrid, Qgrid, dTgrid, u, Hs, ahgrid, awgrid, lagrid, Tmgrid = read_4by5(station,dlat,dlon,hell)\\n#\\n for l in [0,1,2,3]:\\n KL = l #silly to have this as a variable like this \\n# transforming ellipsoidal height to orthometric height:\\n# Hortho = -N + Hell\\n undul[l] = u[KL] \\n hgt = hell-undul[l] \\n# pressure, temperature at the height of the grid\\n T0 = Tgrid[KL,0] + Tgrid[KL,1]*cosfy + Tgrid[KL,2]*sinfy + Tgrid[KL,3]*coshy + Tgrid[KL,4]*sinhy;\\n tg = float(Tgrid[KL,:] *cossin.T)\\n# print(T0,tg)\\n\\n p0 = pgrid[KL,0] + pgrid[KL,1]*cosfy + pgrid[KL,2]*sinfy + pgrid[KL,3]*coshy + pgrid[KL,4]*sinhy;\\n \\n# humidity \\n Ql[l] = Qgrid[KL,0] + Qgrid[KL,1]*cosfy + Qgrid[KL,2]*sinfy + Qgrid[KL,3]*coshy + Qgrid[KL,4]*sinhy;\\n \\n# reduction = stationheight - gridheight\\n Hs1 = Hs[KL]\\n redh = hgt - Hs1;\\n\\n# lapse rate of the temperature in degree / m\\n dTl[l] = dTgrid[KL,0] + dTgrid[KL,1]*cosfy + dTgrid[KL,2]*sinfy + dTgrid[KL,3]*coshy + dTgrid[KL,4]*sinhy;\\n \\n# temperature reduction to station height\\n Tl[l] = T0 + dTl[l]*redh - 273.15;\\n\\n# virtual temperature\\n Tv = T0*(1+0.6077*Ql[l]) \\n c = gm*dMtr/(Rg*Tv) \\n \\n# pressure in hPa\\n pl[l] = (p0*np.exp(-c*redh))/100 \\n \\n# hydrostatic coefficient ah\\n ahl[l] = ahgrid[KL,0] + ahgrid[KL,1]*cosfy + ahgrid[KL,2]*sinfy + ahgrid[KL,3]*coshy + ahgrid[KL,4]*sinhy;\\n \\n# wet coefficient aw\\n awl[l] = awgrid[KL,0] + awgrid[KL,1]*cosfy + awgrid[KL,2]*sinfy + awgrid[KL,3]*coshy + awgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# water vapor decrease factor la - added by GP\\n lal[l] = lagrid[KL,0] + lagrid[KL,1]*cosfy + lagrid[KL,2]*sinfy + lagrid[KL,3]*coshy + lagrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# mean temperature of the water vapor Tm - added by GP\\n Tml[l] = Tmgrid[KL,0] + Tmgrid[KL,1]*cosfy + Tmgrid[KL,2]*sinfy + Tmgrid[KL,3]*coshy + Tmgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\t\\t \\n# water vapor pressure in hPa - changed by GP\\n e0 = Ql[l]*p0/(0.622+0.378*Ql[l])/100; # % on the grid\\n aa = (100*pl[l]/p0)\\n bb = lal[l]+1\\n el[l] = e0*np.power(aa,bb) # % on the station height - (14) Askne and Nordius, 1987\\n \\n dnpod1 = np.abs(diffpod); # % distance nearer point\\n dnpod2 = 1 - dnpod1; # % distance to distant point\\n dnlon1 = np.abs(difflon);\\n dnlon2 = 1 - dnlon1;\\n \\n# pressure\\n R1 = dnpod2*pl[0]+dnpod1*pl[1];\\n R2 = dnpod2*pl[2]+dnpod1*pl[3];\\n p = dnlon2*R1+dnlon1*R2;\\n \\n# temperature\\n R1 = dnpod2*Tl[0]+dnpod1*Tl[1];\\n R2 = dnpod2*Tl[2]+dnpod1*Tl[3];\\n T = dnlon2*R1+dnlon1*R2;\\n \\n# temperature in degree per km\\n R1 = dnpod2*dTl[0]+dnpod1*dTl[1];\\n R2 = dnpod2*dTl[2]+dnpod1*dTl[3];\\n dT = (dnlon2*R1+dnlon1*R2)*1000;\\n \\n# water vapor pressure in hPa - changed by GP\\n R1 = dnpod2*el[0]+dnpod1*el[1];\\n R2 = dnpod2*el[2]+dnpod1*el[3];\\n e = dnlon2*R1+dnlon1*R2;\\n \\n# hydrostatic\\n R1 = dnpod2*ahl[0]+dnpod1*ahl[1];\\n R2 = dnpod2*ahl[2]+dnpod1*ahl[3];\\n ah = dnlon2*R1+dnlon1*R2;\\n \\n# wet\\n R1 = dnpod2*awl[0]+dnpod1*awl[1];\\n R2 = dnpod2*awl[2]+dnpod1*awl[3];\\n aw = dnlon2*R1+dnlon1*R2;\\n \\n# undulation\\n R1 = dnpod2*undul[0]+dnpod1*undul[1];\\n R2 = dnpod2*undul[2]+dnpod1*undul[3];\\n undu = dnlon2*R1+dnlon1*R2;\\n\\n# water vapor decrease factor la - added by GP\\n R1 = dnpod2*lal[0]+dnpod1*lal[1];\\n R2 = dnpod2*lal[2]+dnpod1*lal[3];\\n la = dnlon2*R1+dnlon1*R2;\\n\\t\\t\\n# mean temperature of the water vapor Tm - added by GP\\n R1 = dnpod2*Tml[0]+dnpod1*Tml[1];\\n R2 = dnpod2*Tml[2]+dnpod1*Tml[3];\\n Tm = dnlon2*R1+dnlon1*R2; \\n\\n return p, T, dT,Tm,e,ah,aw,la,undu\",\n \"def GetCoastGrids(LandMask):\\n \\n \\\"\\\"\\\"\\n Define a coastline map. This map will be set to 1 on all coast cells.\\n \\\"\\\"\\\"\\n \\n \\n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\\n \\n \\\"\\\"\\\"\\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \\n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \\n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \\n \\\"\\\"\\\"\\n \\n for i in range(LandMask.shape[0]-1):\\n for j in range(LandMask.shape[1]-1):\\n \\n\\n \\\"\\\"\\\"\\n We have nine if statements, four for the corners, four for the sides and one for the middle\\n of the landmask. \\n \\\"\\\"\\\"\\n\\n if i == 0 and j == 0: #upper left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n \\n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1, j] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n \\n \\n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j-1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j-1] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i-1,j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i-1,j] = 1 \\n CoastlineMap[i-1, j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i-1, j] = 1\\n CoastlineMap[i-1,j-1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n \\n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j+1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n else:\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1 #middle\\n CoastlineMap[i+1,j] = 1#lowermiddle\\n CoastlineMap[i-1,j] = 1#uppermiddle\\n \\n CoastlineMap[i+1, j-1] = 1\\n CoastlineMap[i-1, j-1] = 1\\n CoastlineMap[i, j-1] =1\\n \\n CoastlineMap[i+1, j+1] = 1\\n CoastlineMap[i-1, j+1] = 1\\n CoastlineMap[i, j+1] = 1\\n \\n \\n \\n \\\"\\\"\\\"\\n Here we substract the landmaks from the coastline mask, resulting in only\\n the coastline. \\n \\\"\\\"\\\"\\n \\n \\n Coastgrids = CoastlineMap - LandMask\\n \\n return Coastgrids, CoastlineMap\",\n \"def visitspec(load,plate,mjd,fiber,gridfile='apg_rvsynthgrid',apstar=False) :\\n grid = fits.open(os.environ['APOGEE_DIR']+'/data/synthgrid/'+gridfile+'.fits')\\n if gridfile == 'apg_rvsynthgrid' : hdu=1\\n elif gridfile == 'apg_rvsynthgrid_v2': hdu=0\\n elif apstar : hdu=2\\n else : hdu=1\\n gridspec=grid[hdu].data\\n gridwave = 10.**spectra.fits2vector(grid[hdu].header,2)\\n griderr = np.ones(gridspec.shape[0])\\n #for ispec in range(gridspec.shape[1]) :\\n # cont = norm.cont(gridspec[:,ispec],griderr)\\n # gridspec[:,ispec] /= cont\\n\\n data = load.apVisit(plate,mjd,fiber)\\n\\n # compare with DR14 \\n comp(a,b,domatch=False,out='plots/dr14all')\\n grid.append(['dr14all_1.png',''])\\n xtit.append('all stars: DR14 (dotted) and test DR16 (solid)')\\n\\n comp(a,b,domatch=True,out='plots/dr14match')\\n grid.append(['dr14match_1.png','dr14match_2.png'])\\n xtit.append('same stars: DR14 (dotted) and test DR16 (solid)')\\n # set bad pixels to nan\\n shape=data[1].data.shape\\n spec = copy.copy(data[1].data).flatten()\\n specerr = copy.copy(data[2].data)\\n specwave=data[4].data\\n pixmask=bitmask.PixelBitMask()\\n bd = np.where( ((data[3].data & pixmask.badval()) > 0) | \\n ((data[3].data & pixmask.getval('SIG_SKYLINE')) > 0) ) [0]\\n spec[bd] = np.nan\\n spec = spec.reshape(shape)\\n\\n # continuum normalize and sample to grid\\n outspec = np.full(len(gridwave),np.nan)\\n if not apstar :\\n # apVisit wavelengths are reversed\\n spec=np.flip(spec)\\n specwave=np.flip(specwave)\\n specerr=np.flip(specerr)\\n for ichip in range(3) :\\n cont = norm.cont(spec[ichip,:],specerr[ichip,:])\\n spec[ichip,:] /= cont\\n gd=np.where(np.isfinite(spec[ichip,:]))[0]\\n ip= interpolate.InterpolatedUnivariateSpline(specwave[ichip,gd],spec[ichip,gd],k=3)\\n out = ip(gridwave)\\n gd = np.where( (gridwave > specwave[ichip,0]) & (gridwave < specwave[ichip,-1]) )[0]\\n outspec[gd] = out[gd]\\n plt.plot(specwave[ichip,:],spec[ichip,:])\\n plt.plot(gridwave[gd],out[gd])\\n plt.show()\\n\\n for ispec in range(gridspec.shape[1]) :\\n print(ispec)\\n bd=np.where(np.isnan(outspec))\\n outspec[bd]=1.\\n out=correlate(outspec,gridspec[:,ispec])\\n pdb.set_trace()\",\n \"def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n # Round to nearest integer space\\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n for hval in numpy.arange(min_x,\\n max_x+x_spacing/100.0,\\n x_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%d\\\" % int(hval+0.5))\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,\\n max_y+y_spacing/100.0,\\n y_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%d\\\" % int(vval+0.5))\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def DegViewshed (FLOOR, HEIGHT):\\n\\n #Select Record\\n arcpy.SelectLayerByAttribute_management(PointsFL,\\\"NEW_SELECTION\\\",SQL)\\n \\n #Set Observer Height (OffSETA)\\n arcpy.CalculateField_management(PointsFL,\\\"OFFSETA\\\",HEIGHT,\\\"PYTHON_9.3\\\")\\n \\n #perform viewshed analysis\\n arcpy.SetProgressorLabel(\\\"Performing Viewshed Analysis for point \\\"+str(value))\\n outViewshed = IntermediateFiles+\\\"\\\\\\\\vs_\\\"+str(FLOOR)+\\\"_\\\"+str(value).split(\\\".\\\")[0]\\n arcpy.Viewshed_3d(outCon,PointsFL,outViewshed)\\n\\n #convert viewshed to polygon\\n arcpy.SetProgressorLabel(\\\"Converting viewshed\\\"+str(value)+\\\" on floor \\\"+str(FLOOR)+\\\" to polygon.\\\")\\n OutPoly = IntermediateFiles+\\\"\\\\\\\\\\\"+os.path.basename(outViewshed).split(\\\".\\\")[0]+\\\"_poly.shp\\\"\\n arcpy.RasterToPolygon_conversion(outViewshed,OutPoly)\\n\\n #Intersect viewshed polygon with buffer clip\\n #This will allow the viewshed poly to inherit attribute fields needed for later analysis\\n FinalView = Final_Floor_Viewsheds+\\\"\\\\\\\\FinalViewshed_\\\"+str(FLOOR)+\\\"_\\\"+str(value)+\\\".shp\\\"\\n arcpy.Intersect_analysis([BufferClip,OutPoly],FinalView)\\n \\n #Select features in viewshed polygon with Gridcode = 1\\n #If no records with grid = 1 exist, scriptwill skip to setting viewshed in degrees to 0\\n \\n #Convert viewshed polygon to layer\\n ViewshedLayer = outName(FinalView,\\\"lyr\\\")\\n arcpy.MakeFeatureLayer_management(FinalView,ViewshedLayer)\\n\\n #Select records with gridcode = 1\\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\\\"NEW_SELECTION\\\",\\\"GRIDCODE =\\\"+str(1)+\\\"\\\") \\n\\n #Get count of the # of records selected in viewshed poly layer\\n VsLyrCount = int(arcpy.GetCount_management(ViewshedLayer).getOutput(0))\\n \\n NoView = SummaryTables+\\\"\\\\\\\\summary_\\\"+str(FLOOR)+\\\"_\\\"+str(value)+\\\".dbf\\\"\\n YesView = SummaryTables+\\\"\\\\\\\\summary_\\\"+str(FLOOR)+\\\"_\\\"+str(value)+\\\".dbf\\\"\\n StatsField0 = [[\\\"GRIDCODE\\\",\\\"SUM\\\"]]\\n CaseField0 = [\\\"ID\\\",\\\"SPOT\\\",FloorField] \\n StatsField1 = [[\\\"LENGTH\\\",\\\"SUM\\\"]]\\n CaseField1 = [\\\"GRIDCODE\\\",\\\"ID\\\",\\\"SPOT\\\",FloorField]\\n VsArcLengths = ArcLengths+\\\"\\\\\\\\ArcLength_\\\"+str(FLOOR)+\\\"_\\\"+str(value)+\\\".shp\\\"\\n \\n if VsLyrCount == 0: #no viewable areas exist\\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\\\"CLEAR_SELECTION\\\")\\n arcpy.SetProgressorLabel(\\\"Calculating viewshed statistics for parcel \\\"+str(value))\\n arcpy.Statistics_analysis(ViewshedLayer,NoView, StatsField0,CaseField0)\\n\\n #Add field to summary table to hold viewshed value of 0\\n #Add field to note which floor viewshed corresponds to\\n arcpy.AddField_management(NoView, \\\"FLR_RAN\\\",\\\"SHORT\\\")\\n arcpy.AddField_management(NoView, \\\"VIEW_\\\"+Year,\\\"DOUBLE\\\")\\n arcpy.AddField_management(NoView,\\\"OFFSETA\\\",\\\"SHORT\\\")\\n arcpy.CalculateField_management(NoView,\\\"FLR_RAN\\\",FLOOR)\\n arcpy.CalculateField_management(NoView,\\\"VIEW_\\\"+Year,0)\\n arcpy.CalculateField_management(NoView,\\\"OFFSETA\\\",HEIGHT)\\n\\n else: #Calculate viewshed, in degrees, for selected records\\n arcpy.SetProgressorLabel(\\\"Getting arc length for parcel\\\"+str(value)+\\\" at the \\\"+str(FLOOR)+\\\" floor.\\\")\\n arcpy.Intersect_analysis([BufferLine,ViewshedLayer],VsArcLengths,\\\"\\\",10,\\\"LINE\\\")#Intersect with any line within 10 ft. \\n arcpy.AddField_management(VsArcLengths, \\\"Length\\\",\\\"DOUBLE\\\")\\n arcpy.CalculateField_management(VsArcLengths,\\\"Length\\\",\\\"!SHAPE.length@miles!\\\",\\\"PYTHON_9.3\\\")\\n arcpy.Statistics_analysis(VsArcLengths,YesView,StatsField1,CaseField1)\\n\\n #Add fields to output summary table\\n arcpy.AddField_management(YesView,\\\"FLR_RAN\\\",\\\"SHORT\\\")\\n arcpy.AddField_management(YesView,\\\"VIEW_\\\"+Year,\\\"DOUBLE\\\")\\n arcpy.AddField_management(YesView,\\\"OFFSETA\\\",\\\"SHORT\\\")\\n arcpy.CalculateField_management(YesView,\\\"FLR_RAN\\\",FLOOR)\\n arcpy.CalculateField_management(YesView,\\\"OFFSETA\\\",HEIGHT)\\n arcpy.CalculateField_management(YesView,\\\"VIEW_\\\"+Year,\\\"((!SUM_LENGTH!/3.14)*180)\\\",\\\"PYTHON_9.3\\\")\\n arcpy.SelectLayerByAttribute_management(ViewshedLayer,\\\"CLEAR_SELECTION\\\")\",\n \"def gaddpg_grasps_from_simulate_view(gaddpg, state, time, ef_pose):\\n n = 30\\n mask = get_target_mask(state[0][0])\\n point_state = state[0][0][:, mask]\\n\\n # hand to base\\n point_state = se3_transform_pc(ef_pose, point_state)\\n print('target point shape', point_state.shape)\\n # target center is in base coordinate now\\n target_center = point_state.mean(1)[:3]\\n print('target center', target_center)\\n\\n # set up gaddpg\\n img_state = state[0][1]\\n gaddpg.policy.eval()\\n gaddpg.state_feature_extractor.eval()\\n\\n # sample view (simulated hand) in base\\n view_poses = np.array(sample_ef_view_transform(n, 0.2, 0.5, target_center, linspace=True, anchor=True))\\n\\n # base to view (simulated hand)\\n inv_view_poses = se3_inverse_batch(view_poses)\\n transform_view_points = np.matmul(inv_view_poses[:,:3,:3], point_state[:3]) + inv_view_poses[:,:3,[3]]\\n \\n # gaddpg generate grasps\\n point_state_batch = torch.from_numpy(transform_view_points).cuda().float()\\n time = torch.ones(len(point_state_batch) ).float().cuda() * 10. # time\\n point_state_batch = torch.cat((point_state_batch, torch.zeros_like(point_state_batch)[:, [0]]), dim=1)\\n policy_feat = gaddpg.extract_feature(img_state, point_state_batch, value=False, time_batch=time) \\n _,_,_,gaddpg_aux = gaddpg.policy.sample(policy_feat)\\n \\n # compose with ef poses \\n gaddpg_aux = gaddpg_aux.detach().cpu().numpy()\\n unpacked_poses = [unpack_pose_rot_first(pose) for pose in gaddpg_aux]\\n goal_pose_ws = np.matmul(view_poses, np.array(unpacked_poses)) # grasp to ef\\n planner_cfg.external_grasps = goal_pose_ws\\n\\n # show_grasps(view_poses, 'grasps')\\n # planner_cfg.external_grasps = view_poses\\n # planner_cfg.external_grasps = np.concatenate((goal_pose_ws, view_poses), axis=0) # also visualize view\\n planner_cfg.use_external_grasp = True\",\n \"def galex(band='fuv', ra_ctr=None, dec_ctr=None, size_deg=None, index=None, name=None, pgcname=None, model_bg=True, weight_ims=True, convert_mjysr=True, desired_pix_scale=GALEX_PIX_AS, imtype='intbgsub', wttype='rrhr'):\\n ttype = 'galex'\\n data_dir = os.path.join(_TOP_DIR, ttype, 'sorted_tiles')\\n problem_file = os.path.join(_WORK_DIR, 'problem_galaxies_{}.txt'.format(band))\\n numbers_file = os.path.join(_WORK_DIR, 'gal_reproj_info_{}.txt'.format(band))\\n\\n galaxy_mosaic_file = os.path.join(_MOSAIC_DIR, '_'.join([pgcname, band]).upper() + '.FITS')\\n\\n if not os.path.exists(galaxy_mosaic_file):\\n start_time = time.time()\\n print pgcname, band.upper()\\n\\n # READ THE INDEX FILE (IF NOT PASSED IN)\\n if index is None:\\n indexfile = os.path.join(_INDEX_DIR, 'galex_index_file.fits')\\n ext = 1\\n index, hdr = astropy.io.fits.getdata(indexfile, ext, header=True)\\n\\n # CALCULATE TILE OVERLAP\\n tile_overlaps = calc_tile_overlap(ra_ctr, dec_ctr, pad=size_deg,\\n min_ra=index['MIN_RA'],\\n max_ra=index['MAX_RA'],\\n min_dec=index['MIN_DEC'],\\n max_dec=index['MAX_DEC'])\\n\\n # FIND OVERLAPPING TILES WITH RIGHT BAND\\n # index file set up such that index['fuv'] = 1 where fuv and\\n # index['nuv'] = 1 where nuv\\n ind = np.where((index[band]) & tile_overlaps)\\n\\n\\n # MAKE SURE THERE ARE OVERLAPPING TILES\\n ct_overlap = len(ind[0])\\n if ct_overlap == 0:\\n with open(problem_file, 'a') as myfile:\\n myfile.write(pgcname + ': ' + 'No overlapping tiles\\\\n')\\n return\\n\\n pix_scale = desired_pix_scale / 3600. # 1.5 arbitrary: how should I set it?\\n\\n try:\\n # CREATE NEW TEMP DIRECTORY TO STORE TEMPORARY FILES\\n gal_dir = os.path.join(_WORK_DIR, '_'.join([pgcname, band]).upper())\\n os.makedirs(gal_dir)\\n\\n # MAKE HEADER AND EXTENDED HEADER AND WRITE TO FILE\\n gal_hdr = GalaxyHeader(pgcname, gal_dir, ra_ctr, dec_ctr, size_deg, pix_scale, factor=3)\\n\\n\\n # GATHER THE INPUT FILES\\n input_dir = os.path.join(gal_dir, 'input')\\n if not os.path.exists(input_dir):\\n os.makedirs(input_dir)\\n nfiles = get_input(index, ind, data_dir, input_dir, hdr=gal_hdr)\\n im_dir, wt_dir = input_dir, input_dir\\n\\n # WRITE TABLE OF INPUT IMAGE INFORMATION\\n input_table = os.path.join(im_dir, 'input.tbl')\\n montage.mImgtbl(im_dir, input_table, corners=True)\\n \\n if convert_mjysr:\\n converted_dir = os.path.join(gal_dir, 'converted')\\n if not os.path.exists(converted_dir):\\n os.makedirs(converted_dir)\\n convert_to_flux_input(im_dir, converted_dir, band, desired_pix_scale, imtype=imtype)\\n im_dir = converted_dir\\n\\n\\n # MASK IMAGES\\n masked_dir = os.path.join(gal_dir, 'masked')\\n im_masked_dir = os.path.join(masked_dir, imtype)\\n wt_masked_dir = os.path.join(masked_dir, wttype)\\n for outdir in [masked_dir, im_masked_dir, wt_masked_dir]:\\n os.makedirs(outdir)\\n\\n mask_images(im_dir, wt_dir, im_masked_dir, wt_masked_dir, imtype=imtype, wttype=wttype)\\n im_dir = im_masked_dir\\n wt_dir = wt_masked_dir\\n\\n\\n # REPROJECT IMAGES WITH EXTENDED HEADER\\n reprojected_dir = os.path.join(gal_dir, 'reprojected')\\n reproj_im_dir = os.path.join(reprojected_dir, imtype)\\n reproj_wt_dir = os.path.join(reprojected_dir, wttype)\\n for outdir in [reprojected_dir, reproj_im_dir, reproj_wt_dir]:\\n os.makedirs(outdir)\\n\\n reproject_images(gal_hdr.hdrfile_ext, im_dir, reproj_im_dir, imtype)\\n reproject_images(gal_hdr.hdrfile_ext, wt_dir, reproj_wt_dir, wttype)\\n im_dir = reproj_im_dir\\n wt_dir = reproj_wt_dir\\n\\n\\n # MODEL THE BACKGROUND IN THE IMAGE FILES WITH THE EXTENDED HEADER\\n if model_bg:\\n bg_model_dir = os.path.join(gal_dir, 'background_model')\\n diff_dir = os.path.join(bg_model_dir, 'differences')\\n corr_dir = os.path.join(bg_model_dir, 'corrected')\\n for outdir in [bg_model_dir, diff_dir, corr_dir]:\\n os.makedirs(outdir)\\n bg_model(im_dir, bg_model_dir, diff_dir, corr_dir, gal_hdr.hdrfile_ext, im_type=imtype, level_only=False)\\n im_dir = os.path.join(corr_dir, imtype)\\n\\n\\n # WEIGHT IMAGES\\n if weight_ims:\\n weight_dir = os.path.join(gal_dir, 'weighted')\\n im_weight_dir = os.path.join(weight_dir, imtype)\\n wt_weight_dir = os.path.join(weight_dir, wttype)\\n for outdir in [weight_dir, im_weight_dir, wt_weight_dir]:\\n os.makedirs(outdir)\\n\\n weight_images(im_dir, wt_dir, weight_dir, im_weight_dir, wt_weight_dir, imtype=imtype, wttype=wttype)\\n im_dir = im_weight_dir\\n wt_dir = wt_weight_dir\\n\\n\\n # CREATE THE METADATA TABLES NEEDED FOR COADDITION\\n weight_table = create_table(wt_dir, dir_type=wttype)\\n weighted_table = create_table(im_dir, dir_type=imtype)\\n\\n\\n # COADD THE REPROJECTED, WEIGHTED IMAGES AND THE WEIGHT IMAGES WITH THE REGULAR HEADER FILE\\n penultimate_dir = os.path.join(gal_dir, 'large_mosaic')\\n final_dir = os.path.join(gal_dir, 'mosaic')\\n for outdir in [penultimate_dir, final_dir]:\\n os.makedirs(outdir)\\n \\n coadd(gal_hdr.hdrfile, penultimate_dir, im_dir, output=imtype, add_type='mean')\\n coadd(gal_hdr.hdrfile, penultimate_dir, wt_dir, output=wttype, add_type='mean')\\n\\n\\n # DIVIDE OUT THE WEIGHTS AND CONVERT TO MJY/SR\\n imagefile, wtfile = finish_weight(penultimate_dir, imtype=imtype, wttype=wttype)\\n \\n\\n # COPY IMAGE AND WEIGHTS MOSAIC TO FINAL DIRECTORY\\n outfile = os.path.join(final_dir, 'final_mosaic.fits')\\n shutil.copy(imagefile, outfile)\\n shutil.copy(wtfile, os.path.join(final_dir, '{}_mosaic.fits'.format(wttype)))\\n\\n\\n # COPY MOSAIC FILES TO CUTOUTS DIRECTORY\\n mosaic_file = os.path.join(final_dir, 'final_mosaic.fits')\\n weight_file = os.path.join(final_dir, '{}_mosaic.fits'.format(wttype))\\n\\n newsuffs = ['.FITS', '_weight.FITS']\\n oldfiles = [mosaic_file, weight_file]\\n newfiles = ['_'.join([pgcname, band]).upper() + s for s in newsuffs]\\n\\n for files in zip(oldfiles, newfiles):\\n shutil.copy(files[0], os.path.join(_MOSAIC_DIR, files[1]))\\n\\n\\n # REMOVE TEMP GALAXY DIRECTORY AND EXTRA FILES\\n shutil.rmtree(gal_dir, ignore_errors=True)\\n\\n\\n # NOTE TIME TO FINISH\\n stop_time = time.time()\\n total_time = (stop_time - start_time) / 60.\\n\\n\\n # WRITE OUT THE NUMBER OF TILES THAT OVERLAP THE GIVEN GALAXY\\n out_arr = [pgcname, band.upper(), nfiles, np.around(total_time, 2)]\\n with open(numbers_file, 'a') as nfile:\\n nfile.write('{0: >10}'.format(out_arr[0]))\\n nfile.write('{0: >6}'.format(out_arr[1]))\\n nfile.write('{0: >6}'.format(out_arr[2]))\\n nfile.write('{0: >6}'.format(out_arr[3]) + '\\\\n')\\n\\n\\n # SOMETHING WENT WRONG -- WRITE ERROR TO FILE\\n except Exception as inst:\\n me = sys.exc_info()[0]\\n with open(problem_file, 'a') as myfile:\\n myfile.write(pgcname + ': ' + str(me) + ': '+str(inst)+'\\\\n')\\n shutil.rmtree(gal_dir, ignore_errors=True)\\n\\n return\",\n \"def main(ngrains=100,sigma=15.,c2a=1.6235,mu=0.,\\n prc='cst',isc=False,tilt_1=0.,\\n tilts_about_ax1=0.,tilts_about_ax2=0.):\\n if isc:\\n h = mmm()\\n else:\\n h=np.array([np.identity(3)])\\n gr = []\\n for i in range(ngrains):\\n dth = random.uniform(-180., 180.)\\n if prc=='cst': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=0) # Basal//ND\\n elif prc=='ext': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=1) # Basal//ED\\n else:\\n raise IOError('Unexpected option')\\n for j in range(len(h)):\\n temp = np.dot(g,h[j].T)\\n\\n ## tilts_about_ax1\\n if abs(tilts_about_ax1)>0:\\n g_tilt = rd_rot(tilts_about_ax1)\\n temp = np.dot(temp,g_tilt.T)\\n ## tilts_about_ax2?\\n elif abs(tilts_about_ax2)>0:\\n g_tilt = td_rot(tilts_about_ax2)\\n temp = np.dot(temp,g_tilt.T)\\n elif abs(tilts_about_ax2)>0 and abs(tilts_about_ax2)>0:\\n raise IOError('One tilt at a time is allowed.')\\n\\n phi1,phi,phi2 = euler(a=temp, echo=False)\\n gr.append([phi1,phi,phi2,1./ngrains])\\n\\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\\n mypf.pf_new(poles=[[0,0,0,2],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\\n return np.array(gr)\",\n \"def ggpl_house():\\n\\n\\t# .lines ogni riga ha due coppie di x/y che costituiscono un segmento\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/muri_esterni.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\texternalWalls = MKPOL([verts,cells,None])\\n\\tfloor = SOLIDIFY(externalWalls)\\n\\tfloor = S([1,2,3])([.04,.04,.04])(floor)\\n\\texternalWalls = S([1,2,3])([.04,.04,.04])(externalWalls)\\n\\texternalWalls = OFFSET([.2,.2,4])(externalWalls)\\n\\theightWalls = SIZE([3])(externalWalls)[0]\\n\\tthicknessWalls = SIZE([2])(externalWalls)[0]\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/muri_interni.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\tinternalWalls = MKPOL([verts,cells,None])\\n\\tinternalWalls = S([1,2,3])([.04,.04,.04])(internalWalls)\\n\\tinternalWalls = OFFSET([.2,.2,4])(internalWalls)\\n\\twalls = STRUCT([externalWalls, internalWalls])\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/porte.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\tdoors = MKPOL([verts,cells,None])\\n\\tdoors = SOLIDIFY(doors)\\n\\tdoors = S([1,2,3])([.04,.04,.04])(doors)\\n\\tdoors = OFFSET([.2,.2,3])(doors)\\n\\twalls = DIFFERENCE([walls, doors])\\n\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/finestre.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\twindows = MKPOL([verts,cells,None])\\n\\twindows = SOLIDIFY(windows)\\n\\twindows = S([1,2,3])([.04,.04,.04])(windows)\\n\\twindows = OFFSET([.2,.2,2])(windows)\\n\\theightWindows = SIZE([3])(windows)[0]\\n\\twindows = T(3)((heightWalls-heightWindows)/2.)(windows)\\n\\twalls = DIFFERENCE([walls, windows])\\n\\n\\tfloor = TEXTURE(\\\"texture/floor.jpg\\\")(floor)\\n\\twalls = TEXTURE(\\\"texture/wall.jpg\\\")(walls)\\n\\thome = STRUCT([floor, walls])\\n\\treturn home\",\n \"def generate_mos(laygen, objectname_pfix, placement_grid, routing_grid_m1m2, devname_mos_boundary, devname_mos_body,\\n devname_mos_dmy, m=1, m_dmy=0, origin=np.array([0,0])):\\n pg = placement_grid\\n rg12 = routing_grid_m1m2\\n pfix = objectname_pfix\\n\\n # placement\\n imbl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BL0', templatename=devname_mos_boundary, gridname=pg, xy=origin)\\n refi=imbl0\\n if not m_dmy==0:\\n imdmyl0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYL0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyl0\\n else:\\n imdmyl0 = None\\n im0 = laygen.relplace(name=\\\"I\\\" + pfix + '0', templatename=devname_mos_body, gridname=pg, refobj=refi, shape=[m, 1])\\n refi=im0\\n if not m_dmy==0:\\n imdmyr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'DMYR0', templatename=devname_mos_dmy, gridname=pg, refobj=refi, shape=[m_dmy, 1])\\n refi=imdmyr0\\n else:\\n imdmyr0 = None\\n imbr0 = laygen.relplace(name=\\\"I\\\" + pfix + 'BR0', templatename=devname_mos_boundary, gridname=pg, refobj=imdmyr0)\\n md=im0.elements[:, 0]\\n #route\\n #gate\\n rg0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['G0'], refobj1=md[-1].pins['G0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['G0'], gridname=rg12)\\n #drain\\n rdl0=laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=md[0].pins['D0'], refobj1=md[-1].pins['D0'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 1], refobj=_md.pins['D0'], gridname=rg12)\\n #source\\n rs0=laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=md[0].pins['S0'], refobj1=md[-1].pins['S1'])\\n for _md in md:\\n laygen.via(name=None, xy=[0, 0], refobj=_md.pins['S0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=md[-1].pins['S1'], gridname=rg12)\\n #dmy\\n if m_dmy>=2:\\n mdmyl=imdmyl0.elements[:, 0]\\n mdmyr=imdmyr0.elements[:, 0]\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyl[0].pins['D0'], refobj1=mdmyl[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 1], xy1=[0, 1], gridname0=rg12, refobj0=mdmyr[0].pins['D0'], refobj1=mdmyr[-1].pins['D0'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyl[0].pins['S0'], refobj1=mdmyl[-1].pins['S1'])\\n laygen.route(name=None, xy0=[0, 0], xy1=[0, 0], gridname0=rg12, refobj0=mdmyr[0].pins['S0'], refobj1=mdmyr[-1].pins['S1'])\\n for _mdmyl in mdmyl:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyl.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyl.pins['S0'], gridname=rg12)\\n for _mdmyr in mdmyr:\\n laygen.via(name=None, xy=[0, 1], refobj=_mdmyr.pins['D0'], gridname=rg12)\\n laygen.via(name=None, xy=[0, 0], refobj=_mdmyr.pins['S1'], gridname=rg12)\\n return [imbl0, imdmyl0, im0, imdmyr0, imbr0]\",\n \"def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\\n # assigning cost of changing from one leg to another based on the distance to the desired pose\\n cost_ChangeLeg = 1\\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\\n if dz_final < 1:\\n cost_ChangeLeg = 10\\n elif dz_final < 2:\\n cost_ChangeLeg = 20\\n else:\\n cost_ChangeLeg = 10\\n\\n # assigning weight for cost of predicted repositioning and cost of robot motion\\n w_cost_reposition = 40\\n w_cost_motion = 10\\n\\n # finding object's leg cordinates\\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\\n\\n # initialization (initializeing cost to infinity)\\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\\n cost_legchange = [0, 0, 0, 0]\\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\\n cost_manipulation = [0, 0, 0, 0]\\n cost_motion = [0, 0, 0, 0]\\n force = [0, 0, 0, 0]\\n path = [[[], []], [[], []], [[], []], [[], []]]\\n planned_path_w = [[],[],[],[]]\\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\\n command = [[], [], [], []]\\n des = [[], [], [], [], []]\\n PAM_goal = state()\\n\\n # find the nominal trajectory for manipulation\\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\\n\\n # itterate through each leg to find the leg with minimum cost\\n for leg in range(4):\\n phi_linear = theta\\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\\n \\t# find the cost and required force for manipulation for the leg\\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\\n \\t# adding cost of changing leg\\n if leg != current_leg:\\n cost_legchange[leg] = cost_ChangeLeg\\n # adding cost of PAM motion to PAM goal pose\\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\\n if cost_PAM[leg][push_pull]!= float(\\\"inf\\\"):\\n PAM_s_sim = copy.deepcopy(PAM_s)\\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n # adding cost of predicted re-positionings\\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\\n # print(n_transition)\\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\\n else:\\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\\n\\n if min(cost) < float(\\\"inf\\\"):\\n \\t[min_index, min_value] = [np.argmin(cost), min(cost)]\\n \\t# Finding the grasping goal pose based on the selected plan\\n \\tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\\n \\tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\\n \\tPAM_goal = state()\\n \\tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\\n \\tobject_path_planned = Path()\\n \\tobject_path_planned.header.frame_id = 'frame_0'\\n \\tfor i in range(len(planned_path_w[min_index])):\\n \\t\\tpose = PoseStamped()\\n \\t\\tpose.pose.position.x = planned_path_w[min_index][i][0]\\n \\t\\tpose.pose.position.y = planned_path_w[min_index][i][1]\\n \\t\\tpose.pose.position.z = 0\\n \\t\\tobject_path_planned.poses.append(pose)\\n\\n \\tPAM_path_planned = Path()\\n \\tPAM_path_planned.header.frame_id = 'frame_0'\\n \\tif min_index != current_leg:\\n \\t\\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\\n \\t\\t\\tpose = PoseStamped()\\n \\t\\t\\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\\n \\t\\t\\tPAM_path_planned.poses.append(pose)\\n else:\\n \\tmin_index = 5\\n \\tmin_value = float(\\\"inf\\\")\\n if 0 < min_index and min_index <= 4:\\n force_d = force[min_index][0]\\n else:\\n force_d = [0,0,0]\\n\\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\",\n \"def main():\\n\\n # Log messages to stdout\\n logging.basicConfig(\\n level=logging.DEBUG,\\n format=\\\"%(asctime)s [%(levelname)s] %(message)s\\\",\\n stream=sys.stdout,\\n )\\n\\n # Load the sample dataset: the US states and their corresponding population number.\\n # (data from https://www.census.gov/)\\n us_states_path = os.path.join(os.getcwd(), \\\"sample_data\\\", \\\"cb_2018_us_state_5m.shp\\\")\\n us_pop_path = os.path.join(os.getcwd(), \\\"sample_data\\\", \\\"nst-est2019-01.xlsx\\\")\\n us_states = gpd.read_file(us_states_path)\\n us_inhab = pd.read_excel(us_pop_path, skiprows=3, engine=\\\"openpyxl\\\").add_prefix(\\n \\\"pop_\\\"\\n )\\n # Tidy up rows and column names\\n us_inhab.rename(columns={us_inhab.columns[0]: \\\"NAME\\\"}, inplace=True)\\n us_inhab.NAME = us_inhab.NAME.str.replace(\\\".\\\", \\\"\\\")\\n # Join population numbers and us state geometries.\\n us_states = us_states.merge(us_inhab, on=\\\"NAME\\\").reset_index()\\n # Inspect the data\\n print(us_states.info())\\n\\n # Initialize a circle style cartogram for inhabitants per state in 2019.\\n circle_cg = CircleCartogram(\\n gdf=us_states,\\n size_column=\\\"pop_2019\\\",\\n mode=2,\\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\\n )\\n square_cg = SquareCartogram(\\n gdf=us_states,\\n size_column=\\\"pop_2019\\\",\\n mode=1,\\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\\n )\\n square2_cg = SquareCartogram(\\n gdf=us_states,\\n size_column=\\\"pop_2019\\\",\\n mode=4,\\n time_limit=60, # The total amount of seconds the model is allowed to run. Useful for working with mode 3.\\n )\\n\\n # Calculate the cartogram geometries.\\n circle_cg.calculate()\\n square_cg.calculate()\\n square2_cg.calculate()\\n\\n # Plot both the original map and the cartogram side by side.\\n gdfs = [us_states, circle_cg.gdf, square_cg.gdf, square2_cg.gdf]\\n m = Map(\\n gdfs=gdfs,\\n title=\\\"Population per US State in 2019\\\",\\n column=\\\"pop_2019\\\",\\n labels=\\\"STUSPS\\\",\\n )\\n m.ax[0][0].set_xlim(-150, -60)\\n m.plot()\\n plt.show()\",\n \"def generate_base_tiles(self):\\n\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"NO\\\")\\n\\n print \\\"Generating Base Tiles:\\\"\\n if self.options.verbose:\\n #mx, my = self.out_gt[0], self.out_gt[3] # OriginX, OriginY\\n #px, py = self.mercator.MetersToPixels( mx, my, self.tmaxz)\\n #print \\\"Pixel coordinates:\\\", px, py, (mx, my)\\n print\\n print \\\"Tiles generated from the max zoom level:\\\"\\n print \\\"----------------------------------------\\\"\\n print\\n\\n\\n # Set the bounds\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\\n querysize = self.querysize\\n\\n # Just the center tile\\n #tminx = tminx+ (tmaxx - tminx)/2\\n #tminy = tminy+ (tmaxy - tminy)/2\\n #tmaxx = tminx\\n #tmaxy = tminy\\n\\n #print tminx, tminy, tmaxx, tmaxy\\n tcount = (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n #print tcount\\n ti = 0\\n i_y_column_count=((tmaxy-tminy)+1)\\n ds = self.out_ds\\n tz = self.tmaxz\\n if self.options.verbose:\\n # tx in range(tminx, tmaxx+1) tminx[ 281596 ] tmaxx[ 281744 ] ; ((tmaxx-tmaxy)+1) x_tiles[ 23393 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : tx in range(tminx, tmaxx+1) tminx[\\\",tminx,\\\"] tmaxx[\\\",tmaxx,\\\"] ; ((tmaxx-tmaxy)+1) x_tiles[\\\",tcount,\\\"]\\\"\\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 352409 ] tminy[ 352253 ] ; ((tmaxy-tminy)) y_tiles[ 157 ] 352409-(352253-1)\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\\\",tmaxy,\\\"] tminy[\\\",tminy,\\\"] ; ((tmaxy-tminy+1)) y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n if self.options.resume:\\n i_count = self.tile_exists(0, 0, tz,2)\\n if i_count == tcount:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; x/y-tiles of z[\\\",tz,\\\"] y_tiles[\\\",tcount,\\\"]\\\"\\n return\\n for tx in range(tminx, tmaxx+1):\\n tmaxy_work=tmaxy\\n if self.options.resume:\\n i_count = self.tile_exists(tx, 0, tz,3)\\n if i_count == i_y_column_count:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n break\\n else:\\n if i_count > 0:\\n # this assums the rows are compleate, which may NOT be true\\n tmaxy_work-=i_count\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped to tmaxy[\\\",tmaxy_work,\\\"] because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\\n ty_osm=self.flip_y(tz,ty_tms)\\n ty=ty_tms\\n if self.options.tms_osm:\\n ty=ty_osm\\n if self.stopped:\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n break\\n ti += 1\\n\\n if self.options.resume:\\n exists = self.tile_exists(tx, ty, tz,0)\\n if exists and self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; x =\\\",tx,\\\" ; y_tms =\\\",ty_tms, \\\"; y_osm =\\\",ty_osm\\n else:\\n exists = False\\n\\n if not exists:\\n if self.options.verbose:\\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\\n # Don't scale up by nearest neighbour, better change the querysize\\n # to the native resolution (and return smaller query tile) for scaling\\n if self.options.profile in ('mercator','geodetic'):\\n if self.options.profile == 'mercator':\\n # Tile bounds in EPSG:900913\\n b = self.mercator.TileBounds(tx, ty_tms, tz)\\n elif self.options.profile == 'geodetic':\\n b = self.geodetic.TileBounds(tx, ty_tms, tz)\\n\\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1])\\n nativesize = wb[0]+wb[2] # Pixel size in the raster covering query geo extent\\n if self.options.verbose:\\n print \\\"\\\\tNative Extent (querysize\\\",nativesize,\\\"): \\\", rb, wb\\n\\n querysize = self.querysize\\n # Tile bounds in raster coordinates for ReadRaster query\\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1], querysize=querysize)\\n\\n rx, ry, rxsize, rysize = rb\\n wx, wy, wxsize, wysize = wb\\n else: # 'raster' or 'gearth' or 'garmin' profile:\\n tsize = int(self.tsize[tz]) # tilesize in raster coordinates for actual zoom\\n xsize = self.out_ds.RasterXSize # size of the raster in pixels\\n ysize = self.out_ds.RasterYSize\\n if tz >= self.nativezoom:\\n querysize = self.tilesize # int(2**(self.nativezoom-tz) * self.tilesize)\\n\\n rx = (tx) * tsize\\n rxsize = 0\\n if tx == tmaxx:\\n rxsize = xsize % tsize\\n if rxsize == 0:\\n rxsize = tsize\\n\\n rysize = 0\\n if ty_tms == tmaxy:\\n rysize = ysize % tsize\\n if rysize == 0:\\n rysize = tsize\\n ry = ysize - (ty_tms * tsize) - rysize\\n\\n wx, wy = 0, 0\\n\\n wxsize, wysize = int(rxsize/float(tsize) * querysize), int(rysize/float(tsize) * querysize)\\n if wysize != querysize:\\n wy = querysize - wysize\\n xyzzy = Xyzzy(querysize, rx, ry, rxsize, rysize, wx, wy, wxsize, wysize)\\n try:\\n if self.options.verbose:\\n print ti,'/',tcount,' total ; z =',tz,' ; x =',tx,' ; y_tms =',ty_tms,' ; y_osm =',ty_osm\\n print \\\"\\\\tReadRaster Extent: \\\", (rx, ry, rxsize, rysize), (wx, wy, wxsize, wysize)\\n self.write_base_tile(tx, ty, tz, xyzzy)\\n except ImageOutputException, e:\\n self.error(\\\"'%d/%d/%d': %s\\\" % (tz, tx, ty, e.message))\\n\\n if not self.options.verbose or self.is_subprocess:\\n self.progressbar( ti / float(tcount) )\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\",\n \"def make_NM08_grid(work_dir, log_base, max_range):\\n base_name = 'NM08'\\n dat = fdata.fdata(work_dir=work_dir)\\n dat.files.root = base_name\\n pad_1 = [1500., 1500.]\\n # Symmetric grid in x-y\\n base = log_base\\n dx = pad_1[0]\\n x1 = dx ** (1 - base) * np.linspace(0, dx, max_range) ** base\\n X = np.sort(list(pad_1[0] - x1) + list(pad_1[0] + x1)[1:] + [pad_1[0]])\\n # If no. z nodes > 100, temperature_gradient will not like it...\\n surface_deps = np.linspace(350, -750, 4)\\n cap_grid = np.linspace(-750, -1200, 4)\\n perm_zone = np.linspace(-1200., -2100., 30)\\n lower_reservoir = np.linspace(-2100, -3100, 10)\\n Z = np.sort(list(surface_deps) + list(cap_grid) + list(perm_zone)\\n + list(lower_reservoir))\\n dat.grid.make('{}_GRID.inp'.format(base_name), x=X, y=X, z=Z,\\n full_connectivity=True)\\n grid_dims = [3000., 3000.] # 5x7x5 km grid\\n # Geology time\\n dat.new_zone(1, 'suface_units', rect=[[-0.1, -0.1, 350 + 0.1],\\n [grid_dims[0] + 0.1,\\n grid_dims[1] + 0.1,\\n -750 - 0.1]],\\n permeability=[1.e-15, 1.e-15, 1.e-15], porosity=0.1,\\n density=2477, specific_heat=800., conductivity=2.2)\\n dat.new_zone(2, 'clay_cap', rect=[[-0.1, -0.1, -750],\\n [grid_dims[0] + 0.1,\\n grid_dims[1] + 0.1,\\n -1200 - 0.1]],\\n permeability=1.e-18, porosity=0.01, density=2500,\\n specific_heat=1200., conductivity=2.2)\\n return dat\",\n \"def CalculatePaths(self):\\n agrid = self.agrid \\n self.apath = array([0 for y in range(self.T)], dtype=float)\\n self.cpath = array([0 for y in range(self.T)], dtype=float)\\n self.npath = array([0 for y in range(self.T)], dtype=float)\\n # generate each generation's asset, consumption and labor supply forward\\n for y in range(self.T-1): # y = 0, 1,..., 58\\n self.apath[y+1] = max(0,interp1d(agrid, self.a[y], kind='cubic')(self.apath[y]))\\n if y >= self.W:\\n self.cpath[y], self.npath[y] = (1+self.r)*self.apath[y] + self.b - self.apath[y+1], 0\\n else:\\n self.cpath[y], self.npath[y] = self.solve(self.apath[y], self.apath[y+1])\\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\\n # the oldest generation's consumption and labor supply\\n self.cpath[self.T-1], self.npath[self.T-1] = (1+self.r)*self.apath[self.T-1]+self.b, 0\\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])\",\n \"def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\tlabels = ['no APMB', 'APMB']\\n\\tdeep = {}\\n\\tuzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795 # Why?\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\\n\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n\\n #this is just printing stuff for easier terminal reading\\n if h_agent is not None:\\n hstr = \\\"Specialized Human\\\"\\n else:\\n hstr = \\\"Random Human\\\"\\n if coagent is not None:\\n coagenthelp = True\\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\\n else:\\n coagenthelp = False\\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\\n\\n liRewards = []\\n liRewardsPenalized = []\\n actionsctli =[]\\n heatmap = np.zeros((7, 7))\\n for i in range(episodes):\\n grid.reset()\\n actionct = 0\\n misstepct = 0\\n heatmap[0,0] += 1\\n while (not grid.isEnd) and (grid.numSteps <=200):\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n state_ind = state[1]*(width+1)+state[0]\\n\\n if 'disjoint' in mode:\\n actions = [0, 1, 2, 3]\\n else:\\n #'up','right','down','left','upri','dori','dole','uple'\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n #if we have a special human agent use it, if not use random human\\n if h_agent is None:\\n action = np.random.choice(actions, 1)[0]\\n h_action = action\\n else:\\n action = h_agent.get_action(state_ind)\\n h_action = action\\n if coagenthelp:\\n q_vals = coagent.get_q_values(state_ind)\\n best_action = coagent.get_action(state_ind)\\n best_q = q_vals[best_action]\\n min_q = min(q_vals)\\n human_q = q_vals[action]\\n\\n #closest actions dictionary\\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\\n #value = action index if radial\\n #key = actual action index\\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\\n #actions in order of circle\\n a_radial = [0,4,1,5,2,6,3,7]\\n #co-pilot action choices\\n #override to optimal if suboptimal action selected\\n if \\\"override\\\" in mode:\\n #random percent to decide when to help if wrong action taken\\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\\n actionct += 1\\n action = best_action\\n #select best closest action if human action q-value is negative\\n elif mode == \\\"q-neg\\\" and human_q < 0:\\n actionct += 1\\n a_li = closest_a[action]\\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\\n #Shared Autonomy\\n #select better closest action if difference between best q and human q is past some threshold\\n elif mode == \\\"q-diff\\\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\\n actionct += 1\\n for i in range(1,5):\\n radial_a = a_dist_ind[action]\\n ccw_ra = (radial_a - i) % len(actions)\\n ccw_a = a_radial[ccw_ra]\\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = ccw_a\\n break\\n cw_ra = (radial_a + i) % len(actions)\\n cw_a = a_radial[cw_ra]\\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = cw_a\\n break\\n #take the potentiallny new action\\n grid.step(action)\\n\\n if h_agent is not None:\\n heatmap[grid.state[1],grid.state[0]] += 1\\n\\n #add metrics to their respective lists\\n liRewards.append(grid.reward)\\n liRewardsPenalized.append(grid.reward-actionct)\\n actionsctli.append(actionct)\\n #convert lists to numpy arrays\\n rewards = np.array(liRewards)\\n rewards_penalized = np.array(liRewardsPenalized)\\n actionsctli = np.array(actionsctli)\\n #print some metrics if we want to\\n if verbose:\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\\n if h_agent is not None:\\n plt.figure()\\n print(heatmap)\\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\\n plt.savefig('two.png')\\n\\n return rewards, actionsctli, rewards_penalized\",\n \"def _get_observations(self):\\n food = np.array(self.game.state.data.food.data)\\n walls = np.array(self.game.state.data.layout.walls.data)\\n map_shape = walls.shape\\n capsules = self.game.state.data.capsules\\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\\n\\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\\n self.game.state.data.agentStates[1:]))\\n gosts_scared = list(\\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\\n\\n \\\"\\\"\\\"\\n 0: empty,\\n 1: wall,\\n 2: food,\\n 3: capsules,\\n 4: ghost,\\n 5: scared ghost,\\n 6: pacman\\n \\\"\\\"\\\"\\n\\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\\n\\n def select(l):\\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\\n\\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\\n\\n def pos_to_relative_pos(pos):\\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\\n return None\\n else:\\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\\n\\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\\n\\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\\n if (g_relative_pos is not None):\\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\\n ] = 5 if gosts_scared[i] else 4\\n\\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\\n\\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\\n\\n obs[0, 0] = 2 if np.any(\\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\\n obs[obs.shape[0]-1,\\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\\n\\n obs[0, obs.shape[1] -\\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\\n\\n # print(np.transpose(obs)[::-1, :])\\n\\n return obs\",\n \"def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\\n tmpl_out_path, null_charges=False, growing_mode=\\\"SoftcoreLike\\\"):\\n lambda_to_reduce = float(step/(total_steps+1))\\n templ_ini = TemplateImpact(template_initial_path)\\n \\n for bond in templ_ini.list_of_bonds:\\n key, bond_cont = bond\\n templ_grw = TemplateImpact(template_grown_path)\\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \\n template_grown=templ_grw,\\n hydrogen_to_replace=hydrogen_to_replace)\\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\\n set_linker_bond(templ_grw)\\n if growing_mode == \\\"SoftcoreLike\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\\n null_charges=null_charges)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \\n null_charges=null_charges)\\n \\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"AllLinear\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\\n null_charges=False)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"SpreadHcharge\\\":\\n if step > 1:\\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n else:\\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n else:\\n raise ValueError(\\\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\\\")\\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\\\\n [atom.pdb_atom_name for atom in core_atoms_grown]\",\n \"def main():\\n # https://github.com/caelan/pddlstream/blob/master/examples/motion/run.py\\n # TODO: 3D work and CSpace\\n # TODO: visualize just the tool frame of an end effector\\n\\n np.set_printoptions(precision=3)\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-a', '--algorithm', default='rrt_connect',\\n help='The algorithm seed to use.')\\n parser.add_argument('-d', '--draw', action='store_true',\\n help='When enabled, draws the roadmap')\\n parser.add_argument('-r', '--restarts', default=0, type=int,\\n help='The number of restarts.')\\n parser.add_argument('-s', '--smooth', action='store_true',\\n help='When enabled, smooths paths.')\\n parser.add_argument('-t', '--time', default=1., type=float,\\n help='The maximum runtime.')\\n args = parser.parse_args()\\n\\n #########################\\n\\n obstacles = [\\n create_box(center=(.35, .75), extents=(.25, .25)),\\n create_box(center=(.75, .35), extents=(.225, .225)),\\n create_box(center=(.5, .5), extents=(.225, .225)),\\n ]\\n\\n # TODO: alternate sampling from a mix of regions\\n regions = {\\n 'env': create_box(center=(.5, .5), extents=(1., 1.)),\\n 'green': create_box(center=(.8, .8), extents=(.1, .1)),\\n }\\n\\n start = np.array([0., 0.])\\n goal = 'green'\\n if isinstance(goal, str) and (goal in regions):\\n goal = get_box_center(regions[goal])\\n else:\\n goal = np.array([1., 1.])\\n\\n title = args.algorithm\\n if args.smooth:\\n title += '+shortcut'\\n viewer = draw_environment(obstacles, regions, title=title)\\n\\n #########################\\n\\n #connected_test, roadmap = get_connected_test(obstacles)\\n distance_fn = get_distance_fn(weights=[1, 1]) # distance_fn\\n\\n # samples = list(islice(region_gen('env'), 100))\\n with profiler(field='cumtime'): # cumtime | tottime\\n # TODO: cost bound & best cost\\n for _ in range(args.restarts+1):\\n start_time = time.time()\\n collision_fn, cfree = get_collision_fn(obstacles)\\n sample_fn, samples = get_sample_fn(regions['env'], obstacles=[]) # obstacles\\n extend_fn, roadmap = get_extend_fn(obstacles=obstacles) # obstacles | []\\n\\n if args.algorithm == 'prm':\\n path = prm(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\\n num_samples=200)\\n elif args.algorithm == 'lazy_prm':\\n path = lazy_prm(start, goal, sample_fn, extend_fn, collision_fn,\\n num_samples=200, max_time=args.time)[0]\\n elif args.algorithm == 'rrt':\\n path = rrt(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\\n iterations=INF, max_time=args.time)\\n elif args.algorithm == 'rrt_connect':\\n path = rrt_connect(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\\n max_time=args.time)\\n elif args.algorithm == 'birrt':\\n path = birrt(start, goal, distance_fn=distance_fn, sample_fn=sample_fn,\\n extend_fn=extend_fn, collision_fn=collision_fn,\\n max_time=args.time, smooth=100)\\n elif args.algorithm == 'rrt_star':\\n path = rrt_star(start, goal, distance_fn, sample_fn, extend_fn, collision_fn,\\n radius=1, max_iterations=INF, max_time=args.time)\\n elif args.algorithm == 'lattice':\\n path = lattice(start, goal, extend_fn, collision_fn, distance_fn=distance_fn)\\n else:\\n raise NotImplementedError(args.algorithm)\\n paths = [] if path is None else [path]\\n\\n #paths = random_restarts(rrt_connect, start, goal, distance_fn=distance_fn, sample_fn=sample_fn,\\n # extend_fn=extend_fn, collision_fn=collision_fn, restarts=INF,\\n # max_time=args.time, max_solutions=INF, smooth=100) #, smooth=1000, **kwargs)\\n\\n # paths = exhaustively_select_portfolio(paths, k=2)\\n # print(score_portfolio(paths))\\n\\n #########################\\n\\n if args.draw:\\n # roadmap = samples = cfree = []\\n add_roadmap(viewer, roadmap, color='black')\\n add_points(viewer, samples, color='red', radius=2)\\n #add_points(viewer, cfree, color='blue', radius=2)\\n\\n print('Solutions ({}): {} | Time: {:.3f}'.format(len(paths), [(len(path), round(compute_path_cost(\\n path, distance_fn), 3)) for path in paths], elapsed_time(start_time)))\\n for path in paths:\\n add_path(viewer, path, color='green')\\n\\n if args.smooth:\\n for path in paths:\\n extend_fn, roadmap = get_extend_fn(obstacles=obstacles) # obstacles | []\\n smoothed = smooth_path(path, extend_fn, collision_fn, iterations=INF, max_time=args.time)\\n print('Smoothed distance_fn: {:.3f}'.format(compute_path_cost(smoothed, distance_fn)))\\n add_path(viewer, smoothed, color='red')\\n user_input('Finish?')\",\n \"def generate_aima_grid():\\n\\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\\n\\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\\n\\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\\n\\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\\n\\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\\n\\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\\n\\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\\n\\n print('\\\\n***** aima grid world *****\\\\n')\\n print('Transition matrix:', transitions.shape)\\n print('Reward matrix:', rewards.shape)\\n\\n return transitions, rewards\",\n \"def example_3():\\n\\n # maze = klyubin_world()\\n maze = mazeworld.door_world()\\n emptymaze = MazeWorld(maze.height, maze.width)\\n # maze = mazeworld.tunnel_world()\\n n_step = 3\\n start = time.time()\\n initpos = np.random.randint(maze.dims[0], size=2)\\n initpos = [1,4]\\n s = maze._cell_to_index(initpos)\\n T = emptymaze.compute_model()\\n B = maze.compute_model()\\n E = maze.compute_empowerment(n_step = n_step).reshape(-1)\\n n_s, n_a, _ = T.shape\\n agent = EmpowermentMaximiser(alpha=0.1, gamma=0.9, T = T, n_step=n_step, n_samples=1000, det=1.)\\n steps = int(10000) \\n visited = np.zeros(maze.dims)\\n tau = np.zeros(steps)\\n D_emp = np.zeros(steps)\\n D_mod = n_s*n_a*np.ones(steps)\\n for t in range(steps):\\n # append data for plotting \\n tau[t] = agent.tau\\n D_emp[t] = np.mean((E - agent.E)**2)\\n D_mod[t] = D_mod[t] - np.sum(np.argmax(agent.T, axis=0) == np.argmax(B, axis=0))\\n a = agent.act(s)\\n pos = maze._index_to_cell(s)\\n visited[pos[0],pos[1]] += 1\\n s_ = maze.act(s,list(maze.actions.keys())[a])\\n agent.update(s,a,s_)\\n s = s_\\n print(\\\"elapsed seconds: %0.3f\\\" % (time.time() - start) )\\n plt.figure(1)\\n plt.title(\\\"value map\\\")\\n Vmap = np.max(agent.Q, axis=1).reshape(*maze.dims)\\n maze.plot(colorMap= Vmap )\\n plt.figure(2)\\n plt.title(\\\"subjective empowerment\\\")\\n maze.plot(colorMap= agent.E.reshape(*maze.dims))\\n plt.figure(3)\\n plt.title(\\\"tau\\\")\\n plt.plot(tau)\\n plt.figure(4)\\n plt.scatter(agent.E, visited.reshape(n_s))\\n plt.xlabel('true empowerment')\\n plt.ylabel('visit frequency')\\n plt.figure(5)\\n plt.title(\\\"visited\\\")\\n maze.plot(colorMap=visited.reshape(*maze.dims))\\n fig, ax1 = plt.subplots()\\n red = 'tab:red'\\n ax1.set_xlabel('time')\\n ax1.set_ylabel('MSE of empowerment map', color=red)\\n ax1.plot(D_emp, color=red)\\n ax1.tick_params(axis='y', labelcolor=red)\\n ax2 = ax1.twinx() \\n ax2.set_ylabel('Model disagreement', color='tab:blue') \\n ax2.plot(D_mod, color='tab:blue')\\n ax2.tick_params(axis='y', labelcolor='tab:blue')\\n plt.show()\",\n \"def createStabilizedView():\\n global cc\\n y = b.createNode('StartStabilized')\\n dd = b.createNode('Dot', '', False)\\n de = b.createNode('Dot', '', False)\\n w = b.createNode('EndStabilized')\\n if cc:\\n y = gV(y)\\n w = gX(w)\\n y['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\\n w['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\\n w.connectInput(2, y)\\n stabilizedPrecompNode___connectPrecompNodes(y, w)\\n cd = 250\\n df = 250\\n ez = 50\\n eA = 7\\n cP(dd)\\n de.setSelected(True)\\n eB = b.nodes.BackdropNode(xpos=y.xpos() + cd / 2, bdwidth=cd * 1.5, ypos=y.ypos() - ez, bdheight=df + 2 * ez,\\n tile_color=int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16),\\n note_font_color=4294967040, note_font_size=36, name='MochaImport+')\\n eB['label'].setValue('Stabilized View+')\\n dd.setXpos(y.xpos() + cd)\\n dd.setYpos(y.ypos() + eA)\\n de.setXpos(y.xpos() + cd)\\n de.setYpos(y.ypos() + df + eA)\\n w.setXpos(y.xpos())\\n w.setYpos(y.ypos() + df)\\n eB['help'].setValue(\\n \\\"\\\\n<h2>Basic Usage of Stabilized View Rig</h2>\\\\n<ol>\\\\n<li>From the MochaImport+ menu, create the stabilized view rig consisting of the StartStabilized node, the EndStabilized node, and the Stabilized View Backdrop.</li>\\\\n<li>Load your mocha tracking data in the StartStabilized node.\\\\n</li><li>Do arbitrary manipulations in the Stabilized View by inserting new nodes inside the backdrop. All changes you do there in a stabilized setting will also be visible in your original perspective after the EndStabilized node.</li>\\\\n</ol>\\\\n\\\\n<h2>Lens Distortion</h2>\\\\n<p>If you've used the mocha Lens module to analyze the lens distortion of your clip, you need to do the following things to get an undistorted stabilized view and reapply the lens distortion to the final result:\\\\n</p><ul>\\\\n<li>make sure the mocha corner pin data you load into the StartStabilized node is exported from mocha Pro with the option 'Remove lens distortion'</li>\\\\n<li>as UndistMap input of the StartStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'undistort'.</li>\\\\n<li>as DistMap input of the EndStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'distort'.</li>\\\\n</ul>\\\".replace(\\n '\\\\n', '').replace('\\\\r', ''))\",\n \"def vision(image):\\n vis_map = resize(image, alpha, beta)\\n print(\\\"Resized map from the blue mask\\\")\\n\\n world = rotate(vis_map)\\n\\n plt.figure()\\n plt.imshow(world[:, :, ::-1])\\n plt.show()\\n object_grid, occupancy_grid = detect_object(world)\\n print(\\\"Result of the red mask\\\")\\n plt.figure()\\n plt.imshow(occupancy_grid)\\n plt.show()\\n return object_grid, occupancy_grid, world\",\n \"def __init__(self, gameState, costFn = lambda x: 1, goal=(1,1), start=None, warn=True, visualize=True):\\n self.goal=(1,1)\\n self.goals=[]\\n self.walls = gameState.getWalls()\\n self.startState = gameState.getPacmanPosition()\\n if start != None: self.startState = start\\n\\n n=0\\n try:\\n for j in range(1, 40):\\n n=j\\n x=gameState.hasWall(1, j)\\n except:\\n n=n\\n m=0\\n try:\\n for i in range(1, 40):\\n m=i\\n x=gameState.hasWall(i, 1)\\n except:\\n m=m\\n print('maze dimension: ',m,'x',n)\\n\\n for i in range(1,m):\\n for j in range(1,n):\\n if (gameState.hasFood(i,j)):\\n if(gameState.getNumFood()==1):\\n self.goal=(i,j)\\n else:\\n x=(i,j)\\n self.goals.append(x)\\n\\n #print('goals',self.getFoodPositions())\\n self.costFn = costFn\\n self.visualize = visualize\\n #x=getFoodPosition(gameState)\\n #print(\\\"food positions: \\\" )\\n print(\\\"[R12] Initial position of pacman is \\\"+str(gameState.getPacmanPosition()))\\n print(\\\"[R10] Number of foods is \\\"+str(gameState.getNumFood()))\\n if(gameState.getNumFood()>1):\\n print(\\\"[R10] Final goal positions are \\\", self.goals)\\n else:\\n print(\\\"[R10] Final goal position is \\\"+str(self.goals))\\n print(\\\"[R11] Ghost Positions is/are \\\"+str(gameState.getGhostPositions()))\\n print(\\\"[R15] has the game food? \\\"+str(gameState.hasFood(*goal)))\\n if warn and (gameState.getNumFood() != 1 or not gameState.hasFood(*goal)):\\n print('Warning: this does not look like a regular search maze')\\n\\n # For display purposes\\n self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE\",\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def generate_all_locations(grid, shape):\",\n \"def write_ROMS_grid(grd, visc_factor, diff_factor, filename='roms_grd.nc'):\\n\\n Mm, Lm = grd.hgrid.x_rho.shape\\n\\n \\n # Write ROMS grid to file\\n nc = netCDF.Dataset(filename, 'w', format='NETCDF4')\\n nc.Description = 'ROMS grid'\\n nc.Author = 'Trond Kristiansen'\\n nc.Created = datetime.now().isoformat()\\n nc.type = 'ROMS grid file'\\n\\n nc.createDimension('xi_rho', Lm)\\n nc.createDimension('xi_u', Lm-1)\\n nc.createDimension('xi_v', Lm)\\n nc.createDimension('xi_psi', Lm-1)\\n \\n nc.createDimension('eta_rho', Mm)\\n nc.createDimension('eta_u', Mm)\\n nc.createDimension('eta_v', Mm-1)\\n nc.createDimension('eta_psi', Mm-1)\\n\\n nc.createDimension('xi_vert', Lm+1)\\n nc.createDimension('eta_vert', Mm+1)\\n\\n nc.createDimension('bath', None)\\n\\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\\n N, = grd.vgrid.s_rho.shape\\n nc.createDimension('s_rho', N)\\n nc.createDimension('s_w', N+1)\\n\\n def write_nc_var(var, name, dimensions, long_name=None, units=None):\\n nc.createVariable(name, 'f8', dimensions)\\n if long_name is not None:\\n nc.variables[name].long_name = long_name\\n if units is not None:\\n nc.variables[name].units = units\\n nc.variables[name][:] = var\\n print ' ... wrote ', name\\n\\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\\n write_nc_var(grd.vgrid.theta_s, 'theta_s', (), 'S-coordinate surface control parameter')\\n write_nc_var(grd.vgrid.theta_b, 'theta_b', (), 'S-coordinate bottom control parameter')\\n write_nc_var(grd.vgrid.Tcline, 'Tcline', (), 'S-coordinate surface/bottom layer width', 'meter')\\n write_nc_var(grd.vgrid.hc, 'hc', (), 'S-coordinate parameter, critical depth', 'meter')\\n write_nc_var(grd.vgrid.s_rho, 's_rho', ('s_rho'), 'S-coordinate at RHO-points')\\n write_nc_var(grd.vgrid.s_w, 's_w', ('s_w'), 'S-coordinate at W-points')\\n write_nc_var(grd.vgrid.Cs_r, 'Cs_r', ('s_rho'), 'S-coordinate stretching curves at RHO-points')\\n write_nc_var(grd.vgrid.Cs_w, 'Cs_w', ('s_w'), 'S-coordinate stretching curves at W-points')\\n\\n write_nc_var(grd.vgrid.h, 'h', ('eta_rho', 'xi_rho'), 'bathymetry at RHO-points', 'meter')\\n #ensure that we have a bath dependancy for hraw\\n if len(grd.vgrid.hraw.shape) == 2:\\n hraw = np.zeros((1, grd.vgrid.hraw.shape[0], grd.vgrid.hraw.shape[1]))\\n hraw[0,:] = grd.vgrid.hraw\\n else:\\n hraw = grd.vgrid.hraw\\n write_nc_var(hraw, 'hraw', ('bath', 'eta_rho', 'xi_rho'), 'raw bathymetry at RHO-points', 'meter')\\n write_nc_var(grd.hgrid.f, 'f', ('eta_rho', 'xi_rho'), 'Coriolis parameter at RHO-points', 'second-1')\\n write_nc_var(1./grd.hgrid.dx, 'pm', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in XI', 'meter-1')\\n write_nc_var(1./grd.hgrid.dy, 'pn', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in ETA', 'meter-1')\\n write_nc_var(grd.hgrid.dmde, 'dmde', ('eta_rho', 'xi_rho'), 'XI derivative of inverse metric factor pn', 'meter')\\n write_nc_var(grd.hgrid.dndx, 'dndx', ('eta_rho', 'xi_rho'), 'ETA derivative of inverse metric factor pm', 'meter')\\n write_nc_var(grd.hgrid.xl, 'xl', (), 'domain length in the XI-direction', 'meter')\\n write_nc_var(grd.hgrid.el, 'el', (), 'domain length in the ETA-direction', 'meter')\\n\\n write_nc_var(grd.hgrid.x_rho, 'x_rho', ('eta_rho', 'xi_rho'), 'x location of RHO-points', 'meter')\\n write_nc_var(grd.hgrid.y_rho, 'y_rho', ('eta_rho', 'xi_rho'), 'y location of RHO-points', 'meter')\\n write_nc_var(grd.hgrid.x_u, 'x_u', ('eta_u', 'xi_u'), 'x location of U-points', 'meter')\\n write_nc_var(grd.hgrid.y_u, 'y_u', ('eta_u', 'xi_u'), 'y location of U-points', 'meter')\\n write_nc_var(grd.hgrid.x_v, 'x_v', ('eta_v', 'xi_v'), 'x location of V-points', 'meter')\\n write_nc_var(grd.hgrid.y_v, 'y_v', ('eta_v', 'xi_v'), 'y location of V-points', 'meter')\\n write_nc_var(grd.hgrid.x_psi, 'x_psi', ('eta_psi', 'xi_psi'), 'x location of PSI-points', 'meter')\\n write_nc_var(grd.hgrid.y_psi, 'y_psi', ('eta_psi', 'xi_psi'), 'y location of PSI-points', 'meter')\\n write_nc_var(grd.hgrid.x_vert, 'x_vert', ('eta_vert', 'xi_vert'), 'x location of cell verticies', 'meter')\\n write_nc_var(grd.hgrid.y_vert, 'y_vert', ('eta_vert', 'xi_vert'), 'y location of cell verticies', 'meter')\\n\\n if hasattr(grd.hgrid, 'lon_rho'):\\n write_nc_var(grd.hgrid.lon_rho, 'lon_rho', ('eta_rho', 'xi_rho'), 'longitude of RHO-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_rho, 'lat_rho', ('eta_rho', 'xi_rho'), 'latitude of RHO-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_u, 'lon_u', ('eta_u', 'xi_u'), 'longitude of U-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_u, 'lat_u', ('eta_u', 'xi_u'), 'latitude of U-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_v, 'lon_v', ('eta_v', 'xi_v'), 'longitude of V-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_v, 'lat_v', ('eta_v', 'xi_v'), 'latitude of V-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_psi, 'lon_psi', ('eta_psi', 'xi_psi'), 'longitude of PSI-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_psi, 'lat_psi', ('eta_psi', 'xi_psi'), 'latitude of PSI-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_vert, 'lon_vert', ('eta_vert', 'xi_vert'), 'longitude of cell verticies', 'degree_east')\\n write_nc_var(grd.hgrid.lat_vert, 'lat_vert', ('eta_vert', 'xi_vert'), 'latitude of cell verticies', 'degree_north')\\n\\n nc.createVariable('spherical', 'c')\\n nc.variables['spherical'].long_name = 'Grid type logical switch'\\n nc.variables['spherical'][:] = grd.hgrid.spherical\\n print ' ... wrote ', 'spherical'\\n\\n write_nc_var(grd.hgrid.angle_rho, 'angle', ('eta_rho', 'xi_rho'), 'angle between XI-axis and EAST', 'radians')\\n\\n write_nc_var(grd.hgrid.mask_rho, 'mask_rho', ('eta_rho', 'xi_rho'), 'mask on RHO-points')\\n write_nc_var(grd.hgrid.mask_u, 'mask_u', ('eta_u', 'xi_u'), 'mask on U-points')\\n write_nc_var(grd.hgrid.mask_v, 'mask_v', ('eta_v', 'xi_v'), 'mask on V-points')\\n write_nc_var(grd.hgrid.mask_psi, 'mask_psi', ('eta_psi', 'xi_psi'), 'mask on psi-points')\\n\\n if visc_factor != None:\\n write_nc_var(visc_factor, 'visc_factor', ('eta_rho', 'xi_rho'), 'horizontal viscosity sponge factor')\\n if diff_factor != None:\\n write_nc_var(diff_factor, 'diff_factor', ('eta_rho', 'xi_rho'), 'horizontal diffusivity sponge factor')\\n \\n nc.close()\",\n \"def visualize(self):\\n self.octree.updateInnerOccupancy()\\n print(\\\"Start Octomap Visualization\\\")\\n\\n # define parameters\\n data = imgviz.data.arc2017()\\n camera_info = data['camera_info']\\n K = np.array(camera_info['K']).reshape(3, 3)\\n width=camera_info['width']\\n height=camera_info['height']\\n\\n # get free and occupied grid\\n occupied, _ = self.octree.extractPointCloud()\\n #frontier = self.gen_frontier()\\n \\n print(\\\"load point cloud\\\")\\n window = pyglet.window.Window(\\n width=int(1280), height=int(960)\\n )\\n\\n @window.event\\n def on_key_press(symbol, modifiers):\\n if modifiers == 0:\\n if symbol == pyglet.window.key.Q:\\n window.on_close()\\n\\n gui = glooey.Gui(window)\\n hbox = glooey.HBox()\\n hbox.set_padding(5)\\n\\n camera = trimesh.scene.Camera(\\n resolution=(width, height), focal=(K[0, 0], K[1, 1])\\n )\\n\\n # initial camera pose\\n camera_transform = np.array(\\n [\\n [1, 0, 0, 0],\\n [0, -1, 0, 0],\\n [0, 0, -1, -5],\\n [0.0, 0.0, 0.0, 1.0],\\n ],\\n )\\n\\n \\n\\n occupied_geom = trimesh.voxel.ops.multibox(\\n occupied, pitch=self.resolution, colors=[0.0, 0.0, 0.0, 0.5]\\n )\\n\\n # frontier_geom = trimesh.voxel.ops.multibox(\\n # frontier, pitch=self.resolution, colors=[1.0, 0, 0, 0.5]\\n # )\\n scene = trimesh.Scene(camera=camera, geometry=[occupied_geom])#, frontier_geom])\\n scene.camera_transform = camera_transform\\n hbox.add(self.labeled_scene_widget(scene, label='octomap'))\\n\\n\\n gui.add(hbox)\\n pyglet.app.run()\",\n \"def make_land_agents_2016(self):\\r\\n # add non-gtgp\\r\\n for hh_row in agents: # from excel_import\\r\\n hh_id = return_values(hh_row, 'hh_id')\\r\\n self.total_rice = return_values(hh_row, 'non_gtgp_rice_mu')\\r\\n if self.total_rice in ['-3', '-4', -3, None]:\\r\\n self.total_rice = 0\\r\\n self.total_dry = return_values(hh_row, 'non_gtgp_dry_mu')\\r\\n if self.total_dry in ['-3', '-4', -3, None]:\\r\\n self.total_dry = 0\\r\\n self.gtgp_rice = return_values(hh_row, 'gtgp_rice_mu')\\r\\n if self.gtgp_rice in ['-3', '-4', -3, None]:\\r\\n self.total_rice = 0\\r\\n self.gtgp_dry = return_values(hh_row, 'gtgp_dry_mu')\\r\\n if self.gtgp_dry in ['-3', '-4', -3, None]:\\r\\n self.gtgp_dry = 0\\r\\n\\r\\n landposlist = self.determine_landpos(hh_row, 'non_gtgp_latitude', 'non_gtgp_longitude')\\r\\n self.age_1 = return_values(hh_row, 'age')[0]\\r\\n self.gender_1 = return_values(hh_row, 'gender')[0]\\r\\n self.education_1 = return_values(hh_row, 'education')[0]\\r\\n\\r\\n for landpos in landposlist:\\r\\n try:\\r\\n self.pre_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n\\r\\n try:\\r\\n self.non_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n self.land_time = return_values(hh_row, 'non_gtgp_travel_time')[landposlist.index(landpos)]\\r\\n try:\\r\\n self.plant_type = return_values(hh_row, 'non_gtgp_plant_type')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n self.land_type = return_values(hh_row, 'non_gtgp_land_type')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n self.hh_size = len(return_values(hh_row, 'age'))\\r\\n self.gtgp_enrolled = 0\\r\\n lp = LandParcelAgent(hh_row, self, hh_id, hh_row, landpos, self.gtgp_enrolled,\\r\\n self.age_1, self.gender_1, self.education_1,\\r\\n self.gtgp_dry, self.gtgp_rice, self.total_dry, self.total_rice,\\r\\n self.land_type, self.land_time, self.plant_type, self.non_gtgp_output,\\r\\n self.pre_gtgp_output)\\r\\n self.space.place_agent(lp, landpos)\\r\\n self.schedule.add(lp)\\r\\n if self.gtgp_enrolled == 0 and landpos not in nongtgplist and landpos not in gtgplist:\\r\\n nongtgplist.append(landpos)\\r\\n # except:\\r\\n # pass\\r\\n\\r\\n # add gtgp\\r\\n for hh_row in agents: # from excel_import\\r\\n hh_id = return_values(hh_row, 'hh_id')\\r\\n self.total_rice = return_values(hh_row, 'non_gtgp_rice_mu')\\r\\n if self.total_rice in ['-3', '-4', -3, None]:\\r\\n self.total_rice = 0\\r\\n self.total_dry = return_values(hh_row, 'non_gtgp_dry_mu')\\r\\n if self.total_dry in ['-3', '-4', -3, None]:\\r\\n self.total_dry = 0\\r\\n self.gtgp_rice = return_values(hh_row, 'gtgp_rice_mu')\\r\\n if self.gtgp_rice in ['-3', '-4', -3, None]:\\r\\n self.total_rice = 0\\r\\n self.gtgp_dry = return_values(hh_row, 'gtgp_dry_mu')\\r\\n if self.gtgp_dry in ['-3', '-4', -3, None]:\\r\\n self.gtgp_dry = 0\\r\\n landposlist = self.determine_landpos(hh_row, 'gtgp_latitude', 'gtgp_longitude')\\r\\n self.age_1 = return_values(hh_row, 'age')[0]\\r\\n self.gender_1 = return_values(hh_row, 'gender')[0]\\r\\n self.education_1 = return_values(hh_row, 'education')[0]\\r\\n for landpos in landposlist:\\r\\n try:\\r\\n self.pre_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n self.non_gtgp_output = return_values(hh_row, 'pre_gtgp_output')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n self.land_time = return_values(hh_row, 'gtgp_travel_time')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n self.plant_type = return_values(hh_row, 'pre_gtgp_plant_type')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n self.land_type = return_values(hh_row, 'pre_gtgp_land_type')[landposlist.index(landpos)]\\r\\n except:\\r\\n pass\\r\\n self.hh_size = len(return_values(hh_row, 'age'))\\r\\n self.gtgp_enrolled = 1\\r\\n\\r\\n lp_gtgp = LandParcelAgent(hh_id, self, hh_id, hh_row, landpos, self.gtgp_enrolled,\\r\\n self.age_1, self.gender_1, self.education_1,\\r\\n self.gtgp_dry, self.gtgp_rice, self.total_dry, self.total_rice,\\r\\n self.land_type, self.land_time, self.plant_type, self.non_gtgp_output,\\r\\n self.pre_gtgp_output)\\r\\n self.space.place_agent(lp_gtgp, landpos)\\r\\n self.schedule.add(lp_gtgp)\\r\\n if self.gtgp_enrolled == 1 and landpos not in gtgplist and landpos in nongtgplist:\\r\\n gtgplist.append(landpos)\",\n \"def abstract(res):\\n o = r'\\\\begin{center}'\\n #o += r'\\\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\\n #o += r'\\\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\\n o += r'\\\\begin{tikzpicture}' + '\\\\n'\\n o += r'\\\\draw[blue!40!white] (0,0) rectangle (6,4); \\\\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\\\n'\\n for i in range(res[7]):\\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\\n o += r'\\\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\\\n'\\n o += r'\\\\end{tikzpicture}\\\\end{center}' + '\\\\n'\\n\\n o += r'\\\\begin{tabular}{|l|l|}' + '\\\\n' + r'\\\\hline' + '\\\\n'\\n o += r'Election name& \\\\texttt{\\\"%s\\\"}\\\\\\\\'%res[1]\\n o += r'Box number& \\\\texttt{%s}\\\\\\\\'%res[2]\\n o += r'State& \\\\texttt{%s}\\\\\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\\n o += r'Registration end& \\\\textit{%s}\\\\\\\\'%res[3]\\n o += r'Vote closing& \\\\textit{%s}\\\\\\\\'%res[4]\\n o += r'Casted/registered& $%s/%s$\\\\\\\\'%(res[7],res[6]) +'\\\\n'\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n o += r'\\\\quad' + '\\\\n'\\n o += r'\\\\begin{tabular}{|l|l|}\\\\hline'\\n l = res[8].items()\\n l.sort(key = operator.itemgetter(1),reverse=True)\\n n = 0\\n for x in l:\\n o += r'%s & %s\\\\\\\\'%(r'\\\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\\\texttt{%s}'%x[0],x[1]) \\n if n == 0:\\n o += r'\\\\hline' + '\\\\n'\\n n += 1\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n\\n\\n #o += r'\\\\item The designer\\\\textquoteright s digital signature of this document (the source file \\\\texttt{oeu.py}) is: \\\\tiny $$\\\\verb!%s!$$ \\\\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\\\n'\\n\\n return r'\\\\begin{abstract}' + abstract.__doc__ + r'\\\\end{abstract}' + o\",\n \"def drought_ag_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n ag_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Ag_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Ag Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_ag_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,ag_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_ag_risk_map_view_options':drought_ag_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_ag_risk.html', context)\",\n \"def global_analysis(tomo, b_th, c=18):\\n\\n ## Thesholding and Volume analysis\\n if c == 6:\\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\\n elif c == 18:\\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\\n elif c == 26:\\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\\n else:\\n raise ValueError\\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\\n lut = np.zeros(shape=num_lbls+1, dtype=int)\\n\\n ## COUNTING REGIONS METHODS\\n # import time\\n # hold_t = time.time()\\n # for lbl in range(1, num_lbls + 1):\\n # ids = tomo == lbl\\n # feat_sz = len(ids)\\n # tomo_out[ids] = feat_sz\\n # # print('[1]:', lbl, 'of', num_lbls)\\n # print time.time() - hold_t\\n\\n ## COUNTING PIXELS METHOD\\n ## Count loop\\n # cont, total = 0, np.prod(tomo.shape)\\n # import time\\n # hold_t = time.time()\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n lut[id] += 1\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n #\\n ## Write loop\\n # cont, total = 0, np.prod(tomo.shape)\\n\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n if id > 0:\\n tomo_out[x, y, z] = lut[id]\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n # print time.time() - hold_t\\n\\n return tomo_out\",\n \"def _regr_basic():\",\n \"def localization_full(Gint, focal_genes, \\n num_reps = 200,\\n method = 'LCC', \\n print_counter = False,\\n label = 'focal genes',\\n line_height = 0.1,\\n legend_loc = 'upper left'):\\n \\n numedges_list, numedges_rand, LCC_list, LCC_rand = localization(Gint, focal_genes, num_reps, \\n sample_frac = 1, \\n method = method, \\n plot = False,\\n print_counter = print_counter)\\n if method == 'numedges':\\n analysis_list = numedges_list\\n analysis_rand = numedges_rand\\n title = 'number of edges'\\n else:\\n analysis_list = LCC_list\\n analysis_rand = LCC_rand\\n title = 'largest connected component'\\n\\n # plot distributions for non-sampled case\\n fig, ax = plt.subplots(figsize = (12, 7))\\n sns.set_style('white') \\n plt.vlines(np.mean(analysis_list), ymin = 0, ymax = line_height, color = 'r', lw = 2, label = label)\\n sns.kdeplot(analysis_rand, ax = ax, color = 'k', lw = 2, alpha = 0.5, shade = True, label = 'random')\\n plt.legend(loc = legend_loc, fontsize = 12)\\n plt.ylabel('frequency', fontsize = 16)\\n plt.xlabel(title, fontsize = 16)\\n\\n # print the z-score and fdr\\n analysis_z = (np.mean(analysis_list) - np.mean(analysis_rand))/float(np.std(analysis_rand))\\n\\n print(1 - ndtr(analysis_z))\\n\\n plt.title('permutation p = ' + str(1 - ndtr(analysis_z)))\\n \\n return numedges_list, numedges_rand, LCC_list, LCC_rand\",\n \"def create_grids(self):\\n \\n par = self.par\\n\\n # a. retirement\\n \\n # pre-decision states\\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\\n \\n # post-decision states\\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\\n \\n # b. working: state space (m,n,k) \\n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\\n\\n par.Nn = par.Nm\\n par.n_max = par.m_max + par.n_add\\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\\n\\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\\n\\n # c. working: w interpolant (and wa and wb and wq)\\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\\n par.a_max = par.m_max + par.a_add\\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\\n \\n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\\n par.b_max = par.n_max + par.b_add\\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\\n \\n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\\n \\n # d. working: egm (seperate grids for each segment)\\n \\n if par.solmethod == 'G2EGM':\\n\\n # i. dcon\\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\\n \\n # ii. acon\\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\\n par.a_acon = np.zeros(par.grid_b_acon.shape)\\n par.b_acon = par.grid_b_acon\\n\\n # iii. con\\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\\n \\n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\\n\\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\\n par.a_con = np.zeros(par.c_con.shape)\\n par.d_con = np.zeros(par.c_con.shape)\\n \\n elif par.solmethod == 'NEGM':\\n\\n par.grid_l = par.grid_m\\n\\n # e. shocks\\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\\n\\n if par.Neta > 1:\\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\\n else:\\n par.eta = np.ones(1)\\n par.w_eta = np.ones(1)\\n\\n # f. timings\\n par.time_work = np.zeros(par.T)\\n par.time_w = np.zeros(par.T)\\n par.time_egm = np.zeros(par.T)\\n par.time_vfi = np.zeros(par.T)\",\n \"def registerInitialState(self, gameState):\\r\\n \\r\\n '''\\r\\n Make sure you do not delete the following line. If you would like to\\r\\n use Manhattan distances instead of maze distances in order to save\\r\\n on initialization time, please take a look at\\r\\n CaptureAgent.registerInitialState in captureAgents.py.\\r\\n '''\\r\\n CaptureAgent.registerInitialState(self, gameState)\\r\\n \\r\\n \\r\\n self.teamMates = []\\r\\n for mate in self.getTeam(gameState):\\r\\n if mate is not self.index:\\r\\n self.teamMates.append(mate)\\r\\n \\r\\n def getSuccessors(walls, state):\\r\\n successors = []\\r\\n for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:\\r\\n x,y = state\\r\\n dx, dy = Actions.directionToVector(action)\\r\\n nextx, nexty = int(x + dx), int(y + dy)\\r\\n if not walls[nextx][nexty]:\\r\\n nextState = (nextx, nexty)\\r\\n cost = 1\\r\\n successors.append( ( nextState, action, cost) )\\r\\n return successors\\r\\n \\r\\n \\r\\n \\r\\n class o0State:\\r\\n def __init__(self, pos, node = None):\\r\\n self.pos = pos\\r\\n self.node = node\\r\\n self.deadEndDepth = 0.0\\r\\n self.successors = {}\\r\\n self.successorsByNodePos = {}\\r\\n def isDeadEndNode(self):\\r\\n if self.node is None:\\r\\n return False\\r\\n noneDeadEndCount = 0\\r\\n for successor in self.successors.values():\\r\\n if not successor.isDeadEnd:\\r\\n noneDeadEndCount += 1\\r\\n return noneDeadEndCount is 1\\r\\n class o0Node:\\r\\n def __init__(self, pos):\\r\\n self.pos = pos\\r\\n self.isDeadEnd = False\\r\\n class o0Successor:\\r\\n def __init__(self, direction, nextPos, nextNodePos = None):\\r\\n self.direction = direction\\r\\n self.nextPos = nextPos\\r\\n self.nextNodePos = nextNodePos\\r\\n self.isDeadEnd = False\\r\\n\\r\\n class o0PathMap:\\r\\n def __init__(self, gameState):\\r\\n #print 'init pathMap'\\r\\n walls = gameState.getWalls()\\r\\n positions = walls.asList(False)\\r\\n self.states = {}\\r\\n self.nodes = {}\\r\\n for pos in positions:\\r\\n self.states[pos] = o0State(pos)\\r\\n for successor in getSuccessors(walls,pos):\\r\\n self.states[pos].successors[successor[1]] = o0Successor(successor[1],successor[0])\\r\\n successorCount = len(self.states[pos].successors)\\r\\n if successorCount is not 2:\\r\\n node = o0Node(pos)\\r\\n self.nodes[pos] = node\\r\\n self.states[pos].node = node\\r\\n \\r\\n def connectNode(node):\\r\\n for nodeSuccessor in self.states[node.pos].successors.values():\\r\\n if nodeSuccessor.nextNodePos is None:\\r\\n forwardSuccessors = [nodeSuccessor]\\r\\n backwardSuccessors = []\\r\\n previousPos = node.pos\\r\\n currentPos = nodeSuccessor.nextPos\\r\\n while currentPos not in self.nodes.keys():\\r\\n #print node.pos\\r\\n #print currentPos\\r\\n if len(self.states[currentPos].successors) is not 2:\\r\\n print 'not a path'\\r\\n for successor in self.states[currentPos].successors.values():\\r\\n #print successor.nextPos\\r\\n if successor.nextPos[0] is previousPos[0] and successor.nextPos[1] is previousPos[1]:\\r\\n backwardSuccessors.append(successor)\\r\\n else:\\r\\n forwardSuccessors.append(successor)\\r\\n previousPos = currentPos\\r\\n currentPos = forwardSuccessors[len(forwardSuccessors) - 1].nextPos\\r\\n for successor in self.states[currentPos].successors.values():\\r\\n if successor.nextPos is previousPos:\\r\\n backwardSuccessors.append(successor)\\r\\n \\r\\n for successor in forwardSuccessors:\\r\\n successor.nextNodePos = currentPos\\r\\n for successor in backwardSuccessors:\\r\\n successor.nextNodePos = node.pos\\r\\n \\r\\n #connectNode(self.nodes.values()[0])\\r\\n #connectNode(self.nodes.values()[1])\\r\\n #connectNode(self.nodes.values()[2])\\r\\n #connectNode(self.nodes.values()[3])\\r\\n #connectNode(self.nodes.values()[4])\\r\\n #connectNode(self.nodes.values()[5])\\r\\n \\r\\n for node in self.nodes.values():\\r\\n connectNode(node)#'''\\r\\n for state in self.states.values():\\r\\n for successor in self.states[state.pos].successors.values():\\r\\n self.states[state.pos].successorsByNodePos[successor.nextNodePos] = successor\\r\\n \\r\\n updatedNodes = self.nodes.values()\\r\\n while(len(updatedNodes) is not 0):\\r\\n nodePool = updatedNodes\\r\\n updatedNodes = []\\r\\n for node in nodePool:\\r\\n if self.states[node.pos].isDeadEndNode():\\r\\n self.nodes[node.pos].isDeadEnd = True\\r\\n for successor in self.states[node.pos].successors.values():\\r\\n self.states[successor.nextNodePos].successorsByNodePos[node.pos].isDeadEnd = True\\r\\n updatedNodes.append(self.states[successor.nextNodePos])\\r\\n \\r\\n #node.isDeadEnd = self.states[node.pos].isDeadEndNode()#'''\\r\\n \\r\\n '''\\r\\n for node in self.nodes.values():\\r\\n if self.states[node.pos].isDeadEndNode():\\r\\n node.isDeadEnd = True#'''\\r\\n \\r\\n deadEndNodes = {}\\r\\n noneDeadEndNodes = {}\\r\\n for node in self.nodes.values():\\r\\n if not node.isDeadEnd:\\r\\n noneDeadEndNodes[node.pos] = node\\r\\n else:\\r\\n deadEndNodes[node.pos] = node\\r\\n \\r\\n for node in deadEndNodes.values():#\\r\\n actions = breadthFirstSearch(AnyTargetSearchProblem(gameState,noneDeadEndNodes.keys(),node.pos))\\r\\n nodeConnectedTo = self.nodes[performActions(node.pos, actions)] \\r\\n actions = reverseActions(actions)\\r\\n pos = nodeConnectedTo.pos\\r\\n deadEndDepth = 0.0\\r\\n for action in actions:\\r\\n pos = performActions(pos,[action])\\r\\n deadEndDepth += 1.0\\r\\n self.states[pos].deadEndDepth = deadEndDepth\\r\\n def willDie(self, position, distance, scaredTime = 0):#distance from our agent to closest enemy\\r\\n deadEndDepth = self.states[position].deadEndDepth\\r\\n if deadEndDepth >= distance - deadEndDepth and deadEndDepth >= scaredTime:\\r\\n return True\\r\\n return False\\r\\n def isDeadEnd(self, position):\\r\\n return self.states[position].deadEndDepth >= 0.5\\r\\n #def getAllStatesInDeadEnd(self, anyState):\\r\\n \\r\\n\\r\\n global pathMap\\r\\n if pathMap is None:\\r\\n pathMap = o0PathMap(gameState)\\r\\n self.pathMap = pathMap\\r\\n targets[self.index] = None\\r\\n global lastEattenFoodAreDefendingPos\\r\\n lastEattenFoodAreDefendingPos = None \\r\\n global totalFood\\r\\n totalFood = len(self.getFood(gameState).asList())\\r\\n global leftFood\\r\\n leftFood = totalFood\\r\\n #self.debugDraw(pathMap.deadEndNodes.keys(),[1,0,0])\\r\\n #self.debugDraw(pathMap.nodes.keys(),[0,1,0])\\r\\n \\r\\n global pathMapDebugMode\\r\\n if pathMapDebugMode:\\r\\n for state in self.pathMap.states.values():\\r\\n deadEndColor = 0.3 + state.deadEndDepth * 0.1\\r\\n if deadEndColor>1.0:\\r\\n deadEndColor = 1.0\\r\\n if state.deadEndDepth == 0:\\r\\n deadEndColor = 0.0\\r\\n \\r\\n nodeColor = 0.0\\r\\n if state.node is not None:\\r\\n nodeColor = 0.5\\r\\n self.debugDraw(state.pos,[deadEndColor,0,0])\\r\\n\\r\\n self.curryFoodScore = 0.8\\r\\n \\r\\n \\r\\n \\r\\n global defenseWall\\r\\n global defensePositions\\r\\n if len(defenseWall) is 0:\\r\\n foods = self.getFoodYouAreDefending(gameState)\\r\\n for capsule in self.getCapsulesYouAreDefending(gameState):\\r\\n foods[capsule[0]][capsule[1]] = True\\r\\n defenseWall = actionsToPositions((0,0), aStarSearch(DefenseSearchProblem(gameState, foods, self.index),nullHeuristic))\\r\\n defensePositions = getPositionsNeededToDefense(gameState)\\r\\n global defenseWallDebugMode\\r\\n if defenseWallDebugMode is True:\\r\\n self.debugDraw(defenseWall,[0,0.5,0])\\r\\n self.debugDraw(defensePositions,[0.5,0,0])\\r\\n \\r\\n global agentInDeadEnd\\r\\n agentInDeadEnd[self.index] = False\",\n \"def drawCell(self,land,uland,vland,marked):\\n from math import sqrt, pow\\n #--Tranlate grid point (u,v) to pixel point\\n if not self.changed: self.edit()\\n #--u/v max/min are grid range of visible map. \\n #--wcell is bit width of cell. 512 is bit width of visible map.\\n (umin,umax,vmin,vmax,wcell,wmap) = (-28,27,-27,28,9,512)\\n if not ((umin <= uland <= umax) and (vmin <= vland <= vmax)):\\n return\\n #--x0,y0 is bitmap coordinates of top left of cell in visible map.\\n (x0,y0) = (4 + wcell*(uland-umin), 4 + wcell*(vmax-vland))\\n #--Default to deep\\n mapc = [Fmap.DEEP]*(9*9)\\n heights = land and land.getHeights()\\n if heights:\\n #--Land heights are in 65*65 array, starting from bottom left. \\n #--Coordinate conversion. Subtract one extra from height array because it's edge to edge.\\n converter = [(65-2)*px/(wcell-1) for px in range(wcell)]\\n for yc in range(wcell):\\n ycoff = wcell*yc\\n yhoff = (65-1-converter[yc])*65\\n for xc in range(wcell):\\n height = heights[converter[xc]+yhoff]\\n if height >= 0: #--Land\\n (r0,g0,b0,r1,g1,b1,scale) = (66,48,33,32,23,16,sqrt(height/3000.0))\\n scale = int(scale*10)/10.0 #--Make boundaries sharper.\\n r = chr(max(0,int(r0 - r1*scale)) & ~1)\\n else: #--Sea\\n #--Scale color from shallow to deep color.\\n (r0,g0,b0,r1,g1,b1,scale) = (37,55,50,12,19,17,-height/2048.0)\\n r = chr(max(0,int(r0 - r1*scale)) | 1)\\n g = chr(max(0,int(g0 - g1*scale)))\\n b = chr(max(0,int(b0 - b1*scale)))\\n mapc[xc+ycoff] = r+g+b\\n #--Draw it\\n mapd = self.mapd\\n for yc in range(wcell):\\n ycoff = wcell*yc\\n ymoff = wmap*(y0+yc)\\n for xc in range(wcell):\\n cOld = mapd[x0+xc+ymoff]\\n cNew = mapc[xc+ycoff]\\n rOld = ord(cOld[0])\\n #--New or old is sea.\\n if (ord(cNew[0]) & 1) or ((rOld & 1) and\\n (-2 < (1.467742*rOld - ord(cOld[1])) < 2) and\\n (-2 < (1.338710*rOld - ord(cOld[2])) < 2)):\\n mapd[x0+xc+ymoff] = cNew\\n if marked:\\n self.drawBorder(Fmap.MARKED,x0+2,y0+2,x0+7,y0+7,1)\\n pass\",\n \"def decision(grid):\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\",\n \"def add_building_output_locations(self,dictionary, start,end,step): \\n \\\"\\\"\\\"\\n Given a dictionary of building footprints and associated nodes,element and sides, add the values \\n to the netcdf grid file.\\n \\n The nodes, elements and sides associated with each footprint correspond to the there index in the RiCOM grid file\\n \\n Dictionary format:\\n {id1: {'nodes': [n1, n2,...nn] }, {'elements': [e1,e2,...,en] },{'sides': [s1,s2,...,sn]}, id2: {}, id3 {}, ...., idn {} } \\n \\n idn = the id of the building footprint that the node, elements and sides belong to\\n \\n \\\"\\\"\\\"\\n \\n if (dictionary != {}):\\n maxNodes = 0\\n maxElements = 0\\n maxSides = 0\\n nodesAll = []\\n elementsAll = []\\n sidesAll = []\\n id = []\\n perimeter = []\\n type = []\\n for row in dictionary.iteritems(): \\n id.append(row[0]) \\n n = row[1]['nodes'] \\n e = row[1]['elements']\\n s = row[1]['sides']\\n perimeter.append(row[1]['perimeter'])\\n \\n if row[1]['type'] == \\\"BUILDINGS_AS_HOLES\\\":\\n typeNUM = 1\\n elif row[1]['type'] == \\\"BUILDINGS_GRIDDED\\\":\\n typeNUM = 2\\n\\n elif row[1]['type'] == \\\"BUILDINGS_AS_POINTS\\\":\\n typeNUM = 3\\n else:\\n typeNUM = 0\\n type.append(typeNUM)\\n \\n nodesAll.extend(n)\\n elementsAll.extend(e)\\n sidesAll.extend(s)\\n if maxNodes < len(n): maxNodes = len(n)\\n if maxElements < len(e): maxElements = len(e)\\n if maxSides < len(s): maxSides = len(s)\\n \\n \\n #remove repeated elements, sides and nodes\\n nodesAll = list(set(nodesAll))\\n elementsAll = list(set(elementsAll))\\n sidesAll = list(set(sidesAll))\\n \\n print \\\"# elements = %s\\\" % len(elementsAll)\\n print \\\"# sides = %s\\\" % len(sidesAll)\\n print \\\"# nodes = %s\\\" % len(nodesAll)\\n\\n \\n #initialise arrays for entry into netcdf file\\n nodes = zeros((len(dictionary),maxNodes))\\n elements = zeros((len(dictionary),maxElements))\\n sides = zeros((len(dictionary),maxSides)) \\n \\n i = 0\\n for row in dictionary.iteritems(): \\n nodes[i,0:(len(row[1]['nodes']))] = row[1]['nodes']\\n elements[i,0:(len(row[1]['elements']))] = row[1]['elements']\\n sides[i,0:(len(row[1]['sides']))] = row[1]['sides']\\n i+=1 \\n \\n #create dimensions\\n try: self.buildings.createDimension('max_number_nodes',maxNodes)\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.buildings.createDimension('max_number_elements',maxElements)\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.buildings.createDimension('max_number_sides',maxSides)\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.buildings.createDimension('number_of_buildings',len(dictionary))\\n except Exception, e: print \\\"WARNING: %s\\\" % e \\n try: self.building_nodes.createDimension('number_of_nodes',len(nodesAll))\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.building_elements.createDimension('number_of_elements',len(elementsAll))\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.building_sides.createDimension('number_of_sides',len(sidesAll))\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n \\n \\n #create variables\\n try: building_id = self.buildings.createVariable(varname = 'building_id',datatype = 'i', dimensions=('number_of_buildings',)) \\n except Exception, e:\\n building_id = self.buildings.variables['building_id']\\n print \\\"WARNING: %s\\\" % e\\n \\n try: building_wkt = self.buildings.createVariable(varname = 'building_wkt',datatype = str, dimensions=('number_of_buildings',)) \\n except Exception, e:\\n building_wkt = self.buildings.variables['building_wkt'] \\n print \\\"WARNING: %s\\\" % e\\n\\n try: building_perimeter = self.buildings.createVariable(varname = 'building_perimeter',datatype = 'd', dimensions=('number_of_buildings',)) \\n except Exception, e:\\n building_perimeter = self.buildings.variables['building_perimeter'] \\n print \\\"WARNING: %s\\\" % e\\n\\n\\n try: building_type = self.buildings.createVariable(varname = 'building_type',datatype = 'i', dimensions=('number_of_buildings',)) \\n except Exception, e:\\n building_type = self.buildings.variables['building_type'] \\n print \\\"WARNING: %s\\\" % e\\n\\n try: building_nodes = self.buildings.createVariable(varname = 'building_nodes',datatype = 'i', dimensions=('number_of_buildings','max_number_nodes',)) \\n except Exception, e:\\n building_nodes = self.buildings.variables['building_nodes'] \\n print \\\"WARNING: %s\\\" % e\\n \\n try: building_elements = self.buildings.createVariable(varname = 'building_elements',datatype = 'i', dimensions=('number_of_buildings','max_number_elements',)) \\n except Exception, e:\\n building_elements = self.buildings.variables['building_elements']\\n print \\\"WARNING: %s\\\" % e\\n \\n try: building_sides = self.buildings.createVariable(varname = 'building_sides',datatype = 'i', dimensions=('number_of_buildings','max_number_sides',)) \\n except Exception, e:\\n building_sides = self.buildings.variables['building_sides']\\n print \\\"WARNING: %s\\\" % e\\n \\n building_nodes[:] = nodes\\n building_elements[:] = elements\\n building_sides[:] = sides\\n building_id[:] = array(id) \\n building_perimeter[:] = array(perimeter)\\n building_type[:] = array(type)\\n #Set the attributes\\n self.building_nodes.start = start\\n self.building_nodes.finish = end\\n self.building_nodes.step = step\\n self.building_elements.start = start\\n self.building_elements.finish = end\\n self.building_elements.step = step\\n self.building_sides.start = start\\n self.building_sides.finish = end\\n self.building_sides.step = step\\n \\n #assign the data\\n output_ids = {'nodes': [], 'elements': [], 'sides': []}\\n try: output_ids['nodes'] = self.building_nodes.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_nodes',))\\n except Exception, e:\\n output_ids['nodes'] = self.building_nodes.variables['id']\\n print \\\"WARNING: %s\\\" % e\\n try: output_ids['elements'] = self.building_elements.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_elements',))\\n except Exception, e:\\n output_ids['elements'] = self.building_elements.variables['id']\\n print \\\"WARNING: %s\\\" % e\\n try: output_ids['sides'] = self.building_sides.createVariable(varname = 'id',datatype = 'i', dimensions=('number_of_sides',))\\n except Exception, e:\\n output_ids['sides'] = self.building_sides.variables['id']\\n print \\\"WARNING: %s\\\" % e\\n \\n \\n output_ids['nodes'][:] = array(nodesAll)\\n output_ids['elements'][:] = array(elementsAll)\\n output_ids['sides'][:] = array(sidesAll)\\n \\n \\n self.buildingsAdded = True\\n else:\\n #create dimensions\\n try: self.buildings.createDimension('number_of_buildings',0)\\n except Exception, e: print \\\"WARNING: %s\\\" % e \\n try: self.building_nodes.createDimension('number_of_nodes',0)\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.building_elements.createDimension('number_of_elements',0)\\n except Exception, e: print \\\"WARNING: %s\\\" % e\\n try: self.building_sides.createDimension('number_of_sides',0)\\n except Exception, e: print \\\"WARNING: %s\\\" % e \\n self.buildingsAdded = True\",\n \"def pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\\n def compute_avec(vec,aaa,bbb,grd):\\n\\n avec=np.empty(grd.np0,)\\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\\n avec[grd.vp1] = vec[grd.vp1]\\n\\n return avec,\\n if name_grd is not None:\\n if os.path.isfile(name_grd):\\n with open(name_grd, 'rb') as f:\\n grd = pickle.load(f)\\n else:\\n grd = Grid(lon,lat)\\n with open(name_grd, 'wb') as f:\\n pickle.dump(grd, f)\\n f.close()\\n else:\\n grd = Grid(lon,lat)\\n\\n ny,nx,=np.shape(hg)\\n g=grd.g\\n\\n\\n x=hg[grd.indi,grd.indj]\\n q1d=q[grd.indi,grd.indj]\\n\\n aaa=g/grd.f01d\\n bbb=-g*grd.f01d/c**2\\n ccc=+q1d\\n\\n aaa[grd.vp1]=0\\n bbb[grd.vp1]=1\\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\\n\\n vec=+x\\n\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n p=-gg\\n\\n for itr in range(nitr-1):\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n tmp=np.dot(p,avec)\\n\\n if tmp!=0. : s=-np.dot(p,gg)/tmp\\n else: s=1.\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n vec=+x\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n a2=np.dot(gg,gg)\\n\\n if a1!=0: beta=a2/a1\\n else: beta=1.\\n\\n p=-gg+beta*p\\n\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n val1=-np.dot(p,gg)\\n val2=np.dot(p,avec)\\n if (val2==0.):\\n s=1.\\n else:\\n s=val1/val2\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n\\n # back to 2D\\n h=np.empty((ny,nx))\\n h[:,:]=np.NAN\\n h[grd.indi,grd.indj]=x[:]\\n\\n\\n return h\",\n \"def __init__(self, folder):\\n print \\\"folder passed is \\\", folder\\n self.folder = folder\\n self.geometry = gf.geometry(self.folder)\\n self.elements = gf.dictionary_set()\\n self.area = np.zeros(shape = (8))\\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\\n *self.geometry.properties['span_width']/2))\\n self.F = np.zeros(shape = (8, 8))\\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\\n self.geometry.properties['tra_sidewall_out'],\\n self.geometry.properties['tra_cover_in'],\\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\\n self.geometry.properties['emi_sidewall_out'],\\n self.geometry.properties['emi_cover_in'],\\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \\n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\\n if ((self.tr + self.em).any() > 1.0):\\n print \\\"error in optical properties\\\"\\n self.T = np.zeros(shape = (2,10))\\n self.RH = np.zeros(shape = (2,10))\\n # 8 inside,9 outside \\n self.qcond = np.zeros(shape = (2,8))\\n self.qconv = np.zeros(shape = (2,8))\\n self.qrad = np.zeros(shape = (2,8))\\n self.j = np.zeros(shape = (2,8))\\n self.g = np.zeros(shape = (2,8))\\n self.alpha = np.zeros(shape = (2,8))\\n deltaT = 300\\n RH_in = 0.6\\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\\n 278,\\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\\n self.geometry.properties['sky_temp'])\\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\\n self.geometry.properties['wind_speed'],\\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\\n self.geometry.properties['rho'],self.geometry.properties['cp'],\\n self.Vol,self.geometry.properties['degree_window'],deltaT)\",\n \"def test_for_grader():\\n test_map1 = np.array([\\n [1, 1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 1, 0, 0, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 1, 0, 1, 0, 1, 0, 1],\\n [1, 0, 0, 0, 1, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1, 1]])\\n x_spacing1 = 1\\n y_spacing1 = 1\\n start1 = np.array([[1.5], [1.5], [0]])\\n goal1 = np.array([[7.5], [1], [0]])\\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\\n s = 0\\n for i in range(len(path1)-1):\\n s += np.sqrt((path1[i][0]-path1[i+1][0])**2 + (path1[i][1]-path1[i+1][1])**2)\\n print(\\\"Path 1 length:\\\")\\n print(s)\\n\\n\\n test_map2 = np.array([\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 1, 1, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n start2 = np.array([[0.4], [0.4], [1.5707963267948966]])\\n goal2 = np.array([[0.4], [1.8], [-1.5707963267948966]])\\n x_spacing2 = 0.2\\n y_spacing2 = 0.2\\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\\n s = 0\\n for i in range(len(path2)-1):\\n s += np.sqrt((path2[i][0]-path2[i+1][0])**2 + (path2[i][1]-path2[i+1][1])**2)\\n print(\\\"Path 2 length:\\\")\\n print(s)\",\n \"def generate_trivial_tours(self):\\n self.routes = []\\n for c in range(1, self.vrpdata.NumCust+1):\\n self.routes.append(VRP_Route([c]))\\n return self.get_objective()\",\n \"def workflow(save_dir):\\n year = 2016\\n month_series = range(1, 13)\\n total_potential_biomass_multiplier = 48.8\\n total_standing_biomass_multiplier = 45.25\\n biomass_jitter = 3.\\n diet_sufficiency_multiplier = 0.28\\n diet_sufficiency_jitter = 0.01\\n avg_animal_density = 0.0175\\n animal_density_jitter = 0.005\\n\\n # twelve months of precipitation rasters covering the study area\\n precip_basename_list = [\\n 'chirps-v2.0.{}.{:02d}.tif'.format(year, month) for month in\\n month_series]\\n\\n # reclassify 0 to NoData in CHIRPS rasters\\n output_precip_dir = os.path.join(save_dir, 'precip')\\n if not os.path.exists(output_precip_dir):\\n os.makedirs(output_precip_dir)\\n for bn in precip_basename_list:\\n base_raster = os.path.join(PRECIP_DIR, bn)\\n target_raster = os.path.join(output_precip_dir, bn)\\n pygeoprocessing.raster_calculator(\\n [(base_raster, 1)], zero_to_nodata, target_raster,\\n gdal.GDT_Float32, _IC_NODATA)\\n\\n # generate outputs\\n for month in month_series:\\n precip_raster = os.path.join(\\n output_precip_dir, 'chirps-v2.0.{}.{:02d}.tif'.format(year, month))\\n\\n total_potential_biomass_path = os.path.join(\\n save_dir, 'potential_biomass_{}_{:02d}.tif'.format(year, month))\\n pygeoprocessing.raster_calculator(\\n [(precip_raster, 1)] + [(path, 'raw') for path in [\\n total_potential_biomass_multiplier,\\n biomass_jitter]],\\n precip_to_correlated_output, total_potential_biomass_path,\\n gdal.GDT_Float32, _IC_NODATA)\\n\\n total_standing_biomass_path = os.path.join(\\n save_dir, 'standing_biomass_{}_{:02d}.tif'.format(year, month))\\n pygeoprocessing.raster_calculator(\\n [(precip_raster, 1)] + [(path, 'raw') for path in [\\n total_standing_biomass_multiplier,\\n biomass_jitter]],\\n precip_to_correlated_output, total_standing_biomass_path,\\n gdal.GDT_Float32, _IC_NODATA)\\n\\n diet_sufficiency_path = os.path.join(\\n save_dir, 'diet_sufficiency_{}_{:02d}.tif'.format(year, month))\\n pygeoprocessing.raster_calculator(\\n [(precip_raster, 1)] + [(path, 'raw') for path in [\\n diet_sufficiency_multiplier,\\n diet_sufficiency_jitter]],\\n precip_to_correlated_output, diet_sufficiency_path,\\n gdal.GDT_Float32, _IC_NODATA)\\n\\n animal_density_path = os.path.join(\\n save_dir, 'animal_density_{}_{:02d}.tif'.format(year, month))\\n pygeoprocessing.raster_calculator(\\n [(precip_raster, 1)] + [(path, 'raw') for path in [\\n avg_animal_density,\\n animal_density_jitter]],\\n precip_to_animal_density, animal_density_path,\\n gdal.GDT_Float32, _IC_NODATA)\",\n \"def getMove(self, grid):\\n# global prune\\n# prune = 0\\n def Terminal(stateTup):\\n \\\"\\\"\\\"\\n Checks if the node is a terminal node\\n Returns eval(state) if it is terminal\\n \\\"\\\"\\\"\\n state = stateTup[0]\\n maxDepth = self.depthLimit\\n if stateTup[1] == maxDepth:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n elif len(stateTup[0].getAvailableMoves()) == 0:\\n val = self.h.get(str(state.map))\\n if val == None:\\n Val = Eval(state)\\n self.h[str(state.map)] = Val\\n return Val\\n else:\\n return val\\n\\n def Eval(state):\\n \\\"\\\"\\\"\\n This is the eval function which combines many heuristics and assigns\\n weights to each of them\\n Returns a single value\\n \\\"\\\"\\\"\\n\\n# H1 = htest2(state)\\n# return H1\\n H2 = h1(state)*monotonic(state)\\n return H2\\n\\n\\n def h1(state):\\n Max = state.getMaxTile()\\n left = len(state.getAvailableCells())/16\\n if state.getCellValue([0,0]) == Max:\\n v = 1\\n else:\\n v= 0.3\\n Max = Max/1024\\n return Max*left*v\\n\\n def mono(state):\\n mon = 0\\n# for i in range(4):\\n# row = 0\\n# for j in range(3):\\n# if state.map[i][j] > state.map[i][j+1]:\\n# row+=1\\n# if row == 4:\\n# mon += 1\\n# for i in range(4):\\n# column = 0\\n# for j in range(3):\\n# if state.map[j][i] > state.map[j+1][i]:\\n# column +=1\\n# if column == 4:\\n# mon +=1\\n#\\n#\\n# return mon/8\\n for i in range(4):\\n if all(earlier >= later for earlier, later in zip(grid.map[i], grid.map[i][1:])):\\n mon+=1\\n\\n return mon/8\\n\\n def monotonic(state):\\n cellvals = {}\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n for i in Path1:\\n cellvals[i] = state.getCellValue(i)\\n mon = 0\\n for i in range(4):\\n if cellvals.get((i,0)) >= cellvals.get((i,1)):\\n if cellvals.get((i,1)) >= cellvals.get((i,2)):\\n if cellvals.get((i,2)) >= cellvals.get((i,3)):\\n mon +=1\\n for j in range(4):\\n if cellvals.get((0,j)) >= cellvals.get((1,j)):\\n if cellvals.get((1,j)) >= cellvals.get((2,j)):\\n if cellvals.get((2,j)) >= cellvals.get((3,j)):\\n mon+=1\\n return mon/8\\n\\n\\n\\n def htest2(state):\\n score1 = 0\\n score2 = 0\\n r = 0.5\\n\\n Path1 = [(3,0),(3,1),(3,2),(3,3),(2,3),(2,2),(2,1),(2,0),\\n (1,0),(1,1),(1,2),(1,3),(0,3),(0,2),(0,1),(0,0)]\\n Path2 = [(3,0),(2,0),(1,0),(0,0),(0,1),(1,1),(2,1),(3,1),\\n (3,2),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3),(3,3)]\\n valDict = {}\\n for n in range(16):\\n valDict[Path1[n]] = state.getCellValue(Path1[n])\\n for n in range(16):\\n if n%3 == 0:\\n self.emergency()\\n cell1 = valDict.get(Path1[n])\\n cell2 = valDict.get(Path2[n])\\n score1 += (cell1) * (r**n)\\n score2 += (cell2) * (r**n)\\n return max(score1,score2)\\n\\n\\n def Maximize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n maxChild , maxUtility = None,-999999999\\n state = stateTup[0]\\n Map = self.dict.get(str(state.map))\\n if Map == None:\\n children = []\\n for M in range(4):\\n g = state.clone()\\n if g.move(M):\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Minimize(childTup,A,B)[1]\\n if utility > maxUtility:\\n maxChild , maxUtility = child , utility\\n if maxUtility >= B:\\n# global prune\\n# prune +=1\\n break\\n if maxUtility > A:\\n A = maxUtility\\n\\n return (maxChild,maxUtility)\\n\\n\\n def Minimize(stateTup,A,B):\\n \\\"\\\"\\\"\\n Returns a tuple of state,eval(state)\\n Takes in a stateTup(tuple of grid + depth of the grid), alpha,\\n and beta\\n \\\"\\\"\\\"\\n self.emergency()\\n t = Terminal(stateTup)\\n if t != None:\\n return (None, t)\\n\\n minChild , minUtility = None,999999999\\n state = stateTup[0]\\n Map= self.dict.get(str(state.map))\\n if Map == None:\\n cells= state.getAvailableCells()\\n children = []\\n tiles = [2,4]\\n for i in cells:\\n for j in tiles:\\n g = state.clone()\\n g.insertTile(i,j)\\n children.append(g)\\n self.dict[str(state.map)] = children\\n else:\\n children = Map\\n for child in children:\\n childTup = (child,stateTup[1]+1)\\n utility = Maximize(childTup,A,B)[1]\\n if utility < minUtility:\\n minChild , minUtility = child , utility\\n if minUtility <= A:\\n# global prune\\n# prune +=1\\n break\\n if minUtility < B:\\n B = minUtility\\n\\n return (minChild,minUtility)\\n\\n\\n\\n def decision(grid):\\n \\\"\\\"\\\"\\n Decision function which returns the move which led to the state\\n \\\"\\\"\\\"\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\\n\\n self.dict = {}\\n self.h = {}\\n self.prevTime = time.clock()\\n self.depthLimit = 1\\n self.mL = []\\n self.over = False\\n while self.over == False:\\n self.depthLimit +=1\\n try :\\n self.mL.append(decision(grid))\\n\\n except KeyError:\\n# print(self.depthLimit)\\n return self.mL[-1]\\n except IndexError:\\n return random.randint(0,3)\\n self.Alarm(time.clock())\\n return self.mL[-1]\",\n \"def connect_cells(dfte,vari):\\n # Create the variabel cell for mother, grand mother and grand grand mother\\n if 'g_parent_cell' not in dfte.columns:\\n dfte = rl.genalogy(dfte,'parent_cell') #Create genealogy\\n if 'g_g_parent_cell' not in dfte.columns:\\n dfte = rl.genalogy(dfte,'g_parent_cell')\\n if 'g_g_g_parent_cell' not in dfte.columns:\\n dfte = rl.genalogy(dfte,'g_g_parent_cell')\\n #give unique index to all cells\\n dfte['uid'] = dfte['cell']+dfte['time_sec'].apply(lambda x: str(x))\\n vac=[];sc=[];uid = []\\n # Create a vecotor for the variable of interest of cell,mother,grand mother and grand grand mother and an unique identifier of it\\n for c,idx in enumerate(dfte['cell'].unique()):\\n dau = dfte.loc[dfte['cell']==idx]\\n pc = dau['parent_cell'].iloc[0]\\n mum = dfte.loc[dfte['cell']==pc]\\n gpc = dau['g_parent_cell'].iloc[0]\\n gmum = dfte.loc[dfte['cell']==gpc]\\n ggpc = dau['g_g_parent_cell'].iloc[0]\\n ggmum = dfte.loc[dfte['cell']==ggpc]\\n gggpc = dau['g_g_g_parent_cell'].iloc[0]\\n gggmum = dfte.loc[dfte['cell']==gggpc]\\n fte = lambda x: x[['{}'.format(vari),'uid']].values\\n tmp = np.vstack([fte(gggmum),fte(ggmum),fte(gmum),fte(mum),fte(dau)])\\n vac.append(tmp[:,0])\\n uid.append(tmp[:,1])\\n sc.append(['super_cell_{}'.format(c)]*len(tmp))\\n return pd.DataFrame({'super_cell':np.hstack(sc),'uid':np.hstack(uid),'{}'.format(vari):np.hstack(vac)})\",\n \"def drought_prec_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Previous 7-day precip from USGS (not working) \\n prec7_legend = MVLegendImageClass(value='7-day Precip Total',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP7') \\n precip7day = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'PRECIP_RD7'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='Prev 7-day Precip',\\n legend_classes=[prec7_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # NWS Precip analysis data \\n nws_prec7 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Forecasts_Guidance_Warnings/rfc_dly_qpe/MapServer',\\n 'params': {'LAYERS': 'show:15'}},\\n legend_title='7-day % of Norm',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### USGS WMS Precip Layers\\n precip30_legend = MVLegendImageClass(value='Previous 30-day Precip',\\n image_url='https://vegdri.cr.usgs.gov/wms.php?service=WMS&request=GetLegendGraphic&format=image%2Fpng&width=20&height=20&LAYER=PRECIP_TP30') \\n precip30 = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://vegdri.cr.usgs.gov/wms.php?',\\n 'params': {'LAYERS': 'PRECIP_TP30'},\\n 'serverType': 'geoserver'},\\n layer_options={'visible':True,'opacity':0.4},\\n legend_title='30-day Total Precip',\\n legend_classes=[precip30_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n\\n # NEXRAD Radar reflectivity \\n nexrad_legend = MVLegendImageClass(value='Base Reflectivity',\\n image_url='https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?version=1.1.1&service=WMS&request=GetLegendGraphic&layer=nexrad-n0q-900913&format=image/png&STYLE=default') \\n nexrad = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0q.cgi?',\\n 'params': {'LAYERS': 'nexrad-n0q-900913'}},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='NEXRAD',\\n legend_classes=[nexrad_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # NOAA NOHRSC snow products\\n snodas_swe = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://idpgis.ncep.noaa.gov/arcgis/rest/services/NWS_Observations/NOHRSC_Snow_Analysis/MapServer',\\n 'params': {'LAYERS': 'show:7'}},\\n legend_title='SNODAS Model SWE',\\n layer_options={'visible':True,'opacity':0.7},\\n legend_classes=[\\n MVLegendClass('polygon', '0.04', fill='rgba(144,175,180,0.7)'),\\n MVLegendClass('polygon', '0.20', fill='rgba(128,165,192,0.7)'),\\n MVLegendClass('polygon', '0.39', fill='rgba(95,126,181,0.7)'),\\n MVLegendClass('polygon', '0.78', fill='rgba(69,73,171,0.7)'),\\n MVLegendClass('polygon', '2.00', fill='rgba(71,46,167,0.7)'),\\n MVLegendClass('polygon', '3.90', fill='rgba(79,20,144,0.7)'),\\n MVLegendClass('polygon', '5.90', fill='rgba(135,33,164,0.7)'),\\n MVLegendClass('polygon', '9.80', fill='rgba(155,53,148,0.7)'),\\n MVLegendClass('polygon', '20', fill='rgba(189,88,154,0.7)'),\\n MVLegendClass('polygon', '30', fill='rgba(189,115,144,0.7)'),\\n MVLegendClass('polygon', '39', fill='rgba(195,142,150,0.7)'),\\n MVLegendClass('polygon', '79', fill='rgba(179,158,153,0.7)')],\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Coloado CDSS snowpack data (requires token --- expires)\\n snodas_cdss = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.colorado.gov/oit/rest/services/DNR_CWCB/SNODAS/MapServer',\\n 'params': {'LAYERS': 'show:0','TOKEN':'4HhtbZGoUS6eXs7G93BmoyFjDnjQNfNC_pWr3N-FbLI.'}},\\n legend_title='SNODAS Mean',\\n layer_options={'visible':False,'opacity':0.5},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # testing homemand kml image dispaly for SNODAS % daily median SWE (kml not working - kmz contains png with data??) \\n snodas_kml_med = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/20180322_multyear_perc_med.kmz'},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='SNODAS SWE % of Median',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # Define map view options\\n drought_prec_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'FullScreen', 'ScaleLine', 'WMSLegend',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,snodas_swe,precip30,nexrad,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_prec_map_view_options':drought_prec_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_prec.html', context)\",\n \"def drawValidationNeedles(self): \\n #productive #onButton\\n profprint()\\n # reset report table\\n # print \\\"Draw manually segmented needles...\\\"\\n #self.table =None\\n #self.row=0\\n self.initTableView()\\n self.deleteEvaluationNeedlesFromTable()\\n while slicer.util.getNodes('manual-seg*') != {}:\\n nodes = slicer.util.getNodes('manual-seg*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\\n \\n if self.tableValueCtrPt==[[]]:\\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n for nthNode in range(nbNode):\\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\\n if modelNode.GetAttribute(\\\"ValidationNeedle\\\") == \\\"1\\\":\\n needleNumber = int(modelNode.GetAttribute(\\\"NeedleNumber\\\"))\\n needleStep = int(modelNode.GetAttribute(\\\"NeedleStep\\\"))\\n coord=[0,0,0]\\n modelNode.GetFiducialCoordinates(coord)\\n self.tableValueCtrPt[needleNumber][needleStep]=coord\\n print needleNumber,needleStep,coord\\n # print self.tableValueCtrPt[needleNumber][needleStep]\\n\\n for i in range(len(self.tableValueCtrPt)):\\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\\n colorVar = random.randrange(50,100,1)/float(100)\\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\\n self.addNeedleToScene(controlPoints,i,'Validation')\\n else:\\n # print i\\n pass\",\n \"def drawObturatorNeedles(self):\\n #productive\\n profprint()\\n widget = slicer.modules.NeedleFinderWidget\\n realNeedleLength = widget.realNeedleLength.value\\n\\n # reset report table\\n self.table =None\\n self.row=0\\n self.initTableView()\\n while slicer.util.getNodes('obturator-seg*') != {}:\\n nodes = slicer.util.getNodes('obturator-seg*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\\n \\n if self.obtuNeedleValueCtrPt==[[[]]]:\\n self.obtuNeedleValueCtrPt = [[[999,999,999] for i in range(10)] for j in range(10)]\\n if self.obtuNeedlePt==[[[]]]:\\n self.obtuNeedlePt = [[[999,999,999] for i in range(10)] for j in range(10)]\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n for nthNode in range(nbNode):\\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\\n if modelNode.GetAttribute(\\\"ObturatorNeedle\\\") == \\\"1\\\":\\n needleNumber = int(modelNode.GetAttribute(\\\"NeedleNumber\\\"))\\n needleStep = int(modelNode.GetAttribute(\\\"NeedleStep\\\"))\\n coord=[0,0,0]\\n modelNode.GetFiducialCoordinates(coord)\\n if needleNumber==0:\\n self.obtuNeedleValueCtrPt[needleNumber][needleStep]=coord\\n \\n for i in range(0,len(self.obtuNeedleValueCtrPt)):\\n\\n sign = cmp(self.obtuNeedleValueCtrPt[0][0][2],self.obtuNeedleValueCtrPt[0][1][2])\\n if (i==0 and sign <=-1 ):\\n AA = self.obtuNeedleValueCtrPt[0][0][2]\\n BB = self.obtuNeedleValueCtrPt[0][1][2]\\n self.obtuNeedleValueCtrPt[0][0][2] = BB\\n self.obtuNeedleValueCtrPt[0][1][2] = AA\\n\\n # As we give the tip of the obturator needles, we only want to g in the increasing z direction.\\n\\n Vx = self.obtuNeedleValueCtrPt[0][1][0] - self.obtuNeedleValueCtrPt[0][0][0]\\n Vy = self.obtuNeedleValueCtrPt[0][1][1] - self.obtuNeedleValueCtrPt[0][0][1]\\n Vz = self.obtuNeedleValueCtrPt[0][1][2] - self.obtuNeedleValueCtrPt[0][0][2]\\n\\n L= float(Vx**2 + Vy**2 + Vz**2)**0.5\\n\\n E = self.obtuNeedleValueCtrPt[i][0]\\n Ex = E[0] + realNeedleLength*Vx/L\\n Ey = E[1] + realNeedleLength*Vy/L\\n Ez = E[2] + realNeedleLength*Vz/L\\n self.obtuNeedlePt[i][1] = [Ex,Ey,Ez]\\n self.obtuNeedlePt[i][0] = [E[0],E[1],E[2]]\\n #print needleNumber,needleStep,coord\\n\\n for i in range(len(self.obtuNeedlePt)):\\n if self.obtuNeedlePt[i][0][0]!=999:\\n colorVar = random.randrange(50,100,1)/(100)\\n controlPointsUnsorted = [val for val in self.obtuNeedlePt[i] if val !=[999,999,999]]\\n controlPoints=controlPointsUnsorted\\n #controlPoins = self.obtuNeedlePt[i]\\n if ((i==0 and len(controlPoints)>=1) or i>=1) :\\n self.addNeedleToScene(controlPoints,i,'Obturator')\",\n \"def genGrid(nTot,gDict):\\n \\n # Generate nTot-by-8 array, and dump to disk.\\n grid = np.empty([nTot,8])\\n \\n # Initialize Simulation ID (SID) to keep track of the number of propagations.\\n SID = 1\\n\\n # The grid array is filled in the order: MA, AOP, RAAN, INC, ECC, SMA, MJD.\\n \\n # Get deltas\\n for key in gDict:\\n if gDict[key]['points'] > 1:\\n gDict[key]['delta'] = (gDict[key]['end'] - gDict[key]['start']) / (gDict[key]['points'] - 1)\\n else:\\n gDict[key]['delta'] = 0.\\n \\n # Here's the Big Nested Loop.\\n for i0 in range(0, gDict['MJD']['points']):\\n MJD = gDict['MJD']['start'] + i0 * gDict['MJD']['delta']\\n\\n for i1 in range(0, gDict['SMA']['points']):\\n SMA = gDict['SMA']['start'] + i1 * gDict['SMA']['delta']\\n\\n for i2 in range(0, gDict['ECC']['points']):\\n ECC = gDict['ECC']['start'] + i2 * gDict['ECC']['delta']\\n\\n for i3 in range(0, gDict['INC']['points']):\\n INC = gDict['INC']['start'] + i3 * gDict['INC']['delta']\\n\\n for i4 in range(0, gDict['RAAN']['points']):\\n RAAN = gDict['RAAN']['start'] + i4 * gDict['RAAN']['delta']\\n\\n for i5 in range(0, gDict['AOP']['points']):\\n AOP = gDict['AOP']['start'] + i5 * gDict['AOP']['delta']\\n\\n for i6 in range(0, gDict['MA']['points']):\\n MA = gDict['MA']['start'] + i6 * gDict['MA']['delta']\\n \\n grid[SID - 1,:] = [SID,MJD,SMA,ECC,INC,RAAN,AOP,MA]\\n SID = SID + 1\\n\\n return grid\",\n \"def __init__(self, \\n nd = 2, \\n goal = np.array([1.0,1.0]),\\n state_bound = [[0,1],[0,1]],\\n nA = 4,\\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\\n<<<<<<< HEAD:archive-code/puddleworld.py\\n ngrid = [10.0,10.0],\\n maxStep = 40):\\n ngrid = [40, 40]\\n x_vec = np.linspace(0,1,ngrid[0])\\n y_vec = np.linspace(0,1,ngrid[1])\\n for x in x_vec:\\n for y in y_vec:\\n if ~self.inPuddle([x,y]):\\n puddle.append([x,y])\\n # puddle is a closed loop \\n outpuddlepts = np.asarray(puddle)\\n \\\"\\\"\\\"\\n\\n\\n # Horizontal wing of puddle consists of \\n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\\n # (xchi,ychi) is the center points (h ==> horizantal)\\n # x, y = state[0], state[1]\\n xch1, ych1 = 0.3, 0.7\\n xch2, ych2 = 0.65, ych1\\n radius = 0.1\\n\\n\\n #Vertical wing of puddle consists of \\n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\\n # where (xcvi,ycvi) is the center points (v ==> vertical)\\n xcv1 = 0.45; ycv1=0.4;\\n xcv2 = xcv1; ycv2 = 0.8;\\n\\n # % 2) two half-circle at end edges of rectangle\\n \\n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n puddle.append([xcv1-radius,ych1-radius])\\n \\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n \\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n \\n puddle.append([xcv1-radius,ych1+radius])\\n\\n\\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n\\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1-radius,y])\\n \\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1+radius,y])\\n \\\"\\\"\\\"\\n for y in np.arrange():\\n puddle.append([])\\n \\n for y in np.arrange():\\n puddle.append([])\\n \\\"\\\"\\\"\\n\\n # HALF CIRCLES\\n ngridTheta = 10\\n thetaVec = np.linspace(0,pi,ngridTheta)\\n\\n for t in thetaVec:\\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\\n\\n \\n outpuddlepts = np.asarray(puddle)\\n return outpuddlepts\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if rooms==[]: return\\n xcord=len(rooms)\\n ycord=len(rooms[0])\\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\\n gatenum=1\\n while indexstack != []:\\n newindex=[]\\n for item in indexstack:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=gatenum\\n newindex.append((xpoint,ypoint))\\n indexstack=newindex\\n gatenum+=1\\n ''''\\n for item in index_0:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=1\\n index_1.append((xpoint,ypoint))\\n for item in index_1:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=2\\n index_2.append((xpoint,ypoint))\\n for item in index_2:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=3\\n index_3.append((xpoint,ypoint))\\n for item in index_3:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=4\\n #index_3.append((xpoint,ypoint))'''\",\n \"def get_problem():\\n\\n #User Defined Terrain Elevation\\n #def terr( x_pos, y_pos ):\\n #Defines terrain elevation [m] as a function of x and y positions [m]\\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\\n # return elev\\n\\n #User Defined Tunnel Cost\\n #def tunnel(depth):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #depth below the ground.\\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\\n # return TunnelCost\\n\\n #def bridge(height):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #heigh above the ground.\\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\\n # return BridgeCost\\n\\n # Rename this and/or move to optim package?\\n problem = beluga.optim.Problem('surftest_noinc')\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','m') \\\\\\n .state('y','V*sin(hdg)','m') \\\\\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\\\\n .state('hdg','cmax/V*sin(hdgA)','rad')\\n\\n # Define controls\\n #problem.control('thrA','rad') \\\\\\n # .control('hdgA','rad')\\n problem.control('hdgA','rad')\\n\\n # Define Cost Functional\\n problem.cost['path'] = Expression('1','s')\\n\\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\\n\\n #+ \\\\\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\\\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','m') \\\\\\n .initial('y-y_0','m') \\\\\\n .initial('V-V_0','m/s') \\\\\\n .initial('hdg-hdg_0','rad') \\\\\\n .terminal('x-x_f','m') \\\\\\n .terminal('y-y_f','m')\\n #.terminal('V-V_f','m/s')\\n #.initial('hdg-hdg_0','rad') \\\\\\n\\n #Define constants\\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\\n problem.constant('eps',10,'m/s^2') #Error constant\\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\\n problem.constant('thrA',0,'rad')\\n\\n #Unit scaling\\n problem.scale.unit('m','x') \\\\\\n .unit('s','x/V') \\\\\\n .unit('rad',1) \\\\\\n .unit('USD',1)\\n\\n #Configure solver\\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\\n\\n #Initial Guess\\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\\n\\n #Add Continuation Steps\\n problem.steps.add_step().num_cases(10) \\\\\\n .terminal('x', 10) \\\\\\n .terminal('y', 0)\\n\\n problem.steps.add_step().num_cases(10) \\\\\\n .const('eps', 0.2)\\n\\n #problem.steps.add_step().num_cases(10) \\\\\\n # .terminal('y', 2*pi*1000) \\\\\\n # .terminal('z', 0.0) \\\\\\n # .terminal('inc', 0.0)\\n #^ City B\\n return problem\",\n \"def climb_tree():\\n global UP_TREE\\n westdesc = \\\"\\\"\\n eastdesc = \\\"\\\"\\n northdesc = \\\"\\\"\\n southdesc = \\\"\\\"\\n UP_TREE = True\\n westinvalid = False\\n eastinvalid = False\\n northinvalid = False\\n southinvalid = False\\n\\n\\n printmessage(\\\"You climb the large tree to get a look at your surroundings.\\\", 5, MAGENTA, 2)\\n\\n if ZERO_BASE_PLYR_POS in range(0, 10):\\n northinvalid = True\\n if ZERO_BASE_PLYR_POS in range(90, 100):\\n southinvalid = True\\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\\n eastinvalid = True\\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\\n westinvalid = True\\n \\n if not westinvalid: \\n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\\n if HAS_COMPASS: \\n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \\\"Y\\\"\\n if westpos == 10: # Water\\n westdesc = TREE_VIEWS[2]\\n else:\\n westdesc = TREE_VIEWS[1]\\n\\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\\n if westpos == 1:\\n westdesc = TREE_VIEWS[3]\\n elif westpos == 2:\\n westdesc = TREE_VIEWS[4]\\n else:\\n westdesc = TREE_VIEWS[5]\\n\\n if not eastinvalid:\\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \\\"Y\\\"\\n if eastpos == 10: # Water\\n eastdesc = TREE_VIEWS[2]\\n else:\\n eastdesc = TREE_VIEWS[1]\\n\\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\\n if eastpos == 1:\\n eastdesc = TREE_VIEWS[3]\\n elif eastpos == 2:\\n eastdesc = TREE_VIEWS[4]\\n else:\\n eastdesc = TREE_VIEWS[6]\\n\\n\\n if not northinvalid:\\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \\\"Y\\\"\\n if northpos == 10: # Water\\n northdesc = TREE_VIEWS[2]\\n else:\\n northdesc = TREE_VIEWS[1]\\n\\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\\n if northpos == 1: # bear\\n northdesc = TREE_VIEWS[3]\\n elif northpos == 2: # grizzly\\n northdesc = TREE_VIEWS[4]\\n else:\\n northdesc = TREE_VIEWS[7]\\n\\n\\n if not southinvalid:\\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \\\"Y\\\"\\n if southpos == 10: # Water\\n southdesc = TREE_VIEWS[2]\\n else:\\n southdesc = TREE_VIEWS[1]\\n\\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\\n if southpos == 1: # bear\\n southdesc = TREE_VIEWS[3]\\n elif southpos == 2: # grizzly\\n southdesc = TREE_VIEWS[4]\\n else:\\n southdesc = TREE_VIEWS[8]\\n\\n clear_messages(0)\\n printmessage(\\\"West: \\\" + westdesc, 2, GREEN, 0)\\n printmessage(\\\"East: \\\" + eastdesc, 3, YELLOW, 0)\\n printmessage(\\\"North: \\\" + northdesc, 4, CYAN, 0)\\n printmessage(\\\"South: \\\" + southdesc, 5, MAGENTA, 0)\\n #show_movement(True, 10)\\n update_player_on_map()\\n pause_for_keypress()\\n clear_messages(0)\",\n \"def new_bragg(cls,\\n DESCRIPTOR=\\\"Graphite\\\",\\n H_MILLER_INDEX=0,\\n K_MILLER_INDEX=0,\\n L_MILLER_INDEX=2,\\n TEMPERATURE_FACTOR=1.0,\\n E_MIN=5000.0,\\n E_MAX=15000.0,\\n E_STEP=100.0,\\n SHADOW_FILE=\\\"bragg.dat\\\"):\\n # retrieve physical constants needed\\n codata = scipy.constants.codata.physical_constants\\n codata_e2_mc2, tmp1, tmp2 = codata[\\\"classical electron radius\\\"]\\n # or, hard-code them\\n # In [179]: print(\\\"codata_e2_mc2 = %20.11e \\\\n\\\" % codata_e2_mc2 )\\n # codata_e2_mc2 = 2.81794032500e-15\\n\\n fileout = SHADOW_FILE\\n descriptor = DESCRIPTOR\\n\\n hh = int(H_MILLER_INDEX)\\n kk = int(K_MILLER_INDEX)\\n ll = int(L_MILLER_INDEX)\\n\\n temper = float(TEMPERATURE_FACTOR)\\n\\n emin = float(E_MIN)\\n emax = float(E_MAX)\\n estep = float(E_STEP)\\n\\n #\\n # end input section, start calculations\\n #\\n\\n f = open(fileout, 'wt')\\n\\n cryst = xraylib.Crystal_GetCrystal(descriptor)\\n volume = cryst['volume']\\n\\n #test crystal data - not needed\\n itest = 1\\n if itest:\\n if (cryst == None):\\n sys.exit(1)\\n print (\\\" Unit cell dimensions are %f %f %f\\\" % (cryst['a'],cryst['b'],cryst['c']))\\n print (\\\" Unit cell angles are %f %f %f\\\" % (cryst['alpha'],cryst['beta'],cryst['gamma']))\\n print (\\\" Unit cell volume is %f A^3\\\" % volume )\\n print (\\\" Atoms at:\\\")\\n print (\\\" Z fraction X Y Z\\\")\\n for i in range(cryst['n_atom']):\\n atom = cryst['atom'][i]\\n print (\\\" %3i %f %f %f %f\\\" % (atom['Zatom'], atom['fraction'], atom['x'], atom['y'], atom['z']) )\\n print (\\\" \\\")\\n\\n volume = volume*1e-8*1e-8*1e-8 # in cm^3\\n #flag Graphite Struecture\\n f.write( \\\"%i \\\" % 5)\\n #1/V*electronRadius\\n f.write( \\\"%e \\\" % ((1e0/volume)*(codata_e2_mc2*1e2)) )\\n #dspacing\\n dspacing = xraylib.Crystal_dSpacing(cryst, hh, kk, ll)\\n f.write( \\\"%e \\\" % (dspacing*1e-8) )\\n f.write( \\\"\\\\n\\\")\\n #Z's\\n atom = cryst['atom']\\n f.write( \\\"%i \\\" % atom[0][\\\"Zatom\\\"] )\\n f.write( \\\"%i \\\" % -1 )\\n f.write( \\\"%e \\\" % temper ) # temperature parameter\\n f.write( \\\"\\\\n\\\")\\n\\n ga = (1e0+0j) + cmath.exp(1j*cmath.pi*(hh+kk)) \\\\\\n + cmath.exp(1j*cmath.pi*(hh+ll)) \\\\\\n + cmath.exp(1j*cmath.pi*(kk+ll))\\n # gb = ga * cmath.exp(1j*cmath.pi*0.5*(hh+kk+ll))\\n ga_bar = ga.conjugate()\\n # gb_bar = gb.conjugate()\\n\\n\\n f.write( \\\"(%20.11e,%20.11e ) \\\\n\\\" % (ga.real, ga.imag) )\\n f.write( \\\"(%20.11e,%20.11e ) \\\\n\\\" % (ga_bar.real, ga_bar.imag) )\\n f.write( \\\"(%20.11e,%20.11e ) \\\\n\\\" % (0.0, 0.0) )\\n f.write( \\\"(%20.11e,%20.11e ) \\\\n\\\" % (0.0, 0.0) )\\n\\n zetas = [atom[0][\\\"Zatom\\\"]]\\n for zeta in zetas:\\n xx01 = 1e0/2e0/dspacing\\n xx00 = xx01-0.1\\n xx02 = xx01+0.1\\n yy00= xraylib.FF_Rayl(int(zeta),xx00)\\n yy01= xraylib.FF_Rayl(int(zeta),xx01)\\n yy02= xraylib.FF_Rayl(int(zeta),xx02)\\n xx = numpy.array([xx00,xx01,xx02])\\n yy = numpy.array([yy00,yy01,yy02])\\n fit = numpy.polyfit(xx,yy,2)\\n #print \\\"zeta: \\\",zeta\\n #print \\\"z,xx,YY: \\\",zeta,xx,yy\\n #print \\\"fit: \\\",fit[::-1] # reversed coeffs\\n #print \\\"fit-tuple: \\\",(tuple(fit[::-1].tolist())) # reversed coeffs\\n #print(\\\"fit-tuple: %e %e %e \\\\n\\\" % (tuple(fit[::-1].tolist())) ) # reversed coeffs\\n f.write(\\\"%e %e %e \\\\n\\\" % (tuple(fit[::-1].tolist())) ) # reversed coeffs\\n\\n f.write(\\\"%e %e %e \\\\n\\\" % (0.0, 0.0, 0.0)) # reversed coeffs\\n\\n\\n npoint = int( (emax - emin)/estep + 1 )\\n f.write( (\\\"%i \\\\n\\\") % npoint)\\n for i in range(npoint):\\n energy = (emin+estep*i)\\n f1a = xraylib.Fi(int(zetas[0]),energy*1e-3)\\n f2a = xraylib.Fii(int(zetas[0]),energy*1e-3)\\n # f1b = xraylib.Fi(int(zetas[1]),energy*1e-3)\\n # f2b = xraylib.Fii(int(zetas[1]),energy*1e-3)\\n out = numpy.array([energy,f1a,abs(f2a),1.0, 0.0])\\n f.write( (\\\"%20.11e %20.11e %20.11e \\\\n %20.11e %20.11e \\\\n\\\") % ( tuple(out.tolist()) ) )\\n\\n f.close()\\n print(\\\"File written to disk: %s\\\" % fileout)\",\n \"def robotGridSummaryDict(self):\\n rgd = self.robotGridDict(incRobotDict=False)\\n robotDict = {}\\n for rid, robot in self.robotDict.items():\\n r = {}\\n # print(\\\"rid\\\", robot.id, robot.alpha, robot.beta)\\n r[\\\"id\\\"] = robot.id\\n r[\\\"nDecollide\\\"] = robot.nDecollide\\n r[\\\"lastStepNum\\\"] = robot.lastStepNum\\n r[\\\"assignedTargetID\\\"] = robot.assignedTargetID\\n r[\\\"hasApogee\\\"] = robot.hasApogee\\n r[\\\"hasBoss\\\"] = robot.hasBoss\\n r[\\\"xPos\\\"] = robot.xPos\\n r[\\\"yPos\\\"] = robot.yPos\\n r[\\\"alpha\\\"] = robot.alpha\\n r[\\\"beta\\\"] = robot.beta\\n r[\\\"destinationAlpha\\\"] = robot.destinationAlpha\\n r[\\\"desstinationBeta\\\"] = robot.destinationBeta\\n r[\\\"angStep\\\"] = robot.angStep\\n r[\\\"collisionBuffer\\\"] = robot.collisionBuffer\\n\\n # convert from numpy arrays to lists\\n r[\\\"metFiberPos\\\"] = list(robot.metFiberPos)\\n r[\\\"bossFiberPos\\\"] = list(robot.bossFiberPos)\\n r[\\\"apFiberPos\\\"] = list(robot.apFiberPos)\\n r[\\\"roughAlphaX\\\"] = robot.roughAlphaX[-1][-1]\\n r[\\\"roughAlphaY\\\"] = robot.roughAlphaY[-1][-1]\\n r[\\\"roughBetaX\\\"] = robot.roughBetaX[-1][-1]\\n r[\\\"roughBetaY\\\"] = robot.roughBetaY[-1][-1]\\n # find the step at which this\\n # guy found its target\\n # otv = np.array(robot.onTargetVec)\\n # print(\\\"otargvec\\\", otv)\\n # r[\\\"onTargetVec\\\"] = robot.onTargetVec[-1]\\n # # find last False (after which must be true)\\n # # +1 because step numbers start from 1 and indices start from 0\\n # whereFalse = np.argwhere(otv==False).flatten()\\n # if not whereFalse:\\n # # empty list started on target? thats crazy\\n # lastFalse = 0\\n # else:\\n # lastFalse = int(whereFalse[-1] + 1)\\n # if lastFalse == len(otv):\\n # # last step was false robot never got there\\n # r[\\\"stepConverged\\\"] = str(-1 )# -1 incicates never got to target\\n # else:\\n # r[\\\"stepConverged\\\"] = str(lastFalse)\\n robotDict[robot.id] = r\\n\\n rgd[\\\"robotDict\\\"] = robotDict\\n return rgd\",\n \"def casdetude_genetics():\\n file_path = PROJECT_PATH + \\\"/geographycal_data/Monterusciello/MontEdo_buildings\\\"\\n router = Router(building_file=file_path)\\n\\n router.design_aqueduct(0)\\n\\n router.write2epanet(router.acqueduct, PROJECT_PATH + \\\"/Monterusciello_solution/Monterusciello_acqueduct\\\",\\n diam=False)\\n\\n read_epanet = graphIO.graph_reader(router.acqueduct)\\n read_epanet.read_epanet(PROJECT_PATH + \\\"/geographycal_data/SolvedNet/MonteSolution\\\")\\n kpi_calculator(router.acqueduct)\\n\\n minimal = router.design_minimal_aqueduct(router.acqueduct, \\\"Q*H\\\")\\n router.write2epanet(minimal, PROJECT_PATH + \\\"/Monterusciello_solution/Monterusciello_acqueduct\\\", diam=False)\",\n \"def generate_maze(self):\\r\\n # reset the grid before generation\\r\\n self.initialize_grid()\\r\\n\\r\\n # choose the first cell to put in the visited list\\r\\n # see Step 1 of the algorithm.\\r\\n current = self.unvisited.pop(random.randint(0,len(self.unvisited)-1))\\r\\n self.visited.append(current)\\r\\n self.cut(current)\\r\\n\\r\\n # loop until all cells have been visited\\r\\n while len(self.unvisited) > 0:\\r\\n # choose a random cell to start the walk (Step 2)\\r\\n first = self.unvisited[random.randint(0,len(self.unvisited)-1)]\\r\\n current = first\\r\\n # loop until the random walk reaches a visited cell\\r\\n while True:\\r\\n # choose direction to walk (Step 3)\\r\\n dirNum = random.randint(0,3)\\r\\n # check if direction is valid. If not, choose new direction\\r\\n while not self.is_valid_direction(current,dirNum):\\r\\n dirNum = random.randint(0,3)\\r\\n # save the cell and direction in the path\\r\\n self.path[current] = dirNum\\r\\n # get the next cell in that direction\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n if (current in self.visited): # visited cell is reached (Step 5)\\r\\n break\\r\\n\\r\\n current = first # go to start of path\\r\\n # loop until the end of path is reached\\r\\n while True:\\r\\n # add cell to visited and cut into the maze\\r\\n self.visited.append(current)\\r\\n self.unvisited.remove(current) # (Step 6.b)\\r\\n self.cut(current)\\r\\n\\r\\n # follow the direction to next cell (Step 6.a)\\r\\n dirNum = self.path[current]\\r\\n crossed = self.get_next_cell(current,dirNum,1)\\r\\n self.cut(crossed) # cut crossed edge\\r\\n\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n if (current in self.visited): # end of path is reached\\r\\n self.path = dict() # clear the path\\r\\n break\\r\\n \\r\\n self.generated = True\",\n \"def drought_index_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n\\n # NCDC Climate Divisions\\n climo_divs = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/backgrounds/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Climate Divisions',\\n layer_options={'visible':False,'opacity':0.8},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.3},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n usdm_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/usdm_current.kml'},\\n layer_options={'visible':True,'opacity':0.5},\\n legend_title='USDM',\\n feature_selection=False,\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # ESI Data from USDA\\n esi_1 = MVLayer(\\n source='ImageWMS',\\n options={'url': 'https://hrsl.ba.ars.usda.gov/wms.esi.2012?',\\n 'params': {'LAYERS': 'ESI_current_1month', 'VERSION':'1.1.3', 'CRS':'EPSG:4326'}},\\n layer_options={'visible':False,'opacity':0.5},\\n legend_title='ESI - 1 month',\\n legend_extent=[-126, 24.5, -66.2, 49])\\n\\n # Define SWSI KML Layer\\n swsi_legend = MVLegendImageClass(value='',\\n image_url='/static/tethys_gizmos/data/swsi_legend.PNG')\\n SWSI_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/SWSI_2018Current.kml'},\\n legend_title='SWSI',\\n layer_options={'visible':True,'opacity':0.7},\\n feature_selection=True,\\n legend_classes=[swsi_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # NCDC/NIDIS precip index\\n ncdc_pindex = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:1'}},\\n legend_title='Precipitation Index',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS palmer drought severity index\\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\\n ncdc_pdsi = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:2','layerDefs':'{\\\"2\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='PDSI',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS palmer drought severity index\\n # NOTE: MONTH LOOKUP IS HARDCODED RIGHT NOW\\n ncdc_palmz = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:8','layerDefs':'{\\\"8\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='Palmer Z',\\n layer_options={'visible':False,'opacity':0.7},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_1 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:11','layerDefs':'{\\\"11\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (1-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_3 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:13','layerDefs':'{\\\"13\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (3-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # NCDC/NIDIS standardized precip index\\n ncdc_spi_6 = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://gis.ncdc.noaa.gov/arcgis/rest/services/cdo/indices/MapServer',\\n 'params': {'LAYERS': 'show:14','layerDefs':'{\\\"14\\\":\\\"YEARMONTH='+str(yearnow)+str(prevmonth)+'\\\"}'}},\\n legend_title='SPI (6-month)',\\n layer_options={'visible':False,'opacity':0.6},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n \\n # Define map view options\\n drought_index_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-112, 36.3, -98.5, 41.66]}}],\\n layers=[tiger_boundaries,climo_divs,ncdc_pdsi,ncdc_palmz,ncdc_spi_1,ncdc_spi_3,ncdc_spi_6,SWSI_kml,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_index_map_view_options':drought_index_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_index.html', context)\",\n \"def ShowOneContourBKG(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt):\\n \\n figname='contourBKG_{}_{}.pdf'.format(all_filt[index],index)\\n \\n plt.figure(figsize=(15,6))\\n spec_index_min=100 # cut the left border\\n spec_index_max=1900 # cut the right border\\n star_halfwidth=70\\n \\n YMIN=-100\\n YMAX=100\\n \\n figfilename=os.path.join(dir_top_img,figname) \\n \\n #center is approximately the one on the original raw image (may be changed)\\n #x0=int(all_pointing[index][0])\\n x0=int(thex0[index])\\n \\n \\n # Extract the image \\n full_image=np.copy(all_images[index])\\n \\n # refine center in X,Y\\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\\n \\n profile_X=np.sum(star_region_X,axis=0)\\n profile_Y=np.sum(star_region_X,axis=1)\\n\\n NX=profile_X.shape[0]\\n NY=profile_Y.shape[0]\\n \\n X_=np.arange(NX)\\n Y_=np.arange(NY)\\n \\n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\\n \\n x0=int(avX+x0-star_halfwidth)\\n \\n \\n # find the center in Y on the spectrum\\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\\n y0=np.where(yprofile==yprofile.max())[0][0]\\n\\n # cut the image in vertical and normalise by exposition time\\n reduc_image=full_image[y0+YMIN:y0+YMAX,x0:spec_index_max]/all_expo[index] \\n reduc_image[:,0:100]=0 # erase central star\\n \\n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\\n \\n # calibration in wavelength\\n #grating_name=all_filt[index].replace('dia ','')\\n grating_name=get_disperser_filtname(all_filt[index])\\n \\n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\\n \\n #if grating_name=='Ron200':\\n # holo = Hologram('Ron400',verbose=True)\\n #else: \\n # holo = Hologram(grating_name,verbose=True)\\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\\n #if grating_name=='Ron200':\\n # lambdas=lambdas*2.\\n \\n\\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \\n T=np.transpose(reduc_image)\\n \\n \\n cs=plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\\n #C = plt.contour(X, Y, reduc_image ,10, colors='white', linewidth=.01,origin='lower')\\n \\n cbar = plt.colorbar(cs) \\n \\n for line in LINES:\\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\\n plt.text(line['lambda'],YMAX*0.8,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\\n \\n \\n \\n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\\n plt.title(all_titles[index])\\n plt.grid(color='white', ls='solid')\\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\\n plt.xlabel('$\\\\lambda$ (nm)')\\n plt.ylabel('pixels')\\n plt.ylim(YMIN,YMAX)\\n plt.xlim(0.,1200.)\\n plt.savefig(figfilename)\",\n \"def challenge2(self):\\n # Let's try an octree-type approach\\n # For each grid cube we should be able to find whether a nanobot:\\n # 1) is not in range (is outside grid cube and not in range of nearest face)\\n # 2) is in range of whole cube (all 8 corners are in range)\\n # 3) is in range of part of the cube (i.e. not 1 or 2)\\n # Root node: figure out extent of whole space\\n mins = []\\n maxs = []\\n for axis in range(3):\\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n\\n for count in range(len(self.nanobots), 0, -1):\\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\\n if results and results[0].count >= count:\\n break\\n\\n print(f\\\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\\\")\\n\\n # Find result coord closest to origin\\n closest_dist = np.iinfo(np.int32).max\\n best_coord = None\\n for result in results:\\n for corner in itertools.product(*zip(result.mins, result.maxs)):\\n d = manhattan_dist(corner, (0, 0, 0))\\n if d < closest_dist:\\n closest_dist = d\\n best_coord = corner\\n\\n print(f\\\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\\\")\",\n \"def __init__(self,start,goal,theta_s,clearance,radius,rpm1,rpm2):\\r\\n #clearance = 5\\r\\n #radius = 10\\r\\n self.padding = clearance + radius\\r\\n self.ground_truth={}\\r\\n\\r\\n self.obstacle=[]\\r\\n self.rpm1=rpm1\\r\\n self.rpm2=rpm2\\r\\n self.expanded=[]\\r\\n\\r\\n self.parent=[]\\r\\n self.parent_orignal_data={}\\r\\n \\r\\n self.start=start\\r\\n #print(self.start)\\r\\n self.theta=theta_s\\r\\n self.theta_diff=30\\r\\n self.n=int(self.theta)\\r\\n self.frontier={}\\r\\n self.frontier[self.start[0],self.start[1],self.n]=0\\r\\n self.start_score=self.string(self.start[0],self.start[1],self.n)\\r\\n self.frontier_string=[]\\r\\n self.cost_togo={}\\r\\n self.cost_togo[self.start_score,self.n]=0\\r\\n self.parent_orignal_data[self.start_score]=None\\r\\n self.cost={}\\r\\n #self.cost=0\\r\\n self.goal=goal\\r\\n self.cost[self.start_score,self.n]=self.cost_togo[self.start_score,self.n]+self.h(self.start[0],self.start[1],self.theta)\\r\\n #self.cost[self.start_score,self.n]=self.cost_togo[self.start_score,self.n]+self.h(self.start[0],self.start[1])\\r\\n self.data_with_string={}\\r\\n self.data_with_string[self.start_score]=self.start\\r\\n self.current_score=\\\"00\\\"\\r\\n self.i=1\\r\\n self.theta_diff=30\\r\\n #self.cost={}\\r\\n #self.cost[self.start_score]=0\\r\\n self.dt=0.2\\r\\n self.threshold=1\\r\\n self.maximum_size=999\\r\\n self.parent_pos=(self.start[1],self.maximum_size-self.start[0])\\r\\n self.image_p=np.zeros([int(floor((self.maximum_size+1))),int(floor((self.maximum_size+1))),(360)])\\r\\n self.action_rpm=[[0,rpm1],[rpm1,0],[rpm1,rpm1],[0,rpm2],[rpm2,0],[rpm2,rpm2],[rpm1,rpm2],[rpm2,rpm1]]\\r\\n self.action_index={}\",\n \"def magnetic_reynolds(uu, param, grid, aa=list(), bb=list(), jj=list(),\\n nghost=3, lmix=True):\\n if len(bb) ==0 and len(aa) ==0 and len(jj) ==0:\\n print('magnetic_reynolds WARNING: no aa, bb nor jj provided\\\\n'+\\n 'aa or bb must be provided or aa for only hyper resistivity') \\n #resistive force\\n lres, lhyper3 = False, False\\n for iresi in param.iresistivity:\\n iresi = str.strip(iresi,'\\\\n')\\n if 'hyper' not in iresi and len(iresi) > 0:\\n lres = True\\n if 'hyper3' in iresi:\\n lhyper3 = True\\n fresi = np.zeros_like(uu)\\n if lres:\\n if lhyper3:\\n lhyper3 = lhyper3==lmix\\n if len(jj) == 0:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: calculating jj without aa\\\\n',\\n 'provide aa or jj directly for accurate boundary values')\\n jj = curl(bb,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n else:\\n jj = curl2(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n for j in range(0,3):\\n jj[j, :nghost,:,:] = jj[j,-2*nghost:-nghost,:,:]\\n jj[j,-nghost:,:,:] = jj[j, nghost: 2*nghost,:,:]\\n jj[j,:, :nghost,:] = jj[j,:,-2*nghost:-nghost,:]\\n jj[j,:,-nghost:,:] = jj[j,:, nghost: 2*nghost,:]\\n jj[j,:,:, :nghost] = jj[j,:,:,-2*nghost:-nghost]\\n jj[j,:,:,-nghost:] = jj[j,:,:, nghost: 2*nghost]\\n fresi = fresi + param.eta*param.mu0*jj\\n for iresi in param.iresistivity:\\n iresi = str.strip(iresi,'\\\\n')\\n if 'eta-const' not in iresi and 'hyper' not in iresi\\\\\\n and len(iresi) > 0:\\n print('magnetic_reynolds WARNING: '+iresi+' not implemented\\\\n'+\\n 'terms may be missing from the standard resistive forces')\\n if lhyper3:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: no aa provided\\\\n'+\\n 'aa must be provided for hyper resistivity')\\n return 1\\n else:\\n del6a = np.zeros_like(aa)\\n for j in range(0,3):\\n del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz)\\n del6a[j, :nghost,:,:] = del6a[j,-2*nghost:-nghost,:,:]\\n del6a[j,-nghost:,:,:] = del6a[j, nghost: 2*nghost,:,:]\\n del6a[j,:, :nghost,:] = del6a[j,:,-2*nghost:-nghost,:]\\n del6a[j,:,-nghost:,:] = del6a[j,:, nghost: 2*nghost,:]\\n del6a[j,:,:, :nghost] = del6a[j,:,:,-2*nghost:-nghost]\\n del6a[j,:,:,-nghost:] = del6a[j,:,:, nghost: 2*nghost]\\n #del6 for non-cartesian tba\\n #del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y,\\n # coordinate_system=param.coord_system)\\n #effective at l > 5 grid.dx? \\n fresi = fresi + param.eta_hyper3*del6a\\n del(del6a)\\n fresi2 = np.sqrt(dot2(fresi))\\n del(fresi)\\n #advective force\\n if len(bb) == 0:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: calculating uu x bb without bb\\\\n',\\n 'provide aa or bb directly to proceed')\\n return 1\\n else:\\n bb = curl(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n for j in range(0,3):\\n bb[j, :nghost,:,:] = bb[j,-2*nghost:-nghost,:,:]\\n bb[j,-nghost:,:,:] = bb[j, nghost: 2*nghost,:,:]\\n bb[j,:, :nghost,:] = bb[j,:,-2*nghost:-nghost,:]\\n bb[j,:,-nghost:,:] = bb[j,:, nghost: 2*nghost,:]\\n bb[j,:,:, :nghost] = bb[j,:,:,-2*nghost:-nghost]\\n bb[j,:,:,-nghost:] = bb[j,:,:, nghost: 2*nghost]\\n advec = cross(uu,bb)\\n advec2 = np.sqrt(dot2(advec))\\n del(advec)\\n #avoid division by zero\\n if fresi2.max() > 0:\\n fresi2[np.where(fresi2==0)] = fresi2[np.where(fresi2>0)].min()\\n Rm = advec2/fresi2\\n #set minimum floor to exclude zero-valued Rm \\n if Rm.max() > 0:\\n Rm[np.where(Rm==0)] = Rm[np.where(Rm>0)].min()\\n else:\\n print('Rm undefined')\\n else:\\n Rm = advec2\\n print('Rm undefined')\\n return Rm\",\n \"def do_stuff(self):\\n self.create_tourism_raster()\",\n \"def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\\r\\n \\r\\n nI_agg = len(list(set(indices['ind'][agg_level])))\\r\\n nP_agg = len(list(set(indices['prod'][agg_level])))\\r\\n nW_agg = len(list(set(indices['vadd'][agg_level])))\\r\\n nM_agg = len(list(set(indices['imp'][agg_level])))\\r\\n nY_agg = len(list(set(indices['fd'][agg_level])))\\r\\n nR_agg = len(list(set(indices['exog'][agg_level])))\\r\\n\\r\\n nI_rcot = len(list(set(indices['ind'][rect_level])))\\r\\n nP_rcot = len(list(set(indices['prod'][rect_level])))\\r\\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\\r\\n nM_rcot = len(list(set(indices['imp'][rect_level])))\\r\\n nY_rcot = len(list(set(indices['fd'][rect_level])))\\r\\n nR_rcot = len(list(set(indices['exog'][rect_level])))\\r\\n\\r\\n \\r\\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\\r\\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n \\r\\n indInd = indices_agg['ind']\\r\\n prodInd = indices_agg['prod']\\r\\n vaddInd = indices_agg['vadd']\\r\\n impInd = indices_agg['imp']\\r\\n fdInd = indices_agg['fd']\\r\\n exogInd = indices_agg['exog']\\r\\n\\r\\n zInd = prodInd.append(indInd)\\r\\n zInd = zInd.swaplevel(0,1)\\r\\n \\r\\n\\r\\n for l in range(nL):\\r\\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\\r\\n\\r\\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n ZR_0[l] = Z.values\\r\\n WR_0[l] = W.values\\r\\n MR_0[l] = M.values\\r\\n YR_0[l] = Y.values\\r\\n \\r\\n AR_0[l] = A.values\\r\\n wR_0[l] = w.values\\r\\n mR_0[l] = m.values\\r\\n\\r\\n \\r\\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n\\r\\n ML_RCOT_0 = {\\r\\n 'Z' : ZR_0,\\r\\n 'W' : WR_0,\\r\\n 'M' : MR_0,\\r\\n 'Y' : YR_0,\\r\\n 'R' : RR_0,\\r\\n }\\r\\n\\r\\n ML_RCOT_coeff_0 = {\\r\\n 'A' : AR_0,\\r\\n 'w' : wR_0,\\r\\n 'm' : mR_0,\\r\\n 'Y' : YR_0,\\r\\n 'B' : BR_0,\\r\\n }\\r\\n\\r\\n \\r\\n indices_RCOT = {\\r\\n 'prod/ind' : zInd,\\r\\n 'vadd' : vaddInd,\\r\\n 'imp' : impInd,\\r\\n 'fd' : fdInd,\\r\\n 'exog' : exogInd,\\r\\n 'headers' : indices['headers']\\r\\n }\\r\\n \\r\\n \\r\\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)\",\n \"def __init__(self,height,width): \\r\\n self.width = 2*(width//2) + 1 # Make width odd\\r\\n self.height = 2*(height//2) + 1 # Make height odd\\r\\n\\r\\n # grid of cells\\r\\n self.grid = [[0 for j in range(self.width)] for i in range(self.height)]\\r\\n\\r\\n # declare instance variable\\r\\n self.visited = [] # visited cells\\r\\n self.unvisited = [] # unvisited cells\\r\\n self.path = dict() # random walk path\\r\\n\\r\\n # valid directions in random walk\\r\\n self.directions = [(0,1),(1,0),(0,-1),(-1,0)]\\r\\n\\r\\n # indicates whether a maze is generated\\r\\n self.generated = False\\r\\n\\r\\n # shortest solution\\r\\n self.solution = []\\r\\n self.showSolution = False\\r\\n self.start = (0,0)\\r\\n self.end = (self.height-1,self.width-1)\",\n \"def grass_drass():\",\n \"def update_visualization(self):\\n rpos = self.sim.getAgentPosition(self.robot_num)\\n rvel = self.sim.getAgentVelocity(self.robot_num)\\n rrad = self.sim.getAgentRadius(self.robot_num)\\n v_pref = self.sim.getAgentMaxSpeed(self.robot_num)\\n theta = math.atan2(rvel[1], rvel[0])\\n return_str = \\\"\\\"\\n return_str += str(self.sim.getGlobalTime()) + \\\" \\\"\\n return_str += \\\"(\\\" + str(rpos[0]) + \\\",\\\" + str(rpos[1]) + \\\") \\\"\\n return_str += \\\"(\\\" + str(rvel[0]) + \\\",\\\" + str(rvel[1]) + \\\") \\\"\\n return_str += str(rrad) + \\\" \\\"\\n return_str += str(self.headings[self.robot_num]) + \\\" \\\"\\n return_str += (\\\"(\\\" + str(self.overall_robot_goal[0])\\n + \\\",\\\" + str(self.overall_robot_goal[1]) + \\\") \\\")\\n return_str += str(v_pref) + \\\" \\\"\\n return_str += str(theta) + \\\" \\\"\\n if not self.single:\\n for agent in self.agents:\\n if agent != self.robot_num: # We already wrote out the robot\\n pos = self.sim.getAgentPosition(agent)\\n vel = self.sim.getAgentVelocity(agent)\\n rad = self.sim.getAgentRadius(agent)\\n return_str += \\\"(\\\" + str(pos[0]) + \\\",\\\" + str(pos[1]) + \\\") \\\"\\n return_str += \\\"(\\\" + str(vel[0]) + \\\",\\\" + str(vel[1]) + \\\") \\\"\\n return_str += str(rad) + \\\" \\\"\\n return_str += str(self.headings[agent]) + \\\" \\\"\\n for obs in self.obstacles:\\n if len(obs) > 1:\\n # Polygonal obstacle\\n o = Polygon(obs)\\n p = Point(rpos)\\n p1, p2 = nearest_points(o, p)\\n return_str += \\\"(\\\" + str(p1.x) + \\\",\\\" + str(p1.y) + \\\") \\\"\\n return_str += \\\"(0,0) \\\"\\n return_str += str(self.obs_width) + \\\" \\\"\\n return_str += str(self.headings[self.robot_num]) + \\\" \\\"\\n else:\\n # Point obstacle\\n return_str += \\\\\\n \\\"(\\\" + str(obs[0][0]) + \\\",\\\" +str(obs[0][1]) + \\\") \\\"\\n return_str += \\\"(0,0) \\\"\\n return_str += str(self.obs_width) + \\\" \\\"\\n return_str += str(self.headings[self.robot_num]) + \\\" \\\"\\n return_str += \\\"\\\\n\\\"\\n if self.file is not None:\\n self.file.write(return_str)\\n return return_str\",\n \"def test():\\n test_map1 = np.array([\\n [1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n x_spacing1 = 0.13\\n y_spacing1 = 0.2\\n start1 = np.array([[0.3], [0.3], [0]])\\n goal1 = np.array([[0.6], [1], [0]])\\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\\n true_path1 = np.array([\\n [ 0.3 , 0.3 ],\\n [ 0.325, 0.3 ],\\n [ 0.325, 0.5 ],\\n [ 0.325, 0.7 ],\\n [ 0.455, 0.7 ],\\n [ 0.455, 0.9 ],\\n [ 0.585, 0.9 ],\\n [ 0.600, 1.0 ]\\n ])\\n if np.array_equal(path1,true_path1):\\n print(\\\"Path 1 passes\\\")\\n\\n test_map2 = np.array([\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n start2 = np.array([[0.5], [1.0], [1.5707963267948966]])\\n goal2 = np.array([[1.1], [0.9], [-1.5707963267948966]])\\n x_spacing2 = 0.2\\n y_spacing2 = 0.2\\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\\n true_path2 = np.array([[ 0.5, 1.0],\\n [ 0.5, 1.1],\\n [ 0.5, 1.3],\\n [ 0.5, 1.5],\\n [ 0.7, 1.5],\\n [ 0.9, 1.5],\\n [ 1.1, 1.5],\\n [ 1.1, 1.3],\\n [ 1.1, 1.1],\\n [ 1.1, 0.9]])\\n if np.array_equal(path2,true_path2):\\n print(\\\"Path 2 passes\\\")\",\n \"def make_montage_sagittal(overlay, underlay, png_name, cbar_name):\\n import matplotlib\\n import commands\\n import os\\n import numpy as np\\n matplotlib.rcParams.update({'font.size': 5})\\n ###\\n try:\\n from mpl_toolkits.axes_grid1 import ImageGrid\\n except:\\n from mpl_toolkits.axes_grid import ImageGrid\\n import matplotlib.cm as cm\\n import matplotlib.pyplot as plt\\n import matplotlib.colors as col\\n import nibabel as nb\\n def determine_start_and_end(data, direction, percent):\\n x, y, z = data.shape\\n xx1 = 0\\n xx2 = x - 1\\n zz1 = 0\\n zz2 = z - 1\\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\\n thresh = percent * float(total_non_zero_voxels)\\n start = None\\n end = None\\n if 'axial' in direction:\\n while(zz2 > 0):\\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz2 -= 1\\n while(zz1 < zz2):\\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz1 += 1\\n start = zz1\\n end = zz2\\n else:\\n while(xx2 > 0):\\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx2 -= 1\\n while(xx1 < xx2):\\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx1 += 1\\n start = xx1\\n end = xx2\\n return start, end\\n def get_spacing(across, down, dimension):\\n space = 10\\n prod = (across*down*space)\\n if prod > dimension:\\n while(across*down*space) > dimension:\\n space -= 1\\n else:\\n while(across*down*space) < dimension:\\n space += 1\\n return space\\n\\n Y = nb.load(underlay).get_data()\\n X = nb.load(overlay).get_data()\\n X = X.astype(np.float16)\\n Y = Y.astype(np.float16)\\n\\n\\n if 'skull_vis' in png_name:\\n X[X < 20.0] = 0.0\\n if 'skull_vis' in png_name or 't1_edge_on_mean_func_in_t1' in png_name or 'MNI_edge_on_mean_func_mni' in png_name:\\n max_ = np.nanmax(np.abs(X.flatten()))\\n X[X != 0.0] = max_\\n print '^^', np.unique(X)\\n\\n x1, x2 = determine_start_and_end(Y, 'sagittal', 0.0001)\\n spacing = get_spacing(6, 3, x2 - x1)\\n x, y, z = Y.shape\\n fig = plt.figure(1)\\n max_ = np.max(np.abs(Y))\\n\\n if ('snr' in png_name) or ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\\\"single\\\", cbar_pad=0.5, direction=\\\"row\\\")\\n else:\\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\\\"None\\\", direction=\\\"row\\\")\\n\\n xx = x1\\n for i in range(6*3):\\n\\n if xx >= x2:\\n break\\n\\n im = grid[i].imshow(np.rot90(Y[xx, :, :]), cmap=cm.Greys_r)\\n grid[i].get_xaxis().set_visible(False)\\n grid[i].get_yaxis().set_visible(False)\\n xx += spacing\\n\\n x, y, z = X.shape\\n X[X == 0.0] = np.nan\\n max_ = np.nanmax(np.abs(X.flatten()))\\n print '~~', max_\\n xx = x1\\n for i in range(6*3):\\n\\n\\n if xx >= x2:\\n break\\n im = None\\n if cbar_name is 'red_to_blue':\\n\\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_) ###\\n elif cbar_name is 'green':\\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=0, vmax=max_)\\n else:\\n im = grid[i].imshow(np.rot90(X[xx, :, :]), cmap=cm.get_cmap(cbar_name), alpha=0.82, vmin=- max_, vmax=max_)\\n xx += spacing\\n cbar = grid.cbar_axes[0].colorbar(im)\\n\\n if 'snr' in png_name:\\n cbar.ax.set_yticks(drange(0, max_))\\n\\n elif ('reho' in png_name) or ('vmhc' in png_name) or ('sca_' in png_name) or ('alff' in png_name) or ('centrality' in png_name) or ('temporal_regression_sca' in png_name) or ('temporal_dual_regression' in png_name):\\n cbar.ax.set_yticks(drange(-max_, max_))\\n\\n\\n plt.show()\\n plt.axis(\\\"off\\\")\\n png_name = os.path.join(os.getcwd(), png_name)\\n plt.savefig(png_name, dpi=300, bbox_inches='tight')\\n plt.close()\\n matplotlib.rcdefaults()\\n\\n return png_name\",\n \"def drought_rec_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n rec_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Rec_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Recreation Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_rec_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,rec_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_rec_risk_map_view_options':drought_rec_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_rec_risk.html', context)\",\n \"def jacking_calculations(dictionary, view):\\n f_list = []\\n s_list = []\\n corners = ['Left Front', 'Right Front', 'Left Rear', 'Right Rear']\\n for corner in corners:\\n # Establishing Instant Center Left Front\\n ic_direction, ic_point = plane_intersection_line(\\n plane_equation(dictionary[corner]['Upper Fore'],\\n dictionary[corner]['Upper Aft'],\\n dictionary[corner]['Upper Out']),\\n plane_equation(dictionary[corner]['Lower Fore'],\\n dictionary[corner]['Lower Aft'],\\n dictionary[corner]['Lower Out']),\\n dictionary[corner]['Upper Fore'],\\n dictionary[corner]['Lower Fore'])\\n axis = plot_line(ic_direction, ic_point, np.linspace(0, 2, 2))\\n # Establishing Side View Instant Center\\n ic_xz = three_d_vector_plane_intersection((axis[0][0], axis[1][0], axis[2][0]),\\n (axis[0][1], axis[1][1], axis[2][1]),\\n dictionary[corner]['Wheel Center'],\\n np.add(np.array(dictionary[corner]\\n ['Wheel Center']), np.array([1, 0, 0])),\\n np.add(np.array(dictionary[corner]\\n ['Wheel Center']), np.array([0, 0, 1])))\\n # Establishing Front View Instant Center\\n ic_yz = three_d_vector_plane_intersection((axis[0][0], axis[1][0], axis[2][0]),\\n (axis[0][1], axis[1][1], axis[2][1]),\\n dictionary[corner]['Wheel Center'],\\n np.add(np.array(dictionary[corner]\\n ['Wheel Center']), np.array([0, 1, 0])),\\n np.add(np.array(dictionary[corner]\\n ['Wheel Center']), np.array([0, 0, 1])))\\n # Establishing Jacking Height\\n y_val = dictionary['Performance Figures']['Center of Gravity'][1]\\n cg_plane_points = [[1, y_val, 1], [-1, y_val, 4], [-3, y_val, 6]]\\n wheel_center_ground = [(dictionary[corner]['Wheel Center'][0]),\\n (dictionary[corner]['Wheel Center'][1]), 0]\\n np.array(wheel_center_ground)\\n jacking_height = three_d_vector_plane_intersection(wheel_center_ground,\\n ic_yz, cg_plane_points[0], cg_plane_points[1],\\n cg_plane_points[2])\\n # Establishing Jacking Coefficient\\n wc_jh = np.subtract(jacking_height, wheel_center_ground)\\n jacking_coeff = -abs(wc_jh[2] / wc_jh[1])\\n # Establishing Pitch Coefficient\\n wc_icxz = np.subtract(ic_xz, dictionary[corner]['Wheel Center'])\\n wc_cg = np.subtract(dictionary['Performance Figures']['Center of Gravity'],\\n dictionary[corner]['Wheel Center'])\\n pitch_coeff = (wc_icxz[2] / wc_icxz[0]) / (wc_cg[2] / wc_cg[0])\\n if view == 'Front':\\n f_list.append(jacking_coeff)\\n elif view == 'Side':\\n s_list.append(pitch_coeff)\\n else:\\n print 'Wtf, you want an isometric or something?'\\n return\\n if view == 'Front':\\n return f_list\\n elif view == 'Side':\\n return s_list\\n else:\\n print 'view does not equal Front or Side'\\n return\",\n \"def main():\\n font = {'family' : 'normal',\\n 'weight' : 'normal',\\n 'size' : 18}\\n\\n matplotlib.rc('font', **font)\\n\\n ###Plot overviews\\n\\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full.png\\\",\\n# show_shells=False,title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n \\n plot_overview(plotname=\\\"../paper/figs/12co_nroonly_peak_full_shells.png\\\", show_shells=True,\\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\\n title=r\\\"\\\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\\n )\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_mom0_cometary.png\\\",\\n # show_shells=False, title=r\\\"Combined Integrated $^{12}$CO\\\",\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000,\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(plotname=\\\"12co_nroonly_mom0_cometary.png\\\", show_shells=False,\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000, title=r\\\"NRO Integrated $^{12}$CO\\\",\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full_shells.png\\\",\\n # show_shells=True, shells_highlight=shells_score3, title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # return\\n\\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\\n\\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\\n\\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\\n\\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\\n\\n planck_herschel_file = '../catalogs/planck_herschel.fits'\\n\\n region_file = '../shell_candidates/AllShells.reg'\\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\\n\\n obaf_file = 'stars_obaf.txt'\\n yso_file = \\\"../catalogs/spitzer_orion.fit\\\"\\n\\n obaf = ascii.read(obaf_file)\\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\\\"b'\\\") for sp in obaf['SP_TYPE']])\\n yso = fits.open(yso_file)[1].data\\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\\n\\n # for nshell in range(19,43):\\n # shell = shell_list[nshell-1]\\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n # #Check whether shell is in each mips image coverage.\\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\\n \\n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\\\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\\n # hdu = mips_l1641_hdu\\n # else:\\n # hdu = mips_onc_hdu\\n\\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \\n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\\n\\n\\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\\n\\n spec_cube = SpectralCube.read(cube_file)\\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\\n vel_grid = spec_cube.spectral_axis\\n pad_factor = 1.5\\n\\n #plot_overview(show_shells=True)\\n #plot_overview(plotname=\\\"12co_nro_peak.png\\\", show_shells=False)\\n #plot_overview(cube=\\\"/Volumes/Untitled/13co_pix_2.cm.fits\\\", plotname=\\\"13co_combined_peak.png\\\", show_shells=False)\\n #return\\n #channel_vmax = [12.9, 14]\\n for nshell in range(17,18):\\n shell = shell_list[nshell-1]\\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\\n #print(l1641_xy)\\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\\\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\\n ir_hdu = ir_l1641_hdu\\n else:\\n ir_hdu = ir_onc_hdu\\n\\n #Extract sub_cube around shell.\\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\\\\n (abs(dec_grid - dec) < radius * pad_factor)\\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n\\n #Integrate between vmin and vmax.\\n mom0_hdu = sub_cube.moment0().hdu\\n\\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\\\\n # (abs(dec_grid - dec) < radius)\\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\\n\\n #Calculate contour levels.\\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\\n #print(\\\"sigma: {}\\\".format(sigma))\\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\\n #print(\\\"delta_vel: {}\\\".format(delta_vel))\\n mom0_sigma = sigma * delta_vel\\n #print(mom0_sigma) \\n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\\n\\n #Get source coordinates.\\n\\n\\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \\\"12CO\\\", shell.vmin.value, shell.vmax.value),\\n # return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\\n # cbar_label=\\\"Counts\\\", cmap='inferno',\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\\n # source_labels=[obaf_label, yso_label], dpi=300\\n # )\\n\\n #cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n \\n \\n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\\n # vmin=None, vmax=None, max_chans=12,\\n # #cbar_label=\\\"Counts\\\",\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\\n\\n # angle = 90*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\\n # width=7.5*u.arcsec, angle=angle,\\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\\n # stretch='linear', auto_scale=True, dpi=900.)\\n \\n\\n\\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\\n\\n\\n #movie(test=False, labels=False) \\n\\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n # region_file = '../nro_maps/SouthShells.reg'\\n # N = 2 # Number of shell candidates to plot\\n # shell_list = get_shells(region_file=region_file)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # #cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n\\n # for n in range(1,2):\\n # shell = shell_list[n]\\n # for deg in np.linspace(0, 180, 13):\\n # angle = deg*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\\n # width=7.5*u.arcsec, angle=105*u.deg,\\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\\n # stretch='linear', auto_scale=True)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\\n\\n # cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\",\n \"def SimpleLatLongGrid(min_x,min_y,max_x,max_y,hdeg,hmin,hsec,vdeg,vmin,vsec,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.18,yoff=1.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n x_spacing=float(hdeg)+(float(hmin)+(float(hsec)/60.0))/60.0\\n y_spacing=float(vdeg)+(float(vmin)+(float(vsec)/60.0))/60.0\\n\\n\\n # Round to nearest integer space\\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n for hval in numpy.arange(min_x,\\n max_x+x_spacing/100.0,\\n x_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n hstr=GetLatLongString(hval,'longitude')\\n pshp.set_property('position',hstr)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,\\n max_y+y_spacing/100.0,\\n y_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n vstr=GetLatLongString(vval,'latitude')\\n pshp.set_property('position',vstr)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True)\\n\\n return layer\",\n \"def run_phaseg(locus_file, gam_file, vg_file, canu_alignments, true_haps):\\n\\trecombrate=1.26\\n\\tmax_coverage = 15\\n\\tall_heterozygous = False\\n\\tdistrust_genotypes = True\\n\\twith ExitStack() as stack:\\n\\t\\tnode_seq_list, edge_connections = vg_graph_reader(vg_file)\\n\\t\\tall_reads, alleles_per_pos, locus_branch_mapping = vg_reader(locus_file, gam_file, canu_alignments)\\n\\t\\tall_positions = sorted(all_reads.get_positions())\\n\\t\\tall_components = find_components(all_positions, all_reads)\\n\\t\\tblocks = defaultdict(list)\\n\\t\\tprint(\\\"all_components\\\")\\n\\t\\tfor position, block_id in all_components.items():\\n\\t\\t\\tblocks[block_id].append(locus_branch_mapping[position][0][0][0])\\n\\t\\tfor k,v in blocks.items():\\n\\t\\t\\tprint(k,v)\\n\\t\\tprint(\\\"all_components\\\")\\n\\t\\t\\n\\n\\t\\t#print(all_reads)\\n\\t\\tselected_indices = readselection(all_reads, max_coverage)\\n\\t\\tselected_reads = all_reads.subset(selected_indices)\\n\\n\\t\\t#selected_reads = slice_reads(all_reads, max_coverage)\\n\\t\\t#print('positions from all reads')\\n\\t\\t#print(len(all_reads.get_positions()))\\n\\t\\tprint(\\\"reads after read-selection\\\")\\n\\t\\tprint(len(selected_reads))\\n\\t\\tprint(\\\"positions covered by atleast one read after read selection\\\")\\n\\t\\tprint(len(selected_reads.get_positions()))\\n\\n\\t\\taccessible_positions = sorted(selected_reads.get_positions())\\n\\t\\t\\n\\t\\tprint(\\\"readset after read_selection\\\")\\n\\t\\t#for read in selected_reads:\\n\\t\\t\\t#print(read.name)\\n\\t\\tpedigree = Pedigree(NumericSampleIds())\\n\\t\\t# compute the number of alleles at each position.\\n\\t\\talleles_per_accessible_pos =[]\\n\\t\\tgenotype_likelihoods = []\\n\\t\\tfor pos in accessible_positions:\\n\\t\\t\\tif pos in alleles_per_pos:\\n\\t\\t\\t\\tn_alleles = alleles_per_pos[pos] \\n\\t\\t\\t\\tpossible_genotypes = n_alleles + ncr(n_alleles, 2)\\n\\t\\t\\t\\tgenotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\\n\\t\\t# random input of genotypes, since distrust_genotypes is always ON.\\n\\t\\tpedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\\n\\t\\trecombination_costs = uniform_recombination_map(recombrate, accessible_positions)\\n\\t\\t# Finally, run phasing algorithm\\n\\t\\t#print(selected_reads)\\n\\t\\tdp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\tsuperreads_list, transmission_vector = dp_table.get_super_reads()\\n\\n\\t\\tcost = dp_table.get_optimal_cost()\\n\\t\\tprint(superreads_list[0])\\n\\t\\t#print(cost)\\n\\t\\tread_partitions = dp_table.get_optimal_partitioning()\\n\\t\\t#print(read_partitions)\\n\\t\\t\\n\\t\\t## To generate the connected components and corresponding haplotypes.\\n\\t\\tprint(\\\"in components\\\")\\n\\t\\tf = open('whole_genome' + '.predicted_read_partionting.pred', 'w')\\n\\t\\toverall_components = find_components(accessible_positions, selected_reads)\\n\\t\\t\\n\\t\\tread_partitions_dict ={}\\n\\t\\tfor read, haplotype in zip(selected_reads, read_partitions):\\n\\t\\t\\tphaseset = overall_components[read[0].position] + 1\\n\\t\\t\\tprint(read.name, phaseset, haplotype, file=f)\\n\\t\\t\\tread_partitions_dict[read.name] = haplotype\\n\\t\\t#phaset is blockid\\n\\n\\t\\tn_phased_blocks = len(set(overall_components.values()))\\n\\t\\tall_phased_blocks = len(set(all_components.values()))\\n\\t\\tprint('No. of phased blocks: %d', n_phased_blocks)\\n\\t\\tlargest_component = find_largest_component(overall_components)\\n\\t\\tprint('No. of blocks from all the reads: %d', all_phased_blocks)\\n\\t\\tlargest_component_all_reads = find_largest_component(all_components)\\n\\t\\tif len(largest_component) > 0:\\n\\t\\t\\tprint('Largest component contains %d variants',len(largest_component))\\n\\t\\tif len(largest_component_all_reads) > 0:\\n\\t\\t\\tprint('Largest component contains %d variants',len(largest_component_all_reads))\\n\\t\\t\\n\\t\\t\\n\\t\\t### To generate contig sequences\\n\\t\\tsample = 0\\n\\t\\tsuperreads, components = dict(), dict()\\n\\t\\tsuperreads[sample] = superreads_list[0]\\n\\t\\tcomponents[sample] = overall_components\\n\\t\\t#generate_hap_contigs_based_on_canu(superreads_list[0], components[sample], node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\\n\\t\\t#generate_hap_contigs(superreads_list[0], overall_components, node_seq_list, locus_branch_mapping, edge_connections)\\n\\t\\t\\n\\t\\tnodes_in_bubbles =[]\\n\\t\\twith stream.open(str(locus_file), \\\"rb\\\") as istream:\\n\\t\\t\\tfor data in istream:\\n\\t\\t\\t\\tl = vg_pb2.SnarlTraversal()\\n\\t\\t\\t\\tl.ParseFromString(data)\\n\\t\\t\\t\\tfor i in range(0,len(l.visits)):\\n\\t\\t\\t\\t\\tnodes_in_bubbles.append(l.visits[i].node_id)\\n\\t\\t\\t\\t#nodes_in_bubbles.append(l.snarl.end.node_id)\\n\\t\\t\\t\\t#nodes_in_bubbles.append(l.snarl.start.node_id)\\n\\t\\tedge_connections_tmp = defaultdict(list)\\n\\t\\twith stream.open(str(vg_file), \\\"rb\\\") as istream:\\n\\t\\t\\tfor data in istream:\\n\\t\\t\\t\\tl = vg_pb2.Graph()\\n\\t\\t\\t\\tl.ParseFromString(data)\\n\\t\\t\\t\\tfor j in range(len(l.edge)):\\n\\t\\t\\t\\t\\tfrom_edge = getattr(l.edge[j], \\\"from\\\")\\n\\t\\t\\t\\t\\t#if from_edge not in nodes_in_bubbles and l.edge[j].to not in nodes_in_bubbles:\\n\\t\\t\\t\\t\\tedge_connections_tmp[str(from_edge)].append(str(l.edge[j].to))\\n\\t\\t\\t\\t\\tedge_connections_tmp[str(l.edge[j].to)].append(str(from_edge))\\n\\n\\n\\t\\t#generate_hap_contigs_based_on_canu(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, canu_alignments, vg_file)\\n\\t\\t#generate_hap_contigs_avgRL(superreads, components, node_seq_list, locus_branch_mapping, edge_connections, edge_connections_tmp, gam_file, read_partitions_dict, nodes_in_bubbles)\\n\\t\\t\\n\\t\\t# evaluation partition all the reads based on one iteration\\n\\t\\t#print('partition all the reads based on haplotypes from one iteration')\\n\\t\\t# Check here if you wanna do all reads or selected reads only\\n\\t\\t#haplotag(superreads_list[0], selected_reads, overall_components, 1)\\n\\t\\t\\n\\t\\t#compute_read_partitioning_accuracy(\\\"true_partioning\\\")\\n\\n\\n\\n\\t\\t##generate_hap_contigs(superreads, components, node_seq_list, locus_branch_mapping, edge_connections)\\n\\t\\t\\n\\t\\t##For phasing accuracy, read true haps and generate corresponding superreads\\n\\t\\t#all_reads_true, alleles_per_pos_true, locus_branch_mapping_true = vg_reader(locus_file, true_haps)\\n\\t\\t# Finally, run phasing algorithm for true haplotypes\\n\\t\\t#dp_table_true = PedigreeDPTable(all_reads_true, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\t#superreads_list_true, transmission_vector_true = dp_table_true.get_super_reads()\\n\\t\\t# to compute the phasing accuracy\\n\\t\\t#true_haps = ReadSet()\\n\\t\\t#for read in all_reads_true:\\n\\t\\t\\t#tmp_read = Read(read.name, 0, 0, 0)\\n\\t\\t\\t#for variant in read:\\n\\t\\t\\t\\t#if variant.position in accessible_positions:\\n\\t\\t\\t\\t\\t#tmp_read.add_variant(variant.position, variant.allele, [10])\\n\\t\\t\\t#true_haps.add(tmp_read)\\n\\t\\t#compare(superreads_list[0], true_haps, overall_components)\\n\\t\\t## To perform iterative whatshap phasing\\n\\t\\t#remaining_reads =[]\\n\\t\\t#for read in all_reads:\\n\\t\\t\\t#remaining_reads.append(read.name)\\n\\t\\t#prev_superreads = superreads_list[0]\\n\\t\\t#for read in selected_reads:\\n\\t\\t\\t#remaining_reads.remove(read.name)\\n\\t\\t#while len(remaining_reads)>0:\\n\\t\\t\\t#print('iteration')\\n\\t\\t\\t#iterative_reaset = ReadSet()\\n\\t\\t\\t#for read in all_reads:\\n\\t\\t\\t\\t#if read.name in remaining_reads:\\n\\t\\t\\t\\t\\t#iterative_reaset.add(read)\\n\\n\\t\\t\\t\\t\\n\\t\\t\\t#selected_indices = readselection(iterative_reaset, max_coverage)\\n\\t\\t\\t#selected_reads = iterative_reaset.subset(selected_indices)\\n\\t\\t\\t#for read in prev_superreads:\\n\\t\\t\\t\\t#selected_reads.add(read)\\n\\t\\t\\t\\t#remaining_reads.append(read.name)\\n\\t\\t\\t#accessible_positions = sorted(selected_reads.get_positions())\\n\\t\\t\\t#selected_reads.sort()\\n\\t\\t\\t#pedigree = Pedigree(NumericSampleIds())\\n\\t\\t\\t## compute the number of alleles at each position.\\n\\t\\t\\t#alleles_per_accessible_pos =[]\\n\\t\\t\\t#genotype_likelihoods = []\\n\\t\\t\\t#for pos in accessible_positions:\\n\\t\\t\\t\\t#if pos in alleles_per_pos:\\n\\t\\t\\t\\t\\t#n_alleles = alleles_per_pos[pos] \\n\\t\\t\\t\\t\\t#possible_genotypes = n_alleles + ncr(n_alleles, 2)\\n\\t\\t\\t\\t\\t#genotype_likelihoods.append(None if all_heterozygous else PhredGenotypeLikelihoods([0]* possible_genotypes))\\n\\t\\t\\t## random input of genotypes, since distrust_genotypes is always ON.\\n\\t\\t\\t#pedigree.add_individual('individual0', [0]* len(accessible_positions), genotype_likelihoods)\\n\\t\\t\\t#recombination_costs = uniform_recombination_map(recombrate, accessible_positions)\\n\\t\\t\\t## Finally, run phasing algorithm\\n\\t\\t\\t##print(selected_reads)\\n\\t\\t\\t#dp_table = PedigreeDPTable(selected_reads, recombination_costs, pedigree, distrust_genotypes, accessible_positions)\\n\\t\\t\\t#superreads_list, transmission_vector = dp_table.get_super_reads()\\n\\t\\t\\t#for read in selected_reads:\\n\\t\\t\\t\\t#remaining_reads.remove(read.name)\\n\\t\\t\\t#prev_superreads = superreads_list[0]\\n\\t\\t\\t\\n\\t\\t#print('I am final')\\n\\t\\t#accessible_positions = sorted(all_reads.get_positions())\\n\\t\\t#overall_components = find_components(accessible_positions, all_reads)\\n\\t\\t#haplotag(superreads_list[0], all_reads, overall_components, \\\"all_iter\\\")\\n\\t\\t#compare(superreads_list[0], superreads_list_true[0], overall_components)\\n\\t\\t#print(superreads_list[0])\\n\\t\\t\\n\\t\\t#iterative whatshap for sparse matrices where we fix the phasing for variants at each iteration that reach max coverage.\",\n \"def main():\\n test_file = 'lib/pbk411.tsp'\\n limit = 1000\\n milestones = [10, 25, 100, 500, 1000]\\n\\n lx, ly = parse_data(test_file)\\n algo = Genalgo(lx, ly)\\n current = 0\\n\\n for i in range(0, limit):\\n algo.evolve_new_pop(i)\\n if i == milestones[current]:\\n cities, distance = get_best(algo)\\n cities.append(cities[0])\\n make_plot_solved(lx, ly, cities)\\n save_plot('solved-' + str(milestones[current]) + '.png')\\n print(str(milestones[current]) + ': ' + str(distance))\\n current += 1\\n\\n _, best_tuple = algo.get_best_tours(algo.tours)\\n best = algo.tours[best_tuple[0]]\\n cities = best.cities\\n cities.append(best.cities[0])\\n print('Best: ' + str(best.get_cost()))\\n\\n make_plot_original(lx, ly)\\n save_plot('original.png')\\n make_plot_solved(lx, ly, cities)\\n save_plot('solved.png')\",\n \"def create_matrices(maze, reward, penalty_s, penalty_l, prob):\\n \\n r, c = np.shape(maze)\\n states = r*c\\n p = prob\\n q = (1 - prob)*0.5\\n \\n # Create reward matrix\\n path = maze*penalty_s\\n walls = (1 - maze)*penalty_l\\n combined = path + walls\\n \\n combined[-1, -1] = reward\\n \\n R = np.reshape(combined, states)\\n \\n # Create transition matrix\\n T_up = np.zeros((states, states))\\n T_left = np.zeros((states, states))\\n T_right = np.zeros((states, states))\\n T_down = np.zeros((states, states))\\n \\n wall_ind = np.where(R == penalty_l)[0]\\n\\n for i in range(states):\\n # Up\\n if (i - c) < 0 or (i - c) in wall_ind :\\n T_up[i, i] += p\\n else:\\n T_up[i, i - c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i+1] += q\\n \\n # Down\\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_down[i, i] += p\\n else:\\n T_down[i, i + c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i+1] += q\\n \\n # Left\\n if i%c == 0 or (i - 1) in wall_ind:\\n T_left[i, i] += p\\n else:\\n T_left[i, i-1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i + c] += q\\n \\n # Right\\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_right[i, i] += p\\n else:\\n T_right[i, i+1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i + c] += q\\n \\n T = [T_up, T_left, T_right, T_down] \\n \\n return T, R\",\n \"def visualize_reconstruction(maps_filename, timecourses_filename, data_filename, out_filename, mask_nib, hgap=20, vgap=20, nsamples=10):\\n\\n\\tmaps = np.load(maps_filename)\\n\\ttimecourses = np.load(timecourses_filename)\\n\\tsubject_data = np.load(data_filename)\\n\\n\\t(nframes, nvoxels) = subject_data.shape\\n\\n\\trecon = timecourses.dot(maps)\\n\\n\\tsamples = range(0, 1028, int(math.ceil(nframes / float(nsamples))))\\n\\n\\t# draw the maps and timecourses into temporary files\\n\\tdata_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\trecon_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\n\\tfor i in range(nsamples):\\n\\t\\tplot_map(subject_data[samples[i],:], mask_nib, data_image_files[i])\\n\\t\\tplot_map(recon[samples[i],:], mask_nib, recon_image_files[i])\\n\\n\\tdata_images = [Image.open(fname) for fname in data_image_files]\\n\\trecon_images = [Image.open(fname) for fname in recon_image_files]\\n\\n\\tim_width = data_images[0].size[0]\\n\\tim_height = data_images[0].size[1]\\n\\n\\tresult_width = 2*im_width + hgap \\n\\tresult_height = nsamples * (im_height + vgap)\\n\\n\\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\\n\\ty = 0\\n\\tfor (recon_image, data_image) in zip(recon_images, data_images):\\n\\t\\tresult.paste(im=recon_image, box=(0, y))\\n\\t\\tresult.paste(im=data_image, box=(im_width+hgap, y))\\n\\t\\ty += im_height + vgap\\n\\n\\tresult.save(out_filename)\\n\\n\\tfor i in range(nsamples):\\n\\t\\tos.remove(data_image_files[i])\\n\\t\\tos.remove(recon_image_files[i])\",\n \"def swipeBase (self) :\\n grid = self.grid\\n\\n #we start by putting every tile up\\n for columnNbr in range(4) :\\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\\n\\n for lineNbr in range(4) :\\n counter = 0\\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\\n counter += 1\\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\\n for remainingLine in range (lineNbr, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n #now we do the additions\\n for lineNbr in range(3) :\\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\\n grid[lineNbr, columnNbr] *= 2\\n for remainingLine in range (lineNbr+1, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n return (grid)\",\n \"def print_solution(data, manager, routing, assignment):\\n\\n html_name = './app/templates/res.html'\\n depot_latlon = str2ll(depot)\\n gmap = gmplot.GoogleMapPlotter(depot_latlon[0], depot_latlon[1], 15, api)\\n\\n total_distance = 0\\n total_load = 0\\n\\n routes = []\\n for vehicle_id in range(data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n\\n route = []\\n while not routing.IsEnd(index):\\n node_index = manager.IndexToNode(index)\\n route_load += data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\n\\n route.append(node_index)\\n previous_index = index\\n index = assignment.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n route.append(0)\\n\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\n route_load)\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n print(plan_output)\\n\\n total_distance += route_distance\\n total_load += route_load\\n routes.append([route, route_distance, route_load])\\n \\n # coordinates = []\\n # for i in range(len(route)-1):\\n # src = data['addresses'][route[i]]\\n # dst = data['addresses'][route[i+1]]\\n \\n # latlon = str2ll(src)\\n # if route[i] == 0:\\n # color = 'pink'\\n # else:\\n # color = colors[vehicle_id%len(colors)]\\n\\n # gmap.marker(latlon[0], latlon[1], color)\\n \\n # now = datetime.now()\\n # directions_result = gmaps.directions(src,\\n # dst,\\n # mode=\\\"driving\\\",\\n # departure_time=now)[0]\\n \\n # polyline = directions_result['overview_polyline']['points']\\n # coordinates = np.asarray(decode_polyline(polyline))\\n # gmap.plot(coordinates[:, 0], coordinates[:, 1], colors[vehicle_id%len(colors)], edge_width=2)\\n \\n\\n \\n # if gmap is not None:\\n # #save plot as html\\n # gmap.draw(html_name)\\n\\n print('Total distance of all routes: {}m'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\\n\\n return routes\\n\\n #draw html for this\",\n \"def _plot_pr2(gc_val_lst: list, at_val_lst: list, g3_val_lst: list, a3_val_lst: list, organism_name: str | None = None,\\n save_image: bool = False, folder_path: str = 'Report', gene_analysis: bool = True):\\n N = len(gc_val_lst)\\n gc_arr = np.array(gc_val_lst)\\n g3_arr = np.array(g3_val_lst)\\n at_arr = np.array(at_val_lst)\\n a3_arr = np.array(a3_val_lst)\\n x = g3_arr / gc_arr\\n y = a3_arr / at_arr\\n # [[x_val], [y_val]]\\n ag_lst = [[], []]\\n ag_count = 0\\n tg_lst = [[], []]\\n tg_count = 0\\n tc_lst = [[], []]\\n tc_count = 0\\n ac_lst = [[], []]\\n ac_count = 0\\n no_bias = [[], []]\\n no_bias_count = 0\\n for x_val, y_val in zip(x, y):\\n if x_val > 0.5 and y_val > 0.5:\\n ag_lst[0].append(x_val)\\n ag_lst[1].append(y_val)\\n ag_count += 1\\n elif x_val > 0.5 > y_val:\\n tg_lst[0].append(x_val)\\n tg_lst[1].append(y_val)\\n tg_count += 1\\n elif x_val < 0.5 and y_val < 0.5:\\n tc_lst[0].append(x_val)\\n tc_lst[1].append(y_val)\\n tc_count += 1\\n elif x_val < 0.5 < y_val:\\n ac_lst[0].append(x_val)\\n ac_lst[1].append(y_val)\\n ac_count += 1\\n else:\\n no_bias[0].append(x_val)\\n no_bias[1].append(y_val)\\n no_bias_count += 1\\n fig, ax = plt.subplots(figsize=(9, 5.25))\\n ax.scatter(ag_lst[0], ag_lst[1], s=5, label='AG', alpha=0.5, zorder=2)\\n ax.scatter(tg_lst[0], tg_lst[1], s=5, label='TG', alpha=0.5, zorder=2)\\n ax.scatter(tc_lst[0], tc_lst[1], s=5, label='TC', alpha=0.5, zorder=2)\\n ax.scatter(ac_lst[0], ac_lst[1], s=5, label='AC', alpha=0.5, zorder=2)\\n ax.scatter(no_bias[0], no_bias[1], s=5, label=f'No Bias', alpha=0.5, zorder=3)\\n ax.grid(True, linestyle=':')\\n ax.legend()\\n ax.text(0.6, 0.95, 'AG')\\n ax.text(0.4, 0.95, 'AC')\\n ax.text(0.6, 0.05, 'TG')\\n ax.text(0.4, 0.05, 'TC')\\n ax.text(0, 0, f'AG: {ag_count}\\\\nTG: {tg_count}\\\\nTC: {tc_count}\\\\nAC: {ac_count}\\\\nNo Bias: {no_bias_count}',\\n transform=ax.transAxes)\\n plt.xlim([0, 1])\\n plt.ylim([0, 1])\\n plt.axvline(0.5, color='grey', zorder=1)\\n plt.axhline(0.5, color='grey', zorder=1)\\n plt.xlabel(r\\\"$G_3/GC_3$ Values\\\")\\n plt.ylabel(r\\\"$A_3/AT_3$ Values\\\")\\n suptitle = r'Parity Rule 2 plot' if organism_name is None else f\\\"Parity Rule 2 plot for {organism_name}\\\"\\n plt.suptitle(suptitle, fontsize=16)\\n title = f'Total genes: {N}' if gene_analysis else f'Total genome: {N}'\\n plt.title(title, fontsize=12)\\n if save_image:\\n make_dir(folder_path)\\n name = 'PR2_plot.png' if organism_name is None else f\\\"PR2_plot_{organism_name}.png\\\"\\n file_name = join(folder_path, name)\\n if is_file_writeable(file_name):\\n plt.savefig(file_name, dpi=500)\\n print(f'Saved file can be found as {abspath(file_name)}')\\n plt.show()\\n plt.close()\",\n \"def examineMaze(self, gameState):\\n w = self.walls.width\\n h = self.walls.height\\n walls = self.walls.deepCopy()\\n food1 = self.getFoodYouAreDefending(gameState)\\n food2 = self.getFood(gameState)\\n\\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y]:\\n walls[x][y] = 0\\n elif food1[x][y]:\\n walls[x][y] = 2\\n elif food2[x][y]:\\n walls[x][y] = 2\\n else:\\n walls[x][y] = 1\\n\\n roomsDisplay = []\\n # Detect doors and spaces. Spaces are now negative\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y] > 0:\\n exitsNum = 0\\n if walls[x][y - 1] != 0:\\n exitsNum += 1\\n if walls[x][y + 1] != 0:\\n exitsNum += 1\\n if walls[x - 1][y] != 0:\\n exitsNum += 1\\n if walls[x + 1][y] != 0:\\n exitsNum += 1\\n if exitsNum == 1 or exitsNum == 2:\\n walls[x][y] = -1 * walls[x][y]\\n roomsDisplay.append((x, y))\\n elif exitsNum == 0:\\n # We erase unaccessible cells\\n walls[x][y] = 0\\n else:\\n # These are doors or big rooms, we leave them positive\\n pass\\n\\n # Create roomsGraph: every room has a number, some cells and some doors\\n roomsGraph = []\\n doorsGraph = []\\n for x in range(1, w - 1):\\n for y in range(1, h - 1):\\n if walls[x][y] < 0:\\n spacesNum = 0\\n if walls[x][y - 1] < 0:\\n spacesNum += 1\\n if walls[x][y + 1] < 0:\\n spacesNum += 1\\n if walls[x - 1][y] < 0:\\n spacesNum += 1\\n if walls[x + 1][y] < 0:\\n spacesNum += 1\\n if spacesNum < 2:\\n endOfPath = False\\n graphNode = {\\\"path\\\": [], \\\"doors\\\": [], \\\"food\\\": 0, \\\"isBig\\\": False}\\n auxx = x\\n auxy = y\\n while not endOfPath:\\n graphNode[\\\"path\\\"].append((x, y))\\n graphNode[\\\"food\\\"] += -walls[x][y] - 1\\n walls[x][y] = 0\\n xx = x\\n yy = y\\n if walls[x][y - 1] < 0:\\n yy = y - 1\\n elif walls[x][y + 1] < 0:\\n yy = y + 1\\n elif walls[x - 1][y] < 0:\\n xx = x - 1\\n elif walls[x + 1][y] < 0:\\n xx = x + 1\\n else:\\n endOfPath = True\\n if walls[x][y - 1] > 0:\\n if [(x, y - 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y - 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y - 1), []]))\\n if walls[x][y + 1] > 0:\\n if [(x, y + 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y + 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y + 1), []]))\\n if walls[x - 1][y] > 0:\\n if [(x - 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x - 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x - 1, y), []]))\\n if walls[x + 1][y] > 0:\\n if [(x + 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x + 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x + 1, y), []]))\\n x = xx\\n y = yy\\n roomsGraph.append(graphNode)\\n x = auxx\\n y = auxy\\n\\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\\n for j, door in enumerate(doorsGraph):\\n for i, room in enumerate(roomsGraph):\\n for aDoor in room[\\\"doors\\\"]:\\n if aDoor == j:\\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\\n (x, y) = doorsGraph[j][0]\\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\\n adjacentDoors = []\\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\\n for p in adjacentCells:\\n # Skip if wall\\n if self.walls[p[0]][p[1]]:\\n continue\\n # Skip if door\\n isRoom = False\\n for room in doorsGraph[j][1]:\\n if p in roomsGraph[room][\\\"path\\\"]:\\n isRoom = True\\n break\\n if not isRoom:\\n # Add if existing door\\n doorFound = False\\n for i, neighborDoor in enumerate(doorsGraph):\\n if neighborDoor[0] == p:\\n adjacentDoors.append(i)\\n doorFound = True\\n break\\n # Create if non existing door and add\\n if not doorFound:\\n adjacentDoors.append(len(doorsGraph))\\n doorsGraph.append([p, []])\\n doorsGraph[j].append(adjacentDoors)\\n\\n # Create doorsDistance: maps what doors can be accessed from other doors\\n roomsMapper = {}\\n doorsMapper = {}\\n isRoom = util.Counter()\\n for i, door in enumerate(doorsGraph):\\n doorsMapper[door[0]] = i\\n isRoom[door[0]] = 0\\n for i, room in enumerate(roomsGraph):\\n for p in room[\\\"path\\\"]:\\n roomsMapper[p] = i\\n isRoom[p] = 1\\n\\n # Create self variables\\n self.doorsGraph = doorsGraph\\n self.roomsGraph = roomsGraph\\n self.roomsMapper = roomsMapper\\n self.doorsMapper = doorsMapper\\n self.isRoom = isRoom\\n\\n # # Find dead ends (rooms with only one door)\\n # deadRooms = {}\\n # deadDoors = {}\\n # # deaderDoors = {}\\n # # deaderRooms = {}\\n # for i, room in enumerate(roomsGraph):\\n # if len(room[\\\"doors\\\"]) == 1:\\n # deadRooms[i] = room[\\\"doors\\\"][0]\\n # deadDoors[room[\\\"doors\\\"][0]] = 1\\n # numdR = 0\\n # aliveR = -1\\n # for adjRoom in doorsGraph[room[\\\"doors\\\"][0]][1]:\\n # if adjRoom not in deadRooms:\\n # numdR += 1\\n # aliveR = adjRoom\\n # if numdR + len(doorsGraph[room[\\\"doors\\\"][0]][2]) == 1:\\n # if aliveR >= 0:\\n # deaderRooms[aliveR] = room[\\\"doors\\\"][0]\\n # for adjDoor in roomsGraph[aliveR][\\\"doors\\\"]:\\n # if adjDoor == room[\\\"doors\\\"][0]:\\n # continue\\n # deaderDoors[adjDoor] = 1.0\\n # else:\\n # deaderDoors[doorsGraph[room[\\\"doors\\\"][0]][2][0]] = 1.0\\n\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deaderRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deaderDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, room in enumerate(roomsGraph):\\n # numAliveDoors = 0\\n # aliveDoor = 0\\n # deadDoor = []\\n # for door in room[\\\"doors\\\"]:\\n # if door not in deadDoors:\\n # numAliveDoors += 1\\n # aliveDoor = door\\n # else:\\n # deadDoor.append(door)\\n # if numAliveDoors == 1:\\n # aliveRoom = 0\\n # aliveNeighborDoor = 0\\n # for door in deadDoor:\\n # # aliveNeighborDoor += len(doorsGraph[door][2])\\n # for neighborRoom in doorsGraph[door][1]:\\n # if neighborRoom not in deadRooms:\\n # aliveRoom += 1\\n # if aliveRoom == len(deadDoor):\\n # deadRooms[i] = aliveDoor\\n # deadDoors[aliveDoor] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\\n # for p in room[\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # for p in deadDoor:\\n # roomsCounter[2][doorsGraph[p][0]] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, door in enumerate(doorsGraph):\\n # if i not in deadDoors:\\n # numOpenRooms = 0\\n # openRoom = 0\\n # for j, room in enumerate(door[1]):\\n # if room not in deadRooms:\\n # numOpenRooms += 1\\n # openRoom = j\\n # if numOpenRooms + len(door[2]) == 1:\\n # for room in door[1]:\\n # if room != openRoom:\\n # deadRooms[room] = i\\n # deadDoors[j] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][door[0]] = 1\\n # for rr in door[1]:\\n # print rr\\n # if rr in deadRooms:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # else:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[3][p] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[1][(6, 9)] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deadRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deadDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # Show every room\\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n for room in roomsGraph:\\n for p in room[\\\"path\\\"]:\\n if len(room[\\\"doors\\\"]) > 1:\\n roomsCounter[0][p] = 0.4\\n else:\\n roomsCounter[2][p] = 0.4\\n # Show every door\\n for door in doorsGraph:\\n roomsCounter[1][door[0]] = 0.4\\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\\n self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\",\n \"def drawmaze(self):\\n win=GraphWin(\\\"Perfect Maze\\\",600,600) \\n win.setBackground(\\\"White\\\")\\n scale=600/self.N #Used to generalize the size difference for the input of larger numbers. The background resolution/ grid size, N\\n\\n x1=scale\\n y1=0\\n x2=scale\\n y2=scale\\n\\n ##VERTICAL LINES ####\\n for i in range(self.N,0,-1):\\n for j in range(1,self.N):\\n if self.East[j][i]: #If East is true, draw a line.\\n \\n line=Line(Point(x1,y1),Point(x2,y2)) #lines | |\\n line.setFill(\\\"red\\\")\\n line.draw(win)\\n x1+=scale #Increment causes |->|\\n x2+=scale #Increment causes |->|\\n y1+=scale #Used to draw two more\\n y2+=scale #of the same spaced lines further down.\\n x1=scale #Reset\\n x2=scale #Reset\\n\\n\\n ##HORIZONTAL LINES##\\n x1=0\\n y1=scale\\n x2=scale\\n y2=scale\\n\\n\\n for i in range(self.N,1,-1):\\n for j in range(1,self.N+1):\\n if self.South[j][i]: #If South is true, draw a line.\\n \\n line=Line(Point(x1,y1),Point(x2,y2))\\n line.setFill(\\\"red\\\")\\n line.draw(win)\\n x1+=scale\\n x2+=scale\\n y1+=scale\\n y2+=scale\\n x1=0\\n x2=scale\\n\\n const=scale//5 #Very useful const which helps in placing circles on grid.\\n x=scale//2\\n y=600-scale//2\\n #radius=(scale-(4*scale//self.N))/2\\n radius=scale//2-(const)\\n start=Point(x,y) #START POINT HERE \\n circ=Circle(start,radius)\\n circ.setFill(\\\"Red\\\")\\n label=Text(start,\\\"Start\\\")\\n label.setFill(\\\"Black\\\")\\n circ.draw(win)\\n label.draw(win)\\n #print(self.CurrentCell)\\n #Using the current cell from the finished algorithm(last place visited), a circle can be placed at that point.\\n endpointx=(self.CurrentCell[0]-1)*scale +scale//2 ####MAKING END POINT X\\n endpointy=600-(self.CurrentCell[1]-1)*scale-scale//2 ####MAKING END POINT Y\\n endpoint=Point(endpointx,endpointy)\\n circ2=Circle(endpoint,radius)\\n circ2.setFill(\\\"White\\\")\\n label2=Text(endpoint,\\\"End\\\")\\n circ2.draw(win)\\n label2.draw(win)\\n \\n ###############CREATE KEY########################\\n \\n \\n keypointx=(self.MazeKey[0]-1)*scale +scale//2 ####MAKING END POINT X\\n keypointy=600-(self.MazeKey[1]-1)*scale-scale//2 ####MAKING END POINT Y\\n keypoint=Point(keypointx,keypointy)\\n circ3=Circle(keypoint,radius)\\n circ3.setFill(\\\"Blue\\\")\\n label3=Text(keypoint,\\\"Key\\\")\\n circ3.draw(win)\\n label3.draw(win)\\n pathcol=\\\"Yellow\\\"\\n##\\n\\n \\n for i in range(1,len(self.EntirePath)): \\n pathpointx=(self.EntirePath[i][0]-1)*scale +scale//2 ####MAKING END POINT X\\n pathpointy=600-(self.EntirePath[i][1]-1)*scale-scale//2 ####MAKING END POINT Y\\n pathpoint=Point(pathpointx,pathpointy)\\n drawpath=Circle(pathpoint,radius)\\n drawpath.setFill(pathcol)\\n if self.EntirePath[i]==self.KeyPath[-1]:\\n pathcol=\\\"Violet\\\"\\n label4=Text(keypoint,\\\"Key\\\")\\n label4.draw(win) \\n drawpath.draw(win)\\n drawpath.setWidth(1)\\n sleep(0.1)\\n \\n #drawpath.draw(win)\\n \\n label5=Text(endpoint,\\\"Maze Solved \\\")\\n label5.draw(win)\\n circ4=Circle(start,radius)\\n circ4.setFill(\\\"Red\\\")\\n circ4.draw(win) \\n label6=Text(start,\\\"Start \\\")\\n label6.draw(win)\",\n \"def makeOverviewPage(orbit_list, mtpConstants, paths, occultationObservationDict, nadirObservationDict):\\n mtpNumber = mtpConstants[\\\"mtpNumber\\\"]\\n obsTypeNames = {\\\"ingress\\\":\\\"irIngressLow\\\", \\\"egress\\\":\\\"irEgressLow\\\"}\\n\\n \\n #loop through once to find list of all orders measured\\n ordersAll = []\\n for orbit in orbit_list:\\n occultationObsTypes = [occultationType for occultationType in orbit[\\\"allowedObservationTypes\\\"][:] if occultationType in [\\\"ingress\\\", \\\"egress\\\"]] \\n for occultationObsType in occultationObsTypes:\\n if occultationObsType in orbit.keys():\\n obsTypeName = obsTypeNames[occultationObsType]\\n \\n orders = orbit[\\\"finalOrbitPlan\\\"][obsTypeName+\\\"Orders\\\"]\\n if 0 in orders: #remove darks\\n orders.remove(0)\\n if \\\"COP#\\\" in \\\"%s\\\" %orders[0]: #remove manual COP selection\\n orders = []\\n ordersAll.extend(orders)\\n uniqueOccultationOrders = sorted(list(set(ordersAll)))\\n \\n #loop through again to plot each order on a single graph\\n for chosenOrder in uniqueOccultationOrders:\\n title = \\\"Solar occultations for diffraction order %s\\\" %(chosenOrder)\\n fig = plt.figure(figsize=(FIG_X, FIG_Y))\\n ax = fig.add_subplot(111, projection=\\\"mollweide\\\")\\n ax.grid(True)\\n plt.title(title)\\n \\n lonsAll = [] #pre-make list of all observing points of this order, otherwise colourbar scale will be incorrect\\n latsAll = []\\n altsAll = []\\n for orbit in orbit_list:\\n occultationObsTypes = [occultationType for occultationType in orbit[\\\"allowedObservationTypes\\\"][:] if occultationType in [\\\"ingress\\\", \\\"egress\\\"]] \\n for occultationObsType in occultationObsTypes:\\n if occultationObsType in orbit.keys():\\n obsTypeName = obsTypeNames[occultationObsType]\\n \\n orders = orbit[\\\"finalOrbitPlan\\\"][obsTypeName+\\\"Orders\\\"]\\n if chosenOrder in orders:\\n occultation = orbit[occultationObsType]\\n \\n #if lats/lons/alts not yet in orbitList, find and write to list\\n if \\\"alts\\\" not in occultation.keys():\\n #just plot the half of the occultation closest to the surface, not the high altitude bits\\n #ignore merged or grazing occs at this point\\n if occultationObsType == \\\"ingress\\\":\\n ets = np.arange(occultation[\\\"etMidpoint\\\"], occultation[\\\"etEnd\\\"], OCCULTATION_SEARCH_STEP_SIZE)\\n elif occultationObsType == \\\"egress\\\":\\n ets = np.arange(occultation[\\\"etStart\\\"], occultation[\\\"etMidpoint\\\"], OCCULTATION_SEARCH_STEP_SIZE)\\n lonsLatsLsts = np.asfarray([getLonLatLst(et) for et in ets])\\n occultation[\\\"lons\\\"] = lonsLatsLsts[:, 0]\\n occultation[\\\"lats\\\"] = lonsLatsLsts[:, 1]\\n occultation[\\\"alts\\\"] = np.asfarray([getTangentAltitude(et) for et in ets])\\n \\n #else take lats/lons/alts from orbitList if already exists\\n lonsAll.extend(occultation[\\\"lons\\\"])\\n latsAll.extend(occultation[\\\"lats\\\"])\\n altsAll.extend(occultation[\\\"alts\\\"])\\n \\n plot1 = ax.scatter(np.asfarray(lonsAll)/sp.dpr(), np.asfarray(latsAll)/sp.dpr(), \\\\\\n c=np.asfarray(altsAll), cmap=plt.cm.jet, marker='o', linewidth=0)\\n \\n cbar = fig.colorbar(plot1, fraction=0.046, pad=0.04)\\n cbar.set_label(\\\"Tangent Point Altitude (km)\\\", rotation=270, labelpad=20)\\n fig.tight_layout()\\n plt.savefig(os.path.join(paths[\\\"IMG_MTP_PATH\\\"], \\\"occultations_mtp%03d_order%i_altitude.png\\\" %(mtpNumber, chosenOrder)))\\n plt.close()\\n \\n \\n \\n \\\"\\\"\\\"plot nadir orders\\\"\\\"\\\"\\n #find all orders measured\\n ordersAll = []\\n for orbit in orbit_list:\\n if \\\"dayside\\\" in orbit[\\\"irMeasuredObsTypes\\\"]:\\n orders = orbit[\\\"finalOrbitPlan\\\"][\\\"irDaysideOrders\\\"]\\n if 0 in orders: #remove darks\\n orders.remove(0)\\n if \\\"COP#\\\" in \\\"%s\\\" %orders[0]: #remove manual COP selection\\n orders = []\\n ordersAll.extend(orders)\\n uniqueNadirOrders = sorted(list(set(ordersAll)))\\n \\n #plot each order\\n for chosenOrder in uniqueNadirOrders:\\n title = \\\"Dayside nadirs for diffraction order %s\\\" %(chosenOrder)\\n fig = plt.figure(figsize=(FIG_X, FIG_Y))\\n ax = fig.add_subplot(111, projection=\\\"mollweide\\\")\\n ax.grid(True)\\n plt.title(title)\\n \\n lonsAll = [] #pre-make list of all observing points of this order, otherwise colourbar scale will be incorrect\\n latsAll = []\\n anglesAll = []\\n for orbit in orbit_list:\\n if \\\"dayside\\\" in orbit[\\\"irMeasuredObsTypes\\\"]:\\n orders = orbit[\\\"finalOrbitPlan\\\"][\\\"irDaysideOrders\\\"]\\n if chosenOrder in orders:\\n nadir = orbit[\\\"dayside\\\"]\\n \\n #if lats/lons/incidence angles not yet in orbitList, find and write to list\\n if \\\"incidences\\\" not in nadir.keys():\\n# print(orbit[\\\"orbitNumber\\\"])\\n #nadir start/end times have been modified to fit thermal room\\n realStartTime = nadir[\\\"obsStart\\\"] + PRECOOLING_TIME + INITIALISATION_TIME\\n realEndTime = nadir[\\\"obsEnd\\\"]\\n ets = np.arange(realStartTime, realEndTime, NADIR_SEARCH_STEP_SIZE)\\n lonsLatsIncidencesLsts = np.asfarray([getLonLatIncidenceLst(et) for et in ets])\\n nadir[\\\"lons\\\"] = lonsLatsIncidencesLsts[:, 0]\\n nadir[\\\"lats\\\"] = lonsLatsIncidencesLsts[:, 1]\\n nadir[\\\"incidences\\\"] = lonsLatsIncidencesLsts[:, 2]\\n #else take lats/lons/incidence angles from orbitList if already exists\\n lonsAll.extend(nadir[\\\"lons\\\"])\\n latsAll.extend(nadir[\\\"lats\\\"])\\n anglesAll.extend(nadir[\\\"incidences\\\"])\\n \\n plot1 = ax.scatter(np.asfarray(lonsAll)/sp.dpr(), np.asfarray(latsAll)/sp.dpr(), \\\\\\n c=np.asfarray(anglesAll), cmap=plt.cm.jet, marker='o', linewidth=0)\\n \\n cbar = fig.colorbar(plot1, fraction=0.046, pad=0.04)\\n cbar.set_label(\\\"Incidence Angle (degrees)\\\", rotation=270, labelpad=20)\\n fig.tight_layout()\\n plt.savefig(os.path.join(paths[\\\"IMG_MTP_PATH\\\"], \\\"dayside_nadirs_mtp%03d_order%i_incidence_angle.png\\\" %(mtpNumber, chosenOrder)))\\n plt.close()\\n\\n \\\"\\\"\\\"write mtp overview page\\\"\\\"\\\"\\n h = r\\\"\\\"\\n h += r\\\"<h1>MTP%03d Overview</h1>\\\" %(mtpNumber)\\n h += r\\\"<h2>Geometry</h2>\\\"+\\\"\\\\n\\\"\\n \\n imagename = \\\"mtp%03d_occultation_duration.png\\\" %(mtpNumber)\\n h += r\\\"<img src='%s'>\\\" %imagename\\n imagename = \\\"mtp%03d_occultation_lat.png\\\" %(mtpNumber)\\n h += r\\\"<img src='%s'>\\\" %imagename\\n imagename = \\\"mtp%03d_nadir_minimum_incidence_angle.png\\\" %(mtpNumber)\\n h += r\\\"<img src='%s'>\\\" %imagename\\n \\n h += r\\\"<p>UVIS typically operates on all dayside nadirs and all occultations</p>\\\"+\\\"\\\\n\\\"\\n \\n h += r\\\"<h2>Solar Occultations</h2>\\\"+\\\"\\\\n\\\"\\n \\n h += r\\\"Solar occultation diffraction orders measured this MTP: \\\"+\\\"\\\\n\\\"\\n for chosenOrder in sorted(uniqueOccultationOrders):\\n h += \\\"%i, \\\" %chosenOrder\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n \\n for chosenOrder in sorted(uniqueOccultationOrders):\\n h += \\\"<h3>Solar occultations for diffraction order %i</h3>\\\" %chosenOrder\\n imagename = \\\"img/occultations_mtp%03d_order%i_altitude.png\\\" %(mtpNumber, chosenOrder)\\n h += r\\\"<img src='%s'>\\\" %imagename\\n \\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<h2>Dayside Nadirs</h2>\\\"+\\\"\\\\n\\\"\\n \\n h += r\\\"Dayside nadir diffraction orders measured this MTP: \\\"+\\\"\\\\n\\\"\\n for chosenOrder in sorted(uniqueNadirOrders):\\n h += \\\"%i, \\\" %chosenOrder\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n \\n for chosenOrder in sorted(uniqueNadirOrders):\\n h += \\\"<h3>Dayside nadirs for diffraction order %i</h3>\\\" %chosenOrder\\n imagename = \\\"img/dayside_nadirs_mtp%03d_order%i_incidence_angle.png\\\" %(mtpNumber, chosenOrder)\\n h += r\\\"<img src='%s'>\\\" %imagename\\n \\n \\n \\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n# h += r\\\"<h2>SO/LNO Observation Plan</h2>\\\"+\\\"\\\\n\\\"\\n \\n \\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<h2>SO/LNO Observation Dictionaries</h2>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<h3>Solar Occultation</h3>\\\"+\\\"\\\\n\\\"\\n headers = [\\\"Name\\\", \\\"Diffraction Order 1\\\", \\\"Diffraction Order 2\\\", \\\"Diffraction Order 3\\\", \\\"Diffraction Order 4\\\", \\\"Diffraction Order 5\\\", \\\"Diffraction Order 6\\\", \\\"Integration Time\\\", \\\"Rhythm\\\", \\\"Detector Height\\\"]\\n h += r\\\"<table border=1>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<tr>\\\"+\\\"\\\\n\\\"\\n for header in headers:\\n h += r\\\"<th>%s</th>\\\" %header\\n h += r\\\"</tr>\\\"+\\\"\\\\n\\\"\\n for key in sorted(occultationObservationDict.keys()):\\n orders, integrationTime, rhythm, detectorRows, channelCode = getObsParameters(key, occultationObservationDict)\\n \\n h += r\\\"<tr>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<td>%s</td>\\\" %(key)\\n if \\\"COP\\\" in orders:\\n h += r\\\"<td>%s (manual mode)</td>\\\" %(orders)\\n for order in range(5):\\n h += r\\\"<td>-</td>\\\"+\\\"\\\\n\\\"\\n else: \\n for order in orders:\\n h += r\\\"<td>%s</td>\\\" %(order)\\n for order in range(6-len(orders)):\\n h += r\\\"<td>-</td>\\\"+\\\"\\\\n\\\"\\n \\n h += r\\\"<td>%i</td>\\\" %(integrationTime)\\n h += r\\\"<td>%i</td>\\\" %(rhythm)\\n h += r\\\"<td>%i</td>\\\" %(detectorRows)\\n h += r\\\"</tr>\\\"+\\\"\\\\n\\\"\\n h += r\\\"</table>\\\"+\\\"\\\\n\\\"\\n \\n \\n h += r\\\"<h3>Nadir/Limb</h3>\\\"+\\\"\\\\n\\\"\\n headers = [\\\"Name\\\", \\\"Diffraction Order 1\\\", \\\"Diffraction Order 2\\\", \\\"Diffraction Order 3\\\", \\\"Diffraction Order 4\\\", \\\"Diffraction Order 5\\\", \\\"Diffraction Order 6\\\", \\\"Integration Time\\\", \\\"Rhythm\\\", \\\"Detector Height\\\"]\\n h += r\\\"<table border=1>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<tr>\\\"+\\\"\\\\n\\\"\\n for header in headers:\\n h += r\\\"<th>%s</th>\\\" %header\\n h += r\\\"</tr>\\\"\\n for key in sorted(nadirObservationDict.keys()):\\n orders, integrationTime, rhythm, detectorRows, channelCode = getObsParameters(key, nadirObservationDict)\\n \\n h += r\\\"<tr>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<td>%s</td>\\\" %(key)\\n if \\\"COP\\\" in orders:\\n h += r\\\"<td>%s (manual mode)</td>\\\" %(orders)\\n for order in range(5):\\n h += r\\\"<td>-</td>\\\"+\\\"\\\\n\\\"\\n else: \\n for order in orders:\\n h += r\\\"<td>%s</td>\\\" %(order)\\n for order in range(6-len(orders)):\\n h += r\\\"<td>-</td>\\\"+\\\"\\\\n\\\"\\n \\n h += r\\\"<td>%i</td>\\\" %(integrationTime)\\n h += r\\\"<td>%i</td>\\\" %(rhythm)\\n h += r\\\"<td>%i</td>\\\" %(detectorRows)\\n h += r\\\"</tr>\\\"+\\\"\\\\n\\\"\\n h += r\\\"</table>\\\"+\\\"\\\\n\\\"\\n \\n \\n \\n \\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<br>\\\"+\\\"\\\\n\\\"\\n h += r\\\"<p>Page last modified: %s</p>\\\" %(datetime.now().strftime('%a, %d %b %Y %H:%M:%S')) +\\\"\\\\n\\\"\\n \\n with open(os.path.join(paths[\\\"HTML_MTP_PATH\\\"], \\\"nomad_mtp%03d_overview.html\\\" %(mtpNumber)), 'w') as f:\\n f.write(h)\",\n \"def create_path(self):\\n\\n partials = []\\n partials.append({})\\n #print self.trip_id\\n\\n #this variable is true if we have not yet recorded the first edge of a path\\n first_edge = True\\n #this variable is false until we hit the midpoint\\n hit_midpoint = False\\n\\n first_lasts = []\\n first_lasts.append([0,0])\\n matrices = []\\n matrices.append([np.zeros((self.graph.rows,self.graph.cols)),0])\\n edge_sets = []\\n edge_sets.append([0 for i in range(self.graph.num_edges)])\\n cur_line = self.line_num\\n good_graphs = []\\n good_graphs.append(True)\\n nodes_visited = []\\n nodes_visited.append([])\\n #normalized = dg.normalize(self.graph.lines[cur_line])\\n normalized = normalize_simple(self.graph.lines[cur_line])\\n matrices_index = 0\\n prev_coords = (-1,-1)\\n while normalized[0] == self.trip_id:\\n lat = normalized[1]\\n lon = normalized[2]\\n coords = self.graph.gps_to_coords(lat,lon)\\n node = self.graph.coords_to_node(coords[0],coords[1])\\n\\n if prev_coords == (-1,-1) and coords[0] != -1:\\n first_lasts[matrices_index][0] = node\\n\\n if coords[0] == -1 and prev_coords[0] != -1:\\n prev_node = self.graph.coords_to_node(prev_coords[0],prev_coords[1])\\n first_lasts[matrices_index][1] = prev_node\\n\\n if prev_coords != (-1,-1) and coords[0] != -1 and coords != prev_coords:\\n edge_num = self.graph.edge_num(prev_coords[0],prev_coords[1],coords[0],coords[1])\\n if edge_num == -1:\\n good_graphs[matrices_index] = False\\n else:\\n edge_sets[matrices_index][edge_num] = 1\\n if edge_num in partials[matrices_index] and partials[matrices_index][edge_num] == 0:\\n del partials[matrices_index][edge_num]\\n if not hit_midpoint:\\n if first_edge:\\n above = (prev_coords[0]-1,prev_coords[1])\\n below = (prev_coords[0]+1,prev_coords[1])\\n left = (prev_coords[0],prev_coords[1]-1)\\n right = (prev_coords[0],prev_coords[1]+1)\\n for next_coords in (above,below,left,right):\\n other_edge = self.graph.edge_num(prev_coords[0],prev_coords[1],next_coords[0],next_coords[1])\\n if other_edge != -1:\\n partials[matrices_index][other_edge] = 0\\n first_edge = False\\n if self.graph.coords_to_node(prev_coords[0],prev_coords[1]) == self.midpoint:\\n hit_midpoint = True\\n partials[matrices_index][edge_num] = 1\\n if self.graph.coords_to_node(coords[0],coords[1]) == self.midpoint:\\n hit_midpoint = True\\n\\n\\n\\n if coords[0] == -1:\\n matrices.append([np.zeros((self.graph.rows,self.graph.cols)),0])\\n first_lasts.append([0,0])\\n edge_sets.append([0 for i in range(self.graph.num_edges)])\\n good_graphs.append(True)\\n nodes_visited.append([])\\n matrices_index += 1\\n partials.append({})\\n hit_midpoint = False\\n first_edge = True\\n \\n elif coords[0] < self.graph.rows and coords[1] < self.graph.cols and not matrices[matrices_index][0][coords[0]][coords[1]]:\\n matrices[matrices_index][1] += 1\\n matrices[matrices_index][0][coords[0]][coords[1]] = 1\\n nodes_visited[matrices_index].append(coords)\\n\\n prev_coords = coords\\n\\n cur_line += 1\\n if cur_line == len(self.graph.lines):\\n break\\n #normalized = dg.normalize(self.graph.lines[cur_line])\\n normalized = normalize_simple(self.graph.lines[cur_line])\\n\\n prev_node = self.graph.coords_to_node(prev_coords[0],prev_coords[1])\\n first_lasts[matrices_index][1] = prev_node\\n self.next_line = cur_line\\n best_index = 0\\n best_score = 0\\n for matrix_index in range(len(matrices)):\\n if matrices[matrix_index][1] > best_score:\\n best_score = matrices[matrix_index][1]\\n best_index = matrix_index\\n\\n for coords in nodes_visited[best_index]:\\n self.graph.node_visit(self.trip_id,coords)\\n \\n\\n if self.trip_id not in self.graph.trip_id2line_num:\\n #if first_lasts[best_index] == [28,5]:\\n # print \\\"a to b: %d\\\" % self.trip_id\\n self.graph.first_last2trip_ids[tuple(first_lasts[best_index])].append(self.trip_id)\\n\\n return matrices[best_index][0],edge_sets[best_index],good_graphs[best_index],partials[best_index]\",\n \"def test(indices_to_visit = None):\\n ##0 Chicago\\n ##1 New York City\\n ##2 Los Angeles\\n ##3 Minneapolis\\n ##4 Denver\\n ##5 Dallas\\n ##6 Seattle\\n ##7 Boston\\n ##8 San Francisco\\n ##9 St. Louis\\n ##10 Houston\\n ##11 Phoenix\\n ##12 Salt Lake City\\n ##13 Miami\\n ##14 Atlanta\\n ##15 Kansas City\\n home_index = 15 # Kansas city\\n # 15x15 matrix with main diagonal consisting of 0s and to which data is mirrored along\\n # (values are derived from external resource and multiplied by 1000 for higher accuracy)\\n matrix = np.array([[0.0, 1148413.3550047704, 2813453.6297408855, 572861.4368351421, 1483440.7452179305, 1296355.2188721865, 2801269.1215845253, 1370943.3069385102, 2996683.256068982, 422589.4697157836, 1515737.0196676727, 2343639.7107855356, 2031500.319603397, 1913900.3015914203, 946854.1020487415, 665894.0336505901],\\n [1148413.3550047704, 0.0, 3949451.153672887, 1642119.4792808082, 2628946.6435325537, 2212019.1209020815, 3882177.952930788, 306997.0343229422, 4144977.810718553, 1408454.3261387087, 2286054.8575902223, 3455343.3108375454, 3179102.5335818897, 1754834.3710577146, 1202616.154562711, 1766599.1336905772],\\n [2813453.6297408855, 3949451.153672887, 0.0, 2455296.3791196346, 1339227.410707824, 1998182.1420783552, 1545364.434045008, 4184394.186016967, 559978.4273194656, 2560790.9591738936, 2212581.51715849, 575975.8749662543, 933602.6426595236, 3767490.41517038, 3120118.850020503, 2186473.1552241463],\\n [572861.4368351421, 1642119.4792808082, 2455296.3791196346, 0.0, 1127312.7583590776, 1390159.7734006236, 2249169.1308160927, 1811513.5290266906, 2554165.8167895717, 750916.7305340832, 1701189.1538312144, 2062079.2399570548, 1590460.9488364782, 2434801.332310659, 1462408.5353501518, 662752.1291133759],\\n [1483440.7452179305, 2628946.6435325537, 1339227.410707824, 1127312.7583590776, 0.0, 1067257.7993323756, 1646308.7967673023, 2852307.4164419994, 1530510.2790658756, 1283707.511393525, 1414308.8805983758, 943721.1931707633, 598728.757362067, 2779561.192116527, 1952618.0544916363, 899656.1020173575],\\n [1296355.2188721865, 2212019.1209020815, 1998182.1420783552, 1390159.7734006236, 1067257.7993323756, 0.0, 2709804.112590561, 2500314.4507069485, 2390841.4329337194, 882457.80942383, 361482.7025425731, 1427995.4150203674, 1610768.421819668, 1788903.6065106322, 1161480.3557326929, 730446.8613086065],\\n [2801269.1215845253, 3882177.952930788, 1545364.434045008, 2249169.1308160927, 1646308.7967673023, 2709804.112590561, 0.0, 4018059.834330202, 1093104.7332788548, 2778905.575804111, 3046648.362755992, 1794989.6453295103, 1129464.5539648102, 4404737.747850686, 3516794.375197078, 2427457.036285458],\\n [1370943.3069385102, 306997.0343229422, 4184394.186016967, 1811513.5290266906, 2852307.4164419994, 2500314.4507069485, 4018059.834330202, 0.0, 4350710.853063807, 1673216.4080939887, 2586942.3262796295, 3706392.097841614, 3382851.415271485, 2022974.6418062754, 1509585.60107986, 2015770.1390589625],\\n [2996683.256068982, 4144977.810718553, 559978.4273194656, 2554165.8167895717, 1530510.2790658756, 2390841.4329337194, 1093104.7332788548, 4350710.853063807, 0.0, 2812916.3098878833, 2650547.941880299, 1053620.7288649315, 967859.8344376946, 4179636.203479384, 3448359.745690545, 2428862.4239271535],\\n [422589.4697157836, 1408454.3261387087, 2560790.9591738936, 750916.7305340832, 1283707.511393525, 882457.80942383, 2778905.575804111, 1673216.4080939887, 2812916.3098878833, 0.0, 1093601.4408876144, 2050115.5214378452, 1872971.1741522516, 1708236.6189296674, 752855.8488125347, 384122.2000072272],\\n [1515737.0196676727, 2286054.8575902223, 2212581.51715849, 1701189.1538312144, 1414308.8805983758, 361482.7025425731, 3046648.362755992, 2586942.3262796295, 2650547.941880299, 1093601.4408876144, 0.0, 1636770.4499809493, 1932616.2801687205, 1559260.024532222, 1130480.278513877, 1039856.4844335921],\\n [2343639.7107855356, 3455343.3108375454, 575975.8749662543, 2062079.2399570548, 943721.1931707633, 1427995.4150203674, 1794989.6453295103, 3706392.097841614, 1053620.7288649315, 2050115.5214378452, 1636770.4499809493, 0.0, 812548.5062332726, 3191662.5092484164, 2564665.4531581327, 1690942.142157212],\\n [2031500.319603397, 3179102.5335818897, 933602.6426595236, 1590460.9488364782, 598728.757362067, 1610768.421819668, 1129464.5539648102, 3382851.415271485, 967859.8344376946, 1872971.1741522516, 1932616.2801687205, 812548.5062332726, 0.0, 3364908.7076308434, 2551338.215149899, 1490589.7393085626],\\n [1913900.3015914203, 1754834.3710577146, 3767490.41517038, 2434801.332310659, 2779561.192116527, 1788903.6065106322, 4404737.747850686, 2022974.6418062754, 4179636.203479384, 1708236.6189296674, 1559260.024532222, 3191662.5092484164, 3364908.7076308434, 0.0, 973244.7750437199, 2000112.4162614697],\\n [946854.1020487415, 1202616.154562711, 3120118.850020503, 1462408.5353501518, 1952618.0544916363, 1161480.3557326929, 3516794.375197078, 1509585.60107986, 3448359.745690545, 752855.8488125347, 1130480.278513877, 2564665.4531581327, 2551338.215149899, 973244.7750437199, 0.0, 1089830.6426635552],\\n [665894.0336505901, 1766599.1336905772, 2186473.1552241463, 662752.1291133759, 899656.1020173575, 730446.8613086065, 2427457.036285458, 2015770.1390589625, 2428862.4239271535, 384122.2000072272, 1039856.4844335921, 1690942.142157212, 1490589.7393085626, 2000112.4162614697, 1089830.6426635552, 0.0]])\\n\\n solver = FacilityOrderSolver(matrix, home_index)\\n \\n return solver.solve(indices_to_visit)\",\n \"def drought_env_risk_map(request):\\n \\n view_center = [-105.2, 39.0]\\n view_options = MVView(\\n projection='EPSG:4326',\\n center=view_center,\\n zoom=7.0,\\n maxZoom=12,\\n minZoom=5\\n )\\n\\n # TIGER state/county mapserver\\n tiger_boundaries = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://tigerweb.geo.census.gov/arcgis/rest/services/TIGERweb/State_County/MapServer'},\\n legend_title='States & Counties',\\n layer_options={'visible':True,'opacity':0.2},\\n legend_extent=[-112, 36.3, -98.5, 41.66]) \\n \\n ##### WMS Layers - Ryan\\n usdm_legend = MVLegendImageClass(value='Drought Category',\\n image_url='http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?map=/ms4w/apps/usdm/service/usdm_current_wms.map&version=1.3.0&service=WMS&request=GetLegendGraphic&sld_version=1.1.0&layer=usdm_current&format=image/png&STYLE=default')\\n usdm_current = MVLayer(\\n source='ImageWMS',\\n options={'url': 'http://ndmc-001.unl.edu:8080/cgi-bin/mapserv.exe?',\\n 'params': {'LAYERS':'usdm_current','FORMAT':'image/png','VERSION':'1.1.1','STYLES':'default','MAP':'/ms4w/apps/usdm/service/usdm_current_wms.map'}},\\n layer_options={'visible':False,'opacity':0.25},\\n legend_title='USDM',\\n legend_classes=[usdm_legend],\\n legend_extent=[-126, 24.5, -66.2, 49])\\n \\n # USGS Rest server for HUC watersheds \\n watersheds = MVLayer(\\n source='TileArcGISRest',\\n options={'url': 'https://hydro.nationalmap.gov/arcgis/rest/services/wbd/MapServer'},\\n legend_title='HUC Watersheds',\\n layer_options={'visible':False,'opacity':0.4},\\n legend_extent=[-112, 36.3, -98.5, 41.66])\\n \\n # Sector drought vulnerability county risk score maps -> from 2018 CO Drought Plan update\\n vuln_legend = MVLegendImageClass(value='Risk Score',\\n image_url='/static/tethys_gizmos/data/ag_vuln_legend.jpg')\\n environ_vuln_kml = MVLayer(\\n source='KML',\\n options={'url': '/static/tethys_gizmos/data/CO_Environ_vuln_score_2018.kml'},\\n layer_options={'visible':True,'opacity':0.75},\\n legend_title='Environ Risk Score',\\n feature_selection=True,\\n legend_classes=[vuln_legend],\\n legend_extent=[-109.5, 36.5, -101.5, 41.6])\\n \\n # Define GeoJSON layer\\n # Data from CoCoRaHS Condition Monitoring: https://www.cocorahs.org/maps/conditionmonitoring/\\n with open(como_cocorahs) as f:\\n data = json.load(f)\\n \\n # the section below is grouping data by 'scalebar' drought condition\\n # this is a work around for displaying each drought report classification with a unique colored icon\\n data_sd = {}; data_md ={}; data_ml={}\\n data_sd[u'type'] = data['type']; data_md[u'type'] = data['type']; data_ml[u'type'] = data['type']\\n data_sd[u'features'] = [];data_md[u'features'] = [];data_ml[u'features'] = []\\n for element in data['features']:\\n if 'Severely Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_sd[u'features'].append(element)\\n if 'Moderately Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_md[u'features'].append(element)\\n if 'Mildly Dry' in element['properties']['scalebar']:\\n rdate = datetime.datetime.strptime(element['properties']['reportdate'][:10],\\\"%Y-%m-%d\\\")\\n if rdate >= week20:\\n data_ml[u'features'].append(element)\\n \\n cocojson_sevdry = MVLayer(\\n source='GeoJSON',\\n options=data_sd,\\n legend_title='CoCoRaHS Condition Monitor',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Severely Dry', fill='#67000d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#67000d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_moddry = MVLayer(\\n source='GeoJSON',\\n options=data_md,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Moderately Dry', fill='#a8190d')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#a8190d'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n cocojson_mildry = MVLayer(\\n source='GeoJSON',\\n options=data_ml,\\n legend_title='',\\n legend_extent=[-112, 36.3, -98.5, 41.66],\\n feature_selection=False,\\n legend_classes=[MVLegendClass('point', 'Mildly Dry', fill='#f17d44')],\\n layer_options={'style': {'image': {'circle': {'radius': 6,'fill': {'color': '#f17d44'},'stroke': {'color': '#ffffff', 'width': 1},}}}})\\n\\n \\n # Define map view options\\n drought_env_risk_map_view_options = MapView(\\n height='100%',\\n width='100%',\\n controls=['ZoomSlider', 'Rotate', 'ScaleLine', 'FullScreen',\\n {'MousePosition': {'projection': 'EPSG:4326'}},\\n {'ZoomToExtent': {'projection': 'EPSG:4326', 'extent': [-130, 22, -65, 54]}}],\\n layers=[tiger_boundaries,cocojson_sevdry,cocojson_moddry,cocojson_mildry,environ_vuln_kml,usdm_current,watersheds],\\n view=view_options,\\n basemap='OpenStreetMap',\\n legend=True\\n )\\n\\n context = {\\n 'drought_env_risk_map_view_options':drought_env_risk_map_view_options,\\n }\\n\\n return render(request, 'co_drought/drought_env_risk.html', context)\",\n \"def main(\\n num_sampled=[3, 3],\\n max_depth=2,\\n num_iters=1000,\\n do_graph=False,\\n # These are for checking stats on smaller data\\n subsample=False,\\n plot=False,\\n # Generates a random matrix for comparison\\n random=False,\\n # Visualise the connection matrix\\n vis_connect=False,\\n subsample_vis=False,\\n # Generate final graphs\\n final=False,\\n # Analyse\\n analyse=False,\\n only_exp=False,\\n # Which regions are considered here\\n # A_name, B_name = \\\"MOp\\\", \\\"SSP-ll\\\"\\n A_name=\\\"VISp\\\",\\n B_name=\\\"VISl\\\",\\n desired_depth=1,\\n desired_samples=79,\\n):\\n np.random.seed(42)\\n\\n if random:\\n AB, BA, AA, BB = gen_random_matrix(150, 50, 0, 0.04, 0, 0.0)\\n matrix_vis(AB, BA, AA, BB, 10, name=\\\"test_vis.png\\\")\\n\\n os.makedirs(os.path.dirname(pickle_loc), exist_ok=True)\\n convert_mouse_data(A_name, B_name)\\n to_use = [True, True, True, True]\\n mc, args_dict = load_matrix_data(to_use, A_name, B_name)\\n print(\\\"{} - {}, {} - {}\\\".format(A_name, B_name, mc.num_a, mc.num_b))\\n\\n result = {}\\n result[\\\"matrix_stats\\\"] = print_args_dict(args_dict, out=False)\\n\\n if only_exp:\\n mpf_res = mpf_connectome(mc, num_sampled, max_depth, args_dict)\\n mpf_val = [\\n mpf_res[\\\"expected\\\"],\\n mpf_res[\\\"expected\\\"] / num_sampled[1],\\n \\\"{}_{}\\\".format(A_name, B_name),\\n \\\"Statistical estimation\\\",\\n ]\\n if do_graph:\\n print(\\\"Converting matrix\\\")\\n gc.collect()\\n mc.create_connections()\\n print(\\\"Finished conversion\\\")\\n graph = mc.graph\\n to_write = [mc.num_a, mc.num_b]\\n del mc\\n gc.collect()\\n reverse_graph = reverse(graph)\\n graph_res = graph_connectome(\\n num_sampled,\\n max_depth,\\n graph=graph,\\n reverse_graph=reverse_graph,\\n to_write=to_write,\\n num_iters=num_iters,\\n )\\n to_add = np.mean(graph_res[\\\"full_results\\\"][\\\"Connections\\\"].values)\\n graph_val = [\\n to_add,\\n to_add / num_sampled[1],\\n \\\"{}_{}\\\".format(A_name, B_name),\\n \\\"Statistical estimation\\\",\\n ]\\n return mpf_val, graph_val\\n return mpf_val, None\\n\\n # Convert to a pickle\\n # if not os.path.isfile(pickle_loc):\\n # print(\\\"Converting matrix\\\")\\n # gc.collect()\\n # mc.create_connections()\\n # print(\\\"Finished conversion\\\")\\n # graph = mc.graph\\n # to_write = [mc.num_a, mc.num_b]\\n # del mc\\n # gc.collect()\\n\\n # handle_pickle(graph, \\\"graph.pickle\\\", \\\"w\\\")\\n # handle_pickle(reverse(graph), \\\"r_graph.pickle\\\", \\\"w\\\")\\n # handle_pickle(to_write, \\\"graph_size.pickle\\\", \\\"w\\\")\\n\\n if vis_connect:\\n if subsample_vis:\\n print(\\\"Plotting subsampled matrix vis\\\")\\n new_mc = mc.subsample(int(mc.num_a / 10), int(mc.num_b / 10))\\n matrix_vis(\\n new_mc.ab,\\n new_mc.ba,\\n new_mc.aa,\\n new_mc.bb,\\n 15,\\n name=\\\"mc_mat_vis_sub10.pdf\\\",\\n )\\n else:\\n o_name = \\\"mc_mat_vis_{}_to_{}.pdf\\\".format(A_name, B_name)\\n print(\\\"Plotting full matrix vis\\\")\\n matrix_vis(mc.ab, mc.ba, mc.aa, mc.bb, 150, name=o_name)\\n print(\\\"done vis\\\")\\n\\n print(mc, print_args_dict(args_dict, out=False))\\n\\n result = None\\n if subsample:\\n result = check_stats(mc, 1000, 1, 20000, 1, plot)\\n if final:\\n result = {}\\n\\n # For different depths and number of samples\\n for depth in range(1, 4):\\n for ns in range(1, num_sampled[0] + 1):\\n ns_2 = [ns] * 2\\n mpf_res = mpf_connectome(mc, ns_2, depth, args_dict)\\n result[\\\"mpf_{}_{}\\\".format(depth, ns)] = mpf_res\\n\\n # Save this for plotting\\n cols = [\\\"Number of samples\\\", \\\"Proportion of connections\\\", \\\"Max distance\\\"]\\n depth_name = [None, \\\"Direct synapse\\\", \\\"Two synapses\\\", \\\"Three synapses\\\"]\\n vals = []\\n for depth in range(1, 4):\\n for ns in range(1, num_sampled[0] + 1):\\n this = result[\\\"mpf_{}_{}\\\".format(depth, ns)]\\n val = [ns, this[\\\"expected\\\"] / ns, depth_name[depth]]\\n vals.append(val)\\n df = pd.DataFrame(vals, columns=cols)\\n os.makedirs(os.path.join(here, \\\"..\\\", \\\"results\\\"), exist_ok=True)\\n df.to_csv(\\n os.path.join(\\n here, \\\"..\\\", \\\"results\\\", \\\"{}_to_{}_depth.csv\\\".format(A_name, B_name)\\n ),\\n index=False,\\n )\\n\\n cols = [\\\"Number of sampled connected neurons\\\", \\\"Probability\\\"]\\n total_pmf = result[\\\"mpf_{}_{}\\\".format(desired_depth, desired_samples)][\\\"total\\\"]\\n vals = []\\n for k, v in total_pmf.items():\\n vals.append([k, float(v)])\\n df = pd.DataFrame(vals, columns=cols)\\n df.to_csv(\\n os.path.join(\\n here,\\n \\\"..\\\",\\n \\\"results\\\",\\n \\\"{}_to_{}_pmf_{}_{}.csv\\\".format(\\n A_name, B_name, desired_depth, desired_samples\\n ),\\n ),\\n index=False,\\n )\\n if analyse:\\n result = {}\\n result[\\\"matrix_stats\\\"] = args_dict\\n\\n mpf_res = mpf_connectome(\\n mc,\\n num_sampled,\\n max_depth,\\n args_dict,\\n clt_start=30,\\n sr=None,\\n mean_estimate=True,\\n )\\n result[\\\"mean\\\"] = mpf_res\\n\\n vals = []\\n cols = [\\\"Number of connected neurons\\\", \\\"Probability\\\", \\\"Calculation\\\"]\\n for k, v in mpf_res[\\\"total\\\"].items():\\n vals.append([k, float(v), \\\"Mean estimation\\\"])\\n\\n mpf_res = mpf_connectome(mc, num_sampled, max_depth, args_dict, clt_start=30)\\n result[\\\"mpf\\\"] = mpf_res\\n\\n for k, v in mpf_res[\\\"total\\\"].items():\\n vals.append([k, float(v), \\\"Statistical estimation\\\"])\\n\\n if do_graph:\\n print(\\\"Converting matrix\\\")\\n gc.collect()\\n mc.create_connections()\\n print(\\\"Finished conversion\\\")\\n graph = mc.graph\\n to_write = [mc.num_a, mc.num_b]\\n del mc\\n gc.collect()\\n reverse_graph = reverse(graph)\\n\\n graph_res = graph_connectome(\\n num_sampled,\\n max_depth,\\n graph=graph,\\n reverse_graph=reverse_graph,\\n to_write=to_write,\\n num_iters=num_iters,\\n )\\n\\n result[\\\"difference\\\"] = (\\n dist_difference(mpf_res[\\\"total\\\"], graph_res[\\\"dist\\\"]),\\n )\\n result[\\\"graph\\\"] = graph_res\\n\\n for k, v in graph_res[\\\"dist\\\"].items():\\n vals.append([k, float(v), \\\"Monte Carlo simulation\\\"])\\n\\n df = pd.DataFrame(vals, columns=cols)\\n df.to_csv(\\n os.path.join(\\n here,\\n \\\"..\\\",\\n \\\"results\\\",\\n \\\"{}_to_{}_pmf_final_{}_{}.csv\\\".format(\\n A_name, B_name, max_depth, num_sampled[0]\\n ),\\n ),\\n index=False,\\n )\\n\\n if result is not None:\\n with open(os.path.join(here, \\\"..\\\", \\\"results\\\", \\\"mouse.txt\\\"), \\\"w\\\") as f:\\n pprint(result, width=120, stream=f)\\n\\n return result\",\n \"def __init__(self,\\r\\n ox=0.0, oy=0.0, oz=0.0,\\r\\n dx=1.0, dy=1.0, dz=1.0,\\r\\n nx=200, ny=200, nz=10,\\r\\n gtype='points', gname='image',\\r\\n periodicity=False):\\r\\n\\r\\n self.ox = ox\\r\\n self.oy = oy\\r\\n self.oz = oz\\r\\n self.dx = dx\\r\\n self.dy = dy\\r\\n self.dz = dz\\r\\n self.nx = nx\\r\\n self.ny = ny\\r\\n self.nz = nz\\r\\n self.gtype = gtype\\r\\n self.gname = gname\\r\\n self.periodicity = periodicity\\r\\n\\r\\n if self.gtype == 'points':\\r\\n self.points = self.nx*self.ny*self.nz\\r\\n elif self.gtype == 'cells':\\r\\n self.cells = (self.nx-1 if self.nx> 1 else 1)*(self.ny-1 if self.ny> 1 else 1)*(self.nz-1 if self.nz> 1 else 1)\\r\\n\\r\\n # Compute the size of the grid\\r\\n self._lx = None #self.dx * self.nx - self.ox\\r\\n self._ly = None #self.dy * self.ny - self.oy\\r\\n self._lz = None #self.dz * self.nz - self.oz\\r\",\n \"def go_or_grow(lgca):\\n relevant = lgca.cell_density[lgca.nonborder] > 0\\n coords = [a[relevant] for a in lgca.nonborder]\\n n_m = lgca.nodes[..., :lgca.velocitychannels].sum(-1)\\n n_r = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\\n M1 = np.minimum(n_m, lgca.restchannels - n_r)\\n M2 = np.minimum(n_r, lgca.velocitychannels - n_m)\\n for coord in zip(*coords):\\n # node = lgca.nodes[coord]\\n n = lgca.cell_density[coord]\\n\\n n_mxy = n_m[coord]\\n n_rxy = n_r[coord]\\n\\n rho = n / lgca.K\\n j_1 = npr.binomial(M1[coord], tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\\n j_2 = npr.binomial(M2[coord], 1 - tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\\n n_mxy += j_2 - j_1\\n n_rxy += j_1 - j_2\\n n_mxy -= npr.binomial(n_mxy * np.heaviside(n_mxy, 0), lgca.r_d)\\n n_rxy -= npr.binomial(n_rxy * np.heaviside(n_rxy, 0), lgca.r_d)\\n M = min([n_rxy, lgca.restchannels - n_rxy])\\n n_rxy += npr.binomial(M * np.heaviside(M, 0), lgca.r_b)\\n\\n v_channels = [1] * n_mxy + [0] * (lgca.velocitychannels - n_mxy)\\n v_channels = npr.permutation(v_channels)\\n r_channels = np.zeros(lgca.restchannels)\\n r_channels[:n_rxy] = 1\\n node = np.hstack((v_channels, r_channels))\\n lgca.nodes[coord] = node\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57697564","0.56456137","0.5626997","0.54784644","0.5438757","0.5425025","0.5424559","0.5415921","0.5378045","0.5369334","0.5367731","0.536001","0.53513986","0.5345884","0.52968204","0.52847725","0.5271479","0.52679116","0.5252435","0.5250521","0.5245161","0.52443445","0.52304435","0.5216907","0.52162176","0.5208253","0.52056277","0.51956576","0.5187959","0.5179239","0.51696724","0.51611507","0.5149428","0.51374984","0.5131039","0.5130754","0.5122802","0.5114466","0.5110403","0.5093654","0.50909674","0.508826","0.5085649","0.50853217","0.5079664","0.5068839","0.50657445","0.5064553","0.5060261","0.505952","0.5058285","0.5057191","0.50546104","0.5051111","0.50491226","0.5047035","0.50441355","0.5042143","0.5039386","0.50362074","0.5032431","0.5030879","0.5024409","0.50226057","0.50198627","0.5012766","0.501275","0.5010775","0.5007543","0.5001646","0.50014156","0.5001008","0.49979034","0.49978912","0.49945676","0.49938852","0.49875596","0.49793583","0.4979203","0.49782434","0.4973954","0.4973084","0.49689054","0.49679026","0.49596742","0.49545506","0.49512765","0.49511755","0.49486074","0.4942978","0.49401084","0.4937414","0.4934217","0.49318153","0.49314892","0.4927063","0.49257347","0.49243757","0.49236295","0.4922062","0.491953"],"string":"[\n \"0.57697564\",\n \"0.56456137\",\n \"0.5626997\",\n \"0.54784644\",\n \"0.5438757\",\n \"0.5425025\",\n \"0.5424559\",\n \"0.5415921\",\n \"0.5378045\",\n \"0.5369334\",\n \"0.5367731\",\n \"0.536001\",\n \"0.53513986\",\n \"0.5345884\",\n \"0.52968204\",\n \"0.52847725\",\n \"0.5271479\",\n \"0.52679116\",\n \"0.5252435\",\n \"0.5250521\",\n \"0.5245161\",\n \"0.52443445\",\n \"0.52304435\",\n \"0.5216907\",\n \"0.52162176\",\n \"0.5208253\",\n \"0.52056277\",\n \"0.51956576\",\n \"0.5187959\",\n \"0.5179239\",\n \"0.51696724\",\n \"0.51611507\",\n \"0.5149428\",\n \"0.51374984\",\n \"0.5131039\",\n \"0.5130754\",\n \"0.5122802\",\n \"0.5114466\",\n \"0.5110403\",\n \"0.5093654\",\n \"0.50909674\",\n \"0.508826\",\n \"0.5085649\",\n \"0.50853217\",\n \"0.5079664\",\n \"0.5068839\",\n \"0.50657445\",\n \"0.5064553\",\n \"0.5060261\",\n \"0.505952\",\n \"0.5058285\",\n \"0.5057191\",\n \"0.50546104\",\n \"0.5051111\",\n \"0.50491226\",\n \"0.5047035\",\n \"0.50441355\",\n \"0.5042143\",\n \"0.5039386\",\n \"0.50362074\",\n \"0.5032431\",\n \"0.5030879\",\n \"0.5024409\",\n \"0.50226057\",\n \"0.50198627\",\n \"0.5012766\",\n \"0.501275\",\n \"0.5010775\",\n \"0.5007543\",\n \"0.5001646\",\n \"0.50014156\",\n \"0.5001008\",\n \"0.49979034\",\n \"0.49978912\",\n \"0.49945676\",\n \"0.49938852\",\n \"0.49875596\",\n \"0.49793583\",\n \"0.4979203\",\n \"0.49782434\",\n \"0.4973954\",\n \"0.4973084\",\n \"0.49689054\",\n \"0.49679026\",\n \"0.49596742\",\n \"0.49545506\",\n \"0.49512765\",\n \"0.49511755\",\n \"0.49486074\",\n \"0.4942978\",\n \"0.49401084\",\n \"0.4937414\",\n \"0.4934217\",\n \"0.49318153\",\n \"0.49314892\",\n \"0.4927063\",\n \"0.49257347\",\n \"0.49243757\",\n \"0.49236295\",\n \"0.4922062\",\n \"0.491953\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9296,"cells":{"query":{"kind":"string","value":"Summary This function encapsulates the routine to generate rectified backprojected views of all opponent retinal ganglion cells"},"document":{"kind":"string","value":"def showBPImg(pV,nV):\n # object arrays of the positive and negative images\n inv_crop = np.empty(8, dtype=object)\n inv_crop2 = np.empty(8, dtype=object)\n for t in range(8):\n # backprojection functions\n inverse = retina.inverse(pV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n inv_crop[t] = retina.crop(inverse,x,y,dloc[i])\n inverse2 = retina.inverse(nV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n inv_crop2[t] = retina.crop(inverse2,x,y,dloc[i])\n # place descriptions\n cv2.putText(inv_crop[t],types[t] + \" + \",(xx,yy), font, 1,(0,255,255),2)\n cv2.putText(inv_crop2[t],types[t] + \" - \",(xx,yy), font, 1,(0,255,255),2)\n # stack all images into a grid\n posRG = np.vstack((inv_crop[:4]))\n negRG = np.vstack((inv_crop2[:4]))\n posYB = np.vstack((inv_crop[4:]))\n negYB = np.vstack((inv_crop2[4:]))\n merge = np.concatenate((posRG,negRG,posYB,negYB),axis=1)\n return merge"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def gen_obs_grid(self):\n\n topX, topY, botX, botY = self.get_view_exts()\n\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\n\n # for i in range(self.agent_dir + 1):\n # grid = grid.rotate_left()\n\n # Process occluders and visibility\n # Note that this incurs some performance cost\n if not self.see_through_walls:\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\n self.agent_view_size // 2))\n else:\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\n\n # Make it so the agent sees what it's carrying\n # We do this by placing the carried object at the agent's position\n # in the agent's partially observable view\n agent_pos = grid.width // 2, grid.height // 2\n if self.carrying:\n grid.set(*agent_pos, self.carrying)\n else:\n grid.set(*agent_pos, None)\n\n return grid, vis_mask","def occam_razor() -> None:\r\n print(\"WARNING! Mode three activated. Time to complete may be several minutes\")\r\n temp = [] # x-y-conflicts\r\n global example\r\n backup = example.copy() # Backup so it can backtrack through solutions\r\n for x in range(shape):\r\n for y in range(shape):\r\n conflict_counter = 0\r\n for z in range(shape):\r\n if conflict_space[x, y] != 0:\r\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\r\n conflict_counter += 1\r\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\r\n conflict_counter += 1\r\n if conflict_counter > 0 and no_neighbour(x, y):\r\n temp.append([x, y, conflict_counter])\r\n threshold = [0, 0, 0]\r\n \"\"\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\"\"\"\r\n for x in range(len(temp)):\r\n if temp[x][2] > threshold[2]:\r\n threshold = temp[x]\r\n if threshold[2] > 0:\r\n example[threshold[0], threshold[1]] = 0\r\n shade_neighbours(threshold[0], threshold[1])\r\n if not victory_checker():\r\n \"\"\"code now begins guessing\"\"\"\r\n for x in range(len(temp)):\r\n example = backup.copy()\r\n if no_neighbour(temp[x][0], temp[x][1]):\r\n example[temp[x][0], temp[x][1]] = 0\r\n else:\r\n continue\r\n progress_handler(False, True)\r\n while progress_handler(True, False):\r\n print_debug(\"itteration\")\r\n progress_handler(False, False)\r\n mark_check()\r\n if victory_checker():\r\n completion(True)\r\n if not progress_handler(True, False):\r\n special_corner()\r\n if not progress_handler(True, False):\r\n separation_crawler(True)\r\n if not progress_handler(True, False):\r\n occam_razor() # Recursive\r\n if not progress_handler(True, False):\r\n if victory_checker():\r\n completion(True)\r\n else:\r\n print(\"Searching...\")\r\n continue\r\n conflict_check()","def build_grains(self):\n\t\ttime = datetime.datetime.now()\n\t\tif self.probability == 0:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\t\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tnew_grain = 0\n\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\telse:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tif self.decide_changing(cell,neighbours,5, time):\n\t\t\t\t\t\tneighbours = self.get_nearest_neighbours(cell)\n\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\tneighbours = self.get_further_neighbours(cell)\n\t\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t\t\tnew_grain = 0\n\t\t\t\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\t\t\t\trandom_number = random.random() * 100\n\t\t\t\t\t\t\t\tif random_number <= self.probability:\n\t\t\t\t\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tcontinue","def create_gridworld(self):\n self.num_actions = 4\n self.num_states = self.num_cols * self.num_rows + 1\n self.start_state_seq = row_col_to_seq(self.start_state, self.num_cols)\n self.goal_states_seq = row_col_to_seq(self.goal_states, self.num_cols)\n\n # rewards structure\n self.R = self.r_step * np.ones((self.num_states, 1))\n self.R[self.num_states-1] = 0\n self.R[self.goal_states_seq] = self.r_goal\n for i in range(self.num_bad_states):\n if self.r_bad is None:\n raise Exception(\"Bad state specified but no reward is given\")\n bad_state = row_col_to_seq(self.bad_states[i,:].reshape(1,-1), self.num_cols)\n self.R[bad_state, :] = self.r_bad\n for i in range(self.num_restart_states):\n if self.r_restart is None:\n raise Exception(\"Restart state specified but no reward is given\")\n restart_state = row_col_to_seq(self.restart_states[i,:].reshape(1,-1), self.num_cols)\n self.R[restart_state, :] = self.r_restart\n\n # probability model\n if self.p_good_trans == None:\n raise Exception(\"Must assign probability and bias terms via the add_transition_probability method.\")\n\n self.P = np.zeros((self.num_states,self.num_states,self.num_actions))\n for action in range(self.num_actions):\n for state in range(self.num_states):\n\n # check if state is the fictional end state - self transition\n if state == self.num_states-1:\n self.P[state, state, action] = 1\n continue\n\n # check if the state is the goal state or an obstructed state - transition to end\n row_col = seq_to_col_row(state, self.num_cols)\n if self.obs_states is not None:\n end_states = np.vstack((self.obs_states, self.goal_states))\n else:\n end_states = self.goal_states\n\n if any(np.sum(np.abs(end_states-row_col), 1) == 0):\n self.P[state, self.num_states-1, action] = 1\n\n # else consider stochastic effects of action\n else:\n for dir in range(-1,2,1):\n direction = self._get_direction(action, dir)\n next_state = self._get_state(state, direction)\n if dir == 0:\n prob = self.p_good_trans\n elif dir == -1:\n prob = (1 - self.p_good_trans)*(self.bias)\n elif dir == 1:\n prob = (1 - self.p_good_trans)*(1-self.bias)\n\n self.P[state, next_state, action] += prob\n\n # make restart states transition back to the start state with\n # probability 1\n if self.restart_states is not None:\n if any(np.sum(np.abs(self.restart_states-row_col),1)==0):\n next_state = row_col_to_seq(self.start_state, self.num_cols)\n self.P[state,:,:] = 0\n self.P[state,next_state,:] = 1\n return self","def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\r\n \r\n nI_agg = len(list(set(indices['ind'][agg_level])))\r\n nP_agg = len(list(set(indices['prod'][agg_level])))\r\n nW_agg = len(list(set(indices['vadd'][agg_level])))\r\n nM_agg = len(list(set(indices['imp'][agg_level])))\r\n nY_agg = len(list(set(indices['fd'][agg_level])))\r\n nR_agg = len(list(set(indices['exog'][agg_level])))\r\n\r\n nI_rcot = len(list(set(indices['ind'][rect_level])))\r\n nP_rcot = len(list(set(indices['prod'][rect_level])))\r\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\r\n nM_rcot = len(list(set(indices['imp'][rect_level])))\r\n nY_rcot = len(list(set(indices['fd'][rect_level])))\r\n nR_rcot = len(list(set(indices['exog'][rect_level])))\r\n\r\n \r\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\r\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n \r\n indInd = indices_agg['ind']\r\n prodInd = indices_agg['prod']\r\n vaddInd = indices_agg['vadd']\r\n impInd = indices_agg['imp']\r\n fdInd = indices_agg['fd']\r\n exogInd = indices_agg['exog']\r\n\r\n zInd = prodInd.append(indInd)\r\n zInd = zInd.swaplevel(0,1)\r\n \r\n\r\n for l in range(nL):\r\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\r\n\r\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n ZR_0[l] = Z.values\r\n WR_0[l] = W.values\r\n MR_0[l] = M.values\r\n YR_0[l] = Y.values\r\n \r\n AR_0[l] = A.values\r\n wR_0[l] = w.values\r\n mR_0[l] = m.values\r\n\r\n \r\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n\r\n ML_RCOT_0 = {\r\n 'Z' : ZR_0,\r\n 'W' : WR_0,\r\n 'M' : MR_0,\r\n 'Y' : YR_0,\r\n 'R' : RR_0,\r\n }\r\n\r\n ML_RCOT_coeff_0 = {\r\n 'A' : AR_0,\r\n 'w' : wR_0,\r\n 'm' : mR_0,\r\n 'Y' : YR_0,\r\n 'B' : BR_0,\r\n }\r\n\r\n \r\n indices_RCOT = {\r\n 'prod/ind' : zInd,\r\n 'vadd' : vaddInd,\r\n 'imp' : impInd,\r\n 'fd' : fdInd,\r\n 'exog' : exogInd,\r\n 'headers' : indices['headers']\r\n }\r\n \r\n \r\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)","def gru_cell(self, Xt, h_t_minus_1):\n # 1.update gate: decides how much past information is kept and how much new information is added.\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\n # 2.reset gate: controls how much the past state contributes to the candidate state.\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\n # candiate state h_t~\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\n # new state: a linear combine of pervious hidden state and the current new state h_t~\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\n return h_t","def init(self, windowsize:tuple):\r\n y_count, x_count = 3, 0 #< Set the starting counter for the look_up_table. y starts with three because the first three lines are just Nones\r\n # Creating the constant maze \r\n maze_size = windowsize[0], windowsize[1] - 2 * self.grid_size\r\n self.maze = pg.Surface(maze_size) \r\n \r\n \r\n \r\n # Draw the outermost rectangles on self.maze\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0, 3 * self.grid_size), (28 * self.grid_size, 31 * self.grid_size)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0 + self.grid_size // 2, 3 * self.grid_size + self.grid_size // 2),(27 * self.grid_size, 30 * self.grid_size)), 4) \r\n # Draw the inner rectangles\r\n for y in self.look_up_table[3 : -2]: #< y is a list of one row from the maze\r\n for x in y: #< x is a string that is decoded as already explained\r\n pos = [self.grid_size * x_count, self.grid_size * y_count]\r\n # Set reference position in the middle of one square\r\n pos[0] += self.grid_size // 2\r\n pos[1] += self.grid_size // 2\r\n x_count += 1\r\n # Check if x is rectangle\r\n if x != None and x[0] == 'r':\r\n # When the size of the string is equal or greater than 4 it's rectangle with a specific size and not just a border.\r\n if len(x) >= 4:\r\n # get the x and y size of the rectangle. x will be something like 'rx1_y1' x1 resprestens the size in x direction and y1 in y direction.\r\n xy_dim = x[1:].split(\"_\") \r\n xy_dim[0] = int(xy_dim[0])\r\n xy_dim[1] = int(xy_dim[1])\r\n rect = tuple(pos), (xy_dim[0] * self.grid_size , xy_dim[1] * self.grid_size )\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], rect, self.width)\r\n # If the last char is a w (white), u (up) or l (left) a line gets draw one a specific position \r\n if x[-1] == 'w':\r\n self.draw_line(self.maze, 'u', (x_count,y_count), True)\r\n if x[-1] == 'u' or x[-1] == 'l':\r\n if x_count == 0:\r\n self.draw_line(self.maze, x[-1], (len(y), y_count))\r\n else:\r\n self.draw_line(self.maze, x[-1], (x_count, y_count))\r\n \r\n y_count += 1\r\n x_count = 0\r\n # Just some cosmetic drawing\r\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((0, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((28 * self.grid_size - self.grid_size // 2 - 1, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 13 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 19 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 13 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 19 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((11 * self.grid_size, 16 * self.grid_size), (6 * self.grid_size, 3 * self.grid_size)), self.width)\r\n \r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size // 2 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 18 * self.grid_size + self.grid_size // 2), (self.grid_size // 2 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size * 28 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 18 * self.grid_size + self.grid_size // 2), (self.grid_size * 28 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\r\n self.is_init = True","def _get_closeup(self, idx):\n img_arr = p.getCameraImage(width=self._width,\n height=self._height,\n viewMatrix=self._view_matrix,\n projectionMatrix=self._proj_matrix)\n rgb = img_arr[2]\n depth = img_arr[3]\n min = 0.97\n max=1.0\n segmentation = img_arr[4]\n depth = np.reshape(depth, (self._height, self._width,1) )\n segmentation = np.reshape(segmentation, (self._height, self._width,1) )\n\n np_img_arr = np.reshape(rgb, (self._height, self._width, 4))\n np_img_arr = np_img_arr[:, :, :3].astype(np.float64)\n\n view_mat = np.asarray(self._view_matrix).reshape(4, 4)\n proj_mat = np.asarray(self._proj_matrix).reshape(4, 4)\n # pos = np.reshape(np.asarray(list(p.getBasePositionAndOrientation(self._objectUids[0])[0])+[1]), (4, 1))\n\n AABBs = np.zeros((len(self._objectUids), 2, 3))\n cls_ls = []\n \n for i, (_uid, _cls) in enumerate(zip(self._objectUids, self._objectClasses)):\n AABBs[i] = np.asarray(p.getAABB(_uid)).reshape(2, 3)\n cls_ls.append(NAME2IDX[_cls])\n\n # np.save('/home/tony/Desktop/obj_save/view_mat_'+str(self.img_save_cnt), view_mat)\n # np.save('/home/tony/Desktop/obj_save/proj_mat_'+str(self.img_save_cnt), proj_mat)\n # np.save('/home/tony/Desktop/obj_save/img_'+str(self.img_save_cnt), np_img_arr.astype(np.int16))\n # np.save('/home/tony/Desktop/obj_save/AABB_'+str(self.img_save_cnt), AABBs)\n # np.save('/home/tony/Desktop/obj_save/class_'+str(self.img_save_cnt), np.array(cls_ls))\n\n np.save(OUTPUT_DIR + '/closeup_' + str(self.img_save_cnt - 1) + '_' + str(idx), np_img_arr.astype(np.int16))\n dets = np.zeros((AABBs.shape[0], 5))\n for i in range(AABBs.shape[0]):\n dets[i, :4] = self.get_2d_bbox(AABBs[i], view_mat, proj_mat, IM_HEIGHT, IM_WIDTH)\n dets[i, 4] = int(cls_ls[i])\n # np.save(OUTPUT_DIR + '/annotation_'+str(self.img_save_cnt), dets)\n\n test = np.concatenate([np_img_arr[:, :, 0:2], segmentation], axis=-1)\n\n return test","def proposal_assignments_gtbox(rois, gt_boxes, gt_classes, gt_rels, image_offset, fg_thresh=0.5):\n im_inds = rois[:, 0].long()\n num_im = im_inds[-1] + 1\n fg_rels = gt_rels.clone()\n fg_rels[:, 0] -= image_offset\n offset = {}\n for i, s, e in enumerate_by_image(im_inds):\n offset[i] = s\n for i, s, e in enumerate_by_image(fg_rels[:, 0]):\n fg_rels[s:e, 1:3] += offset[i]\n is_cand = im_inds[:, None] == im_inds[None]\n is_cand.view(-1)[diagonal_inds(is_cand)] = 0\n is_cand.view(-1)[fg_rels[:, 1] * im_inds.size(0) + fg_rels[:, 2]] = 0\n is_bgcand = is_cand.nonzero()\n num_fg = min(fg_rels.size(0), int(RELS_PER_IMG * REL_FG_FRACTION * num_im))\n if num_fg < fg_rels.size(0):\n fg_rels = random_choose(fg_rels, num_fg)\n num_bg = min(is_bgcand.size(0) if is_bgcand.dim() > 0 else 0, int(RELS_PER_IMG * num_im) - num_fg)\n if num_bg > 0:\n bg_rels = torch.cat((im_inds[is_bgcand[:, 0]][:, None], is_bgcand, (is_bgcand[:, 0, None] < -10).long()), 1)\n if num_bg < is_bgcand.size(0):\n bg_rels = random_choose(bg_rels, num_bg)\n rel_labels = torch.cat((fg_rels, bg_rels), 0)\n else:\n rel_labels = fg_rels\n _, perm = torch.sort(rel_labels[:, 0] * gt_boxes.size(0) ** 2 + rel_labels[:, 1] * gt_boxes.size(0) + rel_labels[:, 2])\n rel_labels = rel_labels[perm].contiguous()\n labels = gt_classes[:, 1].contiguous()\n return rois, labels, rel_labels","def __init__(self, \n nd = 2, \n goal = np.array([1.0,1.0]),\n state_bound = [[0,1],[0,1]],\n nA = 4,\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\n<<<<<<< HEAD:archive-code/puddleworld.py\n ngrid = [10.0,10.0],\n maxStep = 40):\n ngrid = [40, 40]\n x_vec = np.linspace(0,1,ngrid[0])\n y_vec = np.linspace(0,1,ngrid[1])\n for x in x_vec:\n for y in y_vec:\n if ~self.inPuddle([x,y]):\n puddle.append([x,y])\n # puddle is a closed loop \n outpuddlepts = np.asarray(puddle)\n \"\"\"\n\n\n # Horizontal wing of puddle consists of \n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\n # (xchi,ychi) is the center points (h ==> horizantal)\n # x, y = state[0], state[1]\n xch1, ych1 = 0.3, 0.7\n xch2, ych2 = 0.65, ych1\n radius = 0.1\n\n\n #Vertical wing of puddle consists of \n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\n # where (xcvi,ycvi) is the center points (v ==> vertical)\n xcv1 = 0.45; ycv1=0.4;\n xcv2 = xcv1; ycv2 = 0.8;\n\n # % 2) two half-circle at end edges of rectangle\n \n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n puddle.append([xcv1-radius,ych1-radius])\n \n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n \n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n \n puddle.append([xcv1-radius,ych1+radius])\n\n\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1-radius,y])\n \n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1+radius,y])\n \"\"\"\n for y in np.arrange():\n puddle.append([])\n \n for y in np.arrange():\n puddle.append([])\n \"\"\"\n\n # HALF CIRCLES\n ngridTheta = 10\n thetaVec = np.linspace(0,pi,ngridTheta)\n\n for t in thetaVec:\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\n\n for t in thetaVec:\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\n\n \n outpuddlepts = np.asarray(puddle)\n return outpuddlepts","def swipeBase (self) :\n grid = self.grid\n\n #we start by putting every tile up\n for columnNbr in range(4) :\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\n\n for lineNbr in range(4) :\n counter = 0\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\n counter += 1\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\n for remainingLine in range (lineNbr, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n #now we do the additions\n for lineNbr in range(3) :\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\n grid[lineNbr, columnNbr] *= 2\n for remainingLine in range (lineNbr+1, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n return (grid)","def generate_grains(self, cells):\n\t\tfor cell_num in range(cells):\n\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\tsample_cell = sample_cell[0]\n\t\t\twhile sample_cell.state != 0:\n\t\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\t\tsample_cell = sample_cell[0]\n\t\t\tsample_cell.change_state(self.init_time ,cell_num)","def test_multigrid_calculates_neighbours_correctly():\n\n # create a grid which will result in 9 cells\n h = 64\n img_dim = (3 * h + 1, 3 * h + 1)\n amg = mg.MultiGrid(img_dim, h, WS=127)\n\n # check that each cell has the expected neighbours\n print(amg.n_cells)\n\n # expected neieghbours left to right, bottom to top\n cells = [{\"north\": amg.cells[3], \"east\": amg.cells[1], \"south\": None, \"west\": None}, # bl\n {\"north\": amg.cells[4], \"east\": amg.cells[2],\n \"south\": None, \"west\": amg.cells[0]}, # bm\n {\"north\": amg.cells[5], \"east\": None,\n \"south\": None, \"west\": amg.cells[1]}, # br\n {\"north\": amg.cells[6], \"east\": amg.cells[4],\n \"south\": amg.cells[0], \"west\": None}, # ml\n {\"north\": amg.cells[7], \"east\": amg.cells[5],\n \"south\": amg.cells[1], \"west\": amg.cells[3]}, # mm\n {\"north\": amg.cells[8], \"east\": None,\n \"south\": amg.cells[2], \"west\": amg.cells[4]}, # mr\n # tl\n {\"north\": None, \"east\": amg.cells[7],\n \"south\": amg.cells[3], \"west\": None},\n # tm\n {\"north\": None,\n \"east\": amg.cells[8], \"south\": amg.cells[4], \"west\": amg.cells[6]},\n {\"north\": None, \"east\": None,\n \"south\": amg.cells[5], \"west\": amg.cells[7]}, # tr\n ]\n\n for ii, (gc, cell) in enumerate(zip(amg.cells, cells)):\n print(ii)\n assert gc.north == cell['north']\n assert gc.east == cell['east']\n assert gc.south == cell['south']\n assert gc.west == cell['west']","def create_glider_gun(i, j, grid):\n\n ggun = np.zeros(11*38).reshape(11, 38)\n\n ggun[5][1] = ggun[5][2] = 1\n ggun[6][1] = ggun[6][2] = 1\n\n ggun[3][13] = ggun[3][14] = 1\n ggun[4][12] = ggun[4][16] = 1\n ggun[5][11] = ggun[5][17] = 1\n ggun[6][11] = ggun[6][15] = ggun[6][17] = ggun[6][18] = 1\n ggun[7][11] = ggun[7][17] = 1\n ggun[8][12] = ggun[8][16] = 1\n ggun[9][13] = ggun[9][14] = 1\n\n ggun[1][25] = 1\n ggun[2][23] = ggun[2][25] = 1\n ggun[3][21] = ggun[3][22] = 1\n ggun[4][21] = ggun[4][22] = 1\n ggun[5][21] = ggun[5][22] = 1\n ggun[6][23] = ggun[6][25] = 1\n ggun[7][25] = 1\n\n ggun[3][35] = ggun[3][36] = 1\n ggun[4][35] = ggun[4][36] = 1\n\n grid[i:i+11, j:j+38] = ggun","def get_grasp_vis(predictions,\n color_heightmap,\n action_rot,\n action_position,\n num_rotations=16):\n canvas = None\n for canvas_row in range(4):\n tmp_row_canvas = None\n for canvas_col in range(int(num_rotations / 4)):\n rotate_idx = int(canvas_row * num_rotations / 4 + canvas_col)\n prediction = predictions[rotate_idx, :, :].copy()\n if rotate_idx == action_rot:\n position = action_position\n else:\n position = None\n prediction_vis = get_workspace_vis(prediction,\n color_heightmap,\n action_position=position)\n if tmp_row_canvas is None:\n tmp_row_canvas = prediction_vis\n else:\n tmp_row_canvas = np.concatenate((tmp_row_canvas,prediction_vis), axis=1)\n if canvas is None:\n canvas = tmp_row_canvas\n else:\n canvas = np.concatenate((canvas,tmp_row_canvas), axis=0)\n return canvas","def vis_grid_disentangling(batch_data, func_style, func_rec, gap_size, save_path):\n images, class_label = batch_data\n # 1. Calculate reconstructions\n # (1) Encoded & get shape. (batch, style_dim)\n style_mu = func_style(images)\n batch, style_dim = style_mu.size()\n # (2) Mesh grid. (batch*batch, style_dim) & (batch*batch, class_dim)\n style_mu = style_mu.unsqueeze(1).expand(batch, batch, style_dim).reshape(-1, style_dim)\n class_label = class_label.unsqueeze(0).expand(batch, batch).reshape(-1, )\n # (3) Decode. (batch*batch, ...)\n recon = func_rec(style_mu, class_label)\n # 2. Get result\n recon = torch.reshape(recon, shape=(batch, batch, *recon.size()[1:]))\n recon = torch.cat([_.squeeze(1) for _ in torch.split(recon, split_size_or_sections=1, dim=1)], dim=3)\n recon = torch.cat([_.squeeze(0) for _ in torch.split(recon, split_size_or_sections=1, dim=0)], dim=1)\n # 1> Right\n hor_images = torch.cat([_.squeeze(0) for _ in torch.split(images, split_size_or_sections=1, dim=0)], dim=2)\n hor_gap = torch.ones(size=(hor_images.size(0), gap_size, hor_images.size(2)), device=hor_images.device)\n ret = torch.cat([hor_images, hor_gap, recon], dim=1)\n # 2> Left\n ver_images = torch.cat([_.squeeze(0) for _ in torch.split(images, split_size_or_sections=1, dim=0)], dim=1)\n ver_images = torch.cat([\n torch.zeros(size=(ver_images.size(0), images.size(2), images.size(3)), device=ver_images.device),\n torch.ones(size=(ver_images.size(0), gap_size, images.size(3)), device=ver_images.device),\n ver_images], dim=1)\n ver_gap = torch.ones(size=(ver_images.size(0), ver_images.size(1), gap_size), device=ver_images.device)\n ver_images = torch.cat([ver_images, ver_gap], dim=2)\n # Result\n ret = torch.cat([ver_images, ret], dim=2)\n # 3. Save\n save_image(ret.unsqueeze(0), save_path)","def recover_model_vis_waterfall(self, info, g = None):\n reds = info.get_reds()\n p1, p2 = self.pol\n v_mdl = {self.pol: {}}\n if g is None:\n if self.gains.gfit is None:\n self.gains.bandpass_fitting(include_red = True)\n g = self.gains.gfit\n SH = self.shape_waterfall\n if not self.data_backup:\n print(\"The tave is set to False, no need to recalculate vis model.\")\n return\n for r in reds:\n bl0 = r[0]\n num = 0\n den = 0\n for bl in r:\n i,j = bl\n try:\n di = self.data_backup[bl][self.pol]\n wi = np.logical_not(self.flag_backup[bl][self.pol])\n except:\n di = self.data_backup[bl[::-1]][self.pol].conj()\n wi = np.logical_not(self.flag_backup[bl[::-1]][self.pol])\n num += di * g[p1][i].conj() * g[p2][j] * wi\n den += np.resize(g[p1][i].conj() * g[p1][i] * g[p2][j].conj() * g[p2][j], SH) * wi\n v_mdl[self.pol][bl0] = num / (den+1e-10)\n self.gains.get_mdl(v_mdl)","def makeGrid(self, width, height, rewardLocs, exit, nPick=1, nAux=1, walls=[]):\n # Make mapping from coordinate (x, y, (takenreward1, takenreward2, ...))\n # to state number, and vice-versa.\n rTaken = iter([(),])\n for nPicked in range(1, nPick+1):\n rTaken = itertools.chain(rTaken, \n myCombinations(rewardLocs, r=nPicked)\n )\n # Iterators are hard to reset, so we list it.\n rTaken = list(rTaken)\n\n # Mappings from state to coordinates, vice-versa\n coordToState = {}\n stateToCoord = {}\n stateIdx = 0\n for x in range(width):\n for y in range(height):\n for stuff in rTaken:\n for holding in self.holdingPossibilities:\n coordToState[(x, y, stuff, holding)] = stateIdx\n stateToCoord[stateIdx] = (x, y, stuff, holding)\n stateIdx += 1\n self.deadEndState = stateIdx\n\n # Actually make the transition function\n def trans(f, p): \n aux = p\n (x, y, stuff, holding) = stateToCoord[f]\n actionMap = {}\n default = {(f, aux): 1}\n # Make the transition dictionary if the dead-end state (state width*height)\n if f == self.F-1:\n for action in range(5):\n actionMap[action] = default\n return actionMap\n\n # Otherwise, determine directions of motion, etc. \n for i in range(4):\n actionMap[i] = default\n if x != 0 and ((x-1, y) not in walls):\n actionMap[0] = {(coordToState[(x-1,y,stuff, holding)], aux): 1}\n if x < width-1 and ((x+1, y) not in walls):\n actionMap[1] = {(coordToState[(x+1,y,stuff, holding)], aux): 1}\n if y != 0 and ((x, y-1) not in walls):\n actionMap[2] = {(coordToState[(x,y-1,stuff, holding)], aux): 1}\n if y < height-1 and ((x, y+1) not in walls):\n actionMap[3] = {(coordToState[(x,y+1,stuff, holding)], aux): 1}\n # What happens when the agent uses action 4?\n if (x, y) == exit:\n # Some cases, depending on self.oneAtATime\n if not self.oneAtATime:\n # The agent is leaving.\n actionMap[4] = {(self.deadEndState, aux): 1}\n else:\n # The agent is dropping off a reward. holeFiller will\n # take care of the reward value.\n if len(stuff) >= nPick:\n # The agent is not allowed to pick up more stuff\n actionMap[4] = {(self.deadEndState, aux): 1}\n else:\n # The agent drops off the object.\n actionMap[4] = {(coordToState[(x,y,stuff, -1)], aux): 1}\n elif (x, y) not in rewardLocs:\n # No reward to pick up. Do nothing.\n actionMap[4] = default\n elif (x, y) in stuff:\n # This reward has already been used. Do nothing.\n actionMap[4] = default\n elif len(stuff) >= nPick or (holding != -1 and holding < len(stuff)\n and self.oneAtATime):\n # The agent has its hands full.\n actionMap[4] = default\n else:\n # The agent is allowed to pick up an object.\n newStuff = tuple(sorted(list(stuff) + [(x, y)]))\n if self.oneAtATime:\n newHoldingIdx = newStuff.index((x, y))\n else:\n newHoldingIdx = -1\n actionMap[4] = {(coordToState[(x, y, newStuff, newHoldingIdx)], aux): 1}\n return actionMap\n\n # Man, I'm outputting a lot of stuff.\n # coordToState[(x, y, rewardsLeft, holding)] -> index of this state\n # stateToCoord[index] -> (x, y, rewardsLeft, holding)\n # rTaken is a list of all possible combinations of leftover rewards.\n return (trans, coordToState, stateToCoord, rTaken)","def create_grids(self):\n \n par = self.par\n\n # a. retirement\n \n # pre-decision states\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\n \n # post-decision states\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\n \n # b. working: state space (m,n,k) \n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\n\n par.Nn = par.Nm\n par.n_max = par.m_max + par.n_add\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\n\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\n\n # c. working: w interpolant (and wa and wb and wq)\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\n par.a_max = par.m_max + par.a_add\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\n \n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\n par.b_max = par.n_max + par.b_add\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\n \n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\n \n # d. working: egm (seperate grids for each segment)\n \n if par.solmethod == 'G2EGM':\n\n # i. dcon\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\n \n # ii. acon\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\n par.a_acon = np.zeros(par.grid_b_acon.shape)\n par.b_acon = par.grid_b_acon\n\n # iii. con\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\n \n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\n\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\n par.a_con = np.zeros(par.c_con.shape)\n par.d_con = np.zeros(par.c_con.shape)\n \n elif par.solmethod == 'NEGM':\n\n par.grid_l = par.grid_m\n\n # e. shocks\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\n\n if par.Neta > 1:\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\n else:\n par.eta = np.ones(1)\n par.w_eta = np.ones(1)\n\n # f. timings\n par.time_work = np.zeros(par.T)\n par.time_w = np.zeros(par.T)\n par.time_egm = np.zeros(par.T)\n par.time_vfi = np.zeros(par.T)","def gaddpg_grasps_from_simulate_view(gaddpg, state, time, ef_pose):\n n = 30\n mask = get_target_mask(state[0][0])\n point_state = state[0][0][:, mask]\n\n # hand to base\n point_state = se3_transform_pc(ef_pose, point_state)\n print('target point shape', point_state.shape)\n # target center is in base coordinate now\n target_center = point_state.mean(1)[:3]\n print('target center', target_center)\n\n # set up gaddpg\n img_state = state[0][1]\n gaddpg.policy.eval()\n gaddpg.state_feature_extractor.eval()\n\n # sample view (simulated hand) in base\n view_poses = np.array(sample_ef_view_transform(n, 0.2, 0.5, target_center, linspace=True, anchor=True))\n\n # base to view (simulated hand)\n inv_view_poses = se3_inverse_batch(view_poses)\n transform_view_points = np.matmul(inv_view_poses[:,:3,:3], point_state[:3]) + inv_view_poses[:,:3,[3]]\n \n # gaddpg generate grasps\n point_state_batch = torch.from_numpy(transform_view_points).cuda().float()\n time = torch.ones(len(point_state_batch) ).float().cuda() * 10. # time\n point_state_batch = torch.cat((point_state_batch, torch.zeros_like(point_state_batch)[:, [0]]), dim=1)\n policy_feat = gaddpg.extract_feature(img_state, point_state_batch, value=False, time_batch=time) \n _,_,_,gaddpg_aux = gaddpg.policy.sample(policy_feat)\n \n # compose with ef poses \n gaddpg_aux = gaddpg_aux.detach().cpu().numpy()\n unpacked_poses = [unpack_pose_rot_first(pose) for pose in gaddpg_aux]\n goal_pose_ws = np.matmul(view_poses, np.array(unpacked_poses)) # grasp to ef\n planner_cfg.external_grasps = goal_pose_ws\n\n # show_grasps(view_poses, 'grasps')\n # planner_cfg.external_grasps = view_poses\n # planner_cfg.external_grasps = np.concatenate((goal_pose_ws, view_poses), axis=0) # also visualize view\n planner_cfg.use_external_grasp = True","def recreate_obstacles(self):\n self.board_matrix = np.full(Dimension.board_size(), 1)\n self.obstacles = self.create_obstacles()","def test_transition_function_empty_grid(self):\r\n map_file_path = os.path.abspath(os.path.join(__file__, MAPS_DIR, 'empty-8-8/empty-8-8.map'))\r\n grid = MapfGrid(parse_map_file(map_file_path))\r\n\r\n # agents are starting a\r\n agent_starts = ((0, 0), (7, 7))\r\n agents_goals = ((0, 2), (5, 7))\r\n\r\n env = MapfEnv(grid, 2, agent_starts, agents_goals,\r\n FAIL_PROB, REWARD_OF_CLASH, REWARD_OF_GOAL, REWARD_OF_LIVING, OptimizationCriteria.Makespan)\r\n\r\n first_step_transitions = [((round(prob, 2), collision), next_state, reward, done)\r\n for ((prob, collision), next_state, reward, done) in\r\n env.P[env.s][vector_action_to_integer((RIGHT, UP))]]\r\n\r\n self.assertEqual(set(first_step_transitions), {\r\n ((0.64, False), env.locations_to_state(((0, 1), (6, 7))), REWARD_OF_LIVING, False), # (RIGHT, UP)\r\n ((0.08, False), env.locations_to_state(((1, 0), (6, 7))), REWARD_OF_LIVING, False), # (DOWN, UP)\r\n ((0.08, False), env.locations_to_state(((0, 0), (6, 7))), REWARD_OF_LIVING, False), # (UP, UP)\r\n ((0.08, False), env.locations_to_state(((0, 1), (7, 7))), REWARD_OF_LIVING, False), # (RIGHT, RIGHT)\r\n ((0.08, False), env.locations_to_state(((0, 1), (7, 6))), REWARD_OF_LIVING, False), # (RIGHT, LEFT)\r\n ((0.01, False), env.locations_to_state(((1, 0), (7, 7))), REWARD_OF_LIVING, False), # (DOWN, RIGHT)\r\n ((0.01, False), env.locations_to_state(((1, 0), (7, 6))), REWARD_OF_LIVING, False), # (DOWN, LEFT)\r\n ((0.01, False), env.locations_to_state(((0, 0), (7, 7))), REWARD_OF_LIVING, False), # (UP, RIGHT)\r\n ((0.01, False), env.locations_to_state(((0, 0), (7, 6))), REWARD_OF_LIVING, False) # (UP, LEFT)\r\n })\r\n\r\n wish_state = env.locations_to_state(((0, 1), (6, 7)))\r\n second_step_transitions = [((round(prob, 2), collision), next_state, reward, done)\r\n for ((prob, collision), next_state, reward, done) in\r\n env.P[wish_state][vector_action_to_integer((RIGHT, UP))]]\r\n\r\n # [(0,0), (7,7)]\r\n self.assertEqual(set(second_step_transitions), {\r\n ((0.64, False), env.locations_to_state(((0, 2), (5, 7))), REWARD_OF_LIVING + REWARD_OF_GOAL, True),\r\n # (RIGHT, UP)\r\n ((0.08, False), env.locations_to_state(((1, 1), (5, 7))), REWARD_OF_LIVING, False), # (DOWN, UP)\r\n ((0.08, False), env.locations_to_state(((0, 1), (5, 7))), REWARD_OF_LIVING, False), # (UP, UP)\r\n ((0.08, False), env.locations_to_state(((0, 2), (6, 7))), REWARD_OF_LIVING, False), # (RIGHT, RIGHT)\r\n ((0.08, False), env.locations_to_state(((0, 2), (6, 6))), REWARD_OF_LIVING, False), # (RIGHT, LEFT)\r\n ((0.01, False), env.locations_to_state(((1, 1), (6, 7))), REWARD_OF_LIVING, False), # (DOWN, RIGHT)\r\n ((0.01, False), env.locations_to_state(((1, 1), (6, 6))), REWARD_OF_LIVING, False), # (DOWN, LEFT)\r\n ((0.01, False), env.locations_to_state(((0, 1), (6, 7))), REWARD_OF_LIVING, False), # (UP, RIGHT)\r\n ((0.01, False), env.locations_to_state(((0, 1), (6, 6))), REWARD_OF_LIVING, False) # (UP, LEFT)\r\n })","def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n hspc=(max_x-min_x)/x_divisions\n vspc=(max_y-min_y)/y_divisions\n\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%.1f\" % hval)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%.1f\" % vval)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def increased_obstacles_map(occupancy_grid):\n\n nb_rows = len(occupancy_grid)\n nb_cols = len(occupancy_grid[0])\n increased_occupancy_grid = np.zeros([nb_rows + 6, nb_cols + 6])\n\n for i in range(nb_rows):\n for j in range(nb_cols):\n\n if occupancy_grid[i, j] == OCCUPIED:\n increased_occupancy_grid[i:i + 7, j:j + 7] = np.ones([7, 7])\n\n final_occupancy_grid = increased_occupancy_grid[3:(LENGTH_case + 3), 3:(WIDTH_case + 3)]\n return final_occupancy_grid","def make_move(grid, n_columns, n_rows):\r\n # Generate the game grid to be manipulated\r\n new_grid = [[0] * (n_columns + 1) for i in range(n_rows + 1)]\r\n\r\n\r\n for i in range(n_rows):\r\n for j in range(n_columns):\r\n upper_left = grid[i-1][j-1] # neighbor to upper left of cell of interest\r\n upper = grid[i-1][j] # neighbor above cell of interest\r\n upper_right = grid[i-1][j+1] # neighbor to upper right of cell of interest\r\n left = grid[i][j-1] # neighbor to left of cell of interest\r\n right = grid[i][j+1] # neighbor to right of cell of interest\r\n bot_left = grid[i+1][j-1] # neighbor to bottom left cell of interest\r\n bot = grid[i+1][j] # neighbor below cell of interest\r\n bot_right = grid[i+1][j+1] # neighbor to bottom right of cell of interest\r\n\r\n # sum of the state of all neighbors\r\n on_neighbors = upper_left + upper + upper_right + left + right + bot_left + bot + bot_right\r\n\r\n # Any ON cell with fewer than two ON neighbors turns OFF\r\n if grid[i][j] == 1 and on_neighbors < 2:\r\n new_grid[i][j] = 0\r\n\r\n # Any ON cell with two or three ON neighbours stays ON\r\n elif grid[i][j] == 1 and (on_neighbors == 2 or on_neighbors == 3):\r\n new_grid[i][j] = 1\r\n\r\n # Any ON cell with more than three ON neighbors turns OFF\r\n elif grid[i][j] == 1 and on_neighbors > 3:\r\n new_grid[i][j] = 0\r\n\r\n # Any OFF cell with three ON neighbors turns ON\r\n elif grid[i][j] == 0 and on_neighbors == 3:\r\n new_grid[i][j] = 1\r\n\r\n return new_grid #manipulated game grid\r","def _get_observations(self):\n food = np.array(self.game.state.data.food.data)\n walls = np.array(self.game.state.data.layout.walls.data)\n map_shape = walls.shape\n capsules = self.game.state.data.capsules\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\n\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\n self.game.state.data.agentStates[1:]))\n gosts_scared = list(\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\n\n \"\"\"\n 0: empty,\n 1: wall,\n 2: food,\n 3: capsules,\n 4: ghost,\n 5: scared ghost,\n 6: pacman\n \"\"\"\n\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\n\n def select(l):\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\n\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\n\n def pos_to_relative_pos(pos):\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\n return None\n else:\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\n\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\n\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\n if (g_relative_pos is not None):\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\n ] = 5 if gosts_scared[i] else 4\n\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\n\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\n\n obs[0, 0] = 2 if np.any(\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\n obs[obs.shape[0]-1,\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\n\n obs[0, obs.shape[1] -\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\n\n # print(np.transpose(obs)[::-1, :])\n\n return obs","def proposal_assignments_det(rpn_rois, gt_boxes, gt_classes, image_offset, fg_thresh=0.5):\n fg_rois_per_image = int(np.round(ROIS_PER_IMG * FG_FRACTION))\n gt_img_inds = gt_classes[:, 0] - image_offset\n all_boxes = torch.cat([rpn_rois[:, 1:], gt_boxes], 0)\n ims_per_box = torch.cat([rpn_rois[:, 0].long(), gt_img_inds], 0)\n im_sorted, idx = torch.sort(ims_per_box, 0)\n all_boxes = all_boxes[idx]\n num_images = int(im_sorted[-1]) + 1\n labels = []\n rois = []\n bbox_targets = []\n for im_ind in range(num_images):\n g_inds = (gt_img_inds == im_ind).nonzero()\n if g_inds.dim() == 0:\n continue\n g_inds = g_inds.squeeze(1)\n g_start = g_inds[0]\n g_end = g_inds[-1] + 1\n t_inds = (im_sorted == im_ind).nonzero().squeeze(1)\n t_start = t_inds[0]\n t_end = t_inds[-1] + 1\n ious = bbox_overlaps(all_boxes[t_start:t_end], gt_boxes[g_start:g_end])\n max_overlaps, gt_assignment = ious.max(1)\n max_overlaps = max_overlaps.cpu().numpy()\n gt_assignment += g_start\n keep_inds_np, num_fg = _sel_inds(max_overlaps, fg_thresh, fg_rois_per_image, ROIS_PER_IMG)\n if keep_inds_np.size == 0:\n continue\n keep_inds = torch.LongTensor(keep_inds_np)\n labels_ = gt_classes[:, 1][gt_assignment[keep_inds]]\n bbox_target_ = gt_boxes[gt_assignment[keep_inds]]\n if num_fg < labels_.size(0):\n labels_[num_fg:] = 0\n rois_ = torch.cat((im_sorted[t_start:t_end, None][keep_inds].float(), all_boxes[t_start:t_end][keep_inds]), 1)\n labels.append(labels_)\n rois.append(rois_)\n bbox_targets.append(bbox_target_)\n rois = torch.cat(rois, 0)\n labels = torch.cat(labels, 0)\n bbox_targets = torch.cat(bbox_targets, 0)\n return rois, labels, bbox_targets","def solve_puzzle(self):\r\n \r\n counter = 0\r\n rows = self._height-1\r\n cols = self._width-1\r\n # print rows, cols\r\n # print 'The greed has %s rows and %s coloumn indexes' %(rows, cols) \r\n solution_move = ''\r\n if self.get_number(0,0) == 0 and \\\r\n self.get_number(0,1) == 1:\r\n # print 'Congrads Puxxle is Aolved at start!!!!!'\r\n return ''\r\n #appropriate_number = (self._height * self._width) - 1\r\n appropriate_number = (rows+1) * (cols+1) -1\r\n # print 'First appropriate_number=',appropriate_number\r\n # print \"Grid first tile that we will solwing has value =\", self._grid[rows][cols]\r\n \r\n while counter < 300:\r\n counter +=1\r\n # print self\r\n #appropriate_number = (rows+1) * (cols+1) -1\r\n # print 'Appropriate number in loop=',appropriate_number\r\n # print 'We are solving %s index_row and %s index_col' %(rows, cols) \r\n ####Case when we use solve_interior_tile\r\n if rows > 1 and cols > 0:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n cols -= 1\r\n appropriate_number -=1\r\n else:\r\n # print 'We are solving interior tile', (rows, cols)\r\n solution_move += self.solve_interior_tile(rows, cols)\r\n # print 'Solution move=', solution_move\r\n cols -= 1\r\n #### Case when we use solve_col0_tile\r\n elif rows > 1 and cols == 0:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows -= 1\r\n cols = self._width-1\r\n appropriate_number -=1\r\n else:\r\n # print 'We are solwing tile 0 in row', rows\r\n # print 'Appropriate number here ='\r\n solution_move += self.solve_col0_tile(rows)\r\n # print 'Solution move=', solution_move\r\n rows -=1\r\n cols = self._width-1\r\n\r\n\r\n #### Cases when we use solve_row0_tile\r\n elif rows == 1 and cols > 1:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows -= 1\r\n #cols = self._width-1\r\n appropriate_number -= self._width\r\n\r\n else:\r\n # print 'Solving upper 2 rows right side'\r\n solution_move += self.solve_row1_tile(cols)\r\n rows -=1\r\n appropriate_number -= self._width\r\n #### Cases when we use solve_row1_tile \r\n if rows < 1 and cols > 1:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows += 1\r\n cols -= 1\r\n appropriate_number +=self._width-1\r\n else:\r\n # print '(1,J) tile solved, lets solwe tile (0,j) in tile',(rows,cols)\r\n # print 'Greed after move solve_row1_tile'\r\n # print self\r\n solution_move += self.solve_row0_tile(cols)\r\n rows +=1\r\n cols -=1\r\n appropriate_number +=self._width-1\r\n\r\n\r\n #### Case when we use solve_2x2\r\n elif rows <= 1 and cols <= 1:\r\n # print 'We are solving 2x2 puzzle'\r\n solution_move += self.solve_2x2()\r\n if self._grid[0][0] == 0 and \\\r\n self._grid[0][1] == 1:\r\n # print 'Congrads Puxxle is SOLVED!!!!!'\r\n break\r\n\r\n\r\n\r\n\r\n if counter > 100:\r\n # print 'COUNTER BREAK'\r\n break\r\n # print solution_move, len(solution_move)\r\n return solution_move\r\n\r\n\r\n\r\n\r\n\r\n\r\n # for row in solution_greed._grid[::-1]:\r\n # print solution_greed._grid\r\n # print 'Row =',row\r\n \r\n # if solution_greed._grid.index(row) > 1:\r\n # print \"Case when we solwing Interior and Tile0 part\"\r\n \r\n\r\n # for col in solution_greed._grid[solution_greed._grid.index(row)][::-1]:\r\n # print 'Coloumn value=', col\r\n #print row[0]\r\n # if col !=row[0]:\r\n # print 'Case when we use just Interior tile solution'\r\n # print solution_greed._grid.index(row)\r\n # print row.index(col)\r\n \r\n # solution += solution_greed.solve_interior_tile(solution_greed._grid.index(row) , row.index(col))\r\n # print 'Solution =', solution\r\n # print self \r\n # print solution_greed._grid\r\n # elif col ==row[0]:\r\n # print 'Case when we use just Col0 solution'\r\n\r\n # else:\r\n # print 'Case when we solwing first two rows'\r\n\r\n #return \"\"\r","def outcome(self, g):\n if g[0][0] == g[1][0] == g[2][0] and g[0][0] != 0:\n return g[0][0]\n if g[0][1] == g[1][1] == g[2][1] and g[0][1] != 0:\n return g[0][1]\n if g[0][2] == g[1][2] == g[2][2] and g[0][2] != 0:\n return g[0][2]\n if g[0][0] == g[0][1] == g[0][2] and g[0][0] != 0:\n return g[0][0]\n if g[1][0] == g[1][1] == g[1][2] and g[1][0] != 0:\n return g[1][0]\n if g[2][0] == g[2][1] == g[2][2] and g[2][0] != 0:\n return g[2][0]\n if g[0][0] == g[1][1] == g[2][2] and g[0][0] != 0:\n return g[0][0]\n if g[0][2] == g[1][1] == g[2][0] and g[0][2] != 0:\n return g[0][2]\n return 0","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def climb_tree():\n global UP_TREE\n westdesc = \"\"\n eastdesc = \"\"\n northdesc = \"\"\n southdesc = \"\"\n UP_TREE = True\n westinvalid = False\n eastinvalid = False\n northinvalid = False\n southinvalid = False\n\n\n printmessage(\"You climb the large tree to get a look at your surroundings.\", 5, MAGENTA, 2)\n\n if ZERO_BASE_PLYR_POS in range(0, 10):\n northinvalid = True\n if ZERO_BASE_PLYR_POS in range(90, 100):\n southinvalid = True\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\n eastinvalid = True\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\n westinvalid = True\n \n if not westinvalid: \n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\n if HAS_COMPASS: \n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \"Y\"\n if westpos == 10: # Water\n westdesc = TREE_VIEWS[2]\n else:\n westdesc = TREE_VIEWS[1]\n\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\n if westpos == 1:\n westdesc = TREE_VIEWS[3]\n elif westpos == 2:\n westdesc = TREE_VIEWS[4]\n else:\n westdesc = TREE_VIEWS[5]\n\n if not eastinvalid:\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \"Y\"\n if eastpos == 10: # Water\n eastdesc = TREE_VIEWS[2]\n else:\n eastdesc = TREE_VIEWS[1]\n\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\n if eastpos == 1:\n eastdesc = TREE_VIEWS[3]\n elif eastpos == 2:\n eastdesc = TREE_VIEWS[4]\n else:\n eastdesc = TREE_VIEWS[6]\n\n\n if not northinvalid:\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \"Y\"\n if northpos == 10: # Water\n northdesc = TREE_VIEWS[2]\n else:\n northdesc = TREE_VIEWS[1]\n\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\n if northpos == 1: # bear\n northdesc = TREE_VIEWS[3]\n elif northpos == 2: # grizzly\n northdesc = TREE_VIEWS[4]\n else:\n northdesc = TREE_VIEWS[7]\n\n\n if not southinvalid:\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \"Y\"\n if southpos == 10: # Water\n southdesc = TREE_VIEWS[2]\n else:\n southdesc = TREE_VIEWS[1]\n\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\n if southpos == 1: # bear\n southdesc = TREE_VIEWS[3]\n elif southpos == 2: # grizzly\n southdesc = TREE_VIEWS[4]\n else:\n southdesc = TREE_VIEWS[8]\n\n clear_messages(0)\n printmessage(\"West: \" + westdesc, 2, GREEN, 0)\n printmessage(\"East: \" + eastdesc, 3, YELLOW, 0)\n printmessage(\"North: \" + northdesc, 4, CYAN, 0)\n printmessage(\"South: \" + southdesc, 5, MAGENTA, 0)\n #show_movement(True, 10)\n update_player_on_map()\n pause_for_keypress()\n clear_messages(0)","def test_no_backg_subt():\n \n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\n test_object.calculate_r_i(correct=True, plot_i=False, thr=80)","def buildpuzzle(self):\r\n self.puzzle = copy.deepcopy(self.rows)\r\n if self.difficulty == 1:\r\n self.removedigits(1)\r\n if self.difficulty == 2:\r\n self.removedigits(2)\r\n if self.difficulty == 3:\r\n self.removedigits(3)","def main_loop(self):\n for iteration in xrange(1, self.num_iterations + 1):\n print \"At iteration %d\" % iteration\n self.it_num = iteration\n \n ### Select cells randomly without replacement\n x, y = np.meshgrid(np.arange(self.x_len), np.arange(self.y_len))\n \n x = x.flat\n y = y.flat\n \n shuffled_indices = np.random.permutation(np.arange(self.x_len * self.y_len))\n \n for index in shuffled_indices:\n # Get the current y and x indices\n cur_y, cur_x = y[index], x[index]\n \n \n if self.altered == False:\n # Use the standard version\n if self.grid[cur_y, cur_x] == 0:\n # If there's no slab there then we can't erode it!\n continue\n else:\n # Use the altered version of checking if we can erde\n if self.grid[cur_y, cur_x] == self.depth[cur_y, cur_x]:\n # We can't erode it, so continue\n continue\n \n # Check to see if the cell is in shadow.\n if self.cell_in_shadow(cur_y, cur_x):\n # If it's in shadow then we can't erode it, so go to the next random cell \n continue\n \n if True:\n # Move a slab\n self.grid[cur_y, cur_x] -= 1\n \n orig_y, orig_x = cur_y, cur_x\n \n # Loop forever - until we break out of it\n while True:\n new_y, new_x = cur_y, self.add_x(cur_x, self.jump_length)\n \n if self.grid[new_y, new_x] == 0:\n prob = self.pd_ns\n else:\n prob = self.pd_s\n \n if np.random.random_sample() <= prob:\n # Drop cell\n break\n else:\n cur_y, cur_x = new_y, new_x\n \n #print \"Dropping on cell\"\n #print new_y, new_x\n # Drop the slab on the cell we've got to\n self.grid[new_y, new_x] += 1\n \n self.do_repose(orig_y, orig_x)\n \n self.do_repose(new_y, new_x)\n \n self.write_file()","def drawValidationNeedles(self): \n #productive #onButton\n profprint()\n # reset report table\n # print \"Draw manually segmented needles...\"\n #self.table =None\n #self.row=0\n self.initTableView()\n self.deleteEvaluationNeedlesFromTable()\n while slicer.util.getNodes('manual-seg*') != {}:\n nodes = slicer.util.getNodes('manual-seg*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)\n \n if self.tableValueCtrPt==[[]]:\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\n nbNode=modelNodes.GetNumberOfItems()\n for nthNode in range(nbNode):\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\n if modelNode.GetAttribute(\"ValidationNeedle\") == \"1\":\n needleNumber = int(modelNode.GetAttribute(\"NeedleNumber\"))\n needleStep = int(modelNode.GetAttribute(\"NeedleStep\"))\n coord=[0,0,0]\n modelNode.GetFiducialCoordinates(coord)\n self.tableValueCtrPt[needleNumber][needleStep]=coord\n print needleNumber,needleStep,coord\n # print self.tableValueCtrPt[needleNumber][needleStep]\n\n for i in range(len(self.tableValueCtrPt)):\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\n colorVar = random.randrange(50,100,1)/float(100)\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\n self.addNeedleToScene(controlPoints,i,'Validation')\n else:\n # print i\n pass","def reset(self):\n\n self.x = np.random.randint(3, self.grid_size-3, size=1)[0]\n self.y = np.random.randint(3, self.grid_size-3, size=1)[0]\n \n self.h_x = []\n self.h_y = []\n for i in range(self.hunters):\n x = np.random.randint(3, self.grid_size-3, size=1)[0]\n y = np.random.randint(3, self.grid_size-3, size=1)[0]\n self.h_x.append(x)\n self.h_y.append(y)\n\n self.trajectory = np.zeros((self.grid_size,self.grid_size))\n\n bonus = 0.5 * np.random.binomial(1,self.temperature,size=self.grid_size**2)\n bonus = bonus.reshape(self.grid_size,self.grid_size)\n\n malus = -1.0 * np.random.binomial(1,self.temperature,size=self.grid_size**2)\n malus = malus.reshape(self.grid_size, self.grid_size)\n\n self.to_draw = np.zeros((self.max_time+2, self.grid_size*self.scale, self.grid_size*self.scale, 3))\n\n\n malus[bonus>0]=0\n\n self.board = bonus + malus\n\n self.position = np.zeros((self.grid_size, self.grid_size))\n self.position[0:2,:]= -1\n self.position[:,0:2] = -1\n self.position[-2:, :] = -1\n self.position[:, -2:] = -1\n self.board[self.x,self.y] = 0\n self.t = 0\n \n self.board_with_hunters[:,:] = 0\n \n for i in range(self.hunters):\n self.board_with_hunters[self.h_x[i],self.h_y[i]] = -100\n \n\n global_state = np.concatenate((\n self.board.reshape(self.grid_size, self.grid_size,1),\n self.position.reshape(self.grid_size, self.grid_size,1),\n self.trajectory.reshape(self.grid_size, self.grid_size,1),\n self.board_with_hunters.reshape(self.grid_size, self.grid_size,1)),axis=2)\n\n state = global_state[self.x - 2:self.x + 3, self.y - 2:self.y + 3, :]\n return state","def createStabilizedView():\n global cc\n y = b.createNode('StartStabilized')\n dd = b.createNode('Dot', '', False)\n de = b.createNode('Dot', '', False)\n w = b.createNode('EndStabilized')\n if cc:\n y = gV(y)\n w = gX(w)\n y['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\n w['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\n w.connectInput(2, y)\n stabilizedPrecompNode___connectPrecompNodes(y, w)\n cd = 250\n df = 250\n ez = 50\n eA = 7\n cP(dd)\n de.setSelected(True)\n eB = b.nodes.BackdropNode(xpos=y.xpos() + cd / 2, bdwidth=cd * 1.5, ypos=y.ypos() - ez, bdheight=df + 2 * ez,\n tile_color=int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16),\n note_font_color=4294967040, note_font_size=36, name='MochaImport+')\n eB['label'].setValue('Stabilized View+')\n dd.setXpos(y.xpos() + cd)\n dd.setYpos(y.ypos() + eA)\n de.setXpos(y.xpos() + cd)\n de.setYpos(y.ypos() + df + eA)\n w.setXpos(y.xpos())\n w.setYpos(y.ypos() + df)\n eB['help'].setValue(\n \"\\n<h2>Basic Usage of Stabilized View Rig</h2>\\n<ol>\\n<li>From the MochaImport+ menu, create the stabilized view rig consisting of the StartStabilized node, the EndStabilized node, and the Stabilized View Backdrop.</li>\\n<li>Load your mocha tracking data in the StartStabilized node.\\n</li><li>Do arbitrary manipulations in the Stabilized View by inserting new nodes inside the backdrop. All changes you do there in a stabilized setting will also be visible in your original perspective after the EndStabilized node.</li>\\n</ol>\\n\\n<h2>Lens Distortion</h2>\\n<p>If you've used the mocha Lens module to analyze the lens distortion of your clip, you need to do the following things to get an undistorted stabilized view and reapply the lens distortion to the final result:\\n</p><ul>\\n<li>make sure the mocha corner pin data you load into the StartStabilized node is exported from mocha Pro with the option 'Remove lens distortion'</li>\\n<li>as UndistMap input of the StartStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'undistort'.</li>\\n<li>as DistMap input of the EndStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'distort'.</li>\\n</ul>\".replace(\n '\\n', '').replace('\\r', ''))","def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\n\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\n \n \n for i in np.arange(0,SHP[0],1):\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\n \n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\n \n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\n\n # normalise lateral flow so that -ve= flow out of cells towards edges\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\n # fluxes if not normalised in this way.\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\n\n # nabla is the inverted delta operator used to denote the divergence \n # of a vector field, here applied to hydrological flow in m3/d \n # calculated as dx/dt + dy/dt + dz/dt\n\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\n \n # divergence gives net in/outflow in m3/t\n # cells/m3 = cells/mL *1000\n\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\n\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \n\n Cells[Cells<0] = 0\n \n CellColumnTot = Cells.sum(axis=1)\n \n\n return Cells, CellColumnTot","def decision(grid):\n child = Maximize((grid,0),-999999999,999999999)[0]\n Child = child.map\n g = grid.clone()\n for M in range(4):\n if g.move(M):\n if g.map == Child:\n # global prune\n # global pruneLog\n # pruneLog.append(prune)\n # print(prune)\n # print(sum(pruneLog)/len(pruneLog))\n return M\n g = grid.clone()","def create_matrices(maze, reward, penalty_s, penalty_l, prob):\n \n r, c = np.shape(maze)\n states = r*c\n p = prob\n q = (1 - prob)*0.5\n \n # Create reward matrix\n path = maze*penalty_s\n walls = (1 - maze)*penalty_l\n combined = path + walls\n \n combined[-1, -1] = reward\n \n R = np.reshape(combined, states)\n \n # Create transition matrix\n T_up = np.zeros((states, states))\n T_left = np.zeros((states, states))\n T_right = np.zeros((states, states))\n T_down = np.zeros((states, states))\n \n wall_ind = np.where(R == penalty_l)[0]\n\n for i in range(states):\n # Up\n if (i - c) < 0 or (i - c) in wall_ind :\n T_up[i, i] += p\n else:\n T_up[i, i - c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i+1] += q\n \n # Down\n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_down[i, i] += p\n else:\n T_down[i, i + c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i+1] += q\n \n # Left\n if i%c == 0 or (i - 1) in wall_ind:\n T_left[i, i] += p\n else:\n T_left[i, i-1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i + c] += q\n \n # Right\n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_right[i, i] += p\n else:\n T_right[i, i+1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i + c] += q\n \n T = [T_up, T_left, T_right, T_down] \n \n return T, R","def vision(image):\n vis_map = resize(image, alpha, beta)\n print(\"Resized map from the blue mask\")\n\n world = rotate(vis_map)\n\n plt.figure()\n plt.imshow(world[:, :, ::-1])\n plt.show()\n object_grid, occupancy_grid = detect_object(world)\n print(\"Result of the red mask\")\n plt.figure()\n plt.imshow(occupancy_grid)\n plt.show()\n return object_grid, occupancy_grid, world","def __generate_goal_board(self):\n element = 1\n array = []\n\n for row in range(self._n):\n row_to_append = []\n for col in range(self._n):\n row_to_append.append(element)\n element += 1\n array.append(row_to_append)\n\n array[self._n - 1][self._n - 1] = 0\n self._solved_board = Board(array=array, space=[self._n - 1, self._n - 1])","def examineMaze(self, gameState):\n w = self.walls.width\n h = self.walls.height\n walls = self.walls.deepCopy()\n food1 = self.getFoodYouAreDefending(gameState)\n food2 = self.getFood(gameState)\n\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\n for x in range(w):\n for y in range(h):\n if walls[x][y]:\n walls[x][y] = 0\n elif food1[x][y]:\n walls[x][y] = 2\n elif food2[x][y]:\n walls[x][y] = 2\n else:\n walls[x][y] = 1\n\n roomsDisplay = []\n # Detect doors and spaces. Spaces are now negative\n for x in range(w):\n for y in range(h):\n if walls[x][y] > 0:\n exitsNum = 0\n if walls[x][y - 1] != 0:\n exitsNum += 1\n if walls[x][y + 1] != 0:\n exitsNum += 1\n if walls[x - 1][y] != 0:\n exitsNum += 1\n if walls[x + 1][y] != 0:\n exitsNum += 1\n if exitsNum == 1 or exitsNum == 2:\n walls[x][y] = -1 * walls[x][y]\n roomsDisplay.append((x, y))\n elif exitsNum == 0:\n # We erase unaccessible cells\n walls[x][y] = 0\n else:\n # These are doors or big rooms, we leave them positive\n pass\n\n # Create roomsGraph: every room has a number, some cells and some doors\n roomsGraph = []\n doorsGraph = []\n for x in range(1, w - 1):\n for y in range(1, h - 1):\n if walls[x][y] < 0:\n spacesNum = 0\n if walls[x][y - 1] < 0:\n spacesNum += 1\n if walls[x][y + 1] < 0:\n spacesNum += 1\n if walls[x - 1][y] < 0:\n spacesNum += 1\n if walls[x + 1][y] < 0:\n spacesNum += 1\n if spacesNum < 2:\n endOfPath = False\n graphNode = {\"path\": [], \"doors\": [], \"food\": 0, \"isBig\": False}\n auxx = x\n auxy = y\n while not endOfPath:\n graphNode[\"path\"].append((x, y))\n graphNode[\"food\"] += -walls[x][y] - 1\n walls[x][y] = 0\n xx = x\n yy = y\n if walls[x][y - 1] < 0:\n yy = y - 1\n elif walls[x][y + 1] < 0:\n yy = y + 1\n elif walls[x - 1][y] < 0:\n xx = x - 1\n elif walls[x + 1][y] < 0:\n xx = x + 1\n else:\n endOfPath = True\n if walls[x][y - 1] > 0:\n if [(x, y - 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y - 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y - 1), []]))\n if walls[x][y + 1] > 0:\n if [(x, y + 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y + 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y + 1), []]))\n if walls[x - 1][y] > 0:\n if [(x - 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x - 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x - 1, y), []]))\n if walls[x + 1][y] > 0:\n if [(x + 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x + 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x + 1, y), []]))\n x = xx\n y = yy\n roomsGraph.append(graphNode)\n x = auxx\n y = auxy\n\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\n for j, door in enumerate(doorsGraph):\n for i, room in enumerate(roomsGraph):\n for aDoor in room[\"doors\"]:\n if aDoor == j:\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\n (x, y) = doorsGraph[j][0]\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\n adjacentDoors = []\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\n for p in adjacentCells:\n # Skip if wall\n if self.walls[p[0]][p[1]]:\n continue\n # Skip if door\n isRoom = False\n for room in doorsGraph[j][1]:\n if p in roomsGraph[room][\"path\"]:\n isRoom = True\n break\n if not isRoom:\n # Add if existing door\n doorFound = False\n for i, neighborDoor in enumerate(doorsGraph):\n if neighborDoor[0] == p:\n adjacentDoors.append(i)\n doorFound = True\n break\n # Create if non existing door and add\n if not doorFound:\n adjacentDoors.append(len(doorsGraph))\n doorsGraph.append([p, []])\n doorsGraph[j].append(adjacentDoors)\n\n # Create doorsDistance: maps what doors can be accessed from other doors\n roomsMapper = {}\n doorsMapper = {}\n isRoom = util.Counter()\n for i, door in enumerate(doorsGraph):\n doorsMapper[door[0]] = i\n isRoom[door[0]] = 0\n for i, room in enumerate(roomsGraph):\n for p in room[\"path\"]:\n roomsMapper[p] = i\n isRoom[p] = 1\n\n # Create self variables\n self.doorsGraph = doorsGraph\n self.roomsGraph = roomsGraph\n self.roomsMapper = roomsMapper\n self.doorsMapper = doorsMapper\n self.isRoom = isRoom\n\n # # Find dead ends (rooms with only one door)\n # deadRooms = {}\n # deadDoors = {}\n # # deaderDoors = {}\n # # deaderRooms = {}\n # for i, room in enumerate(roomsGraph):\n # if len(room[\"doors\"]) == 1:\n # deadRooms[i] = room[\"doors\"][0]\n # deadDoors[room[\"doors\"][0]] = 1\n # numdR = 0\n # aliveR = -1\n # for adjRoom in doorsGraph[room[\"doors\"][0]][1]:\n # if adjRoom not in deadRooms:\n # numdR += 1\n # aliveR = adjRoom\n # if numdR + len(doorsGraph[room[\"doors\"][0]][2]) == 1:\n # if aliveR >= 0:\n # deaderRooms[aliveR] = room[\"doors\"][0]\n # for adjDoor in roomsGraph[aliveR][\"doors\"]:\n # if adjDoor == room[\"doors\"][0]:\n # continue\n # deaderDoors[adjDoor] = 1.0\n # else:\n # deaderDoors[doorsGraph[room[\"doors\"][0]][2][0]] = 1.0\n\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deaderRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deaderDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, room in enumerate(roomsGraph):\n # numAliveDoors = 0\n # aliveDoor = 0\n # deadDoor = []\n # for door in room[\"doors\"]:\n # if door not in deadDoors:\n # numAliveDoors += 1\n # aliveDoor = door\n # else:\n # deadDoor.append(door)\n # if numAliveDoors == 1:\n # aliveRoom = 0\n # aliveNeighborDoor = 0\n # for door in deadDoor:\n # # aliveNeighborDoor += len(doorsGraph[door][2])\n # for neighborRoom in doorsGraph[door][1]:\n # if neighborRoom not in deadRooms:\n # aliveRoom += 1\n # if aliveRoom == len(deadDoor):\n # deadRooms[i] = aliveDoor\n # deadDoors[aliveDoor] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\n # for p in room[\"path\"]:\n # roomsCounter[1][p] = 1\n # for p in deadDoor:\n # roomsCounter[2][doorsGraph[p][0]] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, door in enumerate(doorsGraph):\n # if i not in deadDoors:\n # numOpenRooms = 0\n # openRoom = 0\n # for j, room in enumerate(door[1]):\n # if room not in deadRooms:\n # numOpenRooms += 1\n # openRoom = j\n # if numOpenRooms + len(door[2]) == 1:\n # for room in door[1]:\n # if room != openRoom:\n # deadRooms[room] = i\n # deadDoors[j] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][door[0]] = 1\n # for rr in door[1]:\n # print rr\n # if rr in deadRooms:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[1][p] = 1\n # else:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[3][p] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[1][(6, 9)] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deadRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deadDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # Show every room\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n for room in roomsGraph:\n for p in room[\"path\"]:\n if len(room[\"doors\"]) > 1:\n roomsCounter[0][p] = 0.4\n else:\n roomsCounter[2][p] = 0.4\n # Show every door\n for door in doorsGraph:\n roomsCounter[1][door[0]] = 0.4\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\n self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")","def robotGridSummaryDict(self):\n rgd = self.robotGridDict(incRobotDict=False)\n robotDict = {}\n for rid, robot in self.robotDict.items():\n r = {}\n # print(\"rid\", robot.id, robot.alpha, robot.beta)\n r[\"id\"] = robot.id\n r[\"nDecollide\"] = robot.nDecollide\n r[\"lastStepNum\"] = robot.lastStepNum\n r[\"assignedTargetID\"] = robot.assignedTargetID\n r[\"hasApogee\"] = robot.hasApogee\n r[\"hasBoss\"] = robot.hasBoss\n r[\"xPos\"] = robot.xPos\n r[\"yPos\"] = robot.yPos\n r[\"alpha\"] = robot.alpha\n r[\"beta\"] = robot.beta\n r[\"destinationAlpha\"] = robot.destinationAlpha\n r[\"desstinationBeta\"] = robot.destinationBeta\n r[\"angStep\"] = robot.angStep\n r[\"collisionBuffer\"] = robot.collisionBuffer\n\n # convert from numpy arrays to lists\n r[\"metFiberPos\"] = list(robot.metFiberPos)\n r[\"bossFiberPos\"] = list(robot.bossFiberPos)\n r[\"apFiberPos\"] = list(robot.apFiberPos)\n r[\"roughAlphaX\"] = robot.roughAlphaX[-1][-1]\n r[\"roughAlphaY\"] = robot.roughAlphaY[-1][-1]\n r[\"roughBetaX\"] = robot.roughBetaX[-1][-1]\n r[\"roughBetaY\"] = robot.roughBetaY[-1][-1]\n # find the step at which this\n # guy found its target\n # otv = np.array(robot.onTargetVec)\n # print(\"otargvec\", otv)\n # r[\"onTargetVec\"] = robot.onTargetVec[-1]\n # # find last False (after which must be true)\n # # +1 because step numbers start from 1 and indices start from 0\n # whereFalse = np.argwhere(otv==False).flatten()\n # if not whereFalse:\n # # empty list started on target? thats crazy\n # lastFalse = 0\n # else:\n # lastFalse = int(whereFalse[-1] + 1)\n # if lastFalse == len(otv):\n # # last step was false robot never got there\n # r[\"stepConverged\"] = str(-1 )# -1 incicates never got to target\n # else:\n # r[\"stepConverged\"] = str(lastFalse)\n robotDict[robot.id] = r\n\n rgd[\"robotDict\"] = robotDict\n return rgd","def set_bc(self, problem):\n bcs = problem.bcs\n n_bound = cfg.const['N_GHOST_CELLS']\n # Left X-b.c.\n for i in range(0, self.i_min):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[0] == 't': \n self.U[i][j][k] = self.U[self.i_min][j][k]\n elif bcs[0] == 'w':\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n else:\n print(\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right X-b.c.\n for i in range(self.i_max, self.i_max+n_bound):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[1] == 't':\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\n elif bcs[1] == 'w':\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_min):\n for k in range(self.k_min, self.k_max): \n if bcs[2] == 't':\n self.U[i][j][k] = self.U[i][self.j_min][k]\n elif bcs[2] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(self.j_max, self.j_max+n_bound):\n for k in range(self.k_min, self.k_max): \n if bcs[3] == 't':\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\n elif bcs[3] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(0, self.k_min): \n if bcs[4] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_min]\n elif bcs[4] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(self.k_max, self.k_max+n_bound):\n if bcs[5] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\n elif bcs[5] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")","def mover_bm_arriba(self):\n self.nueva_posicion_posible_parte_superior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0],\n self.casilla[1] - 1],\n [self.vertice_1[0] ,self.vertice_1[1] - self.velocidad],\n [self.vertice_1[0], self.vertice_1[1] - 5 -5])\n self.nueva_posicion_posible_parte_inferior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] + 1,\n self.casilla[1] - 1],\n [self.vertice_2[0] ,self.vertice_2[1] - self.velocidad],\n [self.vertice_1[0],self.vertice_1[1]])\n self.y -= self.velocidad * (self.y >= 15) *(self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1)\n self.posicion = [self.posicion[0],self.y]\n self.casilla = [self.casilla[0],self.casilla[1] - self.nueva_posicion_posible_parte_superior[1] * (self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1)]\n self.redefinir_vertices()","def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\n\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n\n #this is just printing stuff for easier terminal reading\n if h_agent is not None:\n hstr = \"Specialized Human\"\n else:\n hstr = \"Random Human\"\n if coagent is not None:\n coagenthelp = True\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\n else:\n coagenthelp = False\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\n\n liRewards = []\n liRewardsPenalized = []\n actionsctli =[]\n heatmap = np.zeros((7, 7))\n for i in range(episodes):\n grid.reset()\n actionct = 0\n misstepct = 0\n heatmap[0,0] += 1\n while (not grid.isEnd) and (grid.numSteps <=200):\n state = grid.state\n width = grid.getBoardDim()[0]\n state_ind = state[1]*(width+1)+state[0]\n\n if 'disjoint' in mode:\n actions = [0, 1, 2, 3]\n else:\n #'up','right','down','left','upri','dori','dole','uple'\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n #if we have a special human agent use it, if not use random human\n if h_agent is None:\n action = np.random.choice(actions, 1)[0]\n h_action = action\n else:\n action = h_agent.get_action(state_ind)\n h_action = action\n if coagenthelp:\n q_vals = coagent.get_q_values(state_ind)\n best_action = coagent.get_action(state_ind)\n best_q = q_vals[best_action]\n min_q = min(q_vals)\n human_q = q_vals[action]\n\n #closest actions dictionary\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\n #value = action index if radial\n #key = actual action index\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\n #actions in order of circle\n a_radial = [0,4,1,5,2,6,3,7]\n #co-pilot action choices\n #override to optimal if suboptimal action selected\n if \"override\" in mode:\n #random percent to decide when to help if wrong action taken\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\n actionct += 1\n action = best_action\n #select best closest action if human action q-value is negative\n elif mode == \"q-neg\" and human_q < 0:\n actionct += 1\n a_li = closest_a[action]\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\n #Shared Autonomy\n #select better closest action if difference between best q and human q is past some threshold\n elif mode == \"q-diff\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\n actionct += 1\n for i in range(1,5):\n radial_a = a_dist_ind[action]\n ccw_ra = (radial_a - i) % len(actions)\n ccw_a = a_radial[ccw_ra]\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = ccw_a\n break\n cw_ra = (radial_a + i) % len(actions)\n cw_a = a_radial[cw_ra]\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = cw_a\n break\n #take the potentiallny new action\n grid.step(action)\n\n if h_agent is not None:\n heatmap[grid.state[1],grid.state[0]] += 1\n\n #add metrics to their respective lists\n liRewards.append(grid.reward)\n liRewardsPenalized.append(grid.reward-actionct)\n actionsctli.append(actionct)\n #convert lists to numpy arrays\n rewards = np.array(liRewards)\n rewards_penalized = np.array(liRewardsPenalized)\n actionsctli = np.array(actionsctli)\n #print some metrics if we want to\n if verbose:\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\n if h_agent is not None:\n plt.figure()\n print(heatmap)\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\n plt.savefig('two.png')\n\n return rewards, actionsctli, rewards_penalized","def getInitialObstacles():\n # hardcode number of blocks\n # will account for movemnet\n from random import choice\n from globals import TILEWIDTH, TILEHEIGHT, WINHEIGHT, TILEFLOORHEIGHT, LEVEL, HALFWINWIDTH\n\n no_of_blocks = 50\n for b in range(no_of_blocks // 2):\n # get image\n # image = globals.IMAGESDICT['rock']\n for y in range(1,5):\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\n # make rect\n spaceRect = pygame.Rect((b * TILEWIDTH, y * TILEFLOORHEIGHT, TILEWIDTH, TILEFLOORHEIGHT))\n landscape = Landscape(image, spaceRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n image = globals.IMAGESDICT['corner']\n negativeRect = pygame.Rect([-150, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEHEIGHT])\n landscape = Landscape(image, negativeRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n image = globals.IMAGESDICT['corner']\n positiveRect = pygame.Rect([LEVEL[0] - TILEWIDTH, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\n landscape = Landscape(image, positiveRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n bottomRect = pygame.Rect([HALFWINWIDTH, LEVEL[1] - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\n landscape = Landscape(image, bottomRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n for x in range(0, LEVEL[0], 50):\n for y in range(10):\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\n spaceRect = pygame.Rect((x, LEVEL[1] - (y * TILEHEIGHT), TILEWIDTH, TILEFLOORHEIGHT))\n landscape = Landscape(image, spaceRect)\n if choice([0,1,0]):\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n\n return","def rel_assignments(im_inds, rpn_rois, roi_gtlabels, gt_boxes, gt_classes, gt_rels, image_offset, fg_thresh=0.5, num_sample_per_gt=4, filter_non_overlap=True):\n fg_rels_per_image = int(np.round(REL_FG_FRACTION * 64))\n pred_inds_np = im_inds.cpu().numpy()\n pred_boxes_np = rpn_rois.cpu().numpy()\n pred_boxlabels_np = roi_gtlabels.cpu().numpy()\n gt_boxes_np = gt_boxes.cpu().numpy()\n gt_classes_np = gt_classes.cpu().numpy()\n gt_rels_np = gt_rels.cpu().numpy()\n gt_classes_np[:, 0] -= image_offset\n gt_rels_np[:, 0] -= image_offset\n num_im = gt_classes_np[:, 0].max() + 1\n rel_labels = []\n num_box_seen = 0\n for im_ind in range(num_im):\n pred_ind = np.where(pred_inds_np == im_ind)[0]\n gt_ind = np.where(gt_classes_np[:, 0] == im_ind)[0]\n gt_boxes_i = gt_boxes_np[gt_ind]\n gt_classes_i = gt_classes_np[gt_ind, 1]\n gt_rels_i = gt_rels_np[gt_rels_np[:, 0] == im_ind, 1:]\n pred_boxes_i = pred_boxes_np[pred_ind]\n pred_boxlabels_i = pred_boxlabels_np[pred_ind]\n ious = bbox_overlaps(pred_boxes_i, gt_boxes_i)\n is_match = (pred_boxlabels_i[:, None] == gt_classes_i[None]) & (ious >= fg_thresh)\n pbi_iou = bbox_overlaps(pred_boxes_i, pred_boxes_i)\n if filter_non_overlap:\n rel_possibilities = (pbi_iou < 1) & (pbi_iou > 0)\n rels_intersect = rel_possibilities\n else:\n rel_possibilities = np.ones((pred_boxes_i.shape[0], pred_boxes_i.shape[0]), dtype=np.int64) - np.eye(pred_boxes_i.shape[0], dtype=np.int64)\n rels_intersect = (pbi_iou < 1) & (pbi_iou > 0)\n rel_possibilities[pred_boxlabels_i == 0] = 0\n rel_possibilities[:, pred_boxlabels_i == 0] = 0\n fg_rels = []\n p_size = []\n for i, (from_gtind, to_gtind, rel_id) in enumerate(gt_rels_i):\n fg_rels_i = []\n fg_scores_i = []\n for from_ind in np.where(is_match[:, from_gtind])[0]:\n for to_ind in np.where(is_match[:, to_gtind])[0]:\n if from_ind != to_ind:\n fg_rels_i.append((from_ind, to_ind, rel_id))\n fg_scores_i.append(ious[from_ind, from_gtind] * ious[to_ind, to_gtind])\n rel_possibilities[from_ind, to_ind] = 0\n if len(fg_rels_i) == 0:\n continue\n p = np.array(fg_scores_i)\n p = p / p.sum()\n p_size.append(p.shape[0])\n num_to_add = min(p.shape[0], num_sample_per_gt)\n for rel_to_add in npr.choice(p.shape[0], p=p, size=num_to_add, replace=False):\n fg_rels.append(fg_rels_i[rel_to_add])\n fg_rels = np.array(fg_rels, dtype=np.int64)\n if fg_rels.size > 0 and fg_rels.shape[0] > fg_rels_per_image:\n fg_rels = fg_rels[npr.choice(fg_rels.shape[0], size=fg_rels_per_image, replace=False)]\n elif fg_rels.size == 0:\n fg_rels = np.zeros((0, 3), dtype=np.int64)\n bg_rels = np.column_stack(np.where(rel_possibilities))\n bg_rels = np.column_stack((bg_rels, np.zeros(bg_rels.shape[0], dtype=np.int64)))\n num_bg_rel = min(64 - fg_rels.shape[0], bg_rels.shape[0])\n if bg_rels.size > 0:\n bg_rels = bg_rels[np.random.choice(bg_rels.shape[0], size=num_bg_rel, replace=False)]\n else:\n bg_rels = np.zeros((0, 3), dtype=np.int64)\n if fg_rels.size == 0 and bg_rels.size == 0:\n bg_rels = np.array([[0, 0, 0]], dtype=np.int64)\n all_rels_i = np.concatenate((fg_rels, bg_rels), 0)\n all_rels_i[:, 0:2] += num_box_seen\n all_rels_i = all_rels_i[np.lexsort((all_rels_i[:, 1], all_rels_i[:, 0]))]\n rel_labels.append(np.column_stack((im_ind * np.ones(all_rels_i.shape[0], dtype=np.int64), all_rels_i)))\n num_box_seen += pred_boxes_i.shape[0]\n rel_labels = torch.LongTensor(np.concatenate(rel_labels, 0))\n return rel_labels","def get_wm_ws_Gx_bot(self):\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \n z_u_r = self.grid_dict['z_u_r']\n z_u_w = self.grid_dict['z_u_w']\n [Ly,N] = self.b.shape\n #---> j-loop\n for j in range(Ly): \n self.kbl[j] = N # initialize search\n #-> end j-loop\n\n #--> k-loop\n for k in range(N-1,0,-1):\n k_w = k\n k_r = k-1\n # --> j loop \n for j in range(Ly):\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\n self.kbl[j] = k_w\n\n #--> end k\n # --> end j\n\n\n '''\n Compute nondimenisonal shape function coefficeints Gx() by\n matching values and vertical derivatives of interior mixing\n coefficients at hbbl (sigma=1)\n '''\n\n self.Gm1_bot = np.zeros([Ly])\n self.dGm1_dS_bot = np.zeros([Ly])\n self.Gt1_bot = np.zeros([Ly])\n self.dGt1_dS_bot = np.zeros([Ly]) \n self.Av_bl_bot = np.zeros([Ly])\n self.dAv_bl_bot = np.zeros([Ly]) \n self.cff_up_bot = np.zeros([Ly])\n self.cff_dn_bot = np.zeros([Ly])\n\n\n\n\n\n self.wm_bot = np.zeros([Ly])\n self.ws_bot = np.zeros([Ly]) \n\n # CALCULATE ustar for the bottom based on bototm velocities\n \n \n \n # CALCULATE r_D\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \n u = self.u\n v_upts = TTTW_func.v2u(self.v)\n \n ubar = np.mean(u,axis=1)\n vbar = np.mean(v_upts,axis=1)\n\n # --> j loop\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n if self.CD_SWITCH:\n # DEPTH AVERAGED APPROACH\n uref = u[j,0]\n vref = v_upts[j,0]\n ustar2 = self.C_D * (uref**2 + vref**2)\n else:\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n\n self.wm_bot[j] = wm\n self.ws_bot[j] = ws\n \n k_w = self.kbl[j] \n z_bl = z_u_w[j,0] + self.hbbl[j]\n\n if z_bl < z_u_w[j,k_w-1]:\n k_w = k_w-1\n\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl_bot[j] = Av_bl\n self.dAv_bl_bot[j] = dAv_bl\n\n\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\n\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])","def update_grid(self, x):\r\n\r\n # Append boundary rows and columns to matrix\r\n x = self.append_boundary(x) # the boundary is recomputed at each step\r\n y = np.copy(x)\r\n\r\n # For each cell within boundary, compute state according to rules.\r\n chg_0_1 = 0 # the number of cells that changed from state 0 to state 1\r\n chg_1_0 = 0 # the number of cells that changes from state 1 to state 0\r\n chg_none = 0 # the number of cells that did not change\r\n index = np.arange(1, x.shape[0] - 1)\r\n for i in index:\r\n for j in index:\r\n neighborhood = x[i - 1:i + 2:1, j - 1:j + 2:1] # 3x3 sub matrix centered at i, j\r\n y[i, j] = self.update_cell(neighborhood)\r\n change = int(y[i, j] - x[i, j])\r\n if change == -1:\r\n chg_1_0 += 1\r\n if change == 0:\r\n chg_none += 1\r\n if change == 1:\r\n chg_0_1 += 1\r\n\r\n # Compute statistics excluding boundary\r\n total = np.power(x[1:-1:1, 1:-1:1].shape[0] - 1, 2)\r\n start_1 = np.sum(x[1:-1:1, 1:-1:1])\r\n end_1 = np.sum(y[1:-1:1, 1:-1:1])\r\n stats = [total, start_1, end_1, chg_1_0, chg_none, chg_0_1]\r\n\r\n return y[1:-1:1, 1:-1:1], stats # remove the boundary\r","def get_ground_truth_gate_poses_and_half_dims(self):\n gate_names_sorted_bad = sorted(self.airsim_client.simListSceneObjects(\"Gate.*\"))\n assert len(gate_names_sorted_bad) > 0, \"ERROR: the gate list returned by simListSceneObjects is empty\"\n gate_indices_bad = [int(gate_name.split('_')[0][4:]) for gate_name in gate_names_sorted_bad]\n gate_indices_correct = sorted(range(len(gate_indices_bad)), key=lambda k: gate_indices_bad[k])\n gate_names_sorted = [gate_names_sorted_bad[gate_idx] for gate_idx in gate_indices_correct]\n nominal_inner_dims = self.airsim_client.simGetNominalGateInnerDimensions()\n res = []\n for gate_name in gate_names_sorted:\n p = self.airsim_client.simGetObjectPose(object_name=gate_name)\n s = self.airsim_client.simGetObjectScale(object_name=gate_name)\n # print(f\"DEBUG: gate {gate_name}\")\n # print(f\"DEBUG: scale {gate_name}: {s}\")\n cpt = 0\n while (math.isnan(p.position.x_val) or math.isnan(p.position.y_val) or math.isnan(p.position.z_val) or math.isnan(s.x_val) or math.isnan(s.y_val) or math.isnan(s.z_val)) and cpt < MAX_NUMBER_OF_GETOBJECTPOSE_TRIALS:\n print(f\"DEBUG: p for {gate_name} is {p}\")\n print(f\"DEBUG: s for {gate_name} is {s}\")\n print(f\"DEBUG: {gate_name} is nan, retrying...\")\n cpt += 1\n p = self.airsim_client.simGetObjectPose(gate_name)\n assert not math.isnan(p.position.x_val), f\"ERROR: {gate_name} p.position.x_val is still {p.position.x_val} after {cpt} trials\"\n assert not math.isnan(p.position.y_val), f\"ERROR: {gate_name} p.position.y_val is still {p.position.y_val} after {cpt} trials\"\n assert not math.isnan(p.position.z_val), f\"ERROR: {gate_name} p.position.z_val is still {p.position.z_val} after {cpt} trials\"\n assert not math.isnan(s.x_val), f\"ERROR: {gate_name} p.position.x_val is still {s.x_val} after {cpt} trials\"\n assert not math.isnan(s.y_val), f\"ERROR: {gate_name} p.position.y_val is still {s.y_val} after {cpt} trials\"\n assert not math.isnan(s.z_val), f\"ERROR: {gate_name} p.position.z_val is still {s.z_val} after {cpt} trials\"\n res.append([p, airsim.Vector3r(s.x_val * nominal_inner_dims.x_val / 2, s.y_val * nominal_inner_dims.y_val / 2, s.z_val * nominal_inner_dims.z_val / 2)])\n assert len(res) > 0, \"ERROR: the final gates list is empty\"\n return res, gate_names_sorted\n # return [self.airsim_client.simGetObjectPose(gate_name) for gate_name in gate_names_sorted]","def rectangular(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):\n\n from anuga.config import epsilon\n\n delta1 = float(len1)/m\n delta2 = float(len2)/n\n\n #Calculate number of points\n Np = (m+1)*(n+1)\n\n class Index(object):\n\n def __init__(self, n,m):\n self.n = n\n self.m = m\n\n def __call__(self, i,j):\n return j+i*(self.n+1)\n\n\n index = Index(n,m)\n\n points = num.zeros((Np, 2), float)\n\n for i in range(m+1):\n for j in range(n+1):\n\n points[index(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\n\n #Construct 2 triangles per rectangular element and assign tags to boundary\n #Calculate number of triangles\n Nt = 2*m*n\n\n\n elements = num.zeros((Nt, 3), int)\n boundary = {}\n nt = -1\n for i in range(m):\n for j in range(n):\n nt = nt + 1\n i1 = index(i,j+1)\n i2 = index(i,j)\n i3 = index(i+1,j+1)\n i4 = index(i+1,j)\n\n\n #Update boundary dictionary and create elements\n if i == m-1:\n boundary[nt, 2] = 'right'\n if j == 0:\n boundary[nt, 1] = 'bottom'\n elements[nt,:] = [i4,i3,i2] #Lower element\n nt = nt + 1\n\n if i == 0:\n boundary[nt, 2] = 'left'\n if j == n-1:\n boundary[nt, 1] = 'top'\n elements[nt,:] = [i1,i2,i3] #Upper element\n\n return points, elements, boundary","def prepare_roidb(self):\n # for pascal_voc dataset\n roidb = self.gt_roidb()\n # data argument\n if self.cfg.if_flipped is True:\n print('append flipped images to training')\n roidb = self.append_flipped_images(roidb)\n\n sizes = [PIL.Image.open(self.image_path_at(i)).size\n for i in range(self.num_images)]\n\n for i in range(len(self.image_index)):\n roidb[i]['image'] = self.image_path_at(i)\n roidb[i]['width'] = sizes[i][0]\n roidb[i]['height'] = sizes[i][1]\n # need gt_overlaps as a dense array for argmax\n gt_overlaps = roidb[i]['gt_overlaps'].toarray()\n # max overlap with gt over classes (columns)\n max_overlaps = gt_overlaps.max(axis=1)\n # gt class that had the max overlap\n max_classes = gt_overlaps.argmax(axis=1)\n roidb[i]['max_classes'] = max_classes\n roidb[i]['max_overlaps'] = max_overlaps\n # sanity checks\n # max overlap of 0 => class should be zero (background)\n zero_inds = np.where(max_overlaps == 0)[0]\n assert all(max_classes[zero_inds] == 0)\n # max overlap > 0 => class should not be zero (must be a fg class)\n nonzero_inds = np.where(max_overlaps > 0)[0]\n assert all(max_classes[nonzero_inds] != 0)\n\n self.roi_data = ROIGenerator(roidb, self.num_classes, self.cfg)\n return self.roi_data","def refresh_view(self):\n if self._step_number % 2 == 0:\n self._view.draw_enemies(self._game.enemies)\n self._view.draw_towers(self._game.towers)\n self._view.draw_obstacles(self._game.obstacles)","def backtracking(board):\n ##implementing this with reference to MRV \n ##also with forward checking \n if assignmentComplete(board) == True:\n solved_board = board \n return solved_board\n \n\n \n else:\n var, domains = select_MRV(board)\n domain = domains[var]\n \n \n ##now using propogation to check the values \n \n \n ## now implementing forward checking has no legal values \n \n ## we need to go through and check if appplying a particular variable leads to no possible variables for the correct columns, rows and squares\n new_domain = domain\n \n ##go through and select the correct value for the var \n for value in new_domain: \n \n if check_valid_insert(board, var, value) == True:\n board[var] = value \n result = backtracking(board)\n \n if result != \"Failure\":\n return result\n board[var] = 0\n \n return \"Failure\"","def grasp_planning(object, object_pose1_world, object_pose2_world,\n palm_pose_l_object, palm_pose_r_object, N=200, init=True):\n primitive_name = 'grasping'\n # 0. get initial palm poses in world frame\n palm_poses_initial_world = planning_helper.palm_poses_from_object(\n object_pose=object_pose1_world,\n palm_pose_l_object=palm_pose_l_object,\n palm_pose_r_object=palm_pose_r_object)\n\n grasp_width = planning_helper.grasp_width_from_palm_poses(\n palm_pose_l_object, palm_pose_r_object)\n # grasp_width = grasp_width/1.025\n # grasp_width = 0.086 - 0.006\n # grasp_width = 0.086\n # grasp_width = 0.05206\n # grasp_width = 0.135\n # print(\"grasp width: \" + str(grasp_width))\n\n # 1. get lifted object poses\n object_pose_lifted_world = copy.deepcopy(object_pose1_world)\n\n if init:\n object_pose_lifted_world.pose.position.z += 0.05\n # object_pose_lifted_world.pose.position.z += 0.05\n object_pose2_world.pose.position.z += 0.0025\n\n # 2. get lifted palm poses\n palm_poses_lifted_world = planning_helper.palm_poses_from_object(\n object_pose=object_pose_lifted_world,\n palm_pose_l_object=palm_pose_l_object,\n palm_pose_r_object=palm_pose_r_object)\n\n # 3. get rotated object pose\n object_pose_rotated_world = copy.deepcopy(object_pose2_world)\n\n # if init:\n # object_pose_rotated_world.pose.position.z += 0.05\n object_pose_rotated_world.pose.position.z += 0.05\n\n palm_poses_rotated_world = planning_helper.palm_poses_from_object(\n object_pose=object_pose_rotated_world,\n palm_pose_l_object=palm_pose_l_object,\n palm_pose_r_object=palm_pose_r_object)\n\n # 4. get final configuration\n palm_poses_final_world = planning_helper.palm_poses_from_object(\n object_pose=object_pose2_world,\n palm_pose_l_object=palm_pose_l_object,\n palm_pose_r_object=palm_pose_r_object)\n\n # 3. generate pose plans\n # 3.1. initialize plan\n initial_plan = planning_helper.initialize_plan(\n palm_poses_initial=palm_poses_initial_world,\n object_pose_initial=object_pose1_world,\n primitive=primitive_name,\n plan_name='initial_config')\n\n # 3.2. lift the object\n lift_plan = planning_helper.move_cart_synchro(\n palm_poses_final=palm_poses_lifted_world,\n grasp_width=grasp_width,\n plan_previous=initial_plan,\n primitive=primitive_name,\n plan_name='lift_object',\n N=10)\n\n # 3.3. rotate the object\n rotate_plan = planning_helper.move_cart_synchro(\n palm_poses_final=palm_poses_rotated_world,\n grasp_width=grasp_width,\n plan_previous=lift_plan,\n primitive=primitive_name,\n plan_name='rotate_object_final',\n N=N/2,\n is_replan=True)\n\n # 3.4. place the object\n place_plan = planning_helper.move_cart_synchro(\n palm_poses_final=palm_poses_final_world,\n grasp_width=grasp_width,\n plan_previous=rotate_plan,\n primitive=primitive_name,\n plan_name='place_object',\n N=20)\n return [lift_plan] + [rotate_plan] + [place_plan]","def abstract(res):\n o = r'\\begin{center}'\n #o += r'\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\n #o += r'\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\n o += r'\\begin{tikzpicture}' + '\\n'\n o += r'\\draw[blue!40!white] (0,0) rectangle (6,4); \\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\n'\n for i in range(res[7]):\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\n o += r'\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\n'\n o += r'\\end{tikzpicture}\\end{center}' + '\\n'\n\n o += r'\\begin{tabular}{|l|l|}' + '\\n' + r'\\hline' + '\\n'\n o += r'Election name& \\texttt{\"%s\"}\\\\'%res[1]\n o += r'Box number& \\texttt{%s}\\\\'%res[2]\n o += r'State& \\texttt{%s}\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\n o += r'Registration end& \\textit{%s}\\\\'%res[3]\n o += r'Vote closing& \\textit{%s}\\\\'%res[4]\n o += r'Casted/registered& $%s/%s$\\\\'%(res[7],res[6]) +'\\n'\n o += r'\\hline\\end{tabular}' + '\\n'\n o += r'\\quad' + '\\n'\n o += r'\\begin{tabular}{|l|l|}\\hline'\n l = res[8].items()\n l.sort(key = operator.itemgetter(1),reverse=True)\n n = 0\n for x in l:\n o += r'%s & %s\\\\'%(r'\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\texttt{%s}'%x[0],x[1]) \n if n == 0:\n o += r'\\hline' + '\\n'\n n += 1\n o += r'\\hline\\end{tabular}' + '\\n'\n\n\n #o += r'\\item The designer\\textquoteright s digital signature of this document (the source file \\texttt{oeu.py}) is: \\tiny $$\\verb!%s!$$ \\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\n'\n\n return r'\\begin{abstract}' + abstract.__doc__ + r'\\end{abstract}' + o","def visualize_reconstruction(maps_filename, timecourses_filename, data_filename, out_filename, mask_nib, hgap=20, vgap=20, nsamples=10):\n\n\tmaps = np.load(maps_filename)\n\ttimecourses = np.load(timecourses_filename)\n\tsubject_data = np.load(data_filename)\n\n\t(nframes, nvoxels) = subject_data.shape\n\n\trecon = timecourses.dot(maps)\n\n\tsamples = range(0, 1028, int(math.ceil(nframes / float(nsamples))))\n\n\t# draw the maps and timecourses into temporary files\n\tdata_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(nsamples)]\n\trecon_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(nsamples)]\n\n\tfor i in range(nsamples):\n\t\tplot_map(subject_data[samples[i],:], mask_nib, data_image_files[i])\n\t\tplot_map(recon[samples[i],:], mask_nib, recon_image_files[i])\n\n\tdata_images = [Image.open(fname) for fname in data_image_files]\n\trecon_images = [Image.open(fname) for fname in recon_image_files]\n\n\tim_width = data_images[0].size[0]\n\tim_height = data_images[0].size[1]\n\n\tresult_width = 2*im_width + hgap \n\tresult_height = nsamples * (im_height + vgap)\n\n\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\n\ty = 0\n\tfor (recon_image, data_image) in zip(recon_images, data_images):\n\t\tresult.paste(im=recon_image, box=(0, y))\n\t\tresult.paste(im=data_image, box=(im_width+hgap, y))\n\t\ty += im_height + vgap\n\n\tresult.save(out_filename)\n\n\tfor i in range(nsamples):\n\t\tos.remove(data_image_files[i])\n\t\tos.remove(recon_image_files[i])","def run_pass_2():\n global live_cells\n global cell_count\n global attempts\n global cell_age\n \n print(\"Live Cells : \" + str(len(live_cells)))\n \n live_cell_scores = [get_cart_score(c) for c in live_cells]\n live_cells_sorted = [x for _,x in sorted(zip(live_cell_scores,live_cells))]\n del live_cells[:]\n live_cells = live_cells + live_cells_sorted\n \n cell = live_cells.pop(0)\n if check_cart(c) and check_dead(c):\n voxel_data[cart_to_loc(cell)] = 1\n \n cell_age[cart_to_loc(c)] = cell_count\n \n \n cell_count += 1\n \n neighbors = [get_cart_neighbor(c,i) for i in range(6)]\n \n for n in neighbors:\n if check_cart(n) and check_dead(c) and not n in live_cells:\n live_cells.append(n)","def _get_observation(self, unseen=False):\n img_arr = p.getCameraImage(width=self._width,\n height=self._height,\n viewMatrix=self._view_matrix,\n projectionMatrix=self._proj_matrix)\n rgb = img_arr[2]\n depth = img_arr[3]\n min = 0.97\n max=1.0\n segmentation = img_arr[4]\n depth = np.reshape(depth, (self._height, self._width,1) )\n segmentation = np.reshape(segmentation, (self._height, self._width,1) )\n\n np_img_arr = np.reshape(rgb, (self._height, self._width, 4))\n np_img_arr = np_img_arr[:, :, :3].astype(np.float64)\n\n view_mat = np.asarray(self._view_matrix).reshape(4, 4)\n proj_mat = np.asarray(self._proj_matrix).reshape(4, 4)\n # pos = np.reshape(np.asarray(list(p.getBasePositionAndOrientation(self._objectUids[0])[0])+[1]), (4, 1))\n\n AABBs = np.zeros((len(self._objectUids), 2, 3))\n cls_ls = []\n \n for i, (_uid, _cls) in enumerate(zip(self._objectUids, self._objectClasses)):\n AABBs[i] = np.asarray(p.getAABB(_uid)).reshape(2, 3)\n cls_ls.append(NAME2IDX[_cls])\n\n # np.save('/home/tony/Desktop/obj_save/view_mat_'+str(self.img_save_cnt), view_mat)\n # np.save('/home/tony/Desktop/obj_save/proj_mat_'+str(self.img_save_cnt), proj_mat)\n # np.save('/home/tony/Desktop/obj_save/img_'+str(self.img_save_cnt), np_img_arr.astype(np.int16))\n # np.save('/home/tony/Desktop/obj_save/AABB_'+str(self.img_save_cnt), AABBs)\n # np.save('/home/tony/Desktop/obj_save/class_'+str(self.img_save_cnt), np.array(cls_ls))\n\n np.save(OUTPUT_DIR + '/image_' + str(self.img_save_cnt), np_img_arr.astype(np.int16))\n dets = np.zeros((AABBs.shape[0], 5))\n for i in range(AABBs.shape[0]):\n dets[i, :4] = self.get_2d_bbox(AABBs[i], view_mat, proj_mat, IM_HEIGHT, IM_WIDTH)\n dets[i, 4] = int(cls_ls[i])\n np.save(OUTPUT_DIR + '/annotation_'+str(self.img_save_cnt), dets)\n\n test = np.concatenate([np_img_arr[:, :, 0:2], segmentation], axis=-1)\n\n return test","def getGameState(self):\n ### Student code goes here\n row1 = ()\n row2 = ()\n row3 = ()\n for currRow in range(1,4):\n for currCol in range(1,4):\n tileFound = False\n for fact in self.kb.facts:\n if fact.statement.predicate == \"located\":\n tile = fact.statement.terms[0].term.element\n column = fact.statement.terms[1].term.element\n row = fact.statement.terms[2].term.element\n\n tileNumber = int(tile[-1])\n columnNumber = int(column[-1])\n rowNumber = int(row[-1])\n\n if rowNumber == currRow and columnNumber == currCol:\n tileFound = True\n if rowNumber == 1:\n row1 += tuple([tileNumber])\n elif rowNumber == 2:\n row2 += tuple([tileNumber])\n elif rowNumber == 3:\n row3 += tuple([tileNumber])\n \n break\n\n if not tileFound:\n if currRow == 1:\n row1 += tuple([-1])\n elif currRow == 2:\n row2 += tuple([-1])\n elif currRow == 3:\n row3 += tuple([-1])\n\n\n return (row1, row2, row3)","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if rooms==[]: return\n xcord=len(rooms)\n ycord=len(rooms[0])\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\n gatenum=1\n while indexstack != []:\n newindex=[]\n for item in indexstack:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=gatenum\n newindex.append((xpoint,ypoint))\n indexstack=newindex\n gatenum+=1\n ''''\n for item in index_0:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=1\n index_1.append((xpoint,ypoint))\n for item in index_1:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=2\n index_2.append((xpoint,ypoint))\n for item in index_2:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=3\n index_3.append((xpoint,ypoint))\n for item in index_3:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=4\n #index_3.append((xpoint,ypoint))'''","def draw_field_of_view(gameDisplay, hero):\n #Fill with black\n gameDisplay.fill(white)\n \n #Draw ground\n \n for x in range(visible_squares[0]):\n #From left to right <-> 0 to 16\n #\n for y in range(visible_squares[1]):\n g_x, g_y = l2g(x, y, hero)\n p_x, p_y = l2p(x, y)\n \n if not hero.Map.world[g_x][g_y]:\n \"\"\"This should only be the case if the player\n is within sight of the edge of earth\"\"\"\n pygame.draw.rect(gameDisplay, \n black, \n [p_x, p_y,square_size[0], square_size[1]]\n )\n \n elif hero.Map.world[g_x][g_y] == 1:\n pygame.draw.rect(gameDisplay, green, \n [p_x, p_y,square_size[0], square_size[1]])\n\n elif hero.Map.world[g_x][g_y] == 2:\n pygame.draw.rect(gameDisplay, bech, \n [p_x, p_y, square_size[0], square_size[1]])\n \n elif hero.Map.world[g_x][g_y] == 3:\n pygame.draw.rect(gameDisplay, blue, \n [p_x, p_y, square_size[0], square_size[1]])\n \n \n #pygame.draw.rect(gameDisplay, red, [px, py, square_size, square_size]) \n\n #draw_hero\n hero_px, hero_py = l2p(8, 8)\n \n pygame.draw.rect(gameDisplay, red, [hero_px, hero_py, \n square_size[0], square_size[1]])\n #gameDisplay.draw","def return_view(game, data):\n bike = data[\"bike\"]\n range_ = data[\"range\"]\n mono = data[\"mono\"]\n rotate = data[\"rotate\"]\n return {\"Board_view\": str(games.get_bike(game, bike, range_, mono=mono, rotate=rotate,\n compress=True)).replace(\"\\n\", \"\").replace(\"\\t\", \" \"),\n \"TimeStep\": games.get_timestep(game),\n \"Status\": games.games_status[game]['Status'],\n \"Alive\": \"alive\" if games.is_alive(game, bike) else \"death\"}","async def unwindGrid(fps):\n\n rg = homeGrid() # get a grid\n # overwrite the positions to the positions that the robots\n # are reporting\n for r in rg.robotDict.values():\n await fps.positioners[r.id].update_position()\n alpha, beta = fps.positioners[r.id].position\n r.setAlphaBeta(alpha, beta)\n\n forwardPath, reversePath = generatePath(rg)\n\n await fps.send_trajectory(reversePath)","def part2():\n grid[(0, 0)] = 1\n coordinates_value = 0\n layer = 1\n x = 0; y = 0\n done = False\n while not done:\n # print(\"Layer: \", layer)\n # go right one step\n layer += 1; x += 1\n grid[(x,y)] = check_neighbours((x,y))\n\n # go up to the boundary of layer\n for y_up in range(y+1, layer):\n coord = (x, y_up)\n coordinates_value = check_neighbours(coord)\n if coordinates_value > puzzle_input:\n return coordinates_value\n y = y_up\n\n # go left till the boundary of layer\n for x_left in range(x-1, -layer, -1):\n coord = (x_left, y)\n coordinates_value = check_neighbours(coord)\n if coordinates_value > puzzle_input:\n return coordinates_value\n x = x_left\n\n # go down till the boundary of layer\n for y_down in range(y-1, -layer, -1):\n coord = (x, y_down)\n coordinates_value = check_neighbours(coord)\n if coordinates_value > puzzle_input:\n return coordinates_value\n y = y_down\n\n # go right till the boundary of layer\n for x_right in range(x+1, layer):\n coord = (x_right, y)\n coordinates_value = check_neighbours(coord)\n if coordinates_value > puzzle_input:\n return coordinates_value\n x = x_right","def rectangular_periodic(m_g, n_g, len1_g=1.0, len2_g=1.0, origin_g = (0.0, 0.0)):\n\n processor = 0\n numproc = 1\n\n\n n = n_g\n m_low = -1\n m_high = m_g +1\n\n m = m_high - m_low\n\n delta1 = float(len1_g)/m_g\n delta2 = float(len2_g)/n_g\n\n len1 = len1_g*float(m)/float(m_g)\n len2 = len2_g\n origin = ( origin_g[0]+float(m_low)/float(m_g)*len1_g, origin_g[1] )\n\n #Calculate number of points\n Np = (m+1)*(n+1)\n\n class VIndex(object):\n\n def __init__(self, n,m):\n self.n = n\n self.m = m\n\n def __call__(self, i,j):\n return j+i*(self.n+1)\n\n class EIndex(object):\n\n def __init__(self, n,m):\n self.n = n\n self.m = m\n\n def __call__(self, i,j):\n return 2*(j+i*self.n)\n\n\n I = VIndex(n,m)\n E = EIndex(n,m)\n\n points = num.zeros( (Np,2), float)\n\n for i in range(m+1):\n for j in range(n+1):\n\n points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\n\n #Construct 2 triangles per rectangular element and assign tags to boundary\n #Calculate number of triangles\n Nt = 2*m*n\n\n\n elements = num.zeros( (Nt,3), int)\n boundary = {}\n Idgl = []\n Idfl = []\n Idgr = []\n Idfr = []\n\n full_send_dict = {}\n ghost_recv_dict = {}\n nt = -1\n for i in range(m):\n for j in range(n):\n\n i1 = I(i,j+1)\n i2 = I(i,j)\n i3 = I(i+1,j+1)\n i4 = I(i+1,j)\n\n #Lower Element\n nt = E(i,j)\n if i == 0:\n Idgl.append(nt)\n\n if i == 1:\n Idfl.append(nt)\n\n if i == m-2:\n Idfr.append(nt)\n\n if i == m-1:\n Idgr.append(nt)\n\n if i == m-1:\n if processor == numproc-1:\n boundary[nt, 2] = 'right'\n else:\n boundary[nt, 2] = 'ghost'\n\n if j == 0:\n boundary[nt, 1] = 'bottom'\n elements[nt,:] = [i4,i3,i2]\n\n #Upper Element\n nt = E(i,j)+1\n if i == 0:\n Idgl.append(nt)\n\n if i == 1:\n Idfl.append(nt)\n\n if i == m-2:\n Idfr.append(nt)\n\n if i == m-1:\n Idgr.append(nt)\n\n if i == 0:\n if processor == 0:\n boundary[nt, 2] = 'left'\n else:\n boundary[nt, 2] = 'ghost'\n if j == n-1:\n boundary[nt, 1] = 'top'\n elements[nt,:] = [i1,i2,i3]\n\n Idfl.extend(Idfr)\n Idgr.extend(Idgl)\n\n Idfl = num.array(Idfl, int)\n Idgr = num.array(Idgr, int)\n\n full_send_dict[processor] = [Idfl, Idfl]\n ghost_recv_dict[processor] = [Idgr, Idgr]\n\n\n return points, elements, boundary, full_send_dict, ghost_recv_dict","def recreate_grid(self):\n\n self.print_numlist = arcade.SpriteList()\n for row in range(ROW_COUNT):\n for column in range(COLUMN_COUNT):\n sprite = arcade.Sprite(\n f\"Numbers/{self.grid[row][column]}.png\", scale=0.2\n )\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\n sprite.center_x = x\n sprite.center_y = y\n self.print_numlist.append(sprite)\n # Check to see if all squares have been filled in\n if 0 not in self.grid:\n # if Cameron.Check_for_Completion(self.grid) == True:\n self.done = True","def next_round(self, old_round):\n new_round = np.copy(old_round) #copy of the old grid\n # for each square\n for i in range(Lx):\n for j in range(Ly):\n if old_round[i][j] == 0 : #if the cell is dead, it will live if it has 3 living neighbors.\n if self.sum_living_cell(i, j, old_round) == 3:\n new_round[i][j] = 1\n else:\n new_round[i][j] = 0\n if old_round[i][j] == 1 : #if the cell is alive, it won't dead if it has 2 or 3 living neighors.\n square_score = self.sum_living_cell(i, j, old_round)\n if square_score != 2 and square_score != 3 :\n new_round[i][j] = 0\n else:\n new_round[i][j] = 1\n return new_round","def outcome(self):\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\n return self.grid[0][1]\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\n return self.grid[0][2]\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\n return self.grid[1][0]\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\n return self.grid[2][0]\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\n return self.grid[0][2]\n return 0","def reduce_possibilities_by_box(self):\n x = self.targetCell.x\n y = self.targetCell.y\n if x < 3 and y < 3: #top left\n self.check_box1()\n if x > 2 and x < 6 and y < 3: #middle left\n self.check_box2()\n if x > 5 and y < 3: #bottom left\n self.check_box3()\n if x < 3 and y > 2 and y < 6: #top middle\n self.check_box4()\n if x > 2 and x < 6 and y > 2 and y < 6: #center\n self.check_box5()\n if x > 5 and y > 2 and y < 6: #bottom middle\n self.check_box6()\n if x < 3 and y > 5: #top right\n self.check_box7()\n if x > 2 and x < 6 and y > 5: #middle right\n self.check_box8()\n if x > 5 and y > 5: #bottom right\n self.check_box9()\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)","def obstacles(self):\r\n\r\n #Radious arround the head\r\n limit_sight = self.snake_sight\r\n head = self.body[0].position\r\n binary_map_complete = self.complete_mapping()\r\n map_matrix = np.matrix(binary_map_complete)\r\n obstacles = []\r\n\r\n #limits in all directions\r\n left_x = head[0] - limit_sight\r\n right_x = head[0] + limit_sight\r\n up_y = head[1] - limit_sight\r\n down_y = head[1] + limit_sight\r\n\r\n #submatrix with limits size\r\n snake_sight = map_matrix[up_y:down_y+1, left_x:right_x+1]\r\n\r\n #Special cases where the snake approximates to the borders\r\n ##Corners\r\n if left_x < 0 and up_y < 0:\r\n snake_sight = map_matrix[0:down_y+1, 0:right_x+1]\r\n interval_x = [self.limits[0] + left_x, self.limits[0]]\r\n interval_y = [self.limits[1] + up_y, self.limits[1]]\r\n interval_x_matrix = map_matrix[0:down_y+1, interval_x[0]:interval_x[1]]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], 0:right_x+1]\r\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\r\n temporal = np.c_[interval_x_y_matrix, interval_y_matrix]\r\n snake_sight = np.c_[interval_x_matrix, snake_sight]\r\n snake_sight = np.r_[temporal, snake_sight] \r\n return snake_sight\r\n \r\n if left_x < 0 and down_y > self.limits[1] - 1:\r\n snake_sight = map_matrix[up_y:self.limits[1], 0:right_x+1]\r\n interval_x = [self.limits[0] + left_x, self.limits[0]]\r\n interval_y = [0, down_y - self.limits[1] + 1]\r\n interval_x_matrix = map_matrix[up_y:self.limits[1], interval_x[0]:interval_x[1]]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], 0:right_x+1]\r\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\r\n temporal = np.c_[interval_x_y_matrix, interval_y_matrix]\r\n snake_sight = np.c_[interval_x_matrix, snake_sight]\r\n snake_sight = np.r_[snake_sight, temporal]\r\n return snake_sight\r\n \r\n if right_x > self.limits[0]-1 and up_y < 0:\r\n snake_sight = map_matrix[0:down_y+1, left_x:self.limits[0]]\r\n interval_x = [0, right_x - self.limits[0] + 1]\r\n interval_y = [self.limits[1] + up_y, self.limits[1]]\r\n interval_x_matrix = map_matrix[0:down_y+1, interval_x[0]:interval_x[1]]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:self.limits[0]]\r\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\r\n temporal = np.c_[interval_y_matrix, interval_x_y_matrix]\r\n snake_sight = np.c_[snake_sight, interval_x_matrix]\r\n snake_sight = np.r_[temporal, snake_sight]\r\n return snake_sight\r\n \r\n if right_x > self.limits[0]-1 and down_y > self.limits[1]-1:\r\n snake_sight = map_matrix[up_y:self.limits[1], left_x:self.limits[0]]\r\n interval_x = [0, right_x - self.limits[0] + 1]\r\n interval_y = [0, down_y - self.limits[1] + 1]\r\n interval_x_matrix = map_matrix[up_y:self.limits[1], interval_x[0]:interval_x[1]]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:self.limits[0]]\r\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\r\n temporal = np.c_[interval_y_matrix, interval_x_y_matrix]\r\n snake_sight = np.c_[snake_sight, interval_x_matrix]\r\n snake_sight = np.r_[snake_sight, temporal]\r\n return snake_sight\r\n\r\n ##Middle\r\n if left_x < 0:\r\n snake_sight = map_matrix[up_y:down_y+1, 0:right_x+1]\r\n interval_x = [self.limits[0] + left_x, self.limits[0]]\r\n interval_x_matrix = map_matrix[up_y:down_y+1, interval_x[0]:interval_x[1]]\r\n snake_sight = np.c_[interval_x_matrix, snake_sight]\r\n return snake_sight\r\n\r\n if right_x > self.limits[0]-1:\r\n snake_sight = map_matrix[up_y:down_y+1, left_x:self.limits[0]]\r\n interval_x = [0, right_x - self.limits[0] + 1]\r\n interval_x_matrix = map_matrix[up_y:down_y+1, interval_x[0]:interval_x[1]]\r\n snake_sight = np.c_[snake_sight, interval_x_matrix]\r\n return snake_sight\r\n\r\n if up_y < 0:\r\n snake_sight = map_matrix[0:down_y+1, left_x:right_x+1]\r\n interval_y = [self.limits[1] + up_y, self.limits[1]]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:right_x+1]\r\n snake_sight = np.r_[interval_y_matrix, snake_sight]\r\n return snake_sight\r\n \r\n if down_y > self.limits[1]-1:\r\n snake_sight = map_matrix[up_y:self.limits[1], left_x:right_x+1]\r\n interval_y = [0, down_y - self.limits[1] + 1]\r\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:right_x+1]\r\n snake_sight = np.r_[snake_sight, interval_y_matrix]\r\n return snake_sight\r\n\r\n return snake_sight","def generate_all_locations(grid, shape):","def gguess(x,y,xr,yr,xsgn,ysgn):\n \n # Bad until proven okay \n guesspar = None\n guessx = None \n guessy = None\n \n # Making sure it's the right structure \n #tags = tag_names(*(!gstruc.data)) \n #if (len(tags) != 6) : \n # return guesspar,guessx,guessy \n #comp = (tags == ['X','Y','RMS','NOISE','PAR','SIGPAR']) \n #if ((where(comp != 1))(0) != -1) :\n # return guesspar,guessx,guessy \n \n # Saving the originals \n orig_x = x \n orig_y = y \n\n if xr is None:\n xr = [0,2000]\n if yr is None:\n yr = [0,2000] \n \n # Is the x range continuous??\n # Assume not continuous in general\n cont = 0 \n \n # getting the p3 and p4 positions \n # P3 back in x (l-0.5), same y \n # P4 back in y (b-0.5), same x \n x3,y3 = gincrement(x,y,xr,yr,xsgn=-xsgn,ysgn=-ysgn)\n x4,y4 = gincrement(x,y,xr,yr,xsgn=xsgn,ysgn=-ysgn,p2=True)\n \n # CHECKING OUT THE EDGES \n # AT THE LEFT EDGE, and continuous, Moving RIGHT, use neighbor on other side \n # Use it for the guess, but never move to it directly \n if (x == xr[0]) and (xsgn == 1) and (cont == 1): \n y3 = y \n x3 = xr[1] \n \n # AT THE RIGHT EDGE, and continuous, Moving LEFT \n if (x == xr[1]) and (xsgn == -1) and (cont == 1): \n y3 = y \n x3 = xr[0] \n \n # At the edge, NOT continuous, Moving RIGHT, NO P3 NEIGHBOR \n if (x == xr[0]) and (xsgn == 1) and (cont == 0): \n x3 = None \n y3 = None \n \n # At the edge, NOT continuous, Moving LEFT, NO P3 NEIGHBOR \n if (x == xr[1]) and (xsgn == -1) and (cont == 0): \n x3 = None\n y3 = None\n \n # Have they been visited before? \n p3,res3 = gfind(x3,y3)\n p4,res4 = gfind(x4,y4)\n \n # Comparing the solutions \n b34,dbic34 = gbetter(res3,res4)\n \n # selecting the best guess \n if (dbic34<0): # using P3 \n guesspar = res3['par']\n guessx = x3\n guessy = y3 \n if (dbic34>=0): # using P4 \n guesspar = res4['par']\n guessx = x4 \n guessy = y4 \n if np.isfinite(dbic34)==False:\n guesspar = None\n guessx = None \n guessy = None\n \n # Putting the originals back \n x = orig_x \n y = orig_y \n\n return guesspar,guessx,guessy","def gru_cell_decoder(self, Xt, h_t_minus_1,context_vector):\n # 1.update gate: decides how much past information is kept and how much new information is added.\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z_decoder) + tf.matmul(h_t_minus_1,self.U_z_decoder) +tf.matmul(context_vector,self.C_z_decoder)+self.b_z_decoder) # z_t:[batch_size,self.hidden_size]\n # 2.reset gate: controls how much the past state contributes to the candidate state.\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r_decoder) + tf.matmul(h_t_minus_1,self.U_r_decoder) +tf.matmul(context_vector,self.C_r_decoder)+self.b_r_decoder) # r_t:[batch_size,self.hidden_size]\n # candiate state h_t~\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h_decoder) +r_t * (tf.matmul(h_t_minus_1, self.U_h_decoder)) +tf.matmul(context_vector, self.C_h_decoder)+ self.b_h_decoder) # h_t_candiate:[batch_size,self.hidden_size]\n # new state: a linear combine of pervious hidden state and the current new state h_t~\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\n return h_t,h_t","def draw_grid(self):\n\n screen.fill(GREY)\n\n for row in self.grid:\n for cell in row:\n if cell.root:\n color = GREEN\n elif cell.goal:\n color = RED\n elif cell.value:\n color = DARK_BLUE\n elif cell.visited:\n color = LIGHT_BLUE\n elif cell.f:\n color = LIGHT_GREEN\n elif cell.wall:\n color = GRAY\n else:\n color = WHITE\n\n pygame.draw.rect(screen, color, cell.rect)\n\n x, y = cell.rect.x, cell.rect.y\n\n if cell.g:\n self.draw_score(x + 2, y + 2, cell.g)\n if cell.h:\n self.draw_score(x + 18, y + 2, cell.h)\n if cell.f:\n self.draw_score(x + 2, y + self.cell_size - 10, cell.f)","def homeGrid():\n alphaTarget = 0\n betaTarget = 180\n hasApogee = True\n seed = 0\n rg = gridInit(seed)\n\n for r in rg.robotDict.values():\n r.setAlphaBeta(alphaTarget, betaTarget)\n return rg","def create_glider(i, j, grid):\n\n glider = np.array([[0, 0, 1],\n [1, 0, 1],\n [0, 1, 1]])\n grid[i:i+3:, j:j+3] = glider","def generate_candidate_grasps(object_name, dataset, stable_pose,\n num_grasps, gripper, config):\n grasp_set = []\n grasp_set_ids = []\n grasp_set_metrics = []\n\n # read params\n approach_dist = config['approach_dist']\n delta_approach = config['delta_approach']\n rotate_threshold = config['rotate_threshold']\n table_clearance = config['table_clearance']\n dist_thresh = config['grasp_dist_thresh']\n\n # get sorted list of grasps to ensure that we get the top grasp\n graspable = dataset.graspable(object_name)\n graspable.model_name_ = dataset.obj_mesh_filename(object_name)\n grasps = dataset.grasps(object_name, gripper=gripper.name)\n all_grasp_metrics = dataset.grasp_metrics(object_name, grasps, gripper=gripper.name)\n mn, mx = graspable.mesh.bounding_box()\n alpha = 1.0 / np.max(mx-mn)\n print alpha\n\n # prune by collisions\n rave.raveSetDebugLevel(rave.DebugLevel.Error)\n collision_checker = gcc.OpenRaveGraspChecker(gripper, view=False)\n collision_checker.set_object(graspable)\n\n # add the top quality grasps for each metric\n metrics = config['candidate_grasp_metrics']\n for metric in metrics:\n # generate metric tag\n if metric == 'efc':\n metric = db.generate_metric_tag('efcny_L1', config)\n elif metric == 'pfc':\n metric = db.generate_metric_tag('pfc', config)\n elif metric == 'ppc':\n metric = db.generate_metric_tag('ppc_%s' %(stable_pose.id), config)\n\n # sort grasps by the current metric\n grasp_metrics = [all_grasp_metrics[g.grasp_id][metric] for g in grasps]\n grasps_and_metrics = zip(grasps, grasp_metrics)\n grasps_and_metrics.sort(key = lambda x: x[1])\n grasps = [gm[0] for gm in grasps_and_metrics]\n grasp_metrics = [gm[1] for gm in grasps_and_metrics]\n\n # add grasps by quantile\n logging.info('Adding best grasp for metric %s' %(metric))\n i = len(grasps) - 1\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\n\n # check wrist rotation\n psi = grasp_candidate.angle_with_table(stable_pose)\n rotated_from_table = (psi > rotate_threshold)\n\n # check distances\n min_dist = np.inf\n for g in grasp_set:\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\n if dist < min_dist:\n min_dist = dist\n\n # check collisions\n while gripper.collides_with_table(grasp_candidate, stable_pose, table_clearance) \\\n or collides_along_approach(grasp_candidate, gripper, collision_checker, approach_dist, delta_approach) \\\n or rotated_from_table or grasp_candidate.grasp_id in grasp_set_ids \\\n or min_dist < dist_thresh:\n # get the next grasp\n i -= 1\n if i < 0:\n break\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\n\n # check wrist rotation\n psi = grasp_candidate.angle_with_table(stable_pose)\n rotated_from_table = (psi > rotate_threshold)\n\n # check distances\n min_dist = np.inf\n for g in grasp_set:\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\n if dist < min_dist:\n min_dist = dist\n\n # add to sequence\n if i >= 0:\n grasp_set.append(grasp_candidate)\n grasp_set_ids.append(grasp_candidate.grasp_id)\n grasp_set_metrics.append(all_grasp_metrics[grasp_candidate.grasp_id])\n\n # sample the remaining grasps uniformly at random\n i = 0\n random.shuffle(grasps)\n while len(grasp_set) < num_grasps and i < len(grasps):\n # random grasp candidate\n logging.info('Adding grasp %d' %(len(grasp_set)))\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\n\n # check wrist rotation\n psi = grasp_candidate.angle_with_table(stable_pose)\n rotated_from_table = (psi > rotate_threshold)\n\n # check distances\n min_dist = np.inf\n for g in grasp_set:\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\n if dist < min_dist:\n min_dist = dist\n\n # check collisions\n while gripper.collides_with_table(grasp_candidate, stable_pose) \\\n or collides_along_approach(grasp_candidate, gripper, collision_checker, approach_dist, delta_approach) \\\n or rotated_from_table or grasp_candidate.grasp_id in grasp_set_ids \\\n or min_dist < dist_thresh:\n # get the next grasp\n i += 1\n if i >= len(grasps):\n break\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\n\n # check wrist rotation\n psi = grasp_candidate.angle_with_table(stable_pose)\n rotated_from_table = (psi > rotate_threshold)\n\n # check distances\n min_dist = np.inf\n for g in grasp_set:\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\n if dist < min_dist:\n min_dist = dist\n\n # add to sequence\n if i < len(grasps):\n grasp_set.append(grasp_candidate)\n grasp_set_ids.append(grasp_candidate.grasp_id)\n grasp_set_metrics.append(all_grasp_metrics[grasp_candidate.grasp_id])\n\n return grasp_set, grasp_set_ids, grasp_set_metrics","def generation(self,rounds):\n a = []\n b = []\n for i in range(rounds):\n self.fight()\n c = self.avgFitness()\n a.append(c[0])\n b.append(c[1])\n self.sort()\n self.cull()\n self.rePop()\n self.refresh()\n self.fight()\n self.sort()\n print self\n plt.scatter([x for x in range(len(a))],a,color = \"red\")\n plt.scatter([x for x in range(len(b))],b,color = \"green\")\n plt.show()","def generation(self,rounds):\n a = []\n b = []\n for i in range(rounds):\n self.fight()\n c = self.avgFitness()\n a.append(c[0])\n b.append(c[1])\n self.sort()\n self.cull()\n self.rePop()\n self.refresh()\n self.fight()\n self.sort()\n print self\n plt.scatter([x for x in range(len(a))],a,color = \"red\")\n plt.scatter([x for x in range(len(b))],b,color = \"green\")\n plt.show()","def main():\n\n cages = [\n \"AABCCD\",\n \"EFBCGD\",\n \"EFFHGI\",\n \"EJJHGI\",\n \"EKJHGL\",\n \"KKJLLL\",\n ]\n\n peaks = [\n (0, 1),\n (0, 2),\n (1, 3),\n (1, 4),\n (1, 5),\n (2, 1),\n (2, 3),\n (3, 0),\n (3, 5),\n (4, 2),\n (5, 1),\n (5, 4),\n ]\n\n extract = {\n \"A\": (5, 2),\n \"B\": (0, 3),\n \"C\": (3, 2),\n \"D\": (1, 4),\n \"E\": (0, 1),\n \"F\": (1, 5),\n \"G\": (4, 2),\n \"H\": (3, 5),\n \"I\": (1, 0),\n \"J\": (5, 5),\n \"K\": (3, 4),\n \"L\": (5, 1),\n \"M\": (0, 5),\n \"N\": (4, 4),\n }\n\n def answer(sg):\n solved_grid = sg.solved_grid()\n s = \"\"\n s += chr(64 + solved_grid[extract[\"A\"]] + solved_grid[extract[\"B\"]])\n s += chr(64 + solved_grid[extract[\"C\"]] + solved_grid[extract[\"D\"]])\n s += chr(64 + solved_grid[extract[\"E\"]] + solved_grid[extract[\"F\"]] + solved_grid[extract[\"G\"]])\n s += chr(64 + solved_grid[extract[\"H\"]] + solved_grid[extract[\"I\"]])\n s += chr(64 + solved_grid[extract[\"J\"]] + solved_grid[extract[\"K\"]] + solved_grid[extract[\"L\"]])\n s += chr(64 + solved_grid[extract[\"M\"]] + solved_grid[extract[\"N\"]])\n return s\n\n sym = grilops.make_number_range_symbol_set(1, 6)\n lattice = grilops.get_square_lattice(6)\n sg = grilops.SymbolGrid(lattice, sym)\n\n add_sudoku_constraints(sg)\n\n # Constrain regions to match the cages and be rooted at the peaks.\n cage_label_to_region_id = {}\n for py, px in peaks:\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\n\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\n for y, x in lattice.points:\n sg.solver.add(\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\n\n # Within each region, a parent cell must have a greater value than a child\n # cell, so that the values increase as you approach the root cell (the peak).\n for p in lattice.points:\n for n in sg.edge_sharing_neighbors(p):\n sg.solver.add(Implies(\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\n n.symbol > sg.grid[p]\n ))\n\n if sg.solve():\n sg.print()\n print()\n print(answer(sg))\n while not sg.is_unique():\n print()\n print(\"Alternate solution\")\n sg.print()\n print()\n print(answer(sg))\n else:\n print(\"No solution\")","def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n max_cp = 1\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n max_cp += w_inpIdx*X0[inpIdx]\n # saving values\n layerEq[inpIdx] = X0[inpIdx]\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n max_cp += firstComplex + Inhib2/E0*x_eq\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n max_cp += Inhib2/E0*x_eq\n return max_cp","def get_obstacles(image):\n\n ih, iw = image.shape[:2]\n image_copy = image.copy()\n\n #resize the image to the size of arena\n image = cv2.resize(image, ARENA_SIZE, interpolation=cv2.INTER_CUBIC)\n gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\n\n #replace all black pixels to white pixels\n gray[np.where(gray == 0)]= 255\n\n #get the thresholded binary image\n ret,threshold = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)\n\n #find all the countours in the binary image\n _, contours, heiarchy = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n cont = []\n\n #create a mask to draw contours on\n blocks = mask = np.zeros(threshold.shape[:2], np.uint8)\n\n #create a dictionary to hold image roi of all puzzle peices\n blocks_roi = {}\n\n #iterate through all contours\n for i, c in enumerate(contours[1:]):\n\n #find the minimum area fitting rectangle of the contour\n rect = cv2.minAreaRect(c)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n\n #create the copy of the mask\n mask_copy = mask.copy()\n\n #draw the rectangle on the mask\n cv2.drawContours(mask_copy, [box], -1, (255,255,255), 3)\n\n #floodfill the rectangle\n cv2.floodFill(mask_copy, None, (0,0), 255)\n mask_inv = cv2.bitwise_not(mask_copy)\n blocks = cv2.add(blocks, mask_inv)\n\n _, contours, heiarchy = cv2.findContours(blocks, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n obstacles = {}\n\n for c in contours:\n x,y,w,h = cv2.boundingRect(c)\n obstacles.update({(int(x+w/2), int(y+h/2)): BLOCK_SIZE})\n #obstacles.update({(int(x+w/2), int(y+h/2)): (w, h)}) # for unknown block sizes\n bottom_r = remap((x+w, y+h), ARENA_SIZE, (iw,ih))\n top_l = remap((x, y), ARENA_SIZE, (iw,ih))\n blocks_roi.update({(int(x+w/2), int(y+h/2)): image_copy[top_l[1]:bottom_r[1], top_l[0]:bottom_r[0]]})\n\n return obstacles, blocks_roi","def get_obstacles_map(obstacles, placed_pecies):\n \n #create a mask image to draw the obstacles on\n blocks = np.zeros(ARENA_SIZE[::-1], np.uint8)\n\n #get the grid points where the robot needs to placed\n grid = get_grid(ARENA_SIZE)\n\n #draw the obstacles and their safety region on the map\n for i in obstacles.keys():\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\n cv2.rectangle(blocks, (i[0]-int(obstacles[i][0]/4), i[1]-int(obstacles[i][1]/4)), (i[0]+int(obstacles[i][0]/4), i[1]+int(obstacles[i][1]/4)), 255, -1)\n\n #draw the obstacles and their safety region on the map\n for i in placed_pecies.keys():\n try:\n if not i == grid[5]:\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\n else:\n cv2.rectangle(blocks, (int(i[0]-7.4*placed_pecies[i][0]/4), int(i[1]-7.4*placed_pecies[i][1]/4)),\n (int(i[0]+7.4*placed_pecies[i][0]/4), int(i[1]+7.4*placed_pecies[i][1]/4)), 129, -1)\n cv2.rectangle(blocks, (i[0]-int(placed_pecies[i][0]/4), i[1]-int(placed_pecies[i][1]/4)), (i[0]+int(placed_pecies[i][0]/4), i[1]+int(placed_pecies[i][1]/4)), 255, -1)\n except Exception as e:\n print(e)\n\n return cv2.bitwise_not(blocks)","def six_hundred_cell(self):\n verts = []\n q12 = QQ(1)/2\n base = [q12,q12,q12,q12]\n for i in range(2):\n for j in range(2):\n for k in range(2):\n for l in range(2):\n verts.append([x for x in base])\n base[3] = base[3]*(-1)\n base[2] = base[2]*(-1)\n base[1] = base[1]*(-1)\n base[0] = base[0]*(-1)\n for x in permutations([0,0,0,1]):\n verts.append(x)\n for x in permutations([0,0,0,-1]):\n verts.append(x)\n g = QQ(1618033)/1000000 # Golden ratio approximation\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n return Polyhedron(vertices = verts)","def __handle_view_tile(self, gamestate_component):","def global_refine(self):\n gr = super(UnTRIM08Grid,self).global_refine()\n gr.infer_depths()\n gr.location = self.location\n gr.angle = self.angle\n gr.cells['red'][:] = True\n return gr","def getRGFforGrowthAndDeath(self, pairs):\n # Create a list of length pairs with random integers to iterate\n # randomly through the list of pairs\n shuffled_indices = np.random.choice(len(pairs),\n len(pairs),\n replace=False)\n for i in shuffled_indices:\n pair = pairs[i]\n if self.checkRgfAbility(pair=pairs[i]):\n l1, l2 = pair[0], pair[1]\n self._rgf_counter[l1], self._rgf_counter[l2] = 1, 1\n self._potential_partner[l1], self._potential_partner[l2] = \\\n self._plant_names[l2], self._plant_names[l1]\n if (self._variant[l1] == \"V2_adapted\") and \\\n (self._variant[l2] == \"V2_adapted\"):\n # Set initial size of grafted root radius\n self._r_gr_rgf[l1], self._r_gr_rgf[l2] = 0.004, 0.004\n # Get min. radius of grafted roots\n r_gr_min = self.f_radius * min(self._r_stem[l1],\n self._r_stem[l2])\n self._r_gr_min[l1], self._r_gr_min[l2] = [r_gr_min], \\\n [r_gr_min]\n\n # Get length of grafted root section\n distance = self.getDistance(x1=self._xe[l1],\n x2=self._xe[l2],\n y1=self._ye[l1],\n y2=self._ye[l2])\n root_sums = self._r_root[l1] + self._r_root[l2]\n l_gr = (distance + root_sums) / 2\n self._l_gr_rgf[l1], self._l_gr_rgf[l2] = self._r_root[l1] / \\\n root_sums * l_gr, \\\n self._r_root[l2] / \\\n root_sums * l_gr,","def game_of_life():\n # 3x3 neighbourhood\n offsets = [[(y, x) for y in range(-1, 2)] for x in range(-1, 2)]\n\n # Create mappings\n mappings = {}\n for i in range(2 ** 9):\n\n # Determine the initial state (key)\n key = f\"{bin(i)[2:]:0>9}\" # As binary string\n key = tuple(k == \"1\" for k in key) # As tuple of bools\n key = tuple(key[i * 3:i * 3 + 3] for i in range(3)) # Reshape into 2D grid\n\n # Alive counts\n centre = key[1][1]\n others = sum(sum(row) for row in key) - centre\n\n # Skip if state does not evaluate to True\n if centre:\n if others not in (2, 3):\n continue\n\n else:\n if others != 3:\n continue\n\n mappings[key] = True\n\n return Mapping2DRuleset(mappings, offsets)","def sim_grasp_set_row(scene):\n gripper_model = burg.gripper.Robotiq2F85()\n\n target_object = None\n\n found = False\n while found == False:\n print([obj.object_type.identifier for obj in scene.objects])\n buffer_target_object = input(\"Wich object in the previous list do you want to grab ? \")\n\n i = 0\n while i < len(scene.objects):\n if (scene.objects[i].object_type.identifier == buffer_target_object):\n target_object = scene.objects[i]\n found = True\n break\n i += 1\n if found == False :\n print(\"the selected object is not in the list\")\n\n #test a grasp set and create a list of successful grasp\n grasp_set, contact_points, normals, approach_vectors = create_antipodal_grasp_set(target_object)\n sim = burg.sim.SceneGraspSimulator(target_object = target_object, gripper= gripper_model, scene=scene, verbose=False)\n scores = sim.simulate_grasp_set(grasp_set)\n successful_grasps = burg.grasp.GraspSet()\n index_successfull = []\n params_successfull = []\n for index in range(len(scores)):\n if scores[index] == 5:\n successful_grasps.add(grasp_set[index].as_grasp_set())\n index_successfull += [index]\n params_successfull+=[[contact_points[index], normals[index], approach_vectors[index]]]\n sim.dismiss()\n\n print(len(successful_grasps))\n print(\"hellllo\")\n\n time.sleep(10)\n\n #Evaluate each successfull grasp\n sim2 = burg.sim.SceneGraspSimulator(target_object = target_object, gripper= gripper_model, scene=scene, verbose=False)\n results = []\n for i, grasp in enumerate(successful_grasps):\n n_graspset, n_contact_points, n_normals, n_approach_vectors = create_antipodal_noisy_grasp_set(target_object, grasp, params_successfull[i][0][0])\n #n_graspset = perturbations.generate_perturb_grasp_set(grasp = grasp, nb_grasps = 50)\n #burg.visualization.show_grasp_set(objects = [target_object.object_type.mesh], gs = n_graspset, gripper = gripper_model, with_plane = True)\n params_noised = []\n for k in range(len(n_contact_points)):\n params_noised += [[n_contact_points[i], n_normals[i], n_approach_vectors[i]]]\n scores = sim2.simulate_grasp_set(n_graspset)\n robust = sum(scores)/len(scores)\n #metric = quality.probability_force_closure(n_graspset, params_noised)\n metric = quality.epsilon_quality(grasp, params_successfull[i] )\n results += [[grasp, robust, metric]]\n print([grasp, robust, metric])\n #results+= [[grasp, metric]]\n #results += [metric]\n\n print(results)\n sim2.dismiss()\n return results","def buildSurface(self, idx = 0, surface = 1, z = 1, verbose = 1,\\\n strained = False, vacuum = 0, ab = False):\n\n \"\"\"Basis for the selected surface, and the cell repetitions\"\"\"\n rep = np.zeros((3, 4))\n new_base = np.zeros((3, 3))\n\n altBase1 = np.zeros((3, 3))\n altBase2 = np.zeros((3, 3))\n if ab:\n B1, B2 = self.getAB()\n\n if surface == 1:\n old_base = self.base_1\n spec = self.spec_1\n mass = self.mass_1\n pos = self.pos_1\n\n new_base[2, 2] = self.base_1[2, 2] * z\n new_base[0:2, 0:2] = self.cell_1[idx, :, :]\n \n if ab:\n altBase1[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\n altBase1[2, 2] = B1[2, 2] * z\n \n rep[0:2, 0:2] = self.rep_1[idx, :, :]\n rep[:, 2] = np.sum(rep, axis = 1)\n elif surface == 2:\n old_base = self.base_2\n spec = self.spec_2\n mass = self.mass_2\n pos = self.pos_2\n\n new_base[2, 2] = self.base_2[2, 2] * z\n new_base[0:2, 0:2] = self.cell_2[idx, :, :]\n \n if ab:\n altBase2[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\n altBase2[2, 2] = B2[2, 2] * z\n\n rep[0:2, 0:2] = self.rep_2[idx, :, :]\n rep[:, 2] = np.sum(rep, axis = 1)\n\n \"\"\"Set all hi-lo limits for the cell repetitions\"\"\"\n h = 2\n rep = [rep[0, :].min() - h, rep[0, :].max() + h,\\\n rep[1, :].min() - h, rep[1, :].max() + h,\\\n 0, z - 1]\n\n \"\"\"Extend the cell as spcefied\"\"\"\n pos_ext, spec_ext, mass_ext = ut.extendCell(base = old_base, rep = rep,\\\n pos = pos.T, spec = spec,\\\n mass = mass)\n\n if surface == 1:\n \"\"\"Change to alternative base_1 if specified\"\"\"\n if ab:\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n new_base = altBase1\n pos_ext = np.matmul(new_base, pos_d)\n if verbose > 0:\n string = \"Surface 1 constructed with alternative base\"\n ut.infoPrint(string)\n\n elif surface == 2:\n \"\"\"Initial rotation\"\"\"\n initRot = np.deg2rad(self.ang[idx])\n\n \"\"\"Rotate the positions pos_rot = R*pos\"\"\"\n pos_ext = ut.rotate(pos_ext, initRot, verbose = verbose - 1)\n\n \"\"\"Construct it in the alternative base_2 if specified\"\"\"\n if ab:\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n new_base = altBase2\n pos_ext = np.matmul(new_base, pos_d)\n if verbose > 0:\n string = \"Surface 2 constructed with alternative base\"\n ut.infoPrint(string)\n\n \"\"\"Strain the cell if specified\"\"\"\n if strained:\n\n \"\"\"If the cell is to be strained then convert to direct coordinates\"\"\"\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n\n \"\"\"Convert back to cartesian coordinates.\"\"\"\n if ab:\n \"\"\"Strain it to the alternative base_1\"\"\"\n new_base[0:2, 0:2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\n string = \"Surface 2 strained to match surface 1 with an alternative base\"\n \n else:\n \"\"\"Strain it to the bottom surface\"\"\"\n new_base[0:2, 0:2] = self.cell_1[idx, :, :].copy()\n string = \"Surface 2 strained to match surface 1\"\n\n pos_ext = np.matmul(new_base, pos_d)\n\n if verbose > 0:\n ut.infoPrint(string)\n\n \"\"\"Convert the entire new cell to direct coordinates\"\"\"\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n\n \"\"\"Remove all positions outside [0, 1)\"\"\"\n pos_d = np.round(pos_d, 8)\n new_base = np.round(new_base, 8)\n\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\n pos_d = pos_d[:, keep]\n species = spec_ext[keep]\n mass = mass_ext[keep]\n\n \"\"\"Return to cartesian coordinates and change shape to (...,3)\"\"\"\n pos = np.matmul(new_base, pos_d).T\n\n \"\"\"Add vacuum if specified\"\"\"\n new_base[2, 2] = new_base[2, 2] + vacuum\n if verbose: \n string = \"Vacuum added: %.2f\"\\\n % (vacuum)\n ut.infoPrint(string)\n\n return new_base, pos, species, mass","def decision_heatmaps(obs):\n global model\n assert obs > 4 and obs < 1788, \"Chosen observation is outside the range of the demonstration episode.\"\n saved_observations = np.load('saved_observations.npy')\n state = saved_observations[obs-3:obs+1]\n state_batch = np.expand_dims(state, axis=0)\n q_vals = model.compute_q_values(state)\n print(q_vals)\n decision = np.argmax(q_vals)\n print(decision)\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\n decision_node = model.model.output[:, decision]\n last_conv_layer = model.model.layers[3]\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\n pooled_grads = K.mean(grads, axis=(0,2,3))\n frame = Image.fromarray(state[-1])\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\n for i in range(64):\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\n\n heatmap = np.mean(conv_layer_output_value, axis=0)\n heatmap = np.maximum(heatmap, 0)\n heatmap /= np.max(heatmap)\n heatmap = cv2.resize(heatmap, (84, 84))\n heatmap = np.uint8(255 * heatmap)\n superimposed_img = heatmap * .3 + np.array(frame) * .35\n\n plt.xlabel(decision_encodings[decision])\n plt.imshow(superimposed_img, cmap='gray')\n plt.show()","def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\n # create binary mask\n mask = np.zeros(img_slice.shape)\n mask[min_x:max_x, min_y:max_y] = 1\n # keep a copy of original to have background later \n img_orig = np.copy(img_slice)\n mask_binary = np.copy(mask)\n\n # rotate image if coronal\n if views=='coronal':\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\n mask = np.rot90(mask, axes=(1, 0))\n \n # prepare binary mask for net\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask = torch.Tensor(mask) # gives dtype float32\n mask = mask.unsqueeze(0)\n mask = mask.unsqueeze(0)\n\n # prepare seg mask for net\n mask_slice[mask_slice==self.vertebra_id] = 0\n # resize to network size\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\n\n mask_seg = self.map_vert_to_class(mask_seg)\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n\n # prepare img for net \n img_slice = cv2.resize(img_slice, self.resize_size)\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \n img_slice = img_slice[:,:, None]\n img_slice = self.toTensor(img_slice)\n img_slice = img_slice.unsqueeze(0)\n corrupt_img = (1-mask)*img_slice\n\n if self.use_cuda:\n mask = mask.cuda()\n mask_seg = mask_seg.cuda()\n corrupt_img = corrupt_img.cuda() \n\n # inpaint\n if views=='lateral':\n netG = self.netGlat\n elif views=='coronal':\n netG = self.netGcor\n\n # get prediction\n with torch.no_grad():\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\n inpainted_mask = self.softmax(inpainted_mask)\n\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\n\n # set img back to how it was\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\n # set mask back\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\n for i in range(6):\n if views=='coronal':\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\n else:\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\n inpainted_mask = inpainted_mask_resized\n \n if views=='coronal':\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\n\n return inpainted_img, inpainted_mask, mask_binary","def get_GroundTruth(self):\n\n # set first pose to identity\n # first_pose = self.dataset.oxts[0].T_w_imu\n # first_pose_inv = src.se3.inversePose(first_pose)\n # do not correct the orientation\n # first_pose_inv[:3, :3] = np.eye(3)\n\n # do not set first pose to identity\n first_pose_inv = np.eye(4)\n\n for o in self.dataset.oxts:\n\n normalized_pose_original = first_pose_inv @ o.T_w_imu\n self.poses_gt.append(normalized_pose_original)\n\n # gt pose is from I to G\n for i, pose in enumerate(self.poses_gt):\n\n # get gt position\n gt_position = np.reshape(pose[0:3, 3], (-1, 1))\n\n self.gt_position.append(gt_position)\n\n # get gt orientation\n R_wIMU = pose[0:3, 0:3]\n self.gt_orientation.append(R_wIMU)","def mover_bm_izquierda(self):\n self.nueva_posicion_posible_parte_superior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] - 1,\n self.casilla[1]],\n [self.vertice_1[0] - self.velocidad,self.vertice_1[1]], \n [self.vertice_1[0] - 5 - 5, self.vertice_1[1]])\n self.nueva_posicion_posible_parte_inferior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] - 1,\n self.casilla[1] + 1],\n [self.vertice_3[0] - self.velocidad,self.vertice_3[1]],\n [self.vertice_3[0] - 5,self.vertice_3[1]]) \n if self.nueva_posicion_posible_parte_superior[0] != 1 and self.nueva_posicion_posible_parte_inferior[0] != 1:\n self.x -= self.velocidad * (self.x >= 15)\n self.posicion = [self.x,self.posicion[1]]\n self.casilla = [self.casilla[0] - self.nueva_posicion_posible_parte_superior[1] *(self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1), self.casilla[1]]\n self.redefinir_vertices()","def big_tiling():\n t = Tiling(\n obstructions=(\n GriddedPerm(Perm((0,)), ((0, 1),)),\n GriddedPerm(Perm((0,)), ((0, 2),)),\n GriddedPerm(Perm((0,)), ((0, 3),)),\n GriddedPerm(Perm((0,)), ((1, 2),)),\n GriddedPerm(Perm((0,)), ((1, 3),)),\n GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0))),\n GriddedPerm(Perm((1, 0)), ((0, 0), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((0, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 0), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 1))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 2))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 0))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 1))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 2))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 3))),\n ),\n requirements=(),\n )\n return t","def generate_aima_grid():\n\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\n\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\n\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\n\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\n\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\n\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\n\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\n\n print('\\n***** aima grid world *****\\n')\n print('Transition matrix:', transitions.shape)\n print('Reward matrix:', rewards.shape)\n\n return transitions, rewards"],"string":"[\n \"def gen_obs_grid(self):\\n\\n topX, topY, botX, botY = self.get_view_exts()\\n\\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\\n\\n # for i in range(self.agent_dir + 1):\\n # grid = grid.rotate_left()\\n\\n # Process occluders and visibility\\n # Note that this incurs some performance cost\\n if not self.see_through_walls:\\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\\n self.agent_view_size // 2))\\n else:\\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\\n\\n # Make it so the agent sees what it's carrying\\n # We do this by placing the carried object at the agent's position\\n # in the agent's partially observable view\\n agent_pos = grid.width // 2, grid.height // 2\\n if self.carrying:\\n grid.set(*agent_pos, self.carrying)\\n else:\\n grid.set(*agent_pos, None)\\n\\n return grid, vis_mask\",\n \"def occam_razor() -> None:\\r\\n print(\\\"WARNING! Mode three activated. Time to complete may be several minutes\\\")\\r\\n temp = [] # x-y-conflicts\\r\\n global example\\r\\n backup = example.copy() # Backup so it can backtrack through solutions\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n conflict_counter = 0\\r\\n for z in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\\r\\n conflict_counter += 1\\r\\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\\r\\n conflict_counter += 1\\r\\n if conflict_counter > 0 and no_neighbour(x, y):\\r\\n temp.append([x, y, conflict_counter])\\r\\n threshold = [0, 0, 0]\\r\\n \\\"\\\"\\\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n if temp[x][2] > threshold[2]:\\r\\n threshold = temp[x]\\r\\n if threshold[2] > 0:\\r\\n example[threshold[0], threshold[1]] = 0\\r\\n shade_neighbours(threshold[0], threshold[1])\\r\\n if not victory_checker():\\r\\n \\\"\\\"\\\"code now begins guessing\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n example = backup.copy()\\r\\n if no_neighbour(temp[x][0], temp[x][1]):\\r\\n example[temp[x][0], temp[x][1]] = 0\\r\\n else:\\r\\n continue\\r\\n progress_handler(False, True)\\r\\n while progress_handler(True, False):\\r\\n print_debug(\\\"itteration\\\")\\r\\n progress_handler(False, False)\\r\\n mark_check()\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n if not progress_handler(True, False):\\r\\n special_corner()\\r\\n if not progress_handler(True, False):\\r\\n separation_crawler(True)\\r\\n if not progress_handler(True, False):\\r\\n occam_razor() # Recursive\\r\\n if not progress_handler(True, False):\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n else:\\r\\n print(\\\"Searching...\\\")\\r\\n continue\\r\\n conflict_check()\",\n \"def build_grains(self):\\n\\t\\ttime = datetime.datetime.now()\\n\\t\\tif self.probability == 0:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\t\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\telse:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,5, time):\\n\\t\\t\\t\\t\\t\\tneighbours = self.get_nearest_neighbours(cell)\\n\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_further_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\t\\t\\t\\trandom_number = random.random() * 100\\n\\t\\t\\t\\t\\t\\t\\t\\tif random_number <= self.probability:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\",\n \"def create_gridworld(self):\\n self.num_actions = 4\\n self.num_states = self.num_cols * self.num_rows + 1\\n self.start_state_seq = row_col_to_seq(self.start_state, self.num_cols)\\n self.goal_states_seq = row_col_to_seq(self.goal_states, self.num_cols)\\n\\n # rewards structure\\n self.R = self.r_step * np.ones((self.num_states, 1))\\n self.R[self.num_states-1] = 0\\n self.R[self.goal_states_seq] = self.r_goal\\n for i in range(self.num_bad_states):\\n if self.r_bad is None:\\n raise Exception(\\\"Bad state specified but no reward is given\\\")\\n bad_state = row_col_to_seq(self.bad_states[i,:].reshape(1,-1), self.num_cols)\\n self.R[bad_state, :] = self.r_bad\\n for i in range(self.num_restart_states):\\n if self.r_restart is None:\\n raise Exception(\\\"Restart state specified but no reward is given\\\")\\n restart_state = row_col_to_seq(self.restart_states[i,:].reshape(1,-1), self.num_cols)\\n self.R[restart_state, :] = self.r_restart\\n\\n # probability model\\n if self.p_good_trans == None:\\n raise Exception(\\\"Must assign probability and bias terms via the add_transition_probability method.\\\")\\n\\n self.P = np.zeros((self.num_states,self.num_states,self.num_actions))\\n for action in range(self.num_actions):\\n for state in range(self.num_states):\\n\\n # check if state is the fictional end state - self transition\\n if state == self.num_states-1:\\n self.P[state, state, action] = 1\\n continue\\n\\n # check if the state is the goal state or an obstructed state - transition to end\\n row_col = seq_to_col_row(state, self.num_cols)\\n if self.obs_states is not None:\\n end_states = np.vstack((self.obs_states, self.goal_states))\\n else:\\n end_states = self.goal_states\\n\\n if any(np.sum(np.abs(end_states-row_col), 1) == 0):\\n self.P[state, self.num_states-1, action] = 1\\n\\n # else consider stochastic effects of action\\n else:\\n for dir in range(-1,2,1):\\n direction = self._get_direction(action, dir)\\n next_state = self._get_state(state, direction)\\n if dir == 0:\\n prob = self.p_good_trans\\n elif dir == -1:\\n prob = (1 - self.p_good_trans)*(self.bias)\\n elif dir == 1:\\n prob = (1 - self.p_good_trans)*(1-self.bias)\\n\\n self.P[state, next_state, action] += prob\\n\\n # make restart states transition back to the start state with\\n # probability 1\\n if self.restart_states is not None:\\n if any(np.sum(np.abs(self.restart_states-row_col),1)==0):\\n next_state = row_col_to_seq(self.start_state, self.num_cols)\\n self.P[state,:,:] = 0\\n self.P[state,next_state,:] = 1\\n return self\",\n \"def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\\r\\n \\r\\n nI_agg = len(list(set(indices['ind'][agg_level])))\\r\\n nP_agg = len(list(set(indices['prod'][agg_level])))\\r\\n nW_agg = len(list(set(indices['vadd'][agg_level])))\\r\\n nM_agg = len(list(set(indices['imp'][agg_level])))\\r\\n nY_agg = len(list(set(indices['fd'][agg_level])))\\r\\n nR_agg = len(list(set(indices['exog'][agg_level])))\\r\\n\\r\\n nI_rcot = len(list(set(indices['ind'][rect_level])))\\r\\n nP_rcot = len(list(set(indices['prod'][rect_level])))\\r\\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\\r\\n nM_rcot = len(list(set(indices['imp'][rect_level])))\\r\\n nY_rcot = len(list(set(indices['fd'][rect_level])))\\r\\n nR_rcot = len(list(set(indices['exog'][rect_level])))\\r\\n\\r\\n \\r\\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\\r\\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n \\r\\n indInd = indices_agg['ind']\\r\\n prodInd = indices_agg['prod']\\r\\n vaddInd = indices_agg['vadd']\\r\\n impInd = indices_agg['imp']\\r\\n fdInd = indices_agg['fd']\\r\\n exogInd = indices_agg['exog']\\r\\n\\r\\n zInd = prodInd.append(indInd)\\r\\n zInd = zInd.swaplevel(0,1)\\r\\n \\r\\n\\r\\n for l in range(nL):\\r\\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\\r\\n\\r\\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n ZR_0[l] = Z.values\\r\\n WR_0[l] = W.values\\r\\n MR_0[l] = M.values\\r\\n YR_0[l] = Y.values\\r\\n \\r\\n AR_0[l] = A.values\\r\\n wR_0[l] = w.values\\r\\n mR_0[l] = m.values\\r\\n\\r\\n \\r\\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n\\r\\n ML_RCOT_0 = {\\r\\n 'Z' : ZR_0,\\r\\n 'W' : WR_0,\\r\\n 'M' : MR_0,\\r\\n 'Y' : YR_0,\\r\\n 'R' : RR_0,\\r\\n }\\r\\n\\r\\n ML_RCOT_coeff_0 = {\\r\\n 'A' : AR_0,\\r\\n 'w' : wR_0,\\r\\n 'm' : mR_0,\\r\\n 'Y' : YR_0,\\r\\n 'B' : BR_0,\\r\\n }\\r\\n\\r\\n \\r\\n indices_RCOT = {\\r\\n 'prod/ind' : zInd,\\r\\n 'vadd' : vaddInd,\\r\\n 'imp' : impInd,\\r\\n 'fd' : fdInd,\\r\\n 'exog' : exogInd,\\r\\n 'headers' : indices['headers']\\r\\n }\\r\\n \\r\\n \\r\\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)\",\n \"def gru_cell(self, Xt, h_t_minus_1):\\n # 1.update gate: decides how much past information is kept and how much new information is added.\\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\\n # 2.reset gate: controls how much the past state contributes to the candidate state.\\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\\n # candiate state h_t~\\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\\n # new state: a linear combine of pervious hidden state and the current new state h_t~\\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\\n return h_t\",\n \"def init(self, windowsize:tuple):\\r\\n y_count, x_count = 3, 0 #< Set the starting counter for the look_up_table. y starts with three because the first three lines are just Nones\\r\\n # Creating the constant maze \\r\\n maze_size = windowsize[0], windowsize[1] - 2 * self.grid_size\\r\\n self.maze = pg.Surface(maze_size) \\r\\n \\r\\n \\r\\n \\r\\n # Draw the outermost rectangles on self.maze\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0, 3 * self.grid_size), (28 * self.grid_size, 31 * self.grid_size)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0 + self.grid_size // 2, 3 * self.grid_size + self.grid_size // 2),(27 * self.grid_size, 30 * self.grid_size)), 4) \\r\\n # Draw the inner rectangles\\r\\n for y in self.look_up_table[3 : -2]: #< y is a list of one row from the maze\\r\\n for x in y: #< x is a string that is decoded as already explained\\r\\n pos = [self.grid_size * x_count, self.grid_size * y_count]\\r\\n # Set reference position in the middle of one square\\r\\n pos[0] += self.grid_size // 2\\r\\n pos[1] += self.grid_size // 2\\r\\n x_count += 1\\r\\n # Check if x is rectangle\\r\\n if x != None and x[0] == 'r':\\r\\n # When the size of the string is equal or greater than 4 it's rectangle with a specific size and not just a border.\\r\\n if len(x) >= 4:\\r\\n # get the x and y size of the rectangle. x will be something like 'rx1_y1' x1 resprestens the size in x direction and y1 in y direction.\\r\\n xy_dim = x[1:].split(\\\"_\\\") \\r\\n xy_dim[0] = int(xy_dim[0])\\r\\n xy_dim[1] = int(xy_dim[1])\\r\\n rect = tuple(pos), (xy_dim[0] * self.grid_size , xy_dim[1] * self.grid_size )\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], rect, self.width)\\r\\n # If the last char is a w (white), u (up) or l (left) a line gets draw one a specific position \\r\\n if x[-1] == 'w':\\r\\n self.draw_line(self.maze, 'u', (x_count,y_count), True)\\r\\n if x[-1] == 'u' or x[-1] == 'l':\\r\\n if x_count == 0:\\r\\n self.draw_line(self.maze, x[-1], (len(y), y_count))\\r\\n else:\\r\\n self.draw_line(self.maze, x[-1], (x_count, y_count))\\r\\n \\r\\n y_count += 1\\r\\n x_count = 0\\r\\n # Just some cosmetic drawing\\r\\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((0, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((28 * self.grid_size - self.grid_size // 2 - 1, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 13 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 19 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 13 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 19 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((11 * self.grid_size, 16 * self.grid_size), (6 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n \\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size // 2 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 18 * self.grid_size + self.grid_size // 2), (self.grid_size // 2 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size * 28 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 18 * self.grid_size + self.grid_size // 2), (self.grid_size * 28 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\\r\\n self.is_init = True\",\n \"def _get_closeup(self, idx):\\n img_arr = p.getCameraImage(width=self._width,\\n height=self._height,\\n viewMatrix=self._view_matrix,\\n projectionMatrix=self._proj_matrix)\\n rgb = img_arr[2]\\n depth = img_arr[3]\\n min = 0.97\\n max=1.0\\n segmentation = img_arr[4]\\n depth = np.reshape(depth, (self._height, self._width,1) )\\n segmentation = np.reshape(segmentation, (self._height, self._width,1) )\\n\\n np_img_arr = np.reshape(rgb, (self._height, self._width, 4))\\n np_img_arr = np_img_arr[:, :, :3].astype(np.float64)\\n\\n view_mat = np.asarray(self._view_matrix).reshape(4, 4)\\n proj_mat = np.asarray(self._proj_matrix).reshape(4, 4)\\n # pos = np.reshape(np.asarray(list(p.getBasePositionAndOrientation(self._objectUids[0])[0])+[1]), (4, 1))\\n\\n AABBs = np.zeros((len(self._objectUids), 2, 3))\\n cls_ls = []\\n \\n for i, (_uid, _cls) in enumerate(zip(self._objectUids, self._objectClasses)):\\n AABBs[i] = np.asarray(p.getAABB(_uid)).reshape(2, 3)\\n cls_ls.append(NAME2IDX[_cls])\\n\\n # np.save('/home/tony/Desktop/obj_save/view_mat_'+str(self.img_save_cnt), view_mat)\\n # np.save('/home/tony/Desktop/obj_save/proj_mat_'+str(self.img_save_cnt), proj_mat)\\n # np.save('/home/tony/Desktop/obj_save/img_'+str(self.img_save_cnt), np_img_arr.astype(np.int16))\\n # np.save('/home/tony/Desktop/obj_save/AABB_'+str(self.img_save_cnt), AABBs)\\n # np.save('/home/tony/Desktop/obj_save/class_'+str(self.img_save_cnt), np.array(cls_ls))\\n\\n np.save(OUTPUT_DIR + '/closeup_' + str(self.img_save_cnt - 1) + '_' + str(idx), np_img_arr.astype(np.int16))\\n dets = np.zeros((AABBs.shape[0], 5))\\n for i in range(AABBs.shape[0]):\\n dets[i, :4] = self.get_2d_bbox(AABBs[i], view_mat, proj_mat, IM_HEIGHT, IM_WIDTH)\\n dets[i, 4] = int(cls_ls[i])\\n # np.save(OUTPUT_DIR + '/annotation_'+str(self.img_save_cnt), dets)\\n\\n test = np.concatenate([np_img_arr[:, :, 0:2], segmentation], axis=-1)\\n\\n return test\",\n \"def proposal_assignments_gtbox(rois, gt_boxes, gt_classes, gt_rels, image_offset, fg_thresh=0.5):\\n im_inds = rois[:, 0].long()\\n num_im = im_inds[-1] + 1\\n fg_rels = gt_rels.clone()\\n fg_rels[:, 0] -= image_offset\\n offset = {}\\n for i, s, e in enumerate_by_image(im_inds):\\n offset[i] = s\\n for i, s, e in enumerate_by_image(fg_rels[:, 0]):\\n fg_rels[s:e, 1:3] += offset[i]\\n is_cand = im_inds[:, None] == im_inds[None]\\n is_cand.view(-1)[diagonal_inds(is_cand)] = 0\\n is_cand.view(-1)[fg_rels[:, 1] * im_inds.size(0) + fg_rels[:, 2]] = 0\\n is_bgcand = is_cand.nonzero()\\n num_fg = min(fg_rels.size(0), int(RELS_PER_IMG * REL_FG_FRACTION * num_im))\\n if num_fg < fg_rels.size(0):\\n fg_rels = random_choose(fg_rels, num_fg)\\n num_bg = min(is_bgcand.size(0) if is_bgcand.dim() > 0 else 0, int(RELS_PER_IMG * num_im) - num_fg)\\n if num_bg > 0:\\n bg_rels = torch.cat((im_inds[is_bgcand[:, 0]][:, None], is_bgcand, (is_bgcand[:, 0, None] < -10).long()), 1)\\n if num_bg < is_bgcand.size(0):\\n bg_rels = random_choose(bg_rels, num_bg)\\n rel_labels = torch.cat((fg_rels, bg_rels), 0)\\n else:\\n rel_labels = fg_rels\\n _, perm = torch.sort(rel_labels[:, 0] * gt_boxes.size(0) ** 2 + rel_labels[:, 1] * gt_boxes.size(0) + rel_labels[:, 2])\\n rel_labels = rel_labels[perm].contiguous()\\n labels = gt_classes[:, 1].contiguous()\\n return rois, labels, rel_labels\",\n \"def __init__(self, \\n nd = 2, \\n goal = np.array([1.0,1.0]),\\n state_bound = [[0,1],[0,1]],\\n nA = 4,\\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\\n<<<<<<< HEAD:archive-code/puddleworld.py\\n ngrid = [10.0,10.0],\\n maxStep = 40):\\n ngrid = [40, 40]\\n x_vec = np.linspace(0,1,ngrid[0])\\n y_vec = np.linspace(0,1,ngrid[1])\\n for x in x_vec:\\n for y in y_vec:\\n if ~self.inPuddle([x,y]):\\n puddle.append([x,y])\\n # puddle is a closed loop \\n outpuddlepts = np.asarray(puddle)\\n \\\"\\\"\\\"\\n\\n\\n # Horizontal wing of puddle consists of \\n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\\n # (xchi,ychi) is the center points (h ==> horizantal)\\n # x, y = state[0], state[1]\\n xch1, ych1 = 0.3, 0.7\\n xch2, ych2 = 0.65, ych1\\n radius = 0.1\\n\\n\\n #Vertical wing of puddle consists of \\n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\\n # where (xcvi,ycvi) is the center points (v ==> vertical)\\n xcv1 = 0.45; ycv1=0.4;\\n xcv2 = xcv1; ycv2 = 0.8;\\n\\n # % 2) two half-circle at end edges of rectangle\\n \\n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n puddle.append([xcv1-radius,ych1-radius])\\n \\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n \\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n \\n puddle.append([xcv1-radius,ych1+radius])\\n\\n\\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n\\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1-radius,y])\\n \\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1+radius,y])\\n \\\"\\\"\\\"\\n for y in np.arrange():\\n puddle.append([])\\n \\n for y in np.arrange():\\n puddle.append([])\\n \\\"\\\"\\\"\\n\\n # HALF CIRCLES\\n ngridTheta = 10\\n thetaVec = np.linspace(0,pi,ngridTheta)\\n\\n for t in thetaVec:\\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\\n\\n \\n outpuddlepts = np.asarray(puddle)\\n return outpuddlepts\",\n \"def swipeBase (self) :\\n grid = self.grid\\n\\n #we start by putting every tile up\\n for columnNbr in range(4) :\\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\\n\\n for lineNbr in range(4) :\\n counter = 0\\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\\n counter += 1\\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\\n for remainingLine in range (lineNbr, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n #now we do the additions\\n for lineNbr in range(3) :\\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\\n grid[lineNbr, columnNbr] *= 2\\n for remainingLine in range (lineNbr+1, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n return (grid)\",\n \"def generate_grains(self, cells):\\n\\t\\tfor cell_num in range(cells):\\n\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\twhile sample_cell.state != 0:\\n\\t\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\tsample_cell.change_state(self.init_time ,cell_num)\",\n \"def test_multigrid_calculates_neighbours_correctly():\\n\\n # create a grid which will result in 9 cells\\n h = 64\\n img_dim = (3 * h + 1, 3 * h + 1)\\n amg = mg.MultiGrid(img_dim, h, WS=127)\\n\\n # check that each cell has the expected neighbours\\n print(amg.n_cells)\\n\\n # expected neieghbours left to right, bottom to top\\n cells = [{\\\"north\\\": amg.cells[3], \\\"east\\\": amg.cells[1], \\\"south\\\": None, \\\"west\\\": None}, # bl\\n {\\\"north\\\": amg.cells[4], \\\"east\\\": amg.cells[2],\\n \\\"south\\\": None, \\\"west\\\": amg.cells[0]}, # bm\\n {\\\"north\\\": amg.cells[5], \\\"east\\\": None,\\n \\\"south\\\": None, \\\"west\\\": amg.cells[1]}, # br\\n {\\\"north\\\": amg.cells[6], \\\"east\\\": amg.cells[4],\\n \\\"south\\\": amg.cells[0], \\\"west\\\": None}, # ml\\n {\\\"north\\\": amg.cells[7], \\\"east\\\": amg.cells[5],\\n \\\"south\\\": amg.cells[1], \\\"west\\\": amg.cells[3]}, # mm\\n {\\\"north\\\": amg.cells[8], \\\"east\\\": None,\\n \\\"south\\\": amg.cells[2], \\\"west\\\": amg.cells[4]}, # mr\\n # tl\\n {\\\"north\\\": None, \\\"east\\\": amg.cells[7],\\n \\\"south\\\": amg.cells[3], \\\"west\\\": None},\\n # tm\\n {\\\"north\\\": None,\\n \\\"east\\\": amg.cells[8], \\\"south\\\": amg.cells[4], \\\"west\\\": amg.cells[6]},\\n {\\\"north\\\": None, \\\"east\\\": None,\\n \\\"south\\\": amg.cells[5], \\\"west\\\": amg.cells[7]}, # tr\\n ]\\n\\n for ii, (gc, cell) in enumerate(zip(amg.cells, cells)):\\n print(ii)\\n assert gc.north == cell['north']\\n assert gc.east == cell['east']\\n assert gc.south == cell['south']\\n assert gc.west == cell['west']\",\n \"def create_glider_gun(i, j, grid):\\n\\n ggun = np.zeros(11*38).reshape(11, 38)\\n\\n ggun[5][1] = ggun[5][2] = 1\\n ggun[6][1] = ggun[6][2] = 1\\n\\n ggun[3][13] = ggun[3][14] = 1\\n ggun[4][12] = ggun[4][16] = 1\\n ggun[5][11] = ggun[5][17] = 1\\n ggun[6][11] = ggun[6][15] = ggun[6][17] = ggun[6][18] = 1\\n ggun[7][11] = ggun[7][17] = 1\\n ggun[8][12] = ggun[8][16] = 1\\n ggun[9][13] = ggun[9][14] = 1\\n\\n ggun[1][25] = 1\\n ggun[2][23] = ggun[2][25] = 1\\n ggun[3][21] = ggun[3][22] = 1\\n ggun[4][21] = ggun[4][22] = 1\\n ggun[5][21] = ggun[5][22] = 1\\n ggun[6][23] = ggun[6][25] = 1\\n ggun[7][25] = 1\\n\\n ggun[3][35] = ggun[3][36] = 1\\n ggun[4][35] = ggun[4][36] = 1\\n\\n grid[i:i+11, j:j+38] = ggun\",\n \"def get_grasp_vis(predictions,\\n color_heightmap,\\n action_rot,\\n action_position,\\n num_rotations=16):\\n canvas = None\\n for canvas_row in range(4):\\n tmp_row_canvas = None\\n for canvas_col in range(int(num_rotations / 4)):\\n rotate_idx = int(canvas_row * num_rotations / 4 + canvas_col)\\n prediction = predictions[rotate_idx, :, :].copy()\\n if rotate_idx == action_rot:\\n position = action_position\\n else:\\n position = None\\n prediction_vis = get_workspace_vis(prediction,\\n color_heightmap,\\n action_position=position)\\n if tmp_row_canvas is None:\\n tmp_row_canvas = prediction_vis\\n else:\\n tmp_row_canvas = np.concatenate((tmp_row_canvas,prediction_vis), axis=1)\\n if canvas is None:\\n canvas = tmp_row_canvas\\n else:\\n canvas = np.concatenate((canvas,tmp_row_canvas), axis=0)\\n return canvas\",\n \"def vis_grid_disentangling(batch_data, func_style, func_rec, gap_size, save_path):\\n images, class_label = batch_data\\n # 1. Calculate reconstructions\\n # (1) Encoded & get shape. (batch, style_dim)\\n style_mu = func_style(images)\\n batch, style_dim = style_mu.size()\\n # (2) Mesh grid. (batch*batch, style_dim) & (batch*batch, class_dim)\\n style_mu = style_mu.unsqueeze(1).expand(batch, batch, style_dim).reshape(-1, style_dim)\\n class_label = class_label.unsqueeze(0).expand(batch, batch).reshape(-1, )\\n # (3) Decode. (batch*batch, ...)\\n recon = func_rec(style_mu, class_label)\\n # 2. Get result\\n recon = torch.reshape(recon, shape=(batch, batch, *recon.size()[1:]))\\n recon = torch.cat([_.squeeze(1) for _ in torch.split(recon, split_size_or_sections=1, dim=1)], dim=3)\\n recon = torch.cat([_.squeeze(0) for _ in torch.split(recon, split_size_or_sections=1, dim=0)], dim=1)\\n # 1> Right\\n hor_images = torch.cat([_.squeeze(0) for _ in torch.split(images, split_size_or_sections=1, dim=0)], dim=2)\\n hor_gap = torch.ones(size=(hor_images.size(0), gap_size, hor_images.size(2)), device=hor_images.device)\\n ret = torch.cat([hor_images, hor_gap, recon], dim=1)\\n # 2> Left\\n ver_images = torch.cat([_.squeeze(0) for _ in torch.split(images, split_size_or_sections=1, dim=0)], dim=1)\\n ver_images = torch.cat([\\n torch.zeros(size=(ver_images.size(0), images.size(2), images.size(3)), device=ver_images.device),\\n torch.ones(size=(ver_images.size(0), gap_size, images.size(3)), device=ver_images.device),\\n ver_images], dim=1)\\n ver_gap = torch.ones(size=(ver_images.size(0), ver_images.size(1), gap_size), device=ver_images.device)\\n ver_images = torch.cat([ver_images, ver_gap], dim=2)\\n # Result\\n ret = torch.cat([ver_images, ret], dim=2)\\n # 3. Save\\n save_image(ret.unsqueeze(0), save_path)\",\n \"def recover_model_vis_waterfall(self, info, g = None):\\n reds = info.get_reds()\\n p1, p2 = self.pol\\n v_mdl = {self.pol: {}}\\n if g is None:\\n if self.gains.gfit is None:\\n self.gains.bandpass_fitting(include_red = True)\\n g = self.gains.gfit\\n SH = self.shape_waterfall\\n if not self.data_backup:\\n print(\\\"The tave is set to False, no need to recalculate vis model.\\\")\\n return\\n for r in reds:\\n bl0 = r[0]\\n num = 0\\n den = 0\\n for bl in r:\\n i,j = bl\\n try:\\n di = self.data_backup[bl][self.pol]\\n wi = np.logical_not(self.flag_backup[bl][self.pol])\\n except:\\n di = self.data_backup[bl[::-1]][self.pol].conj()\\n wi = np.logical_not(self.flag_backup[bl[::-1]][self.pol])\\n num += di * g[p1][i].conj() * g[p2][j] * wi\\n den += np.resize(g[p1][i].conj() * g[p1][i] * g[p2][j].conj() * g[p2][j], SH) * wi\\n v_mdl[self.pol][bl0] = num / (den+1e-10)\\n self.gains.get_mdl(v_mdl)\",\n \"def makeGrid(self, width, height, rewardLocs, exit, nPick=1, nAux=1, walls=[]):\\n # Make mapping from coordinate (x, y, (takenreward1, takenreward2, ...))\\n # to state number, and vice-versa.\\n rTaken = iter([(),])\\n for nPicked in range(1, nPick+1):\\n rTaken = itertools.chain(rTaken, \\n myCombinations(rewardLocs, r=nPicked)\\n )\\n # Iterators are hard to reset, so we list it.\\n rTaken = list(rTaken)\\n\\n # Mappings from state to coordinates, vice-versa\\n coordToState = {}\\n stateToCoord = {}\\n stateIdx = 0\\n for x in range(width):\\n for y in range(height):\\n for stuff in rTaken:\\n for holding in self.holdingPossibilities:\\n coordToState[(x, y, stuff, holding)] = stateIdx\\n stateToCoord[stateIdx] = (x, y, stuff, holding)\\n stateIdx += 1\\n self.deadEndState = stateIdx\\n\\n # Actually make the transition function\\n def trans(f, p): \\n aux = p\\n (x, y, stuff, holding) = stateToCoord[f]\\n actionMap = {}\\n default = {(f, aux): 1}\\n # Make the transition dictionary if the dead-end state (state width*height)\\n if f == self.F-1:\\n for action in range(5):\\n actionMap[action] = default\\n return actionMap\\n\\n # Otherwise, determine directions of motion, etc. \\n for i in range(4):\\n actionMap[i] = default\\n if x != 0 and ((x-1, y) not in walls):\\n actionMap[0] = {(coordToState[(x-1,y,stuff, holding)], aux): 1}\\n if x < width-1 and ((x+1, y) not in walls):\\n actionMap[1] = {(coordToState[(x+1,y,stuff, holding)], aux): 1}\\n if y != 0 and ((x, y-1) not in walls):\\n actionMap[2] = {(coordToState[(x,y-1,stuff, holding)], aux): 1}\\n if y < height-1 and ((x, y+1) not in walls):\\n actionMap[3] = {(coordToState[(x,y+1,stuff, holding)], aux): 1}\\n # What happens when the agent uses action 4?\\n if (x, y) == exit:\\n # Some cases, depending on self.oneAtATime\\n if not self.oneAtATime:\\n # The agent is leaving.\\n actionMap[4] = {(self.deadEndState, aux): 1}\\n else:\\n # The agent is dropping off a reward. holeFiller will\\n # take care of the reward value.\\n if len(stuff) >= nPick:\\n # The agent is not allowed to pick up more stuff\\n actionMap[4] = {(self.deadEndState, aux): 1}\\n else:\\n # The agent drops off the object.\\n actionMap[4] = {(coordToState[(x,y,stuff, -1)], aux): 1}\\n elif (x, y) not in rewardLocs:\\n # No reward to pick up. Do nothing.\\n actionMap[4] = default\\n elif (x, y) in stuff:\\n # This reward has already been used. Do nothing.\\n actionMap[4] = default\\n elif len(stuff) >= nPick or (holding != -1 and holding < len(stuff)\\n and self.oneAtATime):\\n # The agent has its hands full.\\n actionMap[4] = default\\n else:\\n # The agent is allowed to pick up an object.\\n newStuff = tuple(sorted(list(stuff) + [(x, y)]))\\n if self.oneAtATime:\\n newHoldingIdx = newStuff.index((x, y))\\n else:\\n newHoldingIdx = -1\\n actionMap[4] = {(coordToState[(x, y, newStuff, newHoldingIdx)], aux): 1}\\n return actionMap\\n\\n # Man, I'm outputting a lot of stuff.\\n # coordToState[(x, y, rewardsLeft, holding)] -> index of this state\\n # stateToCoord[index] -> (x, y, rewardsLeft, holding)\\n # rTaken is a list of all possible combinations of leftover rewards.\\n return (trans, coordToState, stateToCoord, rTaken)\",\n \"def create_grids(self):\\n \\n par = self.par\\n\\n # a. retirement\\n \\n # pre-decision states\\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\\n \\n # post-decision states\\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\\n \\n # b. working: state space (m,n,k) \\n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\\n\\n par.Nn = par.Nm\\n par.n_max = par.m_max + par.n_add\\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\\n\\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\\n\\n # c. working: w interpolant (and wa and wb and wq)\\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\\n par.a_max = par.m_max + par.a_add\\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\\n \\n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\\n par.b_max = par.n_max + par.b_add\\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\\n \\n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\\n \\n # d. working: egm (seperate grids for each segment)\\n \\n if par.solmethod == 'G2EGM':\\n\\n # i. dcon\\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\\n \\n # ii. acon\\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\\n par.a_acon = np.zeros(par.grid_b_acon.shape)\\n par.b_acon = par.grid_b_acon\\n\\n # iii. con\\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\\n \\n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\\n\\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\\n par.a_con = np.zeros(par.c_con.shape)\\n par.d_con = np.zeros(par.c_con.shape)\\n \\n elif par.solmethod == 'NEGM':\\n\\n par.grid_l = par.grid_m\\n\\n # e. shocks\\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\\n\\n if par.Neta > 1:\\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\\n else:\\n par.eta = np.ones(1)\\n par.w_eta = np.ones(1)\\n\\n # f. timings\\n par.time_work = np.zeros(par.T)\\n par.time_w = np.zeros(par.T)\\n par.time_egm = np.zeros(par.T)\\n par.time_vfi = np.zeros(par.T)\",\n \"def gaddpg_grasps_from_simulate_view(gaddpg, state, time, ef_pose):\\n n = 30\\n mask = get_target_mask(state[0][0])\\n point_state = state[0][0][:, mask]\\n\\n # hand to base\\n point_state = se3_transform_pc(ef_pose, point_state)\\n print('target point shape', point_state.shape)\\n # target center is in base coordinate now\\n target_center = point_state.mean(1)[:3]\\n print('target center', target_center)\\n\\n # set up gaddpg\\n img_state = state[0][1]\\n gaddpg.policy.eval()\\n gaddpg.state_feature_extractor.eval()\\n\\n # sample view (simulated hand) in base\\n view_poses = np.array(sample_ef_view_transform(n, 0.2, 0.5, target_center, linspace=True, anchor=True))\\n\\n # base to view (simulated hand)\\n inv_view_poses = se3_inverse_batch(view_poses)\\n transform_view_points = np.matmul(inv_view_poses[:,:3,:3], point_state[:3]) + inv_view_poses[:,:3,[3]]\\n \\n # gaddpg generate grasps\\n point_state_batch = torch.from_numpy(transform_view_points).cuda().float()\\n time = torch.ones(len(point_state_batch) ).float().cuda() * 10. # time\\n point_state_batch = torch.cat((point_state_batch, torch.zeros_like(point_state_batch)[:, [0]]), dim=1)\\n policy_feat = gaddpg.extract_feature(img_state, point_state_batch, value=False, time_batch=time) \\n _,_,_,gaddpg_aux = gaddpg.policy.sample(policy_feat)\\n \\n # compose with ef poses \\n gaddpg_aux = gaddpg_aux.detach().cpu().numpy()\\n unpacked_poses = [unpack_pose_rot_first(pose) for pose in gaddpg_aux]\\n goal_pose_ws = np.matmul(view_poses, np.array(unpacked_poses)) # grasp to ef\\n planner_cfg.external_grasps = goal_pose_ws\\n\\n # show_grasps(view_poses, 'grasps')\\n # planner_cfg.external_grasps = view_poses\\n # planner_cfg.external_grasps = np.concatenate((goal_pose_ws, view_poses), axis=0) # also visualize view\\n planner_cfg.use_external_grasp = True\",\n \"def recreate_obstacles(self):\\n self.board_matrix = np.full(Dimension.board_size(), 1)\\n self.obstacles = self.create_obstacles()\",\n \"def test_transition_function_empty_grid(self):\\r\\n map_file_path = os.path.abspath(os.path.join(__file__, MAPS_DIR, 'empty-8-8/empty-8-8.map'))\\r\\n grid = MapfGrid(parse_map_file(map_file_path))\\r\\n\\r\\n # agents are starting a\\r\\n agent_starts = ((0, 0), (7, 7))\\r\\n agents_goals = ((0, 2), (5, 7))\\r\\n\\r\\n env = MapfEnv(grid, 2, agent_starts, agents_goals,\\r\\n FAIL_PROB, REWARD_OF_CLASH, REWARD_OF_GOAL, REWARD_OF_LIVING, OptimizationCriteria.Makespan)\\r\\n\\r\\n first_step_transitions = [((round(prob, 2), collision), next_state, reward, done)\\r\\n for ((prob, collision), next_state, reward, done) in\\r\\n env.P[env.s][vector_action_to_integer((RIGHT, UP))]]\\r\\n\\r\\n self.assertEqual(set(first_step_transitions), {\\r\\n ((0.64, False), env.locations_to_state(((0, 1), (6, 7))), REWARD_OF_LIVING, False), # (RIGHT, UP)\\r\\n ((0.08, False), env.locations_to_state(((1, 0), (6, 7))), REWARD_OF_LIVING, False), # (DOWN, UP)\\r\\n ((0.08, False), env.locations_to_state(((0, 0), (6, 7))), REWARD_OF_LIVING, False), # (UP, UP)\\r\\n ((0.08, False), env.locations_to_state(((0, 1), (7, 7))), REWARD_OF_LIVING, False), # (RIGHT, RIGHT)\\r\\n ((0.08, False), env.locations_to_state(((0, 1), (7, 6))), REWARD_OF_LIVING, False), # (RIGHT, LEFT)\\r\\n ((0.01, False), env.locations_to_state(((1, 0), (7, 7))), REWARD_OF_LIVING, False), # (DOWN, RIGHT)\\r\\n ((0.01, False), env.locations_to_state(((1, 0), (7, 6))), REWARD_OF_LIVING, False), # (DOWN, LEFT)\\r\\n ((0.01, False), env.locations_to_state(((0, 0), (7, 7))), REWARD_OF_LIVING, False), # (UP, RIGHT)\\r\\n ((0.01, False), env.locations_to_state(((0, 0), (7, 6))), REWARD_OF_LIVING, False) # (UP, LEFT)\\r\\n })\\r\\n\\r\\n wish_state = env.locations_to_state(((0, 1), (6, 7)))\\r\\n second_step_transitions = [((round(prob, 2), collision), next_state, reward, done)\\r\\n for ((prob, collision), next_state, reward, done) in\\r\\n env.P[wish_state][vector_action_to_integer((RIGHT, UP))]]\\r\\n\\r\\n # [(0,0), (7,7)]\\r\\n self.assertEqual(set(second_step_transitions), {\\r\\n ((0.64, False), env.locations_to_state(((0, 2), (5, 7))), REWARD_OF_LIVING + REWARD_OF_GOAL, True),\\r\\n # (RIGHT, UP)\\r\\n ((0.08, False), env.locations_to_state(((1, 1), (5, 7))), REWARD_OF_LIVING, False), # (DOWN, UP)\\r\\n ((0.08, False), env.locations_to_state(((0, 1), (5, 7))), REWARD_OF_LIVING, False), # (UP, UP)\\r\\n ((0.08, False), env.locations_to_state(((0, 2), (6, 7))), REWARD_OF_LIVING, False), # (RIGHT, RIGHT)\\r\\n ((0.08, False), env.locations_to_state(((0, 2), (6, 6))), REWARD_OF_LIVING, False), # (RIGHT, LEFT)\\r\\n ((0.01, False), env.locations_to_state(((1, 1), (6, 7))), REWARD_OF_LIVING, False), # (DOWN, RIGHT)\\r\\n ((0.01, False), env.locations_to_state(((1, 1), (6, 6))), REWARD_OF_LIVING, False), # (DOWN, LEFT)\\r\\n ((0.01, False), env.locations_to_state(((0, 1), (6, 7))), REWARD_OF_LIVING, False), # (UP, RIGHT)\\r\\n ((0.01, False), env.locations_to_state(((0, 1), (6, 6))), REWARD_OF_LIVING, False) # (UP, LEFT)\\r\\n })\",\n \"def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n hspc=(max_x-min_x)/x_divisions\\n vspc=(max_y-min_y)/y_divisions\\n\\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%.1f\\\" % hval)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%.1f\\\" % vval)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def increased_obstacles_map(occupancy_grid):\\n\\n nb_rows = len(occupancy_grid)\\n nb_cols = len(occupancy_grid[0])\\n increased_occupancy_grid = np.zeros([nb_rows + 6, nb_cols + 6])\\n\\n for i in range(nb_rows):\\n for j in range(nb_cols):\\n\\n if occupancy_grid[i, j] == OCCUPIED:\\n increased_occupancy_grid[i:i + 7, j:j + 7] = np.ones([7, 7])\\n\\n final_occupancy_grid = increased_occupancy_grid[3:(LENGTH_case + 3), 3:(WIDTH_case + 3)]\\n return final_occupancy_grid\",\n \"def make_move(grid, n_columns, n_rows):\\r\\n # Generate the game grid to be manipulated\\r\\n new_grid = [[0] * (n_columns + 1) for i in range(n_rows + 1)]\\r\\n\\r\\n\\r\\n for i in range(n_rows):\\r\\n for j in range(n_columns):\\r\\n upper_left = grid[i-1][j-1] # neighbor to upper left of cell of interest\\r\\n upper = grid[i-1][j] # neighbor above cell of interest\\r\\n upper_right = grid[i-1][j+1] # neighbor to upper right of cell of interest\\r\\n left = grid[i][j-1] # neighbor to left of cell of interest\\r\\n right = grid[i][j+1] # neighbor to right of cell of interest\\r\\n bot_left = grid[i+1][j-1] # neighbor to bottom left cell of interest\\r\\n bot = grid[i+1][j] # neighbor below cell of interest\\r\\n bot_right = grid[i+1][j+1] # neighbor to bottom right of cell of interest\\r\\n\\r\\n # sum of the state of all neighbors\\r\\n on_neighbors = upper_left + upper + upper_right + left + right + bot_left + bot + bot_right\\r\\n\\r\\n # Any ON cell with fewer than two ON neighbors turns OFF\\r\\n if grid[i][j] == 1 and on_neighbors < 2:\\r\\n new_grid[i][j] = 0\\r\\n\\r\\n # Any ON cell with two or three ON neighbours stays ON\\r\\n elif grid[i][j] == 1 and (on_neighbors == 2 or on_neighbors == 3):\\r\\n new_grid[i][j] = 1\\r\\n\\r\\n # Any ON cell with more than three ON neighbors turns OFF\\r\\n elif grid[i][j] == 1 and on_neighbors > 3:\\r\\n new_grid[i][j] = 0\\r\\n\\r\\n # Any OFF cell with three ON neighbors turns ON\\r\\n elif grid[i][j] == 0 and on_neighbors == 3:\\r\\n new_grid[i][j] = 1\\r\\n\\r\\n return new_grid #manipulated game grid\\r\",\n \"def _get_observations(self):\\n food = np.array(self.game.state.data.food.data)\\n walls = np.array(self.game.state.data.layout.walls.data)\\n map_shape = walls.shape\\n capsules = self.game.state.data.capsules\\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\\n\\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\\n self.game.state.data.agentStates[1:]))\\n gosts_scared = list(\\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\\n\\n \\\"\\\"\\\"\\n 0: empty,\\n 1: wall,\\n 2: food,\\n 3: capsules,\\n 4: ghost,\\n 5: scared ghost,\\n 6: pacman\\n \\\"\\\"\\\"\\n\\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\\n\\n def select(l):\\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\\n\\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\\n\\n def pos_to_relative_pos(pos):\\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\\n return None\\n else:\\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\\n\\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\\n\\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\\n if (g_relative_pos is not None):\\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\\n ] = 5 if gosts_scared[i] else 4\\n\\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\\n\\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\\n\\n obs[0, 0] = 2 if np.any(\\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\\n obs[obs.shape[0]-1,\\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\\n\\n obs[0, obs.shape[1] -\\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\\n\\n # print(np.transpose(obs)[::-1, :])\\n\\n return obs\",\n \"def proposal_assignments_det(rpn_rois, gt_boxes, gt_classes, image_offset, fg_thresh=0.5):\\n fg_rois_per_image = int(np.round(ROIS_PER_IMG * FG_FRACTION))\\n gt_img_inds = gt_classes[:, 0] - image_offset\\n all_boxes = torch.cat([rpn_rois[:, 1:], gt_boxes], 0)\\n ims_per_box = torch.cat([rpn_rois[:, 0].long(), gt_img_inds], 0)\\n im_sorted, idx = torch.sort(ims_per_box, 0)\\n all_boxes = all_boxes[idx]\\n num_images = int(im_sorted[-1]) + 1\\n labels = []\\n rois = []\\n bbox_targets = []\\n for im_ind in range(num_images):\\n g_inds = (gt_img_inds == im_ind).nonzero()\\n if g_inds.dim() == 0:\\n continue\\n g_inds = g_inds.squeeze(1)\\n g_start = g_inds[0]\\n g_end = g_inds[-1] + 1\\n t_inds = (im_sorted == im_ind).nonzero().squeeze(1)\\n t_start = t_inds[0]\\n t_end = t_inds[-1] + 1\\n ious = bbox_overlaps(all_boxes[t_start:t_end], gt_boxes[g_start:g_end])\\n max_overlaps, gt_assignment = ious.max(1)\\n max_overlaps = max_overlaps.cpu().numpy()\\n gt_assignment += g_start\\n keep_inds_np, num_fg = _sel_inds(max_overlaps, fg_thresh, fg_rois_per_image, ROIS_PER_IMG)\\n if keep_inds_np.size == 0:\\n continue\\n keep_inds = torch.LongTensor(keep_inds_np)\\n labels_ = gt_classes[:, 1][gt_assignment[keep_inds]]\\n bbox_target_ = gt_boxes[gt_assignment[keep_inds]]\\n if num_fg < labels_.size(0):\\n labels_[num_fg:] = 0\\n rois_ = torch.cat((im_sorted[t_start:t_end, None][keep_inds].float(), all_boxes[t_start:t_end][keep_inds]), 1)\\n labels.append(labels_)\\n rois.append(rois_)\\n bbox_targets.append(bbox_target_)\\n rois = torch.cat(rois, 0)\\n labels = torch.cat(labels, 0)\\n bbox_targets = torch.cat(bbox_targets, 0)\\n return rois, labels, bbox_targets\",\n \"def solve_puzzle(self):\\r\\n \\r\\n counter = 0\\r\\n rows = self._height-1\\r\\n cols = self._width-1\\r\\n # print rows, cols\\r\\n # print 'The greed has %s rows and %s coloumn indexes' %(rows, cols) \\r\\n solution_move = ''\\r\\n if self.get_number(0,0) == 0 and \\\\\\r\\n self.get_number(0,1) == 1:\\r\\n # print 'Congrads Puxxle is Aolved at start!!!!!'\\r\\n return ''\\r\\n #appropriate_number = (self._height * self._width) - 1\\r\\n appropriate_number = (rows+1) * (cols+1) -1\\r\\n # print 'First appropriate_number=',appropriate_number\\r\\n # print \\\"Grid first tile that we will solwing has value =\\\", self._grid[rows][cols]\\r\\n \\r\\n while counter < 300:\\r\\n counter +=1\\r\\n # print self\\r\\n #appropriate_number = (rows+1) * (cols+1) -1\\r\\n # print 'Appropriate number in loop=',appropriate_number\\r\\n # print 'We are solving %s index_row and %s index_col' %(rows, cols) \\r\\n ####Case when we use solve_interior_tile\\r\\n if rows > 1 and cols > 0:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n cols -= 1\\r\\n appropriate_number -=1\\r\\n else:\\r\\n # print 'We are solving interior tile', (rows, cols)\\r\\n solution_move += self.solve_interior_tile(rows, cols)\\r\\n # print 'Solution move=', solution_move\\r\\n cols -= 1\\r\\n #### Case when we use solve_col0_tile\\r\\n elif rows > 1 and cols == 0:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows -= 1\\r\\n cols = self._width-1\\r\\n appropriate_number -=1\\r\\n else:\\r\\n # print 'We are solwing tile 0 in row', rows\\r\\n # print 'Appropriate number here ='\\r\\n solution_move += self.solve_col0_tile(rows)\\r\\n # print 'Solution move=', solution_move\\r\\n rows -=1\\r\\n cols = self._width-1\\r\\n\\r\\n\\r\\n #### Cases when we use solve_row0_tile\\r\\n elif rows == 1 and cols > 1:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows -= 1\\r\\n #cols = self._width-1\\r\\n appropriate_number -= self._width\\r\\n\\r\\n else:\\r\\n # print 'Solving upper 2 rows right side'\\r\\n solution_move += self.solve_row1_tile(cols)\\r\\n rows -=1\\r\\n appropriate_number -= self._width\\r\\n #### Cases when we use solve_row1_tile \\r\\n if rows < 1 and cols > 1:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows += 1\\r\\n cols -= 1\\r\\n appropriate_number +=self._width-1\\r\\n else:\\r\\n # print '(1,J) tile solved, lets solwe tile (0,j) in tile',(rows,cols)\\r\\n # print 'Greed after move solve_row1_tile'\\r\\n # print self\\r\\n solution_move += self.solve_row0_tile(cols)\\r\\n rows +=1\\r\\n cols -=1\\r\\n appropriate_number +=self._width-1\\r\\n\\r\\n\\r\\n #### Case when we use solve_2x2\\r\\n elif rows <= 1 and cols <= 1:\\r\\n # print 'We are solving 2x2 puzzle'\\r\\n solution_move += self.solve_2x2()\\r\\n if self._grid[0][0] == 0 and \\\\\\r\\n self._grid[0][1] == 1:\\r\\n # print 'Congrads Puxxle is SOLVED!!!!!'\\r\\n break\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n if counter > 100:\\r\\n # print 'COUNTER BREAK'\\r\\n break\\r\\n # print solution_move, len(solution_move)\\r\\n return solution_move\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n # for row in solution_greed._grid[::-1]:\\r\\n # print solution_greed._grid\\r\\n # print 'Row =',row\\r\\n \\r\\n # if solution_greed._grid.index(row) > 1:\\r\\n # print \\\"Case when we solwing Interior and Tile0 part\\\"\\r\\n \\r\\n\\r\\n # for col in solution_greed._grid[solution_greed._grid.index(row)][::-1]:\\r\\n # print 'Coloumn value=', col\\r\\n #print row[0]\\r\\n # if col !=row[0]:\\r\\n # print 'Case when we use just Interior tile solution'\\r\\n # print solution_greed._grid.index(row)\\r\\n # print row.index(col)\\r\\n \\r\\n # solution += solution_greed.solve_interior_tile(solution_greed._grid.index(row) , row.index(col))\\r\\n # print 'Solution =', solution\\r\\n # print self \\r\\n # print solution_greed._grid\\r\\n # elif col ==row[0]:\\r\\n # print 'Case when we use just Col0 solution'\\r\\n\\r\\n # else:\\r\\n # print 'Case when we solwing first two rows'\\r\\n\\r\\n #return \\\"\\\"\\r\",\n \"def outcome(self, g):\\n if g[0][0] == g[1][0] == g[2][0] and g[0][0] != 0:\\n return g[0][0]\\n if g[0][1] == g[1][1] == g[2][1] and g[0][1] != 0:\\n return g[0][1]\\n if g[0][2] == g[1][2] == g[2][2] and g[0][2] != 0:\\n return g[0][2]\\n if g[0][0] == g[0][1] == g[0][2] and g[0][0] != 0:\\n return g[0][0]\\n if g[1][0] == g[1][1] == g[1][2] and g[1][0] != 0:\\n return g[1][0]\\n if g[2][0] == g[2][1] == g[2][2] and g[2][0] != 0:\\n return g[2][0]\\n if g[0][0] == g[1][1] == g[2][2] and g[0][0] != 0:\\n return g[0][0]\\n if g[0][2] == g[1][1] == g[2][0] and g[0][2] != 0:\\n return g[0][2]\\n return 0\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def climb_tree():\\n global UP_TREE\\n westdesc = \\\"\\\"\\n eastdesc = \\\"\\\"\\n northdesc = \\\"\\\"\\n southdesc = \\\"\\\"\\n UP_TREE = True\\n westinvalid = False\\n eastinvalid = False\\n northinvalid = False\\n southinvalid = False\\n\\n\\n printmessage(\\\"You climb the large tree to get a look at your surroundings.\\\", 5, MAGENTA, 2)\\n\\n if ZERO_BASE_PLYR_POS in range(0, 10):\\n northinvalid = True\\n if ZERO_BASE_PLYR_POS in range(90, 100):\\n southinvalid = True\\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\\n eastinvalid = True\\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\\n westinvalid = True\\n \\n if not westinvalid: \\n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\\n if HAS_COMPASS: \\n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \\\"Y\\\"\\n if westpos == 10: # Water\\n westdesc = TREE_VIEWS[2]\\n else:\\n westdesc = TREE_VIEWS[1]\\n\\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\\n if westpos == 1:\\n westdesc = TREE_VIEWS[3]\\n elif westpos == 2:\\n westdesc = TREE_VIEWS[4]\\n else:\\n westdesc = TREE_VIEWS[5]\\n\\n if not eastinvalid:\\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \\\"Y\\\"\\n if eastpos == 10: # Water\\n eastdesc = TREE_VIEWS[2]\\n else:\\n eastdesc = TREE_VIEWS[1]\\n\\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\\n if eastpos == 1:\\n eastdesc = TREE_VIEWS[3]\\n elif eastpos == 2:\\n eastdesc = TREE_VIEWS[4]\\n else:\\n eastdesc = TREE_VIEWS[6]\\n\\n\\n if not northinvalid:\\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \\\"Y\\\"\\n if northpos == 10: # Water\\n northdesc = TREE_VIEWS[2]\\n else:\\n northdesc = TREE_VIEWS[1]\\n\\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\\n if northpos == 1: # bear\\n northdesc = TREE_VIEWS[3]\\n elif northpos == 2: # grizzly\\n northdesc = TREE_VIEWS[4]\\n else:\\n northdesc = TREE_VIEWS[7]\\n\\n\\n if not southinvalid:\\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \\\"Y\\\"\\n if southpos == 10: # Water\\n southdesc = TREE_VIEWS[2]\\n else:\\n southdesc = TREE_VIEWS[1]\\n\\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\\n if southpos == 1: # bear\\n southdesc = TREE_VIEWS[3]\\n elif southpos == 2: # grizzly\\n southdesc = TREE_VIEWS[4]\\n else:\\n southdesc = TREE_VIEWS[8]\\n\\n clear_messages(0)\\n printmessage(\\\"West: \\\" + westdesc, 2, GREEN, 0)\\n printmessage(\\\"East: \\\" + eastdesc, 3, YELLOW, 0)\\n printmessage(\\\"North: \\\" + northdesc, 4, CYAN, 0)\\n printmessage(\\\"South: \\\" + southdesc, 5, MAGENTA, 0)\\n #show_movement(True, 10)\\n update_player_on_map()\\n pause_for_keypress()\\n clear_messages(0)\",\n \"def test_no_backg_subt():\\n \\n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\\n test_object.calculate_r_i(correct=True, plot_i=False, thr=80)\",\n \"def buildpuzzle(self):\\r\\n self.puzzle = copy.deepcopy(self.rows)\\r\\n if self.difficulty == 1:\\r\\n self.removedigits(1)\\r\\n if self.difficulty == 2:\\r\\n self.removedigits(2)\\r\\n if self.difficulty == 3:\\r\\n self.removedigits(3)\",\n \"def main_loop(self):\\n for iteration in xrange(1, self.num_iterations + 1):\\n print \\\"At iteration %d\\\" % iteration\\n self.it_num = iteration\\n \\n ### Select cells randomly without replacement\\n x, y = np.meshgrid(np.arange(self.x_len), np.arange(self.y_len))\\n \\n x = x.flat\\n y = y.flat\\n \\n shuffled_indices = np.random.permutation(np.arange(self.x_len * self.y_len))\\n \\n for index in shuffled_indices:\\n # Get the current y and x indices\\n cur_y, cur_x = y[index], x[index]\\n \\n \\n if self.altered == False:\\n # Use the standard version\\n if self.grid[cur_y, cur_x] == 0:\\n # If there's no slab there then we can't erode it!\\n continue\\n else:\\n # Use the altered version of checking if we can erde\\n if self.grid[cur_y, cur_x] == self.depth[cur_y, cur_x]:\\n # We can't erode it, so continue\\n continue\\n \\n # Check to see if the cell is in shadow.\\n if self.cell_in_shadow(cur_y, cur_x):\\n # If it's in shadow then we can't erode it, so go to the next random cell \\n continue\\n \\n if True:\\n # Move a slab\\n self.grid[cur_y, cur_x] -= 1\\n \\n orig_y, orig_x = cur_y, cur_x\\n \\n # Loop forever - until we break out of it\\n while True:\\n new_y, new_x = cur_y, self.add_x(cur_x, self.jump_length)\\n \\n if self.grid[new_y, new_x] == 0:\\n prob = self.pd_ns\\n else:\\n prob = self.pd_s\\n \\n if np.random.random_sample() <= prob:\\n # Drop cell\\n break\\n else:\\n cur_y, cur_x = new_y, new_x\\n \\n #print \\\"Dropping on cell\\\"\\n #print new_y, new_x\\n # Drop the slab on the cell we've got to\\n self.grid[new_y, new_x] += 1\\n \\n self.do_repose(orig_y, orig_x)\\n \\n self.do_repose(new_y, new_x)\\n \\n self.write_file()\",\n \"def drawValidationNeedles(self): \\n #productive #onButton\\n profprint()\\n # reset report table\\n # print \\\"Draw manually segmented needles...\\\"\\n #self.table =None\\n #self.row=0\\n self.initTableView()\\n self.deleteEvaluationNeedlesFromTable()\\n while slicer.util.getNodes('manual-seg*') != {}:\\n nodes = slicer.util.getNodes('manual-seg*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\\n \\n if self.tableValueCtrPt==[[]]:\\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n for nthNode in range(nbNode):\\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\\n if modelNode.GetAttribute(\\\"ValidationNeedle\\\") == \\\"1\\\":\\n needleNumber = int(modelNode.GetAttribute(\\\"NeedleNumber\\\"))\\n needleStep = int(modelNode.GetAttribute(\\\"NeedleStep\\\"))\\n coord=[0,0,0]\\n modelNode.GetFiducialCoordinates(coord)\\n self.tableValueCtrPt[needleNumber][needleStep]=coord\\n print needleNumber,needleStep,coord\\n # print self.tableValueCtrPt[needleNumber][needleStep]\\n\\n for i in range(len(self.tableValueCtrPt)):\\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\\n colorVar = random.randrange(50,100,1)/float(100)\\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\\n self.addNeedleToScene(controlPoints,i,'Validation')\\n else:\\n # print i\\n pass\",\n \"def reset(self):\\n\\n self.x = np.random.randint(3, self.grid_size-3, size=1)[0]\\n self.y = np.random.randint(3, self.grid_size-3, size=1)[0]\\n \\n self.h_x = []\\n self.h_y = []\\n for i in range(self.hunters):\\n x = np.random.randint(3, self.grid_size-3, size=1)[0]\\n y = np.random.randint(3, self.grid_size-3, size=1)[0]\\n self.h_x.append(x)\\n self.h_y.append(y)\\n\\n self.trajectory = np.zeros((self.grid_size,self.grid_size))\\n\\n bonus = 0.5 * np.random.binomial(1,self.temperature,size=self.grid_size**2)\\n bonus = bonus.reshape(self.grid_size,self.grid_size)\\n\\n malus = -1.0 * np.random.binomial(1,self.temperature,size=self.grid_size**2)\\n malus = malus.reshape(self.grid_size, self.grid_size)\\n\\n self.to_draw = np.zeros((self.max_time+2, self.grid_size*self.scale, self.grid_size*self.scale, 3))\\n\\n\\n malus[bonus>0]=0\\n\\n self.board = bonus + malus\\n\\n self.position = np.zeros((self.grid_size, self.grid_size))\\n self.position[0:2,:]= -1\\n self.position[:,0:2] = -1\\n self.position[-2:, :] = -1\\n self.position[:, -2:] = -1\\n self.board[self.x,self.y] = 0\\n self.t = 0\\n \\n self.board_with_hunters[:,:] = 0\\n \\n for i in range(self.hunters):\\n self.board_with_hunters[self.h_x[i],self.h_y[i]] = -100\\n \\n\\n global_state = np.concatenate((\\n self.board.reshape(self.grid_size, self.grid_size,1),\\n self.position.reshape(self.grid_size, self.grid_size,1),\\n self.trajectory.reshape(self.grid_size, self.grid_size,1),\\n self.board_with_hunters.reshape(self.grid_size, self.grid_size,1)),axis=2)\\n\\n state = global_state[self.x - 2:self.x + 3, self.y - 2:self.y + 3, :]\\n return state\",\n \"def createStabilizedView():\\n global cc\\n y = b.createNode('StartStabilized')\\n dd = b.createNode('Dot', '', False)\\n de = b.createNode('Dot', '', False)\\n w = b.createNode('EndStabilized')\\n if cc:\\n y = gV(y)\\n w = gX(w)\\n y['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\\n w['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\\n w.connectInput(2, y)\\n stabilizedPrecompNode___connectPrecompNodes(y, w)\\n cd = 250\\n df = 250\\n ez = 50\\n eA = 7\\n cP(dd)\\n de.setSelected(True)\\n eB = b.nodes.BackdropNode(xpos=y.xpos() + cd / 2, bdwidth=cd * 1.5, ypos=y.ypos() - ez, bdheight=df + 2 * ez,\\n tile_color=int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16),\\n note_font_color=4294967040, note_font_size=36, name='MochaImport+')\\n eB['label'].setValue('Stabilized View+')\\n dd.setXpos(y.xpos() + cd)\\n dd.setYpos(y.ypos() + eA)\\n de.setXpos(y.xpos() + cd)\\n de.setYpos(y.ypos() + df + eA)\\n w.setXpos(y.xpos())\\n w.setYpos(y.ypos() + df)\\n eB['help'].setValue(\\n \\\"\\\\n<h2>Basic Usage of Stabilized View Rig</h2>\\\\n<ol>\\\\n<li>From the MochaImport+ menu, create the stabilized view rig consisting of the StartStabilized node, the EndStabilized node, and the Stabilized View Backdrop.</li>\\\\n<li>Load your mocha tracking data in the StartStabilized node.\\\\n</li><li>Do arbitrary manipulations in the Stabilized View by inserting new nodes inside the backdrop. All changes you do there in a stabilized setting will also be visible in your original perspective after the EndStabilized node.</li>\\\\n</ol>\\\\n\\\\n<h2>Lens Distortion</h2>\\\\n<p>If you've used the mocha Lens module to analyze the lens distortion of your clip, you need to do the following things to get an undistorted stabilized view and reapply the lens distortion to the final result:\\\\n</p><ul>\\\\n<li>make sure the mocha corner pin data you load into the StartStabilized node is exported from mocha Pro with the option 'Remove lens distortion'</li>\\\\n<li>as UndistMap input of the StartStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'undistort'.</li>\\\\n<li>as DistMap input of the EndStabilized node use a Distortion Map Clip (ST Map) exported with the mocha Pro lens module with option 'distort'.</li>\\\\n</ul>\\\".replace(\\n '\\\\n', '').replace('\\\\r', ''))\",\n \"def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\\n\\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\\n \\n \\n for i in np.arange(0,SHP[0],1):\\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\\n \\n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\\n \\n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\\n\\n # normalise lateral flow so that -ve= flow out of cells towards edges\\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\\n # fluxes if not normalised in this way.\\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\\n\\n # nabla is the inverted delta operator used to denote the divergence \\n # of a vector field, here applied to hydrological flow in m3/d \\n # calculated as dx/dt + dy/dt + dz/dt\\n\\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\\n \\n # divergence gives net in/outflow in m3/t\\n # cells/m3 = cells/mL *1000\\n\\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\\n\\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \\n\\n Cells[Cells<0] = 0\\n \\n CellColumnTot = Cells.sum(axis=1)\\n \\n\\n return Cells, CellColumnTot\",\n \"def decision(grid):\\n child = Maximize((grid,0),-999999999,999999999)[0]\\n Child = child.map\\n g = grid.clone()\\n for M in range(4):\\n if g.move(M):\\n if g.map == Child:\\n # global prune\\n # global pruneLog\\n # pruneLog.append(prune)\\n # print(prune)\\n # print(sum(pruneLog)/len(pruneLog))\\n return M\\n g = grid.clone()\",\n \"def create_matrices(maze, reward, penalty_s, penalty_l, prob):\\n \\n r, c = np.shape(maze)\\n states = r*c\\n p = prob\\n q = (1 - prob)*0.5\\n \\n # Create reward matrix\\n path = maze*penalty_s\\n walls = (1 - maze)*penalty_l\\n combined = path + walls\\n \\n combined[-1, -1] = reward\\n \\n R = np.reshape(combined, states)\\n \\n # Create transition matrix\\n T_up = np.zeros((states, states))\\n T_left = np.zeros((states, states))\\n T_right = np.zeros((states, states))\\n T_down = np.zeros((states, states))\\n \\n wall_ind = np.where(R == penalty_l)[0]\\n\\n for i in range(states):\\n # Up\\n if (i - c) < 0 or (i - c) in wall_ind :\\n T_up[i, i] += p\\n else:\\n T_up[i, i - c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i+1] += q\\n \\n # Down\\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_down[i, i] += p\\n else:\\n T_down[i, i + c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i+1] += q\\n \\n # Left\\n if i%c == 0 or (i - 1) in wall_ind:\\n T_left[i, i] += p\\n else:\\n T_left[i, i-1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i + c] += q\\n \\n # Right\\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_right[i, i] += p\\n else:\\n T_right[i, i+1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i + c] += q\\n \\n T = [T_up, T_left, T_right, T_down] \\n \\n return T, R\",\n \"def vision(image):\\n vis_map = resize(image, alpha, beta)\\n print(\\\"Resized map from the blue mask\\\")\\n\\n world = rotate(vis_map)\\n\\n plt.figure()\\n plt.imshow(world[:, :, ::-1])\\n plt.show()\\n object_grid, occupancy_grid = detect_object(world)\\n print(\\\"Result of the red mask\\\")\\n plt.figure()\\n plt.imshow(occupancy_grid)\\n plt.show()\\n return object_grid, occupancy_grid, world\",\n \"def __generate_goal_board(self):\\n element = 1\\n array = []\\n\\n for row in range(self._n):\\n row_to_append = []\\n for col in range(self._n):\\n row_to_append.append(element)\\n element += 1\\n array.append(row_to_append)\\n\\n array[self._n - 1][self._n - 1] = 0\\n self._solved_board = Board(array=array, space=[self._n - 1, self._n - 1])\",\n \"def examineMaze(self, gameState):\\n w = self.walls.width\\n h = self.walls.height\\n walls = self.walls.deepCopy()\\n food1 = self.getFoodYouAreDefending(gameState)\\n food2 = self.getFood(gameState)\\n\\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y]:\\n walls[x][y] = 0\\n elif food1[x][y]:\\n walls[x][y] = 2\\n elif food2[x][y]:\\n walls[x][y] = 2\\n else:\\n walls[x][y] = 1\\n\\n roomsDisplay = []\\n # Detect doors and spaces. Spaces are now negative\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y] > 0:\\n exitsNum = 0\\n if walls[x][y - 1] != 0:\\n exitsNum += 1\\n if walls[x][y + 1] != 0:\\n exitsNum += 1\\n if walls[x - 1][y] != 0:\\n exitsNum += 1\\n if walls[x + 1][y] != 0:\\n exitsNum += 1\\n if exitsNum == 1 or exitsNum == 2:\\n walls[x][y] = -1 * walls[x][y]\\n roomsDisplay.append((x, y))\\n elif exitsNum == 0:\\n # We erase unaccessible cells\\n walls[x][y] = 0\\n else:\\n # These are doors or big rooms, we leave them positive\\n pass\\n\\n # Create roomsGraph: every room has a number, some cells and some doors\\n roomsGraph = []\\n doorsGraph = []\\n for x in range(1, w - 1):\\n for y in range(1, h - 1):\\n if walls[x][y] < 0:\\n spacesNum = 0\\n if walls[x][y - 1] < 0:\\n spacesNum += 1\\n if walls[x][y + 1] < 0:\\n spacesNum += 1\\n if walls[x - 1][y] < 0:\\n spacesNum += 1\\n if walls[x + 1][y] < 0:\\n spacesNum += 1\\n if spacesNum < 2:\\n endOfPath = False\\n graphNode = {\\\"path\\\": [], \\\"doors\\\": [], \\\"food\\\": 0, \\\"isBig\\\": False}\\n auxx = x\\n auxy = y\\n while not endOfPath:\\n graphNode[\\\"path\\\"].append((x, y))\\n graphNode[\\\"food\\\"] += -walls[x][y] - 1\\n walls[x][y] = 0\\n xx = x\\n yy = y\\n if walls[x][y - 1] < 0:\\n yy = y - 1\\n elif walls[x][y + 1] < 0:\\n yy = y + 1\\n elif walls[x - 1][y] < 0:\\n xx = x - 1\\n elif walls[x + 1][y] < 0:\\n xx = x + 1\\n else:\\n endOfPath = True\\n if walls[x][y - 1] > 0:\\n if [(x, y - 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y - 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y - 1), []]))\\n if walls[x][y + 1] > 0:\\n if [(x, y + 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y + 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y + 1), []]))\\n if walls[x - 1][y] > 0:\\n if [(x - 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x - 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x - 1, y), []]))\\n if walls[x + 1][y] > 0:\\n if [(x + 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x + 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x + 1, y), []]))\\n x = xx\\n y = yy\\n roomsGraph.append(graphNode)\\n x = auxx\\n y = auxy\\n\\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\\n for j, door in enumerate(doorsGraph):\\n for i, room in enumerate(roomsGraph):\\n for aDoor in room[\\\"doors\\\"]:\\n if aDoor == j:\\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\\n (x, y) = doorsGraph[j][0]\\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\\n adjacentDoors = []\\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\\n for p in adjacentCells:\\n # Skip if wall\\n if self.walls[p[0]][p[1]]:\\n continue\\n # Skip if door\\n isRoom = False\\n for room in doorsGraph[j][1]:\\n if p in roomsGraph[room][\\\"path\\\"]:\\n isRoom = True\\n break\\n if not isRoom:\\n # Add if existing door\\n doorFound = False\\n for i, neighborDoor in enumerate(doorsGraph):\\n if neighborDoor[0] == p:\\n adjacentDoors.append(i)\\n doorFound = True\\n break\\n # Create if non existing door and add\\n if not doorFound:\\n adjacentDoors.append(len(doorsGraph))\\n doorsGraph.append([p, []])\\n doorsGraph[j].append(adjacentDoors)\\n\\n # Create doorsDistance: maps what doors can be accessed from other doors\\n roomsMapper = {}\\n doorsMapper = {}\\n isRoom = util.Counter()\\n for i, door in enumerate(doorsGraph):\\n doorsMapper[door[0]] = i\\n isRoom[door[0]] = 0\\n for i, room in enumerate(roomsGraph):\\n for p in room[\\\"path\\\"]:\\n roomsMapper[p] = i\\n isRoom[p] = 1\\n\\n # Create self variables\\n self.doorsGraph = doorsGraph\\n self.roomsGraph = roomsGraph\\n self.roomsMapper = roomsMapper\\n self.doorsMapper = doorsMapper\\n self.isRoom = isRoom\\n\\n # # Find dead ends (rooms with only one door)\\n # deadRooms = {}\\n # deadDoors = {}\\n # # deaderDoors = {}\\n # # deaderRooms = {}\\n # for i, room in enumerate(roomsGraph):\\n # if len(room[\\\"doors\\\"]) == 1:\\n # deadRooms[i] = room[\\\"doors\\\"][0]\\n # deadDoors[room[\\\"doors\\\"][0]] = 1\\n # numdR = 0\\n # aliveR = -1\\n # for adjRoom in doorsGraph[room[\\\"doors\\\"][0]][1]:\\n # if adjRoom not in deadRooms:\\n # numdR += 1\\n # aliveR = adjRoom\\n # if numdR + len(doorsGraph[room[\\\"doors\\\"][0]][2]) == 1:\\n # if aliveR >= 0:\\n # deaderRooms[aliveR] = room[\\\"doors\\\"][0]\\n # for adjDoor in roomsGraph[aliveR][\\\"doors\\\"]:\\n # if adjDoor == room[\\\"doors\\\"][0]:\\n # continue\\n # deaderDoors[adjDoor] = 1.0\\n # else:\\n # deaderDoors[doorsGraph[room[\\\"doors\\\"][0]][2][0]] = 1.0\\n\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deaderRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deaderDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, room in enumerate(roomsGraph):\\n # numAliveDoors = 0\\n # aliveDoor = 0\\n # deadDoor = []\\n # for door in room[\\\"doors\\\"]:\\n # if door not in deadDoors:\\n # numAliveDoors += 1\\n # aliveDoor = door\\n # else:\\n # deadDoor.append(door)\\n # if numAliveDoors == 1:\\n # aliveRoom = 0\\n # aliveNeighborDoor = 0\\n # for door in deadDoor:\\n # # aliveNeighborDoor += len(doorsGraph[door][2])\\n # for neighborRoom in doorsGraph[door][1]:\\n # if neighborRoom not in deadRooms:\\n # aliveRoom += 1\\n # if aliveRoom == len(deadDoor):\\n # deadRooms[i] = aliveDoor\\n # deadDoors[aliveDoor] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\\n # for p in room[\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # for p in deadDoor:\\n # roomsCounter[2][doorsGraph[p][0]] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, door in enumerate(doorsGraph):\\n # if i not in deadDoors:\\n # numOpenRooms = 0\\n # openRoom = 0\\n # for j, room in enumerate(door[1]):\\n # if room not in deadRooms:\\n # numOpenRooms += 1\\n # openRoom = j\\n # if numOpenRooms + len(door[2]) == 1:\\n # for room in door[1]:\\n # if room != openRoom:\\n # deadRooms[room] = i\\n # deadDoors[j] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][door[0]] = 1\\n # for rr in door[1]:\\n # print rr\\n # if rr in deadRooms:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # else:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[3][p] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[1][(6, 9)] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deadRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deadDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # Show every room\\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n for room in roomsGraph:\\n for p in room[\\\"path\\\"]:\\n if len(room[\\\"doors\\\"]) > 1:\\n roomsCounter[0][p] = 0.4\\n else:\\n roomsCounter[2][p] = 0.4\\n # Show every door\\n for door in doorsGraph:\\n roomsCounter[1][door[0]] = 0.4\\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\\n self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\",\n \"def robotGridSummaryDict(self):\\n rgd = self.robotGridDict(incRobotDict=False)\\n robotDict = {}\\n for rid, robot in self.robotDict.items():\\n r = {}\\n # print(\\\"rid\\\", robot.id, robot.alpha, robot.beta)\\n r[\\\"id\\\"] = robot.id\\n r[\\\"nDecollide\\\"] = robot.nDecollide\\n r[\\\"lastStepNum\\\"] = robot.lastStepNum\\n r[\\\"assignedTargetID\\\"] = robot.assignedTargetID\\n r[\\\"hasApogee\\\"] = robot.hasApogee\\n r[\\\"hasBoss\\\"] = robot.hasBoss\\n r[\\\"xPos\\\"] = robot.xPos\\n r[\\\"yPos\\\"] = robot.yPos\\n r[\\\"alpha\\\"] = robot.alpha\\n r[\\\"beta\\\"] = robot.beta\\n r[\\\"destinationAlpha\\\"] = robot.destinationAlpha\\n r[\\\"desstinationBeta\\\"] = robot.destinationBeta\\n r[\\\"angStep\\\"] = robot.angStep\\n r[\\\"collisionBuffer\\\"] = robot.collisionBuffer\\n\\n # convert from numpy arrays to lists\\n r[\\\"metFiberPos\\\"] = list(robot.metFiberPos)\\n r[\\\"bossFiberPos\\\"] = list(robot.bossFiberPos)\\n r[\\\"apFiberPos\\\"] = list(robot.apFiberPos)\\n r[\\\"roughAlphaX\\\"] = robot.roughAlphaX[-1][-1]\\n r[\\\"roughAlphaY\\\"] = robot.roughAlphaY[-1][-1]\\n r[\\\"roughBetaX\\\"] = robot.roughBetaX[-1][-1]\\n r[\\\"roughBetaY\\\"] = robot.roughBetaY[-1][-1]\\n # find the step at which this\\n # guy found its target\\n # otv = np.array(robot.onTargetVec)\\n # print(\\\"otargvec\\\", otv)\\n # r[\\\"onTargetVec\\\"] = robot.onTargetVec[-1]\\n # # find last False (after which must be true)\\n # # +1 because step numbers start from 1 and indices start from 0\\n # whereFalse = np.argwhere(otv==False).flatten()\\n # if not whereFalse:\\n # # empty list started on target? thats crazy\\n # lastFalse = 0\\n # else:\\n # lastFalse = int(whereFalse[-1] + 1)\\n # if lastFalse == len(otv):\\n # # last step was false robot never got there\\n # r[\\\"stepConverged\\\"] = str(-1 )# -1 incicates never got to target\\n # else:\\n # r[\\\"stepConverged\\\"] = str(lastFalse)\\n robotDict[robot.id] = r\\n\\n rgd[\\\"robotDict\\\"] = robotDict\\n return rgd\",\n \"def set_bc(self, problem):\\n bcs = problem.bcs\\n n_bound = cfg.const['N_GHOST_CELLS']\\n # Left X-b.c.\\n for i in range(0, self.i_min):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[0] == 't': \\n self.U[i][j][k] = self.U[self.i_min][j][k]\\n elif bcs[0] == 'w':\\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n else:\\n print(\\\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right X-b.c.\\n for i in range(self.i_max, self.i_max+n_bound):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[1] == 't':\\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\\n elif bcs[1] == 'w':\\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_min):\\n for k in range(self.k_min, self.k_max): \\n if bcs[2] == 't':\\n self.U[i][j][k] = self.U[i][self.j_min][k]\\n elif bcs[2] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(self.j_max, self.j_max+n_bound):\\n for k in range(self.k_min, self.k_max): \\n if bcs[3] == 't':\\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\\n elif bcs[3] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(0, self.k_min): \\n if bcs[4] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_min]\\n elif bcs[4] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(self.k_max, self.k_max+n_bound):\\n if bcs[5] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\\n elif bcs[5] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\",\n \"def mover_bm_arriba(self):\\n self.nueva_posicion_posible_parte_superior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0],\\n self.casilla[1] - 1],\\n [self.vertice_1[0] ,self.vertice_1[1] - self.velocidad],\\n [self.vertice_1[0], self.vertice_1[1] - 5 -5])\\n self.nueva_posicion_posible_parte_inferior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] + 1,\\n self.casilla[1] - 1],\\n [self.vertice_2[0] ,self.vertice_2[1] - self.velocidad],\\n [self.vertice_1[0],self.vertice_1[1]])\\n self.y -= self.velocidad * (self.y >= 15) *(self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1)\\n self.posicion = [self.posicion[0],self.y]\\n self.casilla = [self.casilla[0],self.casilla[1] - self.nueva_posicion_posible_parte_superior[1] * (self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1)]\\n self.redefinir_vertices()\",\n \"def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\\n\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n\\n #this is just printing stuff for easier terminal reading\\n if h_agent is not None:\\n hstr = \\\"Specialized Human\\\"\\n else:\\n hstr = \\\"Random Human\\\"\\n if coagent is not None:\\n coagenthelp = True\\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\\n else:\\n coagenthelp = False\\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\\n\\n liRewards = []\\n liRewardsPenalized = []\\n actionsctli =[]\\n heatmap = np.zeros((7, 7))\\n for i in range(episodes):\\n grid.reset()\\n actionct = 0\\n misstepct = 0\\n heatmap[0,0] += 1\\n while (not grid.isEnd) and (grid.numSteps <=200):\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n state_ind = state[1]*(width+1)+state[0]\\n\\n if 'disjoint' in mode:\\n actions = [0, 1, 2, 3]\\n else:\\n #'up','right','down','left','upri','dori','dole','uple'\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n #if we have a special human agent use it, if not use random human\\n if h_agent is None:\\n action = np.random.choice(actions, 1)[0]\\n h_action = action\\n else:\\n action = h_agent.get_action(state_ind)\\n h_action = action\\n if coagenthelp:\\n q_vals = coagent.get_q_values(state_ind)\\n best_action = coagent.get_action(state_ind)\\n best_q = q_vals[best_action]\\n min_q = min(q_vals)\\n human_q = q_vals[action]\\n\\n #closest actions dictionary\\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\\n #value = action index if radial\\n #key = actual action index\\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\\n #actions in order of circle\\n a_radial = [0,4,1,5,2,6,3,7]\\n #co-pilot action choices\\n #override to optimal if suboptimal action selected\\n if \\\"override\\\" in mode:\\n #random percent to decide when to help if wrong action taken\\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\\n actionct += 1\\n action = best_action\\n #select best closest action if human action q-value is negative\\n elif mode == \\\"q-neg\\\" and human_q < 0:\\n actionct += 1\\n a_li = closest_a[action]\\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\\n #Shared Autonomy\\n #select better closest action if difference between best q and human q is past some threshold\\n elif mode == \\\"q-diff\\\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\\n actionct += 1\\n for i in range(1,5):\\n radial_a = a_dist_ind[action]\\n ccw_ra = (radial_a - i) % len(actions)\\n ccw_a = a_radial[ccw_ra]\\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = ccw_a\\n break\\n cw_ra = (radial_a + i) % len(actions)\\n cw_a = a_radial[cw_ra]\\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = cw_a\\n break\\n #take the potentiallny new action\\n grid.step(action)\\n\\n if h_agent is not None:\\n heatmap[grid.state[1],grid.state[0]] += 1\\n\\n #add metrics to their respective lists\\n liRewards.append(grid.reward)\\n liRewardsPenalized.append(grid.reward-actionct)\\n actionsctli.append(actionct)\\n #convert lists to numpy arrays\\n rewards = np.array(liRewards)\\n rewards_penalized = np.array(liRewardsPenalized)\\n actionsctli = np.array(actionsctli)\\n #print some metrics if we want to\\n if verbose:\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\\n if h_agent is not None:\\n plt.figure()\\n print(heatmap)\\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\\n plt.savefig('two.png')\\n\\n return rewards, actionsctli, rewards_penalized\",\n \"def getInitialObstacles():\\n # hardcode number of blocks\\n # will account for movemnet\\n from random import choice\\n from globals import TILEWIDTH, TILEHEIGHT, WINHEIGHT, TILEFLOORHEIGHT, LEVEL, HALFWINWIDTH\\n\\n no_of_blocks = 50\\n for b in range(no_of_blocks // 2):\\n # get image\\n # image = globals.IMAGESDICT['rock']\\n for y in range(1,5):\\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\\n # make rect\\n spaceRect = pygame.Rect((b * TILEWIDTH, y * TILEFLOORHEIGHT, TILEWIDTH, TILEFLOORHEIGHT))\\n landscape = Landscape(image, spaceRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n image = globals.IMAGESDICT['corner']\\n negativeRect = pygame.Rect([-150, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEHEIGHT])\\n landscape = Landscape(image, negativeRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n image = globals.IMAGESDICT['corner']\\n positiveRect = pygame.Rect([LEVEL[0] - TILEWIDTH, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\\n landscape = Landscape(image, positiveRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n bottomRect = pygame.Rect([HALFWINWIDTH, LEVEL[1] - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\\n landscape = Landscape(image, bottomRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n for x in range(0, LEVEL[0], 50):\\n for y in range(10):\\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\\n spaceRect = pygame.Rect((x, LEVEL[1] - (y * TILEHEIGHT), TILEWIDTH, TILEFLOORHEIGHT))\\n landscape = Landscape(image, spaceRect)\\n if choice([0,1,0]):\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n\\n return\",\n \"def rel_assignments(im_inds, rpn_rois, roi_gtlabels, gt_boxes, gt_classes, gt_rels, image_offset, fg_thresh=0.5, num_sample_per_gt=4, filter_non_overlap=True):\\n fg_rels_per_image = int(np.round(REL_FG_FRACTION * 64))\\n pred_inds_np = im_inds.cpu().numpy()\\n pred_boxes_np = rpn_rois.cpu().numpy()\\n pred_boxlabels_np = roi_gtlabels.cpu().numpy()\\n gt_boxes_np = gt_boxes.cpu().numpy()\\n gt_classes_np = gt_classes.cpu().numpy()\\n gt_rels_np = gt_rels.cpu().numpy()\\n gt_classes_np[:, 0] -= image_offset\\n gt_rels_np[:, 0] -= image_offset\\n num_im = gt_classes_np[:, 0].max() + 1\\n rel_labels = []\\n num_box_seen = 0\\n for im_ind in range(num_im):\\n pred_ind = np.where(pred_inds_np == im_ind)[0]\\n gt_ind = np.where(gt_classes_np[:, 0] == im_ind)[0]\\n gt_boxes_i = gt_boxes_np[gt_ind]\\n gt_classes_i = gt_classes_np[gt_ind, 1]\\n gt_rels_i = gt_rels_np[gt_rels_np[:, 0] == im_ind, 1:]\\n pred_boxes_i = pred_boxes_np[pred_ind]\\n pred_boxlabels_i = pred_boxlabels_np[pred_ind]\\n ious = bbox_overlaps(pred_boxes_i, gt_boxes_i)\\n is_match = (pred_boxlabels_i[:, None] == gt_classes_i[None]) & (ious >= fg_thresh)\\n pbi_iou = bbox_overlaps(pred_boxes_i, pred_boxes_i)\\n if filter_non_overlap:\\n rel_possibilities = (pbi_iou < 1) & (pbi_iou > 0)\\n rels_intersect = rel_possibilities\\n else:\\n rel_possibilities = np.ones((pred_boxes_i.shape[0], pred_boxes_i.shape[0]), dtype=np.int64) - np.eye(pred_boxes_i.shape[0], dtype=np.int64)\\n rels_intersect = (pbi_iou < 1) & (pbi_iou > 0)\\n rel_possibilities[pred_boxlabels_i == 0] = 0\\n rel_possibilities[:, pred_boxlabels_i == 0] = 0\\n fg_rels = []\\n p_size = []\\n for i, (from_gtind, to_gtind, rel_id) in enumerate(gt_rels_i):\\n fg_rels_i = []\\n fg_scores_i = []\\n for from_ind in np.where(is_match[:, from_gtind])[0]:\\n for to_ind in np.where(is_match[:, to_gtind])[0]:\\n if from_ind != to_ind:\\n fg_rels_i.append((from_ind, to_ind, rel_id))\\n fg_scores_i.append(ious[from_ind, from_gtind] * ious[to_ind, to_gtind])\\n rel_possibilities[from_ind, to_ind] = 0\\n if len(fg_rels_i) == 0:\\n continue\\n p = np.array(fg_scores_i)\\n p = p / p.sum()\\n p_size.append(p.shape[0])\\n num_to_add = min(p.shape[0], num_sample_per_gt)\\n for rel_to_add in npr.choice(p.shape[0], p=p, size=num_to_add, replace=False):\\n fg_rels.append(fg_rels_i[rel_to_add])\\n fg_rels = np.array(fg_rels, dtype=np.int64)\\n if fg_rels.size > 0 and fg_rels.shape[0] > fg_rels_per_image:\\n fg_rels = fg_rels[npr.choice(fg_rels.shape[0], size=fg_rels_per_image, replace=False)]\\n elif fg_rels.size == 0:\\n fg_rels = np.zeros((0, 3), dtype=np.int64)\\n bg_rels = np.column_stack(np.where(rel_possibilities))\\n bg_rels = np.column_stack((bg_rels, np.zeros(bg_rels.shape[0], dtype=np.int64)))\\n num_bg_rel = min(64 - fg_rels.shape[0], bg_rels.shape[0])\\n if bg_rels.size > 0:\\n bg_rels = bg_rels[np.random.choice(bg_rels.shape[0], size=num_bg_rel, replace=False)]\\n else:\\n bg_rels = np.zeros((0, 3), dtype=np.int64)\\n if fg_rels.size == 0 and bg_rels.size == 0:\\n bg_rels = np.array([[0, 0, 0]], dtype=np.int64)\\n all_rels_i = np.concatenate((fg_rels, bg_rels), 0)\\n all_rels_i[:, 0:2] += num_box_seen\\n all_rels_i = all_rels_i[np.lexsort((all_rels_i[:, 1], all_rels_i[:, 0]))]\\n rel_labels.append(np.column_stack((im_ind * np.ones(all_rels_i.shape[0], dtype=np.int64), all_rels_i)))\\n num_box_seen += pred_boxes_i.shape[0]\\n rel_labels = torch.LongTensor(np.concatenate(rel_labels, 0))\\n return rel_labels\",\n \"def get_wm_ws_Gx_bot(self):\\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \\n z_u_r = self.grid_dict['z_u_r']\\n z_u_w = self.grid_dict['z_u_w']\\n [Ly,N] = self.b.shape\\n #---> j-loop\\n for j in range(Ly): \\n self.kbl[j] = N # initialize search\\n #-> end j-loop\\n\\n #--> k-loop\\n for k in range(N-1,0,-1):\\n k_w = k\\n k_r = k-1\\n # --> j loop \\n for j in range(Ly):\\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\\n self.kbl[j] = k_w\\n\\n #--> end k\\n # --> end j\\n\\n\\n '''\\n Compute nondimenisonal shape function coefficeints Gx() by\\n matching values and vertical derivatives of interior mixing\\n coefficients at hbbl (sigma=1)\\n '''\\n\\n self.Gm1_bot = np.zeros([Ly])\\n self.dGm1_dS_bot = np.zeros([Ly])\\n self.Gt1_bot = np.zeros([Ly])\\n self.dGt1_dS_bot = np.zeros([Ly]) \\n self.Av_bl_bot = np.zeros([Ly])\\n self.dAv_bl_bot = np.zeros([Ly]) \\n self.cff_up_bot = np.zeros([Ly])\\n self.cff_dn_bot = np.zeros([Ly])\\n\\n\\n\\n\\n\\n self.wm_bot = np.zeros([Ly])\\n self.ws_bot = np.zeros([Ly]) \\n\\n # CALCULATE ustar for the bottom based on bototm velocities\\n \\n \\n \\n # CALCULATE r_D\\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \\n u = self.u\\n v_upts = TTTW_func.v2u(self.v)\\n \\n ubar = np.mean(u,axis=1)\\n vbar = np.mean(v_upts,axis=1)\\n\\n # --> j loop\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n if self.CD_SWITCH:\\n # DEPTH AVERAGED APPROACH\\n uref = u[j,0]\\n vref = v_upts[j,0]\\n ustar2 = self.C_D * (uref**2 + vref**2)\\n else:\\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n\\n self.wm_bot[j] = wm\\n self.ws_bot[j] = ws\\n \\n k_w = self.kbl[j] \\n z_bl = z_u_w[j,0] + self.hbbl[j]\\n\\n if z_bl < z_u_w[j,k_w-1]:\\n k_w = k_w-1\\n\\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl_bot[j] = Av_bl\\n self.dAv_bl_bot[j] = dAv_bl\\n\\n\\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\\n\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])\",\n \"def update_grid(self, x):\\r\\n\\r\\n # Append boundary rows and columns to matrix\\r\\n x = self.append_boundary(x) # the boundary is recomputed at each step\\r\\n y = np.copy(x)\\r\\n\\r\\n # For each cell within boundary, compute state according to rules.\\r\\n chg_0_1 = 0 # the number of cells that changed from state 0 to state 1\\r\\n chg_1_0 = 0 # the number of cells that changes from state 1 to state 0\\r\\n chg_none = 0 # the number of cells that did not change\\r\\n index = np.arange(1, x.shape[0] - 1)\\r\\n for i in index:\\r\\n for j in index:\\r\\n neighborhood = x[i - 1:i + 2:1, j - 1:j + 2:1] # 3x3 sub matrix centered at i, j\\r\\n y[i, j] = self.update_cell(neighborhood)\\r\\n change = int(y[i, j] - x[i, j])\\r\\n if change == -1:\\r\\n chg_1_0 += 1\\r\\n if change == 0:\\r\\n chg_none += 1\\r\\n if change == 1:\\r\\n chg_0_1 += 1\\r\\n\\r\\n # Compute statistics excluding boundary\\r\\n total = np.power(x[1:-1:1, 1:-1:1].shape[0] - 1, 2)\\r\\n start_1 = np.sum(x[1:-1:1, 1:-1:1])\\r\\n end_1 = np.sum(y[1:-1:1, 1:-1:1])\\r\\n stats = [total, start_1, end_1, chg_1_0, chg_none, chg_0_1]\\r\\n\\r\\n return y[1:-1:1, 1:-1:1], stats # remove the boundary\\r\",\n \"def get_ground_truth_gate_poses_and_half_dims(self):\\n gate_names_sorted_bad = sorted(self.airsim_client.simListSceneObjects(\\\"Gate.*\\\"))\\n assert len(gate_names_sorted_bad) > 0, \\\"ERROR: the gate list returned by simListSceneObjects is empty\\\"\\n gate_indices_bad = [int(gate_name.split('_')[0][4:]) for gate_name in gate_names_sorted_bad]\\n gate_indices_correct = sorted(range(len(gate_indices_bad)), key=lambda k: gate_indices_bad[k])\\n gate_names_sorted = [gate_names_sorted_bad[gate_idx] for gate_idx in gate_indices_correct]\\n nominal_inner_dims = self.airsim_client.simGetNominalGateInnerDimensions()\\n res = []\\n for gate_name in gate_names_sorted:\\n p = self.airsim_client.simGetObjectPose(object_name=gate_name)\\n s = self.airsim_client.simGetObjectScale(object_name=gate_name)\\n # print(f\\\"DEBUG: gate {gate_name}\\\")\\n # print(f\\\"DEBUG: scale {gate_name}: {s}\\\")\\n cpt = 0\\n while (math.isnan(p.position.x_val) or math.isnan(p.position.y_val) or math.isnan(p.position.z_val) or math.isnan(s.x_val) or math.isnan(s.y_val) or math.isnan(s.z_val)) and cpt < MAX_NUMBER_OF_GETOBJECTPOSE_TRIALS:\\n print(f\\\"DEBUG: p for {gate_name} is {p}\\\")\\n print(f\\\"DEBUG: s for {gate_name} is {s}\\\")\\n print(f\\\"DEBUG: {gate_name} is nan, retrying...\\\")\\n cpt += 1\\n p = self.airsim_client.simGetObjectPose(gate_name)\\n assert not math.isnan(p.position.x_val), f\\\"ERROR: {gate_name} p.position.x_val is still {p.position.x_val} after {cpt} trials\\\"\\n assert not math.isnan(p.position.y_val), f\\\"ERROR: {gate_name} p.position.y_val is still {p.position.y_val} after {cpt} trials\\\"\\n assert not math.isnan(p.position.z_val), f\\\"ERROR: {gate_name} p.position.z_val is still {p.position.z_val} after {cpt} trials\\\"\\n assert not math.isnan(s.x_val), f\\\"ERROR: {gate_name} p.position.x_val is still {s.x_val} after {cpt} trials\\\"\\n assert not math.isnan(s.y_val), f\\\"ERROR: {gate_name} p.position.y_val is still {s.y_val} after {cpt} trials\\\"\\n assert not math.isnan(s.z_val), f\\\"ERROR: {gate_name} p.position.z_val is still {s.z_val} after {cpt} trials\\\"\\n res.append([p, airsim.Vector3r(s.x_val * nominal_inner_dims.x_val / 2, s.y_val * nominal_inner_dims.y_val / 2, s.z_val * nominal_inner_dims.z_val / 2)])\\n assert len(res) > 0, \\\"ERROR: the final gates list is empty\\\"\\n return res, gate_names_sorted\\n # return [self.airsim_client.simGetObjectPose(gate_name) for gate_name in gate_names_sorted]\",\n \"def rectangular(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):\\n\\n from anuga.config import epsilon\\n\\n delta1 = float(len1)/m\\n delta2 = float(len2)/n\\n\\n #Calculate number of points\\n Np = (m+1)*(n+1)\\n\\n class Index(object):\\n\\n def __init__(self, n,m):\\n self.n = n\\n self.m = m\\n\\n def __call__(self, i,j):\\n return j+i*(self.n+1)\\n\\n\\n index = Index(n,m)\\n\\n points = num.zeros((Np, 2), float)\\n\\n for i in range(m+1):\\n for j in range(n+1):\\n\\n points[index(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\\n\\n #Construct 2 triangles per rectangular element and assign tags to boundary\\n #Calculate number of triangles\\n Nt = 2*m*n\\n\\n\\n elements = num.zeros((Nt, 3), int)\\n boundary = {}\\n nt = -1\\n for i in range(m):\\n for j in range(n):\\n nt = nt + 1\\n i1 = index(i,j+1)\\n i2 = index(i,j)\\n i3 = index(i+1,j+1)\\n i4 = index(i+1,j)\\n\\n\\n #Update boundary dictionary and create elements\\n if i == m-1:\\n boundary[nt, 2] = 'right'\\n if j == 0:\\n boundary[nt, 1] = 'bottom'\\n elements[nt,:] = [i4,i3,i2] #Lower element\\n nt = nt + 1\\n\\n if i == 0:\\n boundary[nt, 2] = 'left'\\n if j == n-1:\\n boundary[nt, 1] = 'top'\\n elements[nt,:] = [i1,i2,i3] #Upper element\\n\\n return points, elements, boundary\",\n \"def prepare_roidb(self):\\n # for pascal_voc dataset\\n roidb = self.gt_roidb()\\n # data argument\\n if self.cfg.if_flipped is True:\\n print('append flipped images to training')\\n roidb = self.append_flipped_images(roidb)\\n\\n sizes = [PIL.Image.open(self.image_path_at(i)).size\\n for i in range(self.num_images)]\\n\\n for i in range(len(self.image_index)):\\n roidb[i]['image'] = self.image_path_at(i)\\n roidb[i]['width'] = sizes[i][0]\\n roidb[i]['height'] = sizes[i][1]\\n # need gt_overlaps as a dense array for argmax\\n gt_overlaps = roidb[i]['gt_overlaps'].toarray()\\n # max overlap with gt over classes (columns)\\n max_overlaps = gt_overlaps.max(axis=1)\\n # gt class that had the max overlap\\n max_classes = gt_overlaps.argmax(axis=1)\\n roidb[i]['max_classes'] = max_classes\\n roidb[i]['max_overlaps'] = max_overlaps\\n # sanity checks\\n # max overlap of 0 => class should be zero (background)\\n zero_inds = np.where(max_overlaps == 0)[0]\\n assert all(max_classes[zero_inds] == 0)\\n # max overlap > 0 => class should not be zero (must be a fg class)\\n nonzero_inds = np.where(max_overlaps > 0)[0]\\n assert all(max_classes[nonzero_inds] != 0)\\n\\n self.roi_data = ROIGenerator(roidb, self.num_classes, self.cfg)\\n return self.roi_data\",\n \"def refresh_view(self):\\n if self._step_number % 2 == 0:\\n self._view.draw_enemies(self._game.enemies)\\n self._view.draw_towers(self._game.towers)\\n self._view.draw_obstacles(self._game.obstacles)\",\n \"def backtracking(board):\\n ##implementing this with reference to MRV \\n ##also with forward checking \\n if assignmentComplete(board) == True:\\n solved_board = board \\n return solved_board\\n \\n\\n \\n else:\\n var, domains = select_MRV(board)\\n domain = domains[var]\\n \\n \\n ##now using propogation to check the values \\n \\n \\n ## now implementing forward checking has no legal values \\n \\n ## we need to go through and check if appplying a particular variable leads to no possible variables for the correct columns, rows and squares\\n new_domain = domain\\n \\n ##go through and select the correct value for the var \\n for value in new_domain: \\n \\n if check_valid_insert(board, var, value) == True:\\n board[var] = value \\n result = backtracking(board)\\n \\n if result != \\\"Failure\\\":\\n return result\\n board[var] = 0\\n \\n return \\\"Failure\\\"\",\n \"def grasp_planning(object, object_pose1_world, object_pose2_world,\\n palm_pose_l_object, palm_pose_r_object, N=200, init=True):\\n primitive_name = 'grasping'\\n # 0. get initial palm poses in world frame\\n palm_poses_initial_world = planning_helper.palm_poses_from_object(\\n object_pose=object_pose1_world,\\n palm_pose_l_object=palm_pose_l_object,\\n palm_pose_r_object=palm_pose_r_object)\\n\\n grasp_width = planning_helper.grasp_width_from_palm_poses(\\n palm_pose_l_object, palm_pose_r_object)\\n # grasp_width = grasp_width/1.025\\n # grasp_width = 0.086 - 0.006\\n # grasp_width = 0.086\\n # grasp_width = 0.05206\\n # grasp_width = 0.135\\n # print(\\\"grasp width: \\\" + str(grasp_width))\\n\\n # 1. get lifted object poses\\n object_pose_lifted_world = copy.deepcopy(object_pose1_world)\\n\\n if init:\\n object_pose_lifted_world.pose.position.z += 0.05\\n # object_pose_lifted_world.pose.position.z += 0.05\\n object_pose2_world.pose.position.z += 0.0025\\n\\n # 2. get lifted palm poses\\n palm_poses_lifted_world = planning_helper.palm_poses_from_object(\\n object_pose=object_pose_lifted_world,\\n palm_pose_l_object=palm_pose_l_object,\\n palm_pose_r_object=palm_pose_r_object)\\n\\n # 3. get rotated object pose\\n object_pose_rotated_world = copy.deepcopy(object_pose2_world)\\n\\n # if init:\\n # object_pose_rotated_world.pose.position.z += 0.05\\n object_pose_rotated_world.pose.position.z += 0.05\\n\\n palm_poses_rotated_world = planning_helper.palm_poses_from_object(\\n object_pose=object_pose_rotated_world,\\n palm_pose_l_object=palm_pose_l_object,\\n palm_pose_r_object=palm_pose_r_object)\\n\\n # 4. get final configuration\\n palm_poses_final_world = planning_helper.palm_poses_from_object(\\n object_pose=object_pose2_world,\\n palm_pose_l_object=palm_pose_l_object,\\n palm_pose_r_object=palm_pose_r_object)\\n\\n # 3. generate pose plans\\n # 3.1. initialize plan\\n initial_plan = planning_helper.initialize_plan(\\n palm_poses_initial=palm_poses_initial_world,\\n object_pose_initial=object_pose1_world,\\n primitive=primitive_name,\\n plan_name='initial_config')\\n\\n # 3.2. lift the object\\n lift_plan = planning_helper.move_cart_synchro(\\n palm_poses_final=palm_poses_lifted_world,\\n grasp_width=grasp_width,\\n plan_previous=initial_plan,\\n primitive=primitive_name,\\n plan_name='lift_object',\\n N=10)\\n\\n # 3.3. rotate the object\\n rotate_plan = planning_helper.move_cart_synchro(\\n palm_poses_final=palm_poses_rotated_world,\\n grasp_width=grasp_width,\\n plan_previous=lift_plan,\\n primitive=primitive_name,\\n plan_name='rotate_object_final',\\n N=N/2,\\n is_replan=True)\\n\\n # 3.4. place the object\\n place_plan = planning_helper.move_cart_synchro(\\n palm_poses_final=palm_poses_final_world,\\n grasp_width=grasp_width,\\n plan_previous=rotate_plan,\\n primitive=primitive_name,\\n plan_name='place_object',\\n N=20)\\n return [lift_plan] + [rotate_plan] + [place_plan]\",\n \"def abstract(res):\\n o = r'\\\\begin{center}'\\n #o += r'\\\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\\n #o += r'\\\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\\n o += r'\\\\begin{tikzpicture}' + '\\\\n'\\n o += r'\\\\draw[blue!40!white] (0,0) rectangle (6,4); \\\\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\\\n'\\n for i in range(res[7]):\\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\\n o += r'\\\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\\\n'\\n o += r'\\\\end{tikzpicture}\\\\end{center}' + '\\\\n'\\n\\n o += r'\\\\begin{tabular}{|l|l|}' + '\\\\n' + r'\\\\hline' + '\\\\n'\\n o += r'Election name& \\\\texttt{\\\"%s\\\"}\\\\\\\\'%res[1]\\n o += r'Box number& \\\\texttt{%s}\\\\\\\\'%res[2]\\n o += r'State& \\\\texttt{%s}\\\\\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\\n o += r'Registration end& \\\\textit{%s}\\\\\\\\'%res[3]\\n o += r'Vote closing& \\\\textit{%s}\\\\\\\\'%res[4]\\n o += r'Casted/registered& $%s/%s$\\\\\\\\'%(res[7],res[6]) +'\\\\n'\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n o += r'\\\\quad' + '\\\\n'\\n o += r'\\\\begin{tabular}{|l|l|}\\\\hline'\\n l = res[8].items()\\n l.sort(key = operator.itemgetter(1),reverse=True)\\n n = 0\\n for x in l:\\n o += r'%s & %s\\\\\\\\'%(r'\\\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\\\texttt{%s}'%x[0],x[1]) \\n if n == 0:\\n o += r'\\\\hline' + '\\\\n'\\n n += 1\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n\\n\\n #o += r'\\\\item The designer\\\\textquoteright s digital signature of this document (the source file \\\\texttt{oeu.py}) is: \\\\tiny $$\\\\verb!%s!$$ \\\\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\\\n'\\n\\n return r'\\\\begin{abstract}' + abstract.__doc__ + r'\\\\end{abstract}' + o\",\n \"def visualize_reconstruction(maps_filename, timecourses_filename, data_filename, out_filename, mask_nib, hgap=20, vgap=20, nsamples=10):\\n\\n\\tmaps = np.load(maps_filename)\\n\\ttimecourses = np.load(timecourses_filename)\\n\\tsubject_data = np.load(data_filename)\\n\\n\\t(nframes, nvoxels) = subject_data.shape\\n\\n\\trecon = timecourses.dot(maps)\\n\\n\\tsamples = range(0, 1028, int(math.ceil(nframes / float(nsamples))))\\n\\n\\t# draw the maps and timecourses into temporary files\\n\\tdata_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\trecon_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\n\\tfor i in range(nsamples):\\n\\t\\tplot_map(subject_data[samples[i],:], mask_nib, data_image_files[i])\\n\\t\\tplot_map(recon[samples[i],:], mask_nib, recon_image_files[i])\\n\\n\\tdata_images = [Image.open(fname) for fname in data_image_files]\\n\\trecon_images = [Image.open(fname) for fname in recon_image_files]\\n\\n\\tim_width = data_images[0].size[0]\\n\\tim_height = data_images[0].size[1]\\n\\n\\tresult_width = 2*im_width + hgap \\n\\tresult_height = nsamples * (im_height + vgap)\\n\\n\\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\\n\\ty = 0\\n\\tfor (recon_image, data_image) in zip(recon_images, data_images):\\n\\t\\tresult.paste(im=recon_image, box=(0, y))\\n\\t\\tresult.paste(im=data_image, box=(im_width+hgap, y))\\n\\t\\ty += im_height + vgap\\n\\n\\tresult.save(out_filename)\\n\\n\\tfor i in range(nsamples):\\n\\t\\tos.remove(data_image_files[i])\\n\\t\\tos.remove(recon_image_files[i])\",\n \"def run_pass_2():\\n global live_cells\\n global cell_count\\n global attempts\\n global cell_age\\n \\n print(\\\"Live Cells : \\\" + str(len(live_cells)))\\n \\n live_cell_scores = [get_cart_score(c) for c in live_cells]\\n live_cells_sorted = [x for _,x in sorted(zip(live_cell_scores,live_cells))]\\n del live_cells[:]\\n live_cells = live_cells + live_cells_sorted\\n \\n cell = live_cells.pop(0)\\n if check_cart(c) and check_dead(c):\\n voxel_data[cart_to_loc(cell)] = 1\\n \\n cell_age[cart_to_loc(c)] = cell_count\\n \\n \\n cell_count += 1\\n \\n neighbors = [get_cart_neighbor(c,i) for i in range(6)]\\n \\n for n in neighbors:\\n if check_cart(n) and check_dead(c) and not n in live_cells:\\n live_cells.append(n)\",\n \"def _get_observation(self, unseen=False):\\n img_arr = p.getCameraImage(width=self._width,\\n height=self._height,\\n viewMatrix=self._view_matrix,\\n projectionMatrix=self._proj_matrix)\\n rgb = img_arr[2]\\n depth = img_arr[3]\\n min = 0.97\\n max=1.0\\n segmentation = img_arr[4]\\n depth = np.reshape(depth, (self._height, self._width,1) )\\n segmentation = np.reshape(segmentation, (self._height, self._width,1) )\\n\\n np_img_arr = np.reshape(rgb, (self._height, self._width, 4))\\n np_img_arr = np_img_arr[:, :, :3].astype(np.float64)\\n\\n view_mat = np.asarray(self._view_matrix).reshape(4, 4)\\n proj_mat = np.asarray(self._proj_matrix).reshape(4, 4)\\n # pos = np.reshape(np.asarray(list(p.getBasePositionAndOrientation(self._objectUids[0])[0])+[1]), (4, 1))\\n\\n AABBs = np.zeros((len(self._objectUids), 2, 3))\\n cls_ls = []\\n \\n for i, (_uid, _cls) in enumerate(zip(self._objectUids, self._objectClasses)):\\n AABBs[i] = np.asarray(p.getAABB(_uid)).reshape(2, 3)\\n cls_ls.append(NAME2IDX[_cls])\\n\\n # np.save('/home/tony/Desktop/obj_save/view_mat_'+str(self.img_save_cnt), view_mat)\\n # np.save('/home/tony/Desktop/obj_save/proj_mat_'+str(self.img_save_cnt), proj_mat)\\n # np.save('/home/tony/Desktop/obj_save/img_'+str(self.img_save_cnt), np_img_arr.astype(np.int16))\\n # np.save('/home/tony/Desktop/obj_save/AABB_'+str(self.img_save_cnt), AABBs)\\n # np.save('/home/tony/Desktop/obj_save/class_'+str(self.img_save_cnt), np.array(cls_ls))\\n\\n np.save(OUTPUT_DIR + '/image_' + str(self.img_save_cnt), np_img_arr.astype(np.int16))\\n dets = np.zeros((AABBs.shape[0], 5))\\n for i in range(AABBs.shape[0]):\\n dets[i, :4] = self.get_2d_bbox(AABBs[i], view_mat, proj_mat, IM_HEIGHT, IM_WIDTH)\\n dets[i, 4] = int(cls_ls[i])\\n np.save(OUTPUT_DIR + '/annotation_'+str(self.img_save_cnt), dets)\\n\\n test = np.concatenate([np_img_arr[:, :, 0:2], segmentation], axis=-1)\\n\\n return test\",\n \"def getGameState(self):\\n ### Student code goes here\\n row1 = ()\\n row2 = ()\\n row3 = ()\\n for currRow in range(1,4):\\n for currCol in range(1,4):\\n tileFound = False\\n for fact in self.kb.facts:\\n if fact.statement.predicate == \\\"located\\\":\\n tile = fact.statement.terms[0].term.element\\n column = fact.statement.terms[1].term.element\\n row = fact.statement.terms[2].term.element\\n\\n tileNumber = int(tile[-1])\\n columnNumber = int(column[-1])\\n rowNumber = int(row[-1])\\n\\n if rowNumber == currRow and columnNumber == currCol:\\n tileFound = True\\n if rowNumber == 1:\\n row1 += tuple([tileNumber])\\n elif rowNumber == 2:\\n row2 += tuple([tileNumber])\\n elif rowNumber == 3:\\n row3 += tuple([tileNumber])\\n \\n break\\n\\n if not tileFound:\\n if currRow == 1:\\n row1 += tuple([-1])\\n elif currRow == 2:\\n row2 += tuple([-1])\\n elif currRow == 3:\\n row3 += tuple([-1])\\n\\n\\n return (row1, row2, row3)\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if rooms==[]: return\\n xcord=len(rooms)\\n ycord=len(rooms[0])\\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\\n gatenum=1\\n while indexstack != []:\\n newindex=[]\\n for item in indexstack:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=gatenum\\n newindex.append((xpoint,ypoint))\\n indexstack=newindex\\n gatenum+=1\\n ''''\\n for item in index_0:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=1\\n index_1.append((xpoint,ypoint))\\n for item in index_1:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=2\\n index_2.append((xpoint,ypoint))\\n for item in index_2:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=3\\n index_3.append((xpoint,ypoint))\\n for item in index_3:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=4\\n #index_3.append((xpoint,ypoint))'''\",\n \"def draw_field_of_view(gameDisplay, hero):\\n #Fill with black\\n gameDisplay.fill(white)\\n \\n #Draw ground\\n \\n for x in range(visible_squares[0]):\\n #From left to right <-> 0 to 16\\n #\\n for y in range(visible_squares[1]):\\n g_x, g_y = l2g(x, y, hero)\\n p_x, p_y = l2p(x, y)\\n \\n if not hero.Map.world[g_x][g_y]:\\n \\\"\\\"\\\"This should only be the case if the player\\n is within sight of the edge of earth\\\"\\\"\\\"\\n pygame.draw.rect(gameDisplay, \\n black, \\n [p_x, p_y,square_size[0], square_size[1]]\\n )\\n \\n elif hero.Map.world[g_x][g_y] == 1:\\n pygame.draw.rect(gameDisplay, green, \\n [p_x, p_y,square_size[0], square_size[1]])\\n\\n elif hero.Map.world[g_x][g_y] == 2:\\n pygame.draw.rect(gameDisplay, bech, \\n [p_x, p_y, square_size[0], square_size[1]])\\n \\n elif hero.Map.world[g_x][g_y] == 3:\\n pygame.draw.rect(gameDisplay, blue, \\n [p_x, p_y, square_size[0], square_size[1]])\\n \\n \\n #pygame.draw.rect(gameDisplay, red, [px, py, square_size, square_size]) \\n\\n #draw_hero\\n hero_px, hero_py = l2p(8, 8)\\n \\n pygame.draw.rect(gameDisplay, red, [hero_px, hero_py, \\n square_size[0], square_size[1]])\\n #gameDisplay.draw\",\n \"def return_view(game, data):\\n bike = data[\\\"bike\\\"]\\n range_ = data[\\\"range\\\"]\\n mono = data[\\\"mono\\\"]\\n rotate = data[\\\"rotate\\\"]\\n return {\\\"Board_view\\\": str(games.get_bike(game, bike, range_, mono=mono, rotate=rotate,\\n compress=True)).replace(\\\"\\\\n\\\", \\\"\\\").replace(\\\"\\\\t\\\", \\\" \\\"),\\n \\\"TimeStep\\\": games.get_timestep(game),\\n \\\"Status\\\": games.games_status[game]['Status'],\\n \\\"Alive\\\": \\\"alive\\\" if games.is_alive(game, bike) else \\\"death\\\"}\",\n \"async def unwindGrid(fps):\\n\\n rg = homeGrid() # get a grid\\n # overwrite the positions to the positions that the robots\\n # are reporting\\n for r in rg.robotDict.values():\\n await fps.positioners[r.id].update_position()\\n alpha, beta = fps.positioners[r.id].position\\n r.setAlphaBeta(alpha, beta)\\n\\n forwardPath, reversePath = generatePath(rg)\\n\\n await fps.send_trajectory(reversePath)\",\n \"def part2():\\n grid[(0, 0)] = 1\\n coordinates_value = 0\\n layer = 1\\n x = 0; y = 0\\n done = False\\n while not done:\\n # print(\\\"Layer: \\\", layer)\\n # go right one step\\n layer += 1; x += 1\\n grid[(x,y)] = check_neighbours((x,y))\\n\\n # go up to the boundary of layer\\n for y_up in range(y+1, layer):\\n coord = (x, y_up)\\n coordinates_value = check_neighbours(coord)\\n if coordinates_value > puzzle_input:\\n return coordinates_value\\n y = y_up\\n\\n # go left till the boundary of layer\\n for x_left in range(x-1, -layer, -1):\\n coord = (x_left, y)\\n coordinates_value = check_neighbours(coord)\\n if coordinates_value > puzzle_input:\\n return coordinates_value\\n x = x_left\\n\\n # go down till the boundary of layer\\n for y_down in range(y-1, -layer, -1):\\n coord = (x, y_down)\\n coordinates_value = check_neighbours(coord)\\n if coordinates_value > puzzle_input:\\n return coordinates_value\\n y = y_down\\n\\n # go right till the boundary of layer\\n for x_right in range(x+1, layer):\\n coord = (x_right, y)\\n coordinates_value = check_neighbours(coord)\\n if coordinates_value > puzzle_input:\\n return coordinates_value\\n x = x_right\",\n \"def rectangular_periodic(m_g, n_g, len1_g=1.0, len2_g=1.0, origin_g = (0.0, 0.0)):\\n\\n processor = 0\\n numproc = 1\\n\\n\\n n = n_g\\n m_low = -1\\n m_high = m_g +1\\n\\n m = m_high - m_low\\n\\n delta1 = float(len1_g)/m_g\\n delta2 = float(len2_g)/n_g\\n\\n len1 = len1_g*float(m)/float(m_g)\\n len2 = len2_g\\n origin = ( origin_g[0]+float(m_low)/float(m_g)*len1_g, origin_g[1] )\\n\\n #Calculate number of points\\n Np = (m+1)*(n+1)\\n\\n class VIndex(object):\\n\\n def __init__(self, n,m):\\n self.n = n\\n self.m = m\\n\\n def __call__(self, i,j):\\n return j+i*(self.n+1)\\n\\n class EIndex(object):\\n\\n def __init__(self, n,m):\\n self.n = n\\n self.m = m\\n\\n def __call__(self, i,j):\\n return 2*(j+i*self.n)\\n\\n\\n I = VIndex(n,m)\\n E = EIndex(n,m)\\n\\n points = num.zeros( (Np,2), float)\\n\\n for i in range(m+1):\\n for j in range(n+1):\\n\\n points[I(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\\n\\n #Construct 2 triangles per rectangular element and assign tags to boundary\\n #Calculate number of triangles\\n Nt = 2*m*n\\n\\n\\n elements = num.zeros( (Nt,3), int)\\n boundary = {}\\n Idgl = []\\n Idfl = []\\n Idgr = []\\n Idfr = []\\n\\n full_send_dict = {}\\n ghost_recv_dict = {}\\n nt = -1\\n for i in range(m):\\n for j in range(n):\\n\\n i1 = I(i,j+1)\\n i2 = I(i,j)\\n i3 = I(i+1,j+1)\\n i4 = I(i+1,j)\\n\\n #Lower Element\\n nt = E(i,j)\\n if i == 0:\\n Idgl.append(nt)\\n\\n if i == 1:\\n Idfl.append(nt)\\n\\n if i == m-2:\\n Idfr.append(nt)\\n\\n if i == m-1:\\n Idgr.append(nt)\\n\\n if i == m-1:\\n if processor == numproc-1:\\n boundary[nt, 2] = 'right'\\n else:\\n boundary[nt, 2] = 'ghost'\\n\\n if j == 0:\\n boundary[nt, 1] = 'bottom'\\n elements[nt,:] = [i4,i3,i2]\\n\\n #Upper Element\\n nt = E(i,j)+1\\n if i == 0:\\n Idgl.append(nt)\\n\\n if i == 1:\\n Idfl.append(nt)\\n\\n if i == m-2:\\n Idfr.append(nt)\\n\\n if i == m-1:\\n Idgr.append(nt)\\n\\n if i == 0:\\n if processor == 0:\\n boundary[nt, 2] = 'left'\\n else:\\n boundary[nt, 2] = 'ghost'\\n if j == n-1:\\n boundary[nt, 1] = 'top'\\n elements[nt,:] = [i1,i2,i3]\\n\\n Idfl.extend(Idfr)\\n Idgr.extend(Idgl)\\n\\n Idfl = num.array(Idfl, int)\\n Idgr = num.array(Idgr, int)\\n\\n full_send_dict[processor] = [Idfl, Idfl]\\n ghost_recv_dict[processor] = [Idgr, Idgr]\\n\\n\\n return points, elements, boundary, full_send_dict, ghost_recv_dict\",\n \"def recreate_grid(self):\\n\\n self.print_numlist = arcade.SpriteList()\\n for row in range(ROW_COUNT):\\n for column in range(COLUMN_COUNT):\\n sprite = arcade.Sprite(\\n f\\\"Numbers/{self.grid[row][column]}.png\\\", scale=0.2\\n )\\n x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2\\n y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2\\n sprite.center_x = x\\n sprite.center_y = y\\n self.print_numlist.append(sprite)\\n # Check to see if all squares have been filled in\\n if 0 not in self.grid:\\n # if Cameron.Check_for_Completion(self.grid) == True:\\n self.done = True\",\n \"def next_round(self, old_round):\\n new_round = np.copy(old_round) #copy of the old grid\\n # for each square\\n for i in range(Lx):\\n for j in range(Ly):\\n if old_round[i][j] == 0 : #if the cell is dead, it will live if it has 3 living neighbors.\\n if self.sum_living_cell(i, j, old_round) == 3:\\n new_round[i][j] = 1\\n else:\\n new_round[i][j] = 0\\n if old_round[i][j] == 1 : #if the cell is alive, it won't dead if it has 2 or 3 living neighors.\\n square_score = self.sum_living_cell(i, j, old_round)\\n if square_score != 2 and square_score != 3 :\\n new_round[i][j] = 0\\n else:\\n new_round[i][j] = 1\\n return new_round\",\n \"def outcome(self):\\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\\n return self.grid[0][1]\\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\\n return self.grid[1][0]\\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\\n return self.grid[2][0]\\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n return 0\",\n \"def reduce_possibilities_by_box(self):\\n x = self.targetCell.x\\n y = self.targetCell.y\\n if x < 3 and y < 3: #top left\\n self.check_box1()\\n if x > 2 and x < 6 and y < 3: #middle left\\n self.check_box2()\\n if x > 5 and y < 3: #bottom left\\n self.check_box3()\\n if x < 3 and y > 2 and y < 6: #top middle\\n self.check_box4()\\n if x > 2 and x < 6 and y > 2 and y < 6: #center\\n self.check_box5()\\n if x > 5 and y > 2 and y < 6: #bottom middle\\n self.check_box6()\\n if x < 3 and y > 5: #top right\\n self.check_box7()\\n if x > 2 and x < 6 and y > 5: #middle right\\n self.check_box8()\\n if x > 5 and y > 5: #bottom right\\n self.check_box9()\\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)\",\n \"def obstacles(self):\\r\\n\\r\\n #Radious arround the head\\r\\n limit_sight = self.snake_sight\\r\\n head = self.body[0].position\\r\\n binary_map_complete = self.complete_mapping()\\r\\n map_matrix = np.matrix(binary_map_complete)\\r\\n obstacles = []\\r\\n\\r\\n #limits in all directions\\r\\n left_x = head[0] - limit_sight\\r\\n right_x = head[0] + limit_sight\\r\\n up_y = head[1] - limit_sight\\r\\n down_y = head[1] + limit_sight\\r\\n\\r\\n #submatrix with limits size\\r\\n snake_sight = map_matrix[up_y:down_y+1, left_x:right_x+1]\\r\\n\\r\\n #Special cases where the snake approximates to the borders\\r\\n ##Corners\\r\\n if left_x < 0 and up_y < 0:\\r\\n snake_sight = map_matrix[0:down_y+1, 0:right_x+1]\\r\\n interval_x = [self.limits[0] + left_x, self.limits[0]]\\r\\n interval_y = [self.limits[1] + up_y, self.limits[1]]\\r\\n interval_x_matrix = map_matrix[0:down_y+1, interval_x[0]:interval_x[1]]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], 0:right_x+1]\\r\\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\\r\\n temporal = np.c_[interval_x_y_matrix, interval_y_matrix]\\r\\n snake_sight = np.c_[interval_x_matrix, snake_sight]\\r\\n snake_sight = np.r_[temporal, snake_sight] \\r\\n return snake_sight\\r\\n \\r\\n if left_x < 0 and down_y > self.limits[1] - 1:\\r\\n snake_sight = map_matrix[up_y:self.limits[1], 0:right_x+1]\\r\\n interval_x = [self.limits[0] + left_x, self.limits[0]]\\r\\n interval_y = [0, down_y - self.limits[1] + 1]\\r\\n interval_x_matrix = map_matrix[up_y:self.limits[1], interval_x[0]:interval_x[1]]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], 0:right_x+1]\\r\\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\\r\\n temporal = np.c_[interval_x_y_matrix, interval_y_matrix]\\r\\n snake_sight = np.c_[interval_x_matrix, snake_sight]\\r\\n snake_sight = np.r_[snake_sight, temporal]\\r\\n return snake_sight\\r\\n \\r\\n if right_x > self.limits[0]-1 and up_y < 0:\\r\\n snake_sight = map_matrix[0:down_y+1, left_x:self.limits[0]]\\r\\n interval_x = [0, right_x - self.limits[0] + 1]\\r\\n interval_y = [self.limits[1] + up_y, self.limits[1]]\\r\\n interval_x_matrix = map_matrix[0:down_y+1, interval_x[0]:interval_x[1]]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:self.limits[0]]\\r\\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\\r\\n temporal = np.c_[interval_y_matrix, interval_x_y_matrix]\\r\\n snake_sight = np.c_[snake_sight, interval_x_matrix]\\r\\n snake_sight = np.r_[temporal, snake_sight]\\r\\n return snake_sight\\r\\n \\r\\n if right_x > self.limits[0]-1 and down_y > self.limits[1]-1:\\r\\n snake_sight = map_matrix[up_y:self.limits[1], left_x:self.limits[0]]\\r\\n interval_x = [0, right_x - self.limits[0] + 1]\\r\\n interval_y = [0, down_y - self.limits[1] + 1]\\r\\n interval_x_matrix = map_matrix[up_y:self.limits[1], interval_x[0]:interval_x[1]]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:self.limits[0]]\\r\\n interval_x_y_matrix = map_matrix[interval_y[0]:interval_y[1], interval_x[0]:interval_x[1]]\\r\\n temporal = np.c_[interval_y_matrix, interval_x_y_matrix]\\r\\n snake_sight = np.c_[snake_sight, interval_x_matrix]\\r\\n snake_sight = np.r_[snake_sight, temporal]\\r\\n return snake_sight\\r\\n\\r\\n ##Middle\\r\\n if left_x < 0:\\r\\n snake_sight = map_matrix[up_y:down_y+1, 0:right_x+1]\\r\\n interval_x = [self.limits[0] + left_x, self.limits[0]]\\r\\n interval_x_matrix = map_matrix[up_y:down_y+1, interval_x[0]:interval_x[1]]\\r\\n snake_sight = np.c_[interval_x_matrix, snake_sight]\\r\\n return snake_sight\\r\\n\\r\\n if right_x > self.limits[0]-1:\\r\\n snake_sight = map_matrix[up_y:down_y+1, left_x:self.limits[0]]\\r\\n interval_x = [0, right_x - self.limits[0] + 1]\\r\\n interval_x_matrix = map_matrix[up_y:down_y+1, interval_x[0]:interval_x[1]]\\r\\n snake_sight = np.c_[snake_sight, interval_x_matrix]\\r\\n return snake_sight\\r\\n\\r\\n if up_y < 0:\\r\\n snake_sight = map_matrix[0:down_y+1, left_x:right_x+1]\\r\\n interval_y = [self.limits[1] + up_y, self.limits[1]]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:right_x+1]\\r\\n snake_sight = np.r_[interval_y_matrix, snake_sight]\\r\\n return snake_sight\\r\\n \\r\\n if down_y > self.limits[1]-1:\\r\\n snake_sight = map_matrix[up_y:self.limits[1], left_x:right_x+1]\\r\\n interval_y = [0, down_y - self.limits[1] + 1]\\r\\n interval_y_matrix = map_matrix[interval_y[0]:interval_y[1], left_x:right_x+1]\\r\\n snake_sight = np.r_[snake_sight, interval_y_matrix]\\r\\n return snake_sight\\r\\n\\r\\n return snake_sight\",\n \"def generate_all_locations(grid, shape):\",\n \"def gguess(x,y,xr,yr,xsgn,ysgn):\\n \\n # Bad until proven okay \\n guesspar = None\\n guessx = None \\n guessy = None\\n \\n # Making sure it's the right structure \\n #tags = tag_names(*(!gstruc.data)) \\n #if (len(tags) != 6) : \\n # return guesspar,guessx,guessy \\n #comp = (tags == ['X','Y','RMS','NOISE','PAR','SIGPAR']) \\n #if ((where(comp != 1))(0) != -1) :\\n # return guesspar,guessx,guessy \\n \\n # Saving the originals \\n orig_x = x \\n orig_y = y \\n\\n if xr is None:\\n xr = [0,2000]\\n if yr is None:\\n yr = [0,2000] \\n \\n # Is the x range continuous??\\n # Assume not continuous in general\\n cont = 0 \\n \\n # getting the p3 and p4 positions \\n # P3 back in x (l-0.5), same y \\n # P4 back in y (b-0.5), same x \\n x3,y3 = gincrement(x,y,xr,yr,xsgn=-xsgn,ysgn=-ysgn)\\n x4,y4 = gincrement(x,y,xr,yr,xsgn=xsgn,ysgn=-ysgn,p2=True)\\n \\n # CHECKING OUT THE EDGES \\n # AT THE LEFT EDGE, and continuous, Moving RIGHT, use neighbor on other side \\n # Use it for the guess, but never move to it directly \\n if (x == xr[0]) and (xsgn == 1) and (cont == 1): \\n y3 = y \\n x3 = xr[1] \\n \\n # AT THE RIGHT EDGE, and continuous, Moving LEFT \\n if (x == xr[1]) and (xsgn == -1) and (cont == 1): \\n y3 = y \\n x3 = xr[0] \\n \\n # At the edge, NOT continuous, Moving RIGHT, NO P3 NEIGHBOR \\n if (x == xr[0]) and (xsgn == 1) and (cont == 0): \\n x3 = None \\n y3 = None \\n \\n # At the edge, NOT continuous, Moving LEFT, NO P3 NEIGHBOR \\n if (x == xr[1]) and (xsgn == -1) and (cont == 0): \\n x3 = None\\n y3 = None\\n \\n # Have they been visited before? \\n p3,res3 = gfind(x3,y3)\\n p4,res4 = gfind(x4,y4)\\n \\n # Comparing the solutions \\n b34,dbic34 = gbetter(res3,res4)\\n \\n # selecting the best guess \\n if (dbic34<0): # using P3 \\n guesspar = res3['par']\\n guessx = x3\\n guessy = y3 \\n if (dbic34>=0): # using P4 \\n guesspar = res4['par']\\n guessx = x4 \\n guessy = y4 \\n if np.isfinite(dbic34)==False:\\n guesspar = None\\n guessx = None \\n guessy = None\\n \\n # Putting the originals back \\n x = orig_x \\n y = orig_y \\n\\n return guesspar,guessx,guessy\",\n \"def gru_cell_decoder(self, Xt, h_t_minus_1,context_vector):\\n # 1.update gate: decides how much past information is kept and how much new information is added.\\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z_decoder) + tf.matmul(h_t_minus_1,self.U_z_decoder) +tf.matmul(context_vector,self.C_z_decoder)+self.b_z_decoder) # z_t:[batch_size,self.hidden_size]\\n # 2.reset gate: controls how much the past state contributes to the candidate state.\\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r_decoder) + tf.matmul(h_t_minus_1,self.U_r_decoder) +tf.matmul(context_vector,self.C_r_decoder)+self.b_r_decoder) # r_t:[batch_size,self.hidden_size]\\n # candiate state h_t~\\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h_decoder) +r_t * (tf.matmul(h_t_minus_1, self.U_h_decoder)) +tf.matmul(context_vector, self.C_h_decoder)+ self.b_h_decoder) # h_t_candiate:[batch_size,self.hidden_size]\\n # new state: a linear combine of pervious hidden state and the current new state h_t~\\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\\n return h_t,h_t\",\n \"def draw_grid(self):\\n\\n screen.fill(GREY)\\n\\n for row in self.grid:\\n for cell in row:\\n if cell.root:\\n color = GREEN\\n elif cell.goal:\\n color = RED\\n elif cell.value:\\n color = DARK_BLUE\\n elif cell.visited:\\n color = LIGHT_BLUE\\n elif cell.f:\\n color = LIGHT_GREEN\\n elif cell.wall:\\n color = GRAY\\n else:\\n color = WHITE\\n\\n pygame.draw.rect(screen, color, cell.rect)\\n\\n x, y = cell.rect.x, cell.rect.y\\n\\n if cell.g:\\n self.draw_score(x + 2, y + 2, cell.g)\\n if cell.h:\\n self.draw_score(x + 18, y + 2, cell.h)\\n if cell.f:\\n self.draw_score(x + 2, y + self.cell_size - 10, cell.f)\",\n \"def homeGrid():\\n alphaTarget = 0\\n betaTarget = 180\\n hasApogee = True\\n seed = 0\\n rg = gridInit(seed)\\n\\n for r in rg.robotDict.values():\\n r.setAlphaBeta(alphaTarget, betaTarget)\\n return rg\",\n \"def create_glider(i, j, grid):\\n\\n glider = np.array([[0, 0, 1],\\n [1, 0, 1],\\n [0, 1, 1]])\\n grid[i:i+3:, j:j+3] = glider\",\n \"def generate_candidate_grasps(object_name, dataset, stable_pose,\\n num_grasps, gripper, config):\\n grasp_set = []\\n grasp_set_ids = []\\n grasp_set_metrics = []\\n\\n # read params\\n approach_dist = config['approach_dist']\\n delta_approach = config['delta_approach']\\n rotate_threshold = config['rotate_threshold']\\n table_clearance = config['table_clearance']\\n dist_thresh = config['grasp_dist_thresh']\\n\\n # get sorted list of grasps to ensure that we get the top grasp\\n graspable = dataset.graspable(object_name)\\n graspable.model_name_ = dataset.obj_mesh_filename(object_name)\\n grasps = dataset.grasps(object_name, gripper=gripper.name)\\n all_grasp_metrics = dataset.grasp_metrics(object_name, grasps, gripper=gripper.name)\\n mn, mx = graspable.mesh.bounding_box()\\n alpha = 1.0 / np.max(mx-mn)\\n print alpha\\n\\n # prune by collisions\\n rave.raveSetDebugLevel(rave.DebugLevel.Error)\\n collision_checker = gcc.OpenRaveGraspChecker(gripper, view=False)\\n collision_checker.set_object(graspable)\\n\\n # add the top quality grasps for each metric\\n metrics = config['candidate_grasp_metrics']\\n for metric in metrics:\\n # generate metric tag\\n if metric == 'efc':\\n metric = db.generate_metric_tag('efcny_L1', config)\\n elif metric == 'pfc':\\n metric = db.generate_metric_tag('pfc', config)\\n elif metric == 'ppc':\\n metric = db.generate_metric_tag('ppc_%s' %(stable_pose.id), config)\\n\\n # sort grasps by the current metric\\n grasp_metrics = [all_grasp_metrics[g.grasp_id][metric] for g in grasps]\\n grasps_and_metrics = zip(grasps, grasp_metrics)\\n grasps_and_metrics.sort(key = lambda x: x[1])\\n grasps = [gm[0] for gm in grasps_and_metrics]\\n grasp_metrics = [gm[1] for gm in grasps_and_metrics]\\n\\n # add grasps by quantile\\n logging.info('Adding best grasp for metric %s' %(metric))\\n i = len(grasps) - 1\\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\\n\\n # check wrist rotation\\n psi = grasp_candidate.angle_with_table(stable_pose)\\n rotated_from_table = (psi > rotate_threshold)\\n\\n # check distances\\n min_dist = np.inf\\n for g in grasp_set:\\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\\n if dist < min_dist:\\n min_dist = dist\\n\\n # check collisions\\n while gripper.collides_with_table(grasp_candidate, stable_pose, table_clearance) \\\\\\n or collides_along_approach(grasp_candidate, gripper, collision_checker, approach_dist, delta_approach) \\\\\\n or rotated_from_table or grasp_candidate.grasp_id in grasp_set_ids \\\\\\n or min_dist < dist_thresh:\\n # get the next grasp\\n i -= 1\\n if i < 0:\\n break\\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\\n\\n # check wrist rotation\\n psi = grasp_candidate.angle_with_table(stable_pose)\\n rotated_from_table = (psi > rotate_threshold)\\n\\n # check distances\\n min_dist = np.inf\\n for g in grasp_set:\\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\\n if dist < min_dist:\\n min_dist = dist\\n\\n # add to sequence\\n if i >= 0:\\n grasp_set.append(grasp_candidate)\\n grasp_set_ids.append(grasp_candidate.grasp_id)\\n grasp_set_metrics.append(all_grasp_metrics[grasp_candidate.grasp_id])\\n\\n # sample the remaining grasps uniformly at random\\n i = 0\\n random.shuffle(grasps)\\n while len(grasp_set) < num_grasps and i < len(grasps):\\n # random grasp candidate\\n logging.info('Adding grasp %d' %(len(grasp_set)))\\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\\n\\n # check wrist rotation\\n psi = grasp_candidate.angle_with_table(stable_pose)\\n rotated_from_table = (psi > rotate_threshold)\\n\\n # check distances\\n min_dist = np.inf\\n for g in grasp_set:\\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\\n if dist < min_dist:\\n min_dist = dist\\n\\n # check collisions\\n while gripper.collides_with_table(grasp_candidate, stable_pose) \\\\\\n or collides_along_approach(grasp_candidate, gripper, collision_checker, approach_dist, delta_approach) \\\\\\n or rotated_from_table or grasp_candidate.grasp_id in grasp_set_ids \\\\\\n or min_dist < dist_thresh:\\n # get the next grasp\\n i += 1\\n if i >= len(grasps):\\n break\\n grasp_candidate = grasps[i].grasp_aligned_with_stable_pose(stable_pose)\\n\\n # check wrist rotation\\n psi = grasp_candidate.angle_with_table(stable_pose)\\n rotated_from_table = (psi > rotate_threshold)\\n\\n # check distances\\n min_dist = np.inf\\n for g in grasp_set:\\n dist = grasp_module.ParallelJawPtGrasp3D.distance(g, grasp_candidate)\\n if dist < min_dist:\\n min_dist = dist\\n\\n # add to sequence\\n if i < len(grasps):\\n grasp_set.append(grasp_candidate)\\n grasp_set_ids.append(grasp_candidate.grasp_id)\\n grasp_set_metrics.append(all_grasp_metrics[grasp_candidate.grasp_id])\\n\\n return grasp_set, grasp_set_ids, grasp_set_metrics\",\n \"def generation(self,rounds):\\n a = []\\n b = []\\n for i in range(rounds):\\n self.fight()\\n c = self.avgFitness()\\n a.append(c[0])\\n b.append(c[1])\\n self.sort()\\n self.cull()\\n self.rePop()\\n self.refresh()\\n self.fight()\\n self.sort()\\n print self\\n plt.scatter([x for x in range(len(a))],a,color = \\\"red\\\")\\n plt.scatter([x for x in range(len(b))],b,color = \\\"green\\\")\\n plt.show()\",\n \"def generation(self,rounds):\\n a = []\\n b = []\\n for i in range(rounds):\\n self.fight()\\n c = self.avgFitness()\\n a.append(c[0])\\n b.append(c[1])\\n self.sort()\\n self.cull()\\n self.rePop()\\n self.refresh()\\n self.fight()\\n self.sort()\\n print self\\n plt.scatter([x for x in range(len(a))],a,color = \\\"red\\\")\\n plt.scatter([x for x in range(len(b))],b,color = \\\"green\\\")\\n plt.show()\",\n \"def main():\\n\\n cages = [\\n \\\"AABCCD\\\",\\n \\\"EFBCGD\\\",\\n \\\"EFFHGI\\\",\\n \\\"EJJHGI\\\",\\n \\\"EKJHGL\\\",\\n \\\"KKJLLL\\\",\\n ]\\n\\n peaks = [\\n (0, 1),\\n (0, 2),\\n (1, 3),\\n (1, 4),\\n (1, 5),\\n (2, 1),\\n (2, 3),\\n (3, 0),\\n (3, 5),\\n (4, 2),\\n (5, 1),\\n (5, 4),\\n ]\\n\\n extract = {\\n \\\"A\\\": (5, 2),\\n \\\"B\\\": (0, 3),\\n \\\"C\\\": (3, 2),\\n \\\"D\\\": (1, 4),\\n \\\"E\\\": (0, 1),\\n \\\"F\\\": (1, 5),\\n \\\"G\\\": (4, 2),\\n \\\"H\\\": (3, 5),\\n \\\"I\\\": (1, 0),\\n \\\"J\\\": (5, 5),\\n \\\"K\\\": (3, 4),\\n \\\"L\\\": (5, 1),\\n \\\"M\\\": (0, 5),\\n \\\"N\\\": (4, 4),\\n }\\n\\n def answer(sg):\\n solved_grid = sg.solved_grid()\\n s = \\\"\\\"\\n s += chr(64 + solved_grid[extract[\\\"A\\\"]] + solved_grid[extract[\\\"B\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"C\\\"]] + solved_grid[extract[\\\"D\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"E\\\"]] + solved_grid[extract[\\\"F\\\"]] + solved_grid[extract[\\\"G\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"H\\\"]] + solved_grid[extract[\\\"I\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"J\\\"]] + solved_grid[extract[\\\"K\\\"]] + solved_grid[extract[\\\"L\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"M\\\"]] + solved_grid[extract[\\\"N\\\"]])\\n return s\\n\\n sym = grilops.make_number_range_symbol_set(1, 6)\\n lattice = grilops.get_square_lattice(6)\\n sg = grilops.SymbolGrid(lattice, sym)\\n\\n add_sudoku_constraints(sg)\\n\\n # Constrain regions to match the cages and be rooted at the peaks.\\n cage_label_to_region_id = {}\\n for py, px in peaks:\\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\\n\\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\\n for y, x in lattice.points:\\n sg.solver.add(\\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\\n\\n # Within each region, a parent cell must have a greater value than a child\\n # cell, so that the values increase as you approach the root cell (the peak).\\n for p in lattice.points:\\n for n in sg.edge_sharing_neighbors(p):\\n sg.solver.add(Implies(\\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\\n n.symbol > sg.grid[p]\\n ))\\n\\n if sg.solve():\\n sg.print()\\n print()\\n print(answer(sg))\\n while not sg.is_unique():\\n print()\\n print(\\\"Alternate solution\\\")\\n sg.print()\\n print()\\n print(answer(sg))\\n else:\\n print(\\\"No solution\\\")\",\n \"def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n max_cp = 1\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n max_cp += w_inpIdx*X0[inpIdx]\\n # saving values\\n layerEq[inpIdx] = X0[inpIdx]\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n max_cp += firstComplex + Inhib2/E0*x_eq\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n max_cp += Inhib2/E0*x_eq\\n return max_cp\",\n \"def get_obstacles(image):\\n\\n ih, iw = image.shape[:2]\\n image_copy = image.copy()\\n\\n #resize the image to the size of arena\\n image = cv2.resize(image, ARENA_SIZE, interpolation=cv2.INTER_CUBIC)\\n gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\n\\n #replace all black pixels to white pixels\\n gray[np.where(gray == 0)]= 255\\n\\n #get the thresholded binary image\\n ret,threshold = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)\\n\\n #find all the countours in the binary image\\n _, contours, heiarchy = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n cont = []\\n\\n #create a mask to draw contours on\\n blocks = mask = np.zeros(threshold.shape[:2], np.uint8)\\n\\n #create a dictionary to hold image roi of all puzzle peices\\n blocks_roi = {}\\n\\n #iterate through all contours\\n for i, c in enumerate(contours[1:]):\\n\\n #find the minimum area fitting rectangle of the contour\\n rect = cv2.minAreaRect(c)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n\\n #create the copy of the mask\\n mask_copy = mask.copy()\\n\\n #draw the rectangle on the mask\\n cv2.drawContours(mask_copy, [box], -1, (255,255,255), 3)\\n\\n #floodfill the rectangle\\n cv2.floodFill(mask_copy, None, (0,0), 255)\\n mask_inv = cv2.bitwise_not(mask_copy)\\n blocks = cv2.add(blocks, mask_inv)\\n\\n _, contours, heiarchy = cv2.findContours(blocks, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n obstacles = {}\\n\\n for c in contours:\\n x,y,w,h = cv2.boundingRect(c)\\n obstacles.update({(int(x+w/2), int(y+h/2)): BLOCK_SIZE})\\n #obstacles.update({(int(x+w/2), int(y+h/2)): (w, h)}) # for unknown block sizes\\n bottom_r = remap((x+w, y+h), ARENA_SIZE, (iw,ih))\\n top_l = remap((x, y), ARENA_SIZE, (iw,ih))\\n blocks_roi.update({(int(x+w/2), int(y+h/2)): image_copy[top_l[1]:bottom_r[1], top_l[0]:bottom_r[0]]})\\n\\n return obstacles, blocks_roi\",\n \"def get_obstacles_map(obstacles, placed_pecies):\\n \\n #create a mask image to draw the obstacles on\\n blocks = np.zeros(ARENA_SIZE[::-1], np.uint8)\\n\\n #get the grid points where the robot needs to placed\\n grid = get_grid(ARENA_SIZE)\\n\\n #draw the obstacles and their safety region on the map\\n for i in obstacles.keys():\\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\\n cv2.rectangle(blocks, (i[0]-int(obstacles[i][0]/4), i[1]-int(obstacles[i][1]/4)), (i[0]+int(obstacles[i][0]/4), i[1]+int(obstacles[i][1]/4)), 255, -1)\\n\\n #draw the obstacles and their safety region on the map\\n for i in placed_pecies.keys():\\n try:\\n if not i == grid[5]:\\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\\n else:\\n cv2.rectangle(blocks, (int(i[0]-7.4*placed_pecies[i][0]/4), int(i[1]-7.4*placed_pecies[i][1]/4)),\\n (int(i[0]+7.4*placed_pecies[i][0]/4), int(i[1]+7.4*placed_pecies[i][1]/4)), 129, -1)\\n cv2.rectangle(blocks, (i[0]-int(placed_pecies[i][0]/4), i[1]-int(placed_pecies[i][1]/4)), (i[0]+int(placed_pecies[i][0]/4), i[1]+int(placed_pecies[i][1]/4)), 255, -1)\\n except Exception as e:\\n print(e)\\n\\n return cv2.bitwise_not(blocks)\",\n \"def six_hundred_cell(self):\\n verts = []\\n q12 = QQ(1)/2\\n base = [q12,q12,q12,q12]\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n for l in range(2):\\n verts.append([x for x in base])\\n base[3] = base[3]*(-1)\\n base[2] = base[2]*(-1)\\n base[1] = base[1]*(-1)\\n base[0] = base[0]*(-1)\\n for x in permutations([0,0,0,1]):\\n verts.append(x)\\n for x in permutations([0,0,0,-1]):\\n verts.append(x)\\n g = QQ(1618033)/1000000 # Golden ratio approximation\\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n return Polyhedron(vertices = verts)\",\n \"def __handle_view_tile(self, gamestate_component):\",\n \"def global_refine(self):\\n gr = super(UnTRIM08Grid,self).global_refine()\\n gr.infer_depths()\\n gr.location = self.location\\n gr.angle = self.angle\\n gr.cells['red'][:] = True\\n return gr\",\n \"def getRGFforGrowthAndDeath(self, pairs):\\n # Create a list of length pairs with random integers to iterate\\n # randomly through the list of pairs\\n shuffled_indices = np.random.choice(len(pairs),\\n len(pairs),\\n replace=False)\\n for i in shuffled_indices:\\n pair = pairs[i]\\n if self.checkRgfAbility(pair=pairs[i]):\\n l1, l2 = pair[0], pair[1]\\n self._rgf_counter[l1], self._rgf_counter[l2] = 1, 1\\n self._potential_partner[l1], self._potential_partner[l2] = \\\\\\n self._plant_names[l2], self._plant_names[l1]\\n if (self._variant[l1] == \\\"V2_adapted\\\") and \\\\\\n (self._variant[l2] == \\\"V2_adapted\\\"):\\n # Set initial size of grafted root radius\\n self._r_gr_rgf[l1], self._r_gr_rgf[l2] = 0.004, 0.004\\n # Get min. radius of grafted roots\\n r_gr_min = self.f_radius * min(self._r_stem[l1],\\n self._r_stem[l2])\\n self._r_gr_min[l1], self._r_gr_min[l2] = [r_gr_min], \\\\\\n [r_gr_min]\\n\\n # Get length of grafted root section\\n distance = self.getDistance(x1=self._xe[l1],\\n x2=self._xe[l2],\\n y1=self._ye[l1],\\n y2=self._ye[l2])\\n root_sums = self._r_root[l1] + self._r_root[l2]\\n l_gr = (distance + root_sums) / 2\\n self._l_gr_rgf[l1], self._l_gr_rgf[l2] = self._r_root[l1] / \\\\\\n root_sums * l_gr, \\\\\\n self._r_root[l2] / \\\\\\n root_sums * l_gr,\",\n \"def game_of_life():\\n # 3x3 neighbourhood\\n offsets = [[(y, x) for y in range(-1, 2)] for x in range(-1, 2)]\\n\\n # Create mappings\\n mappings = {}\\n for i in range(2 ** 9):\\n\\n # Determine the initial state (key)\\n key = f\\\"{bin(i)[2:]:0>9}\\\" # As binary string\\n key = tuple(k == \\\"1\\\" for k in key) # As tuple of bools\\n key = tuple(key[i * 3:i * 3 + 3] for i in range(3)) # Reshape into 2D grid\\n\\n # Alive counts\\n centre = key[1][1]\\n others = sum(sum(row) for row in key) - centre\\n\\n # Skip if state does not evaluate to True\\n if centre:\\n if others not in (2, 3):\\n continue\\n\\n else:\\n if others != 3:\\n continue\\n\\n mappings[key] = True\\n\\n return Mapping2DRuleset(mappings, offsets)\",\n \"def sim_grasp_set_row(scene):\\n gripper_model = burg.gripper.Robotiq2F85()\\n\\n target_object = None\\n\\n found = False\\n while found == False:\\n print([obj.object_type.identifier for obj in scene.objects])\\n buffer_target_object = input(\\\"Wich object in the previous list do you want to grab ? \\\")\\n\\n i = 0\\n while i < len(scene.objects):\\n if (scene.objects[i].object_type.identifier == buffer_target_object):\\n target_object = scene.objects[i]\\n found = True\\n break\\n i += 1\\n if found == False :\\n print(\\\"the selected object is not in the list\\\")\\n\\n #test a grasp set and create a list of successful grasp\\n grasp_set, contact_points, normals, approach_vectors = create_antipodal_grasp_set(target_object)\\n sim = burg.sim.SceneGraspSimulator(target_object = target_object, gripper= gripper_model, scene=scene, verbose=False)\\n scores = sim.simulate_grasp_set(grasp_set)\\n successful_grasps = burg.grasp.GraspSet()\\n index_successfull = []\\n params_successfull = []\\n for index in range(len(scores)):\\n if scores[index] == 5:\\n successful_grasps.add(grasp_set[index].as_grasp_set())\\n index_successfull += [index]\\n params_successfull+=[[contact_points[index], normals[index], approach_vectors[index]]]\\n sim.dismiss()\\n\\n print(len(successful_grasps))\\n print(\\\"hellllo\\\")\\n\\n time.sleep(10)\\n\\n #Evaluate each successfull grasp\\n sim2 = burg.sim.SceneGraspSimulator(target_object = target_object, gripper= gripper_model, scene=scene, verbose=False)\\n results = []\\n for i, grasp in enumerate(successful_grasps):\\n n_graspset, n_contact_points, n_normals, n_approach_vectors = create_antipodal_noisy_grasp_set(target_object, grasp, params_successfull[i][0][0])\\n #n_graspset = perturbations.generate_perturb_grasp_set(grasp = grasp, nb_grasps = 50)\\n #burg.visualization.show_grasp_set(objects = [target_object.object_type.mesh], gs = n_graspset, gripper = gripper_model, with_plane = True)\\n params_noised = []\\n for k in range(len(n_contact_points)):\\n params_noised += [[n_contact_points[i], n_normals[i], n_approach_vectors[i]]]\\n scores = sim2.simulate_grasp_set(n_graspset)\\n robust = sum(scores)/len(scores)\\n #metric = quality.probability_force_closure(n_graspset, params_noised)\\n metric = quality.epsilon_quality(grasp, params_successfull[i] )\\n results += [[grasp, robust, metric]]\\n print([grasp, robust, metric])\\n #results+= [[grasp, metric]]\\n #results += [metric]\\n\\n print(results)\\n sim2.dismiss()\\n return results\",\n \"def buildSurface(self, idx = 0, surface = 1, z = 1, verbose = 1,\\\\\\n strained = False, vacuum = 0, ab = False):\\n\\n \\\"\\\"\\\"Basis for the selected surface, and the cell repetitions\\\"\\\"\\\"\\n rep = np.zeros((3, 4))\\n new_base = np.zeros((3, 3))\\n\\n altBase1 = np.zeros((3, 3))\\n altBase2 = np.zeros((3, 3))\\n if ab:\\n B1, B2 = self.getAB()\\n\\n if surface == 1:\\n old_base = self.base_1\\n spec = self.spec_1\\n mass = self.mass_1\\n pos = self.pos_1\\n\\n new_base[2, 2] = self.base_1[2, 2] * z\\n new_base[0:2, 0:2] = self.cell_1[idx, :, :]\\n \\n if ab:\\n altBase1[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\\n altBase1[2, 2] = B1[2, 2] * z\\n \\n rep[0:2, 0:2] = self.rep_1[idx, :, :]\\n rep[:, 2] = np.sum(rep, axis = 1)\\n elif surface == 2:\\n old_base = self.base_2\\n spec = self.spec_2\\n mass = self.mass_2\\n pos = self.pos_2\\n\\n new_base[2, 2] = self.base_2[2, 2] * z\\n new_base[0:2, 0:2] = self.cell_2[idx, :, :]\\n \\n if ab:\\n altBase2[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\\n altBase2[2, 2] = B2[2, 2] * z\\n\\n rep[0:2, 0:2] = self.rep_2[idx, :, :]\\n rep[:, 2] = np.sum(rep, axis = 1)\\n\\n \\\"\\\"\\\"Set all hi-lo limits for the cell repetitions\\\"\\\"\\\"\\n h = 2\\n rep = [rep[0, :].min() - h, rep[0, :].max() + h,\\\\\\n rep[1, :].min() - h, rep[1, :].max() + h,\\\\\\n 0, z - 1]\\n\\n \\\"\\\"\\\"Extend the cell as spcefied\\\"\\\"\\\"\\n pos_ext, spec_ext, mass_ext = ut.extendCell(base = old_base, rep = rep,\\\\\\n pos = pos.T, spec = spec,\\\\\\n mass = mass)\\n\\n if surface == 1:\\n \\\"\\\"\\\"Change to alternative base_1 if specified\\\"\\\"\\\"\\n if ab:\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n new_base = altBase1\\n pos_ext = np.matmul(new_base, pos_d)\\n if verbose > 0:\\n string = \\\"Surface 1 constructed with alternative base\\\"\\n ut.infoPrint(string)\\n\\n elif surface == 2:\\n \\\"\\\"\\\"Initial rotation\\\"\\\"\\\"\\n initRot = np.deg2rad(self.ang[idx])\\n\\n \\\"\\\"\\\"Rotate the positions pos_rot = R*pos\\\"\\\"\\\"\\n pos_ext = ut.rotate(pos_ext, initRot, verbose = verbose - 1)\\n\\n \\\"\\\"\\\"Construct it in the alternative base_2 if specified\\\"\\\"\\\"\\n if ab:\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n new_base = altBase2\\n pos_ext = np.matmul(new_base, pos_d)\\n if verbose > 0:\\n string = \\\"Surface 2 constructed with alternative base\\\"\\n ut.infoPrint(string)\\n\\n \\\"\\\"\\\"Strain the cell if specified\\\"\\\"\\\"\\n if strained:\\n\\n \\\"\\\"\\\"If the cell is to be strained then convert to direct coordinates\\\"\\\"\\\"\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n\\n \\\"\\\"\\\"Convert back to cartesian coordinates.\\\"\\\"\\\"\\n if ab:\\n \\\"\\\"\\\"Strain it to the alternative base_1\\\"\\\"\\\"\\n new_base[0:2, 0:2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\\n string = \\\"Surface 2 strained to match surface 1 with an alternative base\\\"\\n \\n else:\\n \\\"\\\"\\\"Strain it to the bottom surface\\\"\\\"\\\"\\n new_base[0:2, 0:2] = self.cell_1[idx, :, :].copy()\\n string = \\\"Surface 2 strained to match surface 1\\\"\\n\\n pos_ext = np.matmul(new_base, pos_d)\\n\\n if verbose > 0:\\n ut.infoPrint(string)\\n\\n \\\"\\\"\\\"Convert the entire new cell to direct coordinates\\\"\\\"\\\"\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n\\n \\\"\\\"\\\"Remove all positions outside [0, 1)\\\"\\\"\\\"\\n pos_d = np.round(pos_d, 8)\\n new_base = np.round(new_base, 8)\\n\\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\\n pos_d = pos_d[:, keep]\\n species = spec_ext[keep]\\n mass = mass_ext[keep]\\n\\n \\\"\\\"\\\"Return to cartesian coordinates and change shape to (...,3)\\\"\\\"\\\"\\n pos = np.matmul(new_base, pos_d).T\\n\\n \\\"\\\"\\\"Add vacuum if specified\\\"\\\"\\\"\\n new_base[2, 2] = new_base[2, 2] + vacuum\\n if verbose: \\n string = \\\"Vacuum added: %.2f\\\"\\\\\\n % (vacuum)\\n ut.infoPrint(string)\\n\\n return new_base, pos, species, mass\",\n \"def decision_heatmaps(obs):\\n global model\\n assert obs > 4 and obs < 1788, \\\"Chosen observation is outside the range of the demonstration episode.\\\"\\n saved_observations = np.load('saved_observations.npy')\\n state = saved_observations[obs-3:obs+1]\\n state_batch = np.expand_dims(state, axis=0)\\n q_vals = model.compute_q_values(state)\\n print(q_vals)\\n decision = np.argmax(q_vals)\\n print(decision)\\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\\n decision_node = model.model.output[:, decision]\\n last_conv_layer = model.model.layers[3]\\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\\n pooled_grads = K.mean(grads, axis=(0,2,3))\\n frame = Image.fromarray(state[-1])\\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\\n for i in range(64):\\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\\n\\n heatmap = np.mean(conv_layer_output_value, axis=0)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (84, 84))\\n heatmap = np.uint8(255 * heatmap)\\n superimposed_img = heatmap * .3 + np.array(frame) * .35\\n\\n plt.xlabel(decision_encodings[decision])\\n plt.imshow(superimposed_img, cmap='gray')\\n plt.show()\",\n \"def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\\n # create binary mask\\n mask = np.zeros(img_slice.shape)\\n mask[min_x:max_x, min_y:max_y] = 1\\n # keep a copy of original to have background later \\n img_orig = np.copy(img_slice)\\n mask_binary = np.copy(mask)\\n\\n # rotate image if coronal\\n if views=='coronal':\\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\\n mask = np.rot90(mask, axes=(1, 0))\\n \\n # prepare binary mask for net\\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask = torch.Tensor(mask) # gives dtype float32\\n mask = mask.unsqueeze(0)\\n mask = mask.unsqueeze(0)\\n\\n # prepare seg mask for net\\n mask_slice[mask_slice==self.vertebra_id] = 0\\n # resize to network size\\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\\n\\n mask_seg = self.map_vert_to_class(mask_seg)\\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n\\n # prepare img for net \\n img_slice = cv2.resize(img_slice, self.resize_size)\\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \\n img_slice = img_slice[:,:, None]\\n img_slice = self.toTensor(img_slice)\\n img_slice = img_slice.unsqueeze(0)\\n corrupt_img = (1-mask)*img_slice\\n\\n if self.use_cuda:\\n mask = mask.cuda()\\n mask_seg = mask_seg.cuda()\\n corrupt_img = corrupt_img.cuda() \\n\\n # inpaint\\n if views=='lateral':\\n netG = self.netGlat\\n elif views=='coronal':\\n netG = self.netGcor\\n\\n # get prediction\\n with torch.no_grad():\\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\\n inpainted_mask = self.softmax(inpainted_mask)\\n\\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\\n\\n # set img back to how it was\\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \\n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\\n # set mask back\\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\\n for i in range(6):\\n if views=='coronal':\\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\\n else:\\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\\n inpainted_mask = inpainted_mask_resized\\n \\n if views=='coronal':\\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\\n\\n return inpainted_img, inpainted_mask, mask_binary\",\n \"def get_GroundTruth(self):\\n\\n # set first pose to identity\\n # first_pose = self.dataset.oxts[0].T_w_imu\\n # first_pose_inv = src.se3.inversePose(first_pose)\\n # do not correct the orientation\\n # first_pose_inv[:3, :3] = np.eye(3)\\n\\n # do not set first pose to identity\\n first_pose_inv = np.eye(4)\\n\\n for o in self.dataset.oxts:\\n\\n normalized_pose_original = first_pose_inv @ o.T_w_imu\\n self.poses_gt.append(normalized_pose_original)\\n\\n # gt pose is from I to G\\n for i, pose in enumerate(self.poses_gt):\\n\\n # get gt position\\n gt_position = np.reshape(pose[0:3, 3], (-1, 1))\\n\\n self.gt_position.append(gt_position)\\n\\n # get gt orientation\\n R_wIMU = pose[0:3, 0:3]\\n self.gt_orientation.append(R_wIMU)\",\n \"def mover_bm_izquierda(self):\\n self.nueva_posicion_posible_parte_superior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] - 1,\\n self.casilla[1]],\\n [self.vertice_1[0] - self.velocidad,self.vertice_1[1]], \\n [self.vertice_1[0] - 5 - 5, self.vertice_1[1]])\\n self.nueva_posicion_posible_parte_inferior = self.mapa.consultar_casilla_por_movimiento([self.casilla[0] - 1,\\n self.casilla[1] + 1],\\n [self.vertice_3[0] - self.velocidad,self.vertice_3[1]],\\n [self.vertice_3[0] - 5,self.vertice_3[1]]) \\n if self.nueva_posicion_posible_parte_superior[0] != 1 and self.nueva_posicion_posible_parte_inferior[0] != 1:\\n self.x -= self.velocidad * (self.x >= 15)\\n self.posicion = [self.x,self.posicion[1]]\\n self.casilla = [self.casilla[0] - self.nueva_posicion_posible_parte_superior[1] *(self.nueva_posicion_posible_parte_inferior[0] != 1) * (self.nueva_posicion_posible_parte_superior[0] != 1), self.casilla[1]]\\n self.redefinir_vertices()\",\n \"def big_tiling():\\n t = Tiling(\\n obstructions=(\\n GriddedPerm(Perm((0,)), ((0, 1),)),\\n GriddedPerm(Perm((0,)), ((0, 2),)),\\n GriddedPerm(Perm((0,)), ((0, 3),)),\\n GriddedPerm(Perm((0,)), ((1, 2),)),\\n GriddedPerm(Perm((0,)), ((1, 3),)),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0))),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 0), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 1))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 2))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 0))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 1))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 2))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 3))),\\n ),\\n requirements=(),\\n )\\n return t\",\n \"def generate_aima_grid():\\n\\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\\n\\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\\n\\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\\n\\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\\n\\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\\n\\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\\n\\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\\n\\n print('\\\\n***** aima grid world *****\\\\n')\\n print('Transition matrix:', transitions.shape)\\n print('Reward matrix:', rewards.shape)\\n\\n return transitions, rewards\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60112906","0.56915206","0.5676106","0.56413585","0.5641","0.56370586","0.5621993","0.55501646","0.55181795","0.5482959","0.541228","0.540904","0.5401558","0.54013026","0.5396132","0.538648","0.53705466","0.533314","0.530924","0.5304909","0.5286061","0.5281701","0.5280558","0.52673703","0.5266801","0.52667135","0.5259429","0.525738","0.5257002","0.52524877","0.52524877","0.5236358","0.52350336","0.5227571","0.5224883","0.52217644","0.52188516","0.5215805","0.521242","0.52113587","0.52112263","0.5191553","0.5180857","0.5160151","0.51536596","0.5149759","0.5146121","0.5144936","0.5142098","0.5140293","0.5139525","0.5137867","0.51366603","0.51346976","0.5134264","0.5131843","0.51314634","0.51255685","0.5119762","0.51096773","0.5109547","0.5106678","0.5105047","0.50983596","0.5097802","0.50953364","0.50927144","0.5090519","0.508966","0.50852114","0.5079829","0.50774366","0.50728256","0.507002","0.50697213","0.5069342","0.50684947","0.50646436","0.5060259","0.50558823","0.50509703","0.50350934","0.50350934","0.5028885","0.50255394","0.5024946","0.5023249","0.5019602","0.5017442","0.5015574","0.5012612","0.5012311","0.5012216","0.5005841","0.5005262","0.49992067","0.4997708","0.49947447","0.49903512","0.4989457"],"string":"[\n \"0.60112906\",\n \"0.56915206\",\n \"0.5676106\",\n \"0.56413585\",\n \"0.5641\",\n \"0.56370586\",\n \"0.5621993\",\n \"0.55501646\",\n \"0.55181795\",\n \"0.5482959\",\n \"0.541228\",\n \"0.540904\",\n \"0.5401558\",\n \"0.54013026\",\n \"0.5396132\",\n \"0.538648\",\n \"0.53705466\",\n \"0.533314\",\n \"0.530924\",\n \"0.5304909\",\n \"0.5286061\",\n \"0.5281701\",\n \"0.5280558\",\n \"0.52673703\",\n \"0.5266801\",\n \"0.52667135\",\n \"0.5259429\",\n \"0.525738\",\n \"0.5257002\",\n \"0.52524877\",\n \"0.52524877\",\n \"0.5236358\",\n \"0.52350336\",\n \"0.5227571\",\n \"0.5224883\",\n \"0.52217644\",\n \"0.52188516\",\n \"0.5215805\",\n \"0.521242\",\n \"0.52113587\",\n \"0.52112263\",\n \"0.5191553\",\n \"0.5180857\",\n \"0.5160151\",\n \"0.51536596\",\n \"0.5149759\",\n \"0.5146121\",\n \"0.5144936\",\n \"0.5142098\",\n \"0.5140293\",\n \"0.5139525\",\n \"0.5137867\",\n \"0.51366603\",\n \"0.51346976\",\n \"0.5134264\",\n \"0.5131843\",\n \"0.51314634\",\n \"0.51255685\",\n \"0.5119762\",\n \"0.51096773\",\n \"0.5109547\",\n \"0.5106678\",\n \"0.5105047\",\n \"0.50983596\",\n \"0.5097802\",\n \"0.50953364\",\n \"0.50927144\",\n \"0.5090519\",\n \"0.508966\",\n \"0.50852114\",\n \"0.5079829\",\n \"0.50774366\",\n \"0.50728256\",\n \"0.507002\",\n \"0.50697213\",\n \"0.5069342\",\n \"0.50684947\",\n \"0.50646436\",\n \"0.5060259\",\n \"0.50558823\",\n \"0.50509703\",\n \"0.50350934\",\n \"0.50350934\",\n \"0.5028885\",\n \"0.50255394\",\n \"0.5024946\",\n \"0.5023249\",\n \"0.5019602\",\n \"0.5017442\",\n \"0.5015574\",\n \"0.5012612\",\n \"0.5012311\",\n \"0.5012216\",\n \"0.5005841\",\n \"0.5005262\",\n \"0.49992067\",\n \"0.4997708\",\n \"0.49947447\",\n \"0.49903512\",\n \"0.4989457\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51816034"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":9297,"cells":{"query":{"kind":"string","value":"Summary This function encapsulates the routine to generate rectified cortical views of all opponent retinal ganglion cells"},"document":{"kind":"string","value":"def showCortexImg(pV,nV):\n # object arrays of the positive and negative images\n pos_cort_img = np.empty(8, dtype=object)\n neg_cort_img = np.empty(8, dtype=object)\n for t in range(8):\n # cortical mapping functions\n lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)\n neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)\n # stack all images into a grid\n posRGcort = np.vstack((pos_cort_img[:4]))\n negRGcort = np.vstack((neg_cort_img[:4]))\n posYBcort = np.vstack((pos_cort_img[4:]))\n negYBcort = np.vstack((neg_cort_img[4:]))\n mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)\n return mergecort"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def gen_obs_grid(self):\n\n topX, topY, botX, botY = self.get_view_exts()\n\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\n\n # for i in range(self.agent_dir + 1):\n # grid = grid.rotate_left()\n\n # Process occluders and visibility\n # Note that this incurs some performance cost\n if not self.see_through_walls:\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\n self.agent_view_size // 2))\n else:\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\n\n # Make it so the agent sees what it's carrying\n # We do this by placing the carried object at the agent's position\n # in the agent's partially observable view\n agent_pos = grid.width // 2, grid.height // 2\n if self.carrying:\n grid.set(*agent_pos, self.carrying)\n else:\n grid.set(*agent_pos, None)\n\n return grid, vis_mask","def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\n\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\n \n \n for i in np.arange(0,SHP[0],1):\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\n \n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\n \n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\n\n # normalise lateral flow so that -ve= flow out of cells towards edges\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\n # fluxes if not normalised in this way.\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\n\n # nabla is the inverted delta operator used to denote the divergence \n # of a vector field, here applied to hydrological flow in m3/d \n # calculated as dx/dt + dy/dt + dz/dt\n\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\n \n # divergence gives net in/outflow in m3/t\n # cells/m3 = cells/mL *1000\n\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\n\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \n\n Cells[Cells<0] = 0\n \n CellColumnTot = Cells.sum(axis=1)\n \n\n return Cells, CellColumnTot","def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\n\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n\n #this is just printing stuff for easier terminal reading\n if h_agent is not None:\n hstr = \"Specialized Human\"\n else:\n hstr = \"Random Human\"\n if coagent is not None:\n coagenthelp = True\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\n else:\n coagenthelp = False\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\n\n liRewards = []\n liRewardsPenalized = []\n actionsctli =[]\n heatmap = np.zeros((7, 7))\n for i in range(episodes):\n grid.reset()\n actionct = 0\n misstepct = 0\n heatmap[0,0] += 1\n while (not grid.isEnd) and (grid.numSteps <=200):\n state = grid.state\n width = grid.getBoardDim()[0]\n state_ind = state[1]*(width+1)+state[0]\n\n if 'disjoint' in mode:\n actions = [0, 1, 2, 3]\n else:\n #'up','right','down','left','upri','dori','dole','uple'\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n #if we have a special human agent use it, if not use random human\n if h_agent is None:\n action = np.random.choice(actions, 1)[0]\n h_action = action\n else:\n action = h_agent.get_action(state_ind)\n h_action = action\n if coagenthelp:\n q_vals = coagent.get_q_values(state_ind)\n best_action = coagent.get_action(state_ind)\n best_q = q_vals[best_action]\n min_q = min(q_vals)\n human_q = q_vals[action]\n\n #closest actions dictionary\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\n #value = action index if radial\n #key = actual action index\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\n #actions in order of circle\n a_radial = [0,4,1,5,2,6,3,7]\n #co-pilot action choices\n #override to optimal if suboptimal action selected\n if \"override\" in mode:\n #random percent to decide when to help if wrong action taken\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\n actionct += 1\n action = best_action\n #select best closest action if human action q-value is negative\n elif mode == \"q-neg\" and human_q < 0:\n actionct += 1\n a_li = closest_a[action]\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\n #Shared Autonomy\n #select better closest action if difference between best q and human q is past some threshold\n elif mode == \"q-diff\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\n actionct += 1\n for i in range(1,5):\n radial_a = a_dist_ind[action]\n ccw_ra = (radial_a - i) % len(actions)\n ccw_a = a_radial[ccw_ra]\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = ccw_a\n break\n cw_ra = (radial_a + i) % len(actions)\n cw_a = a_radial[cw_ra]\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = cw_a\n break\n #take the potentiallny new action\n grid.step(action)\n\n if h_agent is not None:\n heatmap[grid.state[1],grid.state[0]] += 1\n\n #add metrics to their respective lists\n liRewards.append(grid.reward)\n liRewardsPenalized.append(grid.reward-actionct)\n actionsctli.append(actionct)\n #convert lists to numpy arrays\n rewards = np.array(liRewards)\n rewards_penalized = np.array(liRewardsPenalized)\n actionsctli = np.array(actionsctli)\n #print some metrics if we want to\n if verbose:\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\n if h_agent is not None:\n plt.figure()\n print(heatmap)\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\n plt.savefig('two.png')\n\n return rewards, actionsctli, rewards_penalized","def occam_razor() -> None:\r\n print(\"WARNING! Mode three activated. Time to complete may be several minutes\")\r\n temp = [] # x-y-conflicts\r\n global example\r\n backup = example.copy() # Backup so it can backtrack through solutions\r\n for x in range(shape):\r\n for y in range(shape):\r\n conflict_counter = 0\r\n for z in range(shape):\r\n if conflict_space[x, y] != 0:\r\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\r\n conflict_counter += 1\r\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\r\n conflict_counter += 1\r\n if conflict_counter > 0 and no_neighbour(x, y):\r\n temp.append([x, y, conflict_counter])\r\n threshold = [0, 0, 0]\r\n \"\"\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\"\"\"\r\n for x in range(len(temp)):\r\n if temp[x][2] > threshold[2]:\r\n threshold = temp[x]\r\n if threshold[2] > 0:\r\n example[threshold[0], threshold[1]] = 0\r\n shade_neighbours(threshold[0], threshold[1])\r\n if not victory_checker():\r\n \"\"\"code now begins guessing\"\"\"\r\n for x in range(len(temp)):\r\n example = backup.copy()\r\n if no_neighbour(temp[x][0], temp[x][1]):\r\n example[temp[x][0], temp[x][1]] = 0\r\n else:\r\n continue\r\n progress_handler(False, True)\r\n while progress_handler(True, False):\r\n print_debug(\"itteration\")\r\n progress_handler(False, False)\r\n mark_check()\r\n if victory_checker():\r\n completion(True)\r\n if not progress_handler(True, False):\r\n special_corner()\r\n if not progress_handler(True, False):\r\n separation_crawler(True)\r\n if not progress_handler(True, False):\r\n occam_razor() # Recursive\r\n if not progress_handler(True, False):\r\n if victory_checker():\r\n completion(True)\r\n else:\r\n print(\"Searching...\")\r\n continue\r\n conflict_check()","def increased_obstacles_map(occupancy_grid):\n\n nb_rows = len(occupancy_grid)\n nb_cols = len(occupancy_grid[0])\n increased_occupancy_grid = np.zeros([nb_rows + 6, nb_cols + 6])\n\n for i in range(nb_rows):\n for j in range(nb_cols):\n\n if occupancy_grid[i, j] == OCCUPIED:\n increased_occupancy_grid[i:i + 7, j:j + 7] = np.ones([7, 7])\n\n final_occupancy_grid = increased_occupancy_grid[3:(LENGTH_case + 3), 3:(WIDTH_case + 3)]\n return final_occupancy_grid","def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\r\n \r\n nI_agg = len(list(set(indices['ind'][agg_level])))\r\n nP_agg = len(list(set(indices['prod'][agg_level])))\r\n nW_agg = len(list(set(indices['vadd'][agg_level])))\r\n nM_agg = len(list(set(indices['imp'][agg_level])))\r\n nY_agg = len(list(set(indices['fd'][agg_level])))\r\n nR_agg = len(list(set(indices['exog'][agg_level])))\r\n\r\n nI_rcot = len(list(set(indices['ind'][rect_level])))\r\n nP_rcot = len(list(set(indices['prod'][rect_level])))\r\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\r\n nM_rcot = len(list(set(indices['imp'][rect_level])))\r\n nY_rcot = len(list(set(indices['fd'][rect_level])))\r\n nR_rcot = len(list(set(indices['exog'][rect_level])))\r\n\r\n \r\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\r\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\r\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\r\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\r\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\r\n\r\n \r\n indInd = indices_agg['ind']\r\n prodInd = indices_agg['prod']\r\n vaddInd = indices_agg['vadd']\r\n impInd = indices_agg['imp']\r\n fdInd = indices_agg['fd']\r\n exogInd = indices_agg['exog']\r\n\r\n zInd = prodInd.append(indInd)\r\n zInd = zInd.swaplevel(0,1)\r\n \r\n\r\n for l in range(nL):\r\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\r\n\r\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n ZR_0[l] = Z.values\r\n WR_0[l] = W.values\r\n MR_0[l] = M.values\r\n YR_0[l] = Y.values\r\n \r\n AR_0[l] = A.values\r\n wR_0[l] = w.values\r\n mR_0[l] = m.values\r\n\r\n \r\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\r\n \r\n\r\n ML_RCOT_0 = {\r\n 'Z' : ZR_0,\r\n 'W' : WR_0,\r\n 'M' : MR_0,\r\n 'Y' : YR_0,\r\n 'R' : RR_0,\r\n }\r\n\r\n ML_RCOT_coeff_0 = {\r\n 'A' : AR_0,\r\n 'w' : wR_0,\r\n 'm' : mR_0,\r\n 'Y' : YR_0,\r\n 'B' : BR_0,\r\n }\r\n\r\n \r\n indices_RCOT = {\r\n 'prod/ind' : zInd,\r\n 'vadd' : vaddInd,\r\n 'imp' : impInd,\r\n 'fd' : fdInd,\r\n 'exog' : exogInd,\r\n 'headers' : indices['headers']\r\n }\r\n \r\n \r\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)","def build_occupancy_map(human : Human, other_agents : np.array, cell_num : int, cell_size : float, om_channel_size : int) -> np.array:\n other_px = other_agents[:, 0] - human.px\n other_py = other_agents[:, 1] - human.py\n\n # new x-axis is in the direction of human's velocity\n human_velocity_angle = np.arctan2(human.vy, human.vx)\n other_human_orientation = np.arctan2(other_py, other_px)\n rotation = other_human_orientation - human_velocity_angle\n distance = np.linalg.norm([other_px, other_py], axis=0)\n other_px = np.cos(rotation) * distance\n other_py = np.sin(rotation) * distance\n\n # compute indices of humans in the grid\n other_x_index = np.floor(other_px / cell_size + cell_num / 2)\n other_y_index = np.floor(other_py / cell_size + cell_num / 2)\n other_x_index[other_x_index < 0] = float('-inf')\n other_x_index[other_x_index >= cell_num] = float('-inf')\n other_y_index[other_y_index < 0] = float('-inf')\n other_y_index[other_y_index >= cell_num] = float('-inf')\n grid_indices = cell_num * other_y_index + other_x_index\n occupancy_map = np.isin(range(cell_num ** 2), grid_indices)\n if om_channel_size == 1:\n return occupancy_map.astype(int)\n else:\n # calculate relative velocity for other agents\n other_human_velocity_angles = np.arctan2(other_agents[:, 3], other_agents[:, 2])\n rotation = other_human_velocity_angles - human_velocity_angle\n speed = np.linalg.norm(other_agents[:, 2:4], axis=1)\n other_vx = np.cos(rotation) * speed\n other_vy = np.sin(rotation) * speed\n dm = [list() for _ in range(cell_num ** 2 * om_channel_size)]\n for i, index in np.ndenumerate(grid_indices):\n if index in range(cell_num ** 2):\n if om_channel_size == 2:\n dm[2 * int(index)].append(other_vx[i])\n dm[2 * int(index) + 1].append(other_vy[i])\n elif om_channel_size == 3:\n dm[int(index)].append(1)\n dm[int(index) + cell_num ** 2].append(other_vx[i])\n dm[int(index) + cell_num ** 2 * 2].append(other_vy[i])\n else:\n raise NotImplementedError\n for i, cell in enumerate(dm):\n dm[i] = sum(dm[i]) / len(dm[i]) if len(dm[i]) != 0 else 0\n return dm","def showNonOpponency(C,theta):\n GI = retina.gauss_norm_img(x, y, dcoeff[i], dloc[i], imsize=imgsize,rgb=False)\n # Sample using the other recepetive field, note there is no temporal response with still images\n S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True)\n #backproject the imagevectors\n ncentreV,nsurrV = rgc.nonopponency(C,S,theta)\n ninverse = retina.inverse(ncentreV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n ninv_crop = retina.crop(ninverse,x,y,dloc[i])\n ninverse2 = retina.inverse(nsurrV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n ninv_crop2 = retina.crop(ninverse2,x,y,dloc[i])\n # place descriptive text onto generated images\n cv2.putText(ninv_crop,\"R+G + \",(xx,yy), font, 1,(255,255,255),2)\n cv2.putText(ninv_crop2,\"R+G - \",(xx,yy), font, 1,(255,255,255),2)\n merged = np.concatenate((ninv_crop, ninv_crop2),axis=1)\n \n # create cortical maps of the imagevectors\n lposnon, rposnon = cortex.cort_img(ncentreV, L, L_loc, R, R_loc, cort_size, G)\n lnegnon, rnegnon = cortex.cort_img(nsurrV, L, L_loc, R, R_loc, cort_size, G)\n pos_cort_img = np.concatenate((np.rot90(lposnon),np.rot90(rposnon,k=3)),axis=1)\n neg_cort_img = np.concatenate((np.rot90(lnegnon),np.rot90(rnegnon,k=3)),axis=1)\n mergecort = np.concatenate((pos_cort_img,neg_cort_img),axis=1)\n return merged, mergecort","def _get_observations(self):\n food = np.array(self.game.state.data.food.data)\n walls = np.array(self.game.state.data.layout.walls.data)\n map_shape = walls.shape\n capsules = self.game.state.data.capsules\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\n\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\n self.game.state.data.agentStates[1:]))\n gosts_scared = list(\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\n\n \"\"\"\n 0: empty,\n 1: wall,\n 2: food,\n 3: capsules,\n 4: ghost,\n 5: scared ghost,\n 6: pacman\n \"\"\"\n\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\n\n def select(l):\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\n\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\n\n def pos_to_relative_pos(pos):\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\n return None\n else:\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\n\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\n\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\n if (g_relative_pos is not None):\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\n ] = 5 if gosts_scared[i] else 4\n\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\n\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\n\n obs[0, 0] = 2 if np.any(\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\n obs[obs.shape[0]-1,\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\n\n obs[0, obs.shape[1] -\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\n\n # print(np.transpose(obs)[::-1, :])\n\n return obs","def generate_grains(self, cells):\n\t\tfor cell_num in range(cells):\n\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\tsample_cell = sample_cell[0]\n\t\t\twhile sample_cell.state != 0:\n\t\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\t\tsample_cell = sample_cell[0]\n\t\t\tsample_cell.change_state(self.init_time ,cell_num)","def reduce_possibilities_by_box(self):\n x = self.targetCell.x\n y = self.targetCell.y\n if x < 3 and y < 3: #top left\n self.check_box1()\n if x > 2 and x < 6 and y < 3: #middle left\n self.check_box2()\n if x > 5 and y < 3: #bottom left\n self.check_box3()\n if x < 3 and y > 2 and y < 6: #top middle\n self.check_box4()\n if x > 2 and x < 6 and y > 2 and y < 6: #center\n self.check_box5()\n if x > 5 and y > 2 and y < 6: #bottom middle\n self.check_box6()\n if x < 3 and y > 5: #top right\n self.check_box7()\n if x > 2 and x < 6 and y > 5: #middle right\n self.check_box8()\n if x > 5 and y > 5: #bottom right\n self.check_box9()\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)","def make_move(grid, n_columns, n_rows):\r\n # Generate the game grid to be manipulated\r\n new_grid = [[0] * (n_columns + 1) for i in range(n_rows + 1)]\r\n\r\n\r\n for i in range(n_rows):\r\n for j in range(n_columns):\r\n upper_left = grid[i-1][j-1] # neighbor to upper left of cell of interest\r\n upper = grid[i-1][j] # neighbor above cell of interest\r\n upper_right = grid[i-1][j+1] # neighbor to upper right of cell of interest\r\n left = grid[i][j-1] # neighbor to left of cell of interest\r\n right = grid[i][j+1] # neighbor to right of cell of interest\r\n bot_left = grid[i+1][j-1] # neighbor to bottom left cell of interest\r\n bot = grid[i+1][j] # neighbor below cell of interest\r\n bot_right = grid[i+1][j+1] # neighbor to bottom right of cell of interest\r\n\r\n # sum of the state of all neighbors\r\n on_neighbors = upper_left + upper + upper_right + left + right + bot_left + bot + bot_right\r\n\r\n # Any ON cell with fewer than two ON neighbors turns OFF\r\n if grid[i][j] == 1 and on_neighbors < 2:\r\n new_grid[i][j] = 0\r\n\r\n # Any ON cell with two or three ON neighbours stays ON\r\n elif grid[i][j] == 1 and (on_neighbors == 2 or on_neighbors == 3):\r\n new_grid[i][j] = 1\r\n\r\n # Any ON cell with more than three ON neighbors turns OFF\r\n elif grid[i][j] == 1 and on_neighbors > 3:\r\n new_grid[i][j] = 0\r\n\r\n # Any OFF cell with three ON neighbors turns ON\r\n elif grid[i][j] == 0 and on_neighbors == 3:\r\n new_grid[i][j] = 1\r\n\r\n return new_grid #manipulated game grid\r","def get_grasp_vis(predictions,\n color_heightmap,\n action_rot,\n action_position,\n num_rotations=16):\n canvas = None\n for canvas_row in range(4):\n tmp_row_canvas = None\n for canvas_col in range(int(num_rotations / 4)):\n rotate_idx = int(canvas_row * num_rotations / 4 + canvas_col)\n prediction = predictions[rotate_idx, :, :].copy()\n if rotate_idx == action_rot:\n position = action_position\n else:\n position = None\n prediction_vis = get_workspace_vis(prediction,\n color_heightmap,\n action_position=position)\n if tmp_row_canvas is None:\n tmp_row_canvas = prediction_vis\n else:\n tmp_row_canvas = np.concatenate((tmp_row_canvas,prediction_vis), axis=1)\n if canvas is None:\n canvas = tmp_row_canvas\n else:\n canvas = np.concatenate((canvas,tmp_row_canvas), axis=0)\n return canvas","def run_pass_2():\n global live_cells\n global cell_count\n global attempts\n global cell_age\n \n print(\"Live Cells : \" + str(len(live_cells)))\n \n live_cell_scores = [get_cart_score(c) for c in live_cells]\n live_cells_sorted = [x for _,x in sorted(zip(live_cell_scores,live_cells))]\n del live_cells[:]\n live_cells = live_cells + live_cells_sorted\n \n cell = live_cells.pop(0)\n if check_cart(c) and check_dead(c):\n voxel_data[cart_to_loc(cell)] = 1\n \n cell_age[cart_to_loc(c)] = cell_count\n \n \n cell_count += 1\n \n neighbors = [get_cart_neighbor(c,i) for i in range(6)]\n \n for n in neighbors:\n if check_cart(n) and check_dead(c) and not n in live_cells:\n live_cells.append(n)","def examineMaze(self, gameState):\n w = self.walls.width\n h = self.walls.height\n walls = self.walls.deepCopy()\n food1 = self.getFoodYouAreDefending(gameState)\n food2 = self.getFood(gameState)\n\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\n for x in range(w):\n for y in range(h):\n if walls[x][y]:\n walls[x][y] = 0\n elif food1[x][y]:\n walls[x][y] = 2\n elif food2[x][y]:\n walls[x][y] = 2\n else:\n walls[x][y] = 1\n\n roomsDisplay = []\n # Detect doors and spaces. Spaces are now negative\n for x in range(w):\n for y in range(h):\n if walls[x][y] > 0:\n exitsNum = 0\n if walls[x][y - 1] != 0:\n exitsNum += 1\n if walls[x][y + 1] != 0:\n exitsNum += 1\n if walls[x - 1][y] != 0:\n exitsNum += 1\n if walls[x + 1][y] != 0:\n exitsNum += 1\n if exitsNum == 1 or exitsNum == 2:\n walls[x][y] = -1 * walls[x][y]\n roomsDisplay.append((x, y))\n elif exitsNum == 0:\n # We erase unaccessible cells\n walls[x][y] = 0\n else:\n # These are doors or big rooms, we leave them positive\n pass\n\n # Create roomsGraph: every room has a number, some cells and some doors\n roomsGraph = []\n doorsGraph = []\n for x in range(1, w - 1):\n for y in range(1, h - 1):\n if walls[x][y] < 0:\n spacesNum = 0\n if walls[x][y - 1] < 0:\n spacesNum += 1\n if walls[x][y + 1] < 0:\n spacesNum += 1\n if walls[x - 1][y] < 0:\n spacesNum += 1\n if walls[x + 1][y] < 0:\n spacesNum += 1\n if spacesNum < 2:\n endOfPath = False\n graphNode = {\"path\": [], \"doors\": [], \"food\": 0, \"isBig\": False}\n auxx = x\n auxy = y\n while not endOfPath:\n graphNode[\"path\"].append((x, y))\n graphNode[\"food\"] += -walls[x][y] - 1\n walls[x][y] = 0\n xx = x\n yy = y\n if walls[x][y - 1] < 0:\n yy = y - 1\n elif walls[x][y + 1] < 0:\n yy = y + 1\n elif walls[x - 1][y] < 0:\n xx = x - 1\n elif walls[x + 1][y] < 0:\n xx = x + 1\n else:\n endOfPath = True\n if walls[x][y - 1] > 0:\n if [(x, y - 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y - 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y - 1), []]))\n if walls[x][y + 1] > 0:\n if [(x, y + 1), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x, y + 1), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x, y + 1), []]))\n if walls[x - 1][y] > 0:\n if [(x - 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x - 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x - 1, y), []]))\n if walls[x + 1][y] > 0:\n if [(x + 1, y), []] not in doorsGraph:\n graphNode[\"doors\"].append(len(doorsGraph))\n doorsGraph.append([(x + 1, y), []])\n else:\n graphNode[\"doors\"].append(doorsGraph.index([(x + 1, y), []]))\n x = xx\n y = yy\n roomsGraph.append(graphNode)\n x = auxx\n y = auxy\n\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\n for j, door in enumerate(doorsGraph):\n for i, room in enumerate(roomsGraph):\n for aDoor in room[\"doors\"]:\n if aDoor == j:\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\n (x, y) = doorsGraph[j][0]\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\n adjacentDoors = []\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\n for p in adjacentCells:\n # Skip if wall\n if self.walls[p[0]][p[1]]:\n continue\n # Skip if door\n isRoom = False\n for room in doorsGraph[j][1]:\n if p in roomsGraph[room][\"path\"]:\n isRoom = True\n break\n if not isRoom:\n # Add if existing door\n doorFound = False\n for i, neighborDoor in enumerate(doorsGraph):\n if neighborDoor[0] == p:\n adjacentDoors.append(i)\n doorFound = True\n break\n # Create if non existing door and add\n if not doorFound:\n adjacentDoors.append(len(doorsGraph))\n doorsGraph.append([p, []])\n doorsGraph[j].append(adjacentDoors)\n\n # Create doorsDistance: maps what doors can be accessed from other doors\n roomsMapper = {}\n doorsMapper = {}\n isRoom = util.Counter()\n for i, door in enumerate(doorsGraph):\n doorsMapper[door[0]] = i\n isRoom[door[0]] = 0\n for i, room in enumerate(roomsGraph):\n for p in room[\"path\"]:\n roomsMapper[p] = i\n isRoom[p] = 1\n\n # Create self variables\n self.doorsGraph = doorsGraph\n self.roomsGraph = roomsGraph\n self.roomsMapper = roomsMapper\n self.doorsMapper = doorsMapper\n self.isRoom = isRoom\n\n # # Find dead ends (rooms with only one door)\n # deadRooms = {}\n # deadDoors = {}\n # # deaderDoors = {}\n # # deaderRooms = {}\n # for i, room in enumerate(roomsGraph):\n # if len(room[\"doors\"]) == 1:\n # deadRooms[i] = room[\"doors\"][0]\n # deadDoors[room[\"doors\"][0]] = 1\n # numdR = 0\n # aliveR = -1\n # for adjRoom in doorsGraph[room[\"doors\"][0]][1]:\n # if adjRoom not in deadRooms:\n # numdR += 1\n # aliveR = adjRoom\n # if numdR + len(doorsGraph[room[\"doors\"][0]][2]) == 1:\n # if aliveR >= 0:\n # deaderRooms[aliveR] = room[\"doors\"][0]\n # for adjDoor in roomsGraph[aliveR][\"doors\"]:\n # if adjDoor == room[\"doors\"][0]:\n # continue\n # deaderDoors[adjDoor] = 1.0\n # else:\n # deaderDoors[doorsGraph[room[\"doors\"][0]][2][0]] = 1.0\n\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deaderRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deaderDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, room in enumerate(roomsGraph):\n # numAliveDoors = 0\n # aliveDoor = 0\n # deadDoor = []\n # for door in room[\"doors\"]:\n # if door not in deadDoors:\n # numAliveDoors += 1\n # aliveDoor = door\n # else:\n # deadDoor.append(door)\n # if numAliveDoors == 1:\n # aliveRoom = 0\n # aliveNeighborDoor = 0\n # for door in deadDoor:\n # # aliveNeighborDoor += len(doorsGraph[door][2])\n # for neighborRoom in doorsGraph[door][1]:\n # if neighborRoom not in deadRooms:\n # aliveRoom += 1\n # if aliveRoom == len(deadDoor):\n # deadRooms[i] = aliveDoor\n # deadDoors[aliveDoor] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\n # for p in room[\"path\"]:\n # roomsCounter[1][p] = 1\n # for p in deadDoor:\n # roomsCounter[2][doorsGraph[p][0]] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\n # deadEndsChanged = True\n # while deadEndsChanged:\n # deadEndsChanged = False\n # for i, door in enumerate(doorsGraph):\n # if i not in deadDoors:\n # numOpenRooms = 0\n # openRoom = 0\n # for j, room in enumerate(door[1]):\n # if room not in deadRooms:\n # numOpenRooms += 1\n # openRoom = j\n # if numOpenRooms + len(door[2]) == 1:\n # for room in door[1]:\n # if room != openRoom:\n # deadRooms[room] = i\n # deadDoors[j] = 1\n # deadEndsChanged = True\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[0][door[0]] = 1\n # for rr in door[1]:\n # print rr\n # if rr in deadRooms:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[1][p] = 1\n # else:\n # for p in roomsGraph[rr][\"path\"]:\n # roomsCounter[3][p] = 1\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # print deadDoors\n # print\n # print deadRooms\n # print \"-----------------\"\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # roomsCounter[1][(6, 9)] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n # for r in deadRooms:\n # for p in roomsGraph[r][\"path\"]:\n # roomsCounter[0][p] = 0.4\n # for d in deadDoors:\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\n # self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")\n\n # Show every room\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\n for room in roomsGraph:\n for p in room[\"path\"]:\n if len(room[\"doors\"]) > 1:\n roomsCounter[0][p] = 0.4\n else:\n roomsCounter[2][p] = 0.4\n # Show every door\n for door in doorsGraph:\n roomsCounter[1][door[0]] = 0.4\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\n self.displayDistributionsOverPositions(roomsCounter)\n # raw_input(\"Press Enter to continue ...\")","def __checkvictory__(self,playerchar):\n\t\tvictory = False\n\t\tboardx = deepcopy(self.board)\n\t\trow = 5\n\t\tcolumn = 6\n\t\tstarburst_bag = []\n\t\tcats_game = True\n\t\tfor a in range(row+1):\n\t\t\tfor b in range(column+1):\n\t\t\t\tstarburst = []\n\t\t\t\tstarburst.append((a,b))\n\t\t\t\t\n\t\t\t\tif self.__checkplace__(a,b) is True:\n\t\t\t\t\tcats_game = False\n\t\t\t\t\tcontinue\n\t\t\t\telif self.__checkplace__(a,b) == playerchar:\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a-starburst[1] < 0:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a-starburst[1],b) == playerchar:\n\t\t\t\t\t\t\tstarburst[1] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a-starburst[2] < 0:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif b+starburst[2] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a-starburst[2],b+starburst[2])\\\n\t\t\t\t\t\t == playerchar:\n\t\t\t\t\t\t\tstarburst[2] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif b+starburst[3] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a,b+starburst[3]) == playerchar:\n\t\t\t\t\t\t\tstarburst[3] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\tstarburst.append(1)\n\t\t\t\t\t\n\t\t\t\t\twhile True:\n\t\t\t\t\t\tif a+starburst[4] > 5:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif b+starburst[4] > 6:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif self.__checkplace__(a+starburst[4],b+starburst[4])\\\n\t\t\t\t\t\t== playerchar:\n\t\t\t\t\t\t\tstarburst[4] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\tstarburst_bag.append(starburst)\n\t\t\n\t\tfor starburst in starburst_bag:\n\t\t\t\n\t\t\ta = starburst[0][0]\n\t\t\tb = starburst[0][1]\n\t\t\t\n\t\t\tif starburst[1] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[1]):\n\t\t\t\t\tboardx[a-i][b] = boardx[a-i][b].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[2] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[2]):\n\t\t\t\t\tboardx[a-i][b+i] = boardx[a-i][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[3] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[3]):\n\t\t\t\t\tboardx[a][b+i] = boardx[a][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\tif starburst[4] > 3:\n\t\t\t\tvictory = True\n\t\t\t\tfor i in range(starburst[4]):\n\t\t\t\t\tboardx[a+i][b+i] = boardx[a+i][b+i].\\\n\t\t\t\t\treplace(playerchar,playerchar.upper())\n\t\t\t\n\t\tif cats_game:\n\t\t\treturn None\n\t\tif victory:\n\t\t\treturn boardx\n\t\telse:\n\t\t\treturn False","def build_grains(self):\n\t\ttime = datetime.datetime.now()\n\t\tif self.probability == 0:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\t\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tnew_grain = 0\n\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\telse:\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state != 0 :\n\t\t\t\t\tcontinue\n\t\t\t\telif self.check_empty_neighbours(cell):\n\t\t\t\t\tcontinue\n\t\t\t\telse:\n\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\tif self.decide_changing(cell,neighbours,5, time):\n\t\t\t\t\t\tneighbours = self.get_nearest_neighbours(cell)\n\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\tneighbours = self.get_further_neighbours(cell)\n\t\t\t\t\t\t\tif self.decide_changing(cell,neighbours,3, time):\n\t\t\t\t\t\t\t\tneighbours = self.get_neighbours(cell)\n\t\t\t\t\t\t\t\tgrains = [0 for i in range(self.grains)]\n\t\t\t\t\t\t\t\tfor i in range(1,self.grains+1):\n\t\t\t\t\t\t\t\t\tfor neighbour in neighbours:\n\t\t\t\t\t\t\t\t\t\tif neighbour.state == i and neighbour.timestamp < time:\n\t\t\t\t\t\t\t\t\t\t\tgrains[i] = grains[i] + 1\n\t\t\t\t\t\t\t\tif grains == [0 for i in range(self.grains)]:\n\t\t\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t\t\tnew_grain = 0\n\t\t\t\t\t\t\t\tfor i in range(self.grains):\n\t\t\t\t\t\t\t\t\tif grains[i] >= new_grain:\n\t\t\t\t\t\t\t\t\t\tnew_grain = i\n\t\t\t\t\t\t\t\trandom_number = random.random() * 100\n\t\t\t\t\t\t\t\tif random_number <= self.probability:\n\t\t\t\t\t\t\t\t\tcell.change_state(time, new_grain)\n\t\t\t\t\t\t\t\t\tself.empty_cells = self.empty_cells - 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tcontinue","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def main_loop(self):\n for iteration in xrange(1, self.num_iterations + 1):\n print \"At iteration %d\" % iteration\n self.it_num = iteration\n \n ### Select cells randomly without replacement\n x, y = np.meshgrid(np.arange(self.x_len), np.arange(self.y_len))\n \n x = x.flat\n y = y.flat\n \n shuffled_indices = np.random.permutation(np.arange(self.x_len * self.y_len))\n \n for index in shuffled_indices:\n # Get the current y and x indices\n cur_y, cur_x = y[index], x[index]\n \n \n if self.altered == False:\n # Use the standard version\n if self.grid[cur_y, cur_x] == 0:\n # If there's no slab there then we can't erode it!\n continue\n else:\n # Use the altered version of checking if we can erde\n if self.grid[cur_y, cur_x] == self.depth[cur_y, cur_x]:\n # We can't erode it, so continue\n continue\n \n # Check to see if the cell is in shadow.\n if self.cell_in_shadow(cur_y, cur_x):\n # If it's in shadow then we can't erode it, so go to the next random cell \n continue\n \n if True:\n # Move a slab\n self.grid[cur_y, cur_x] -= 1\n \n orig_y, orig_x = cur_y, cur_x\n \n # Loop forever - until we break out of it\n while True:\n new_y, new_x = cur_y, self.add_x(cur_x, self.jump_length)\n \n if self.grid[new_y, new_x] == 0:\n prob = self.pd_ns\n else:\n prob = self.pd_s\n \n if np.random.random_sample() <= prob:\n # Drop cell\n break\n else:\n cur_y, cur_x = new_y, new_x\n \n #print \"Dropping on cell\"\n #print new_y, new_x\n # Drop the slab on the cell we've got to\n self.grid[new_y, new_x] += 1\n \n self.do_repose(orig_y, orig_x)\n \n self.do_repose(new_y, new_x)\n \n self.write_file()","def build_occupancy_map_torch(human: torch.Tensor, other_agents: torch.Tensor, cell_num: int, cell_size: float,\n om_channel_size: int) -> torch.Tensor:\n other_px = other_agents[:, 0] - human[0]\n other_py = other_agents[:, 1] - human[1]\n\n # new x-axis is in the direction of human's velocity\n human_velocity_angle = torch.atan2(human[1], human[0])\n other_human_orientation = torch.atan2(other_py, other_px)\n rotation = other_human_orientation - human_velocity_angle\n distance = torch.norm(torch.cat([other_px.view(-1, 1), other_py.view(-1, 1)], axis=1), dim=1)\n other_px = torch.cos(rotation) * distance\n other_py = torch.sin(rotation) * distance\n\n # compute indices of humans in the grid\n other_x_index = torch.floor(other_px / cell_size + cell_num / 2)\n other_y_index = torch.floor(other_py / cell_size + cell_num / 2)\n other_x_index[other_x_index < 0] = float('-inf')\n other_x_index[other_x_index >= cell_num] = float('-inf')\n other_y_index[other_y_index < 0] = float('-inf')\n other_y_index[other_y_index >= cell_num] = float('-inf')\n grid_indices = cell_num * other_y_index + other_x_index\n\n # calculate relative velocity for other agents\n other_human_velocity_angles = torch.atan2(other_agents[:, 3], other_agents[:, 2])\n rotation = other_human_velocity_angles - human_velocity_angle\n speed = torch.norm(other_agents[:, 2:4],dim=1)\n other_vx = torch.cos(rotation) * speed\n other_vy = torch.sin(rotation) * speed\n\n # occupy map\n dm = torch.zeros(3, cell_num ** 2)\n for i, index in np.ndenumerate(grid_indices):\n if index in range(cell_num ** 2):\n dm[0, int(index)] += 1\n dm[1, int(index)] += other_vx[i]\n dm[2, int(index)] += other_vy[i]\n\n mask = dm[0, :] != 0\n count = dm[0, mask]\n dm[0:3, mask] /= count\n\n if om_channel_size == 1:\n return dm[0, :].view(-1)\n elif om_channel_size == 2:\n return dm[1:3, :].view(-1)\n else:\n return dm.view(-1)","def init(self, windowsize:tuple):\r\n y_count, x_count = 3, 0 #< Set the starting counter for the look_up_table. y starts with three because the first three lines are just Nones\r\n # Creating the constant maze \r\n maze_size = windowsize[0], windowsize[1] - 2 * self.grid_size\r\n self.maze = pg.Surface(maze_size) \r\n \r\n \r\n \r\n # Draw the outermost rectangles on self.maze\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0, 3 * self.grid_size), (28 * self.grid_size, 31 * self.grid_size)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0 + self.grid_size // 2, 3 * self.grid_size + self.grid_size // 2),(27 * self.grid_size, 30 * self.grid_size)), 4) \r\n # Draw the inner rectangles\r\n for y in self.look_up_table[3 : -2]: #< y is a list of one row from the maze\r\n for x in y: #< x is a string that is decoded as already explained\r\n pos = [self.grid_size * x_count, self.grid_size * y_count]\r\n # Set reference position in the middle of one square\r\n pos[0] += self.grid_size // 2\r\n pos[1] += self.grid_size // 2\r\n x_count += 1\r\n # Check if x is rectangle\r\n if x != None and x[0] == 'r':\r\n # When the size of the string is equal or greater than 4 it's rectangle with a specific size and not just a border.\r\n if len(x) >= 4:\r\n # get the x and y size of the rectangle. x will be something like 'rx1_y1' x1 resprestens the size in x direction and y1 in y direction.\r\n xy_dim = x[1:].split(\"_\") \r\n xy_dim[0] = int(xy_dim[0])\r\n xy_dim[1] = int(xy_dim[1])\r\n rect = tuple(pos), (xy_dim[0] * self.grid_size , xy_dim[1] * self.grid_size )\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], rect, self.width)\r\n # If the last char is a w (white), u (up) or l (left) a line gets draw one a specific position \r\n if x[-1] == 'w':\r\n self.draw_line(self.maze, 'u', (x_count,y_count), True)\r\n if x[-1] == 'u' or x[-1] == 'l':\r\n if x_count == 0:\r\n self.draw_line(self.maze, x[-1], (len(y), y_count))\r\n else:\r\n self.draw_line(self.maze, x[-1], (x_count, y_count))\r\n \r\n y_count += 1\r\n x_count = 0\r\n # Just some cosmetic drawing\r\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((0, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((28 * self.grid_size - self.grid_size // 2 - 1, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 13 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 19 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 13 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 19 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\r\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((11 * self.grid_size, 16 * self.grid_size), (6 * self.grid_size, 3 * self.grid_size)), self.width)\r\n \r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size // 2 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 18 * self.grid_size + self.grid_size // 2), (self.grid_size // 2 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size * 28 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\r\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 18 * self.grid_size + self.grid_size // 2), (self.grid_size * 28 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\r\n self.is_init = True","def __init__(self, \n nd = 2, \n goal = np.array([1.0,1.0]),\n state_bound = [[0,1],[0,1]],\n nA = 4,\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\n<<<<<<< HEAD:archive-code/puddleworld.py\n ngrid = [10.0,10.0],\n maxStep = 40):\n ngrid = [40, 40]\n x_vec = np.linspace(0,1,ngrid[0])\n y_vec = np.linspace(0,1,ngrid[1])\n for x in x_vec:\n for y in y_vec:\n if ~self.inPuddle([x,y]):\n puddle.append([x,y])\n # puddle is a closed loop \n outpuddlepts = np.asarray(puddle)\n \"\"\"\n\n\n # Horizontal wing of puddle consists of \n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\n # (xchi,ychi) is the center points (h ==> horizantal)\n # x, y = state[0], state[1]\n xch1, ych1 = 0.3, 0.7\n xch2, ych2 = 0.65, ych1\n radius = 0.1\n\n\n #Vertical wing of puddle consists of \n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\n # where (xcvi,ycvi) is the center points (v ==> vertical)\n xcv1 = 0.45; ycv1=0.4;\n xcv2 = xcv1; ycv2 = 0.8;\n\n # % 2) two half-circle at end edges of rectangle\n \n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n puddle.append([xcv1-radius,ych1-radius])\n \n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n \n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n \n puddle.append([xcv1-radius,ych1+radius])\n\n\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1-radius,y])\n \n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1+radius,y])\n \"\"\"\n for y in np.arrange():\n puddle.append([])\n \n for y in np.arrange():\n puddle.append([])\n \"\"\"\n\n # HALF CIRCLES\n ngridTheta = 10\n thetaVec = np.linspace(0,pi,ngridTheta)\n\n for t in thetaVec:\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\n\n for t in thetaVec:\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\n\n \n outpuddlepts = np.asarray(puddle)\n return outpuddlepts","def big_tiling():\n t = Tiling(\n obstructions=(\n GriddedPerm(Perm((0,)), ((0, 1),)),\n GriddedPerm(Perm((0,)), ((0, 2),)),\n GriddedPerm(Perm((0,)), ((0, 3),)),\n GriddedPerm(Perm((0,)), ((1, 2),)),\n GriddedPerm(Perm((0,)), ((1, 3),)),\n GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0))),\n GriddedPerm(Perm((1, 0)), ((0, 0), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((0, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 0), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 1))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 0), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 0))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 1))),\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 2))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 0))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 1))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 2))),\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 3))),\n ),\n requirements=(),\n )\n return t","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if rooms==[]: return\n xcord=len(rooms)\n ycord=len(rooms[0])\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\n gatenum=1\n while indexstack != []:\n newindex=[]\n for item in indexstack:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=gatenum\n newindex.append((xpoint,ypoint))\n indexstack=newindex\n gatenum+=1\n ''''\n for item in index_0:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=1\n index_1.append((xpoint,ypoint))\n for item in index_1:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=2\n index_2.append((xpoint,ypoint))\n for item in index_2:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=3\n index_3.append((xpoint,ypoint))\n for item in index_3:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=4\n #index_3.append((xpoint,ypoint))'''","def challenge2(self):\n # Let's try an octree-type approach\n # For each grid cube we should be able to find whether a nanobot:\n # 1) is not in range (is outside grid cube and not in range of nearest face)\n # 2) is in range of whole cube (all 8 corners are in range)\n # 3) is in range of part of the cube (i.e. not 1 or 2)\n # Root node: figure out extent of whole space\n mins = []\n maxs = []\n for axis in range(3):\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n\n for count in range(len(self.nanobots), 0, -1):\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\n if results and results[0].count >= count:\n break\n\n print(f\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\")\n\n # Find result coord closest to origin\n closest_dist = np.iinfo(np.int32).max\n best_coord = None\n for result in results:\n for corner in itertools.product(*zip(result.mins, result.maxs)):\n d = manhattan_dist(corner, (0, 0, 0))\n if d < closest_dist:\n closest_dist = d\n best_coord = corner\n\n print(f\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\")","def gru_cell(self, Xt, h_t_minus_1):\n # 1.update gate: decides how much past information is kept and how much new information is added.\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\n # 2.reset gate: controls how much the past state contributes to the candidate state.\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\n # candiate state h_t~\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\n # new state: a linear combine of pervious hidden state and the current new state h_t~\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\n return h_t","def solve_puzzle(self):\r\n \r\n counter = 0\r\n rows = self._height-1\r\n cols = self._width-1\r\n # print rows, cols\r\n # print 'The greed has %s rows and %s coloumn indexes' %(rows, cols) \r\n solution_move = ''\r\n if self.get_number(0,0) == 0 and \\\r\n self.get_number(0,1) == 1:\r\n # print 'Congrads Puxxle is Aolved at start!!!!!'\r\n return ''\r\n #appropriate_number = (self._height * self._width) - 1\r\n appropriate_number = (rows+1) * (cols+1) -1\r\n # print 'First appropriate_number=',appropriate_number\r\n # print \"Grid first tile that we will solwing has value =\", self._grid[rows][cols]\r\n \r\n while counter < 300:\r\n counter +=1\r\n # print self\r\n #appropriate_number = (rows+1) * (cols+1) -1\r\n # print 'Appropriate number in loop=',appropriate_number\r\n # print 'We are solving %s index_row and %s index_col' %(rows, cols) \r\n ####Case when we use solve_interior_tile\r\n if rows > 1 and cols > 0:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n cols -= 1\r\n appropriate_number -=1\r\n else:\r\n # print 'We are solving interior tile', (rows, cols)\r\n solution_move += self.solve_interior_tile(rows, cols)\r\n # print 'Solution move=', solution_move\r\n cols -= 1\r\n #### Case when we use solve_col0_tile\r\n elif rows > 1 and cols == 0:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows -= 1\r\n cols = self._width-1\r\n appropriate_number -=1\r\n else:\r\n # print 'We are solwing tile 0 in row', rows\r\n # print 'Appropriate number here ='\r\n solution_move += self.solve_col0_tile(rows)\r\n # print 'Solution move=', solution_move\r\n rows -=1\r\n cols = self._width-1\r\n\r\n\r\n #### Cases when we use solve_row0_tile\r\n elif rows == 1 and cols > 1:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows -= 1\r\n #cols = self._width-1\r\n appropriate_number -= self._width\r\n\r\n else:\r\n # print 'Solving upper 2 rows right side'\r\n solution_move += self.solve_row1_tile(cols)\r\n rows -=1\r\n appropriate_number -= self._width\r\n #### Cases when we use solve_row1_tile \r\n if rows < 1 and cols > 1:\r\n if self._grid[rows][cols] == appropriate_number:\r\n # print 'This tile is already solved!!!'\r\n rows += 1\r\n cols -= 1\r\n appropriate_number +=self._width-1\r\n else:\r\n # print '(1,J) tile solved, lets solwe tile (0,j) in tile',(rows,cols)\r\n # print 'Greed after move solve_row1_tile'\r\n # print self\r\n solution_move += self.solve_row0_tile(cols)\r\n rows +=1\r\n cols -=1\r\n appropriate_number +=self._width-1\r\n\r\n\r\n #### Case when we use solve_2x2\r\n elif rows <= 1 and cols <= 1:\r\n # print 'We are solving 2x2 puzzle'\r\n solution_move += self.solve_2x2()\r\n if self._grid[0][0] == 0 and \\\r\n self._grid[0][1] == 1:\r\n # print 'Congrads Puxxle is SOLVED!!!!!'\r\n break\r\n\r\n\r\n\r\n\r\n if counter > 100:\r\n # print 'COUNTER BREAK'\r\n break\r\n # print solution_move, len(solution_move)\r\n return solution_move\r\n\r\n\r\n\r\n\r\n\r\n\r\n # for row in solution_greed._grid[::-1]:\r\n # print solution_greed._grid\r\n # print 'Row =',row\r\n \r\n # if solution_greed._grid.index(row) > 1:\r\n # print \"Case when we solwing Interior and Tile0 part\"\r\n \r\n\r\n # for col in solution_greed._grid[solution_greed._grid.index(row)][::-1]:\r\n # print 'Coloumn value=', col\r\n #print row[0]\r\n # if col !=row[0]:\r\n # print 'Case when we use just Interior tile solution'\r\n # print solution_greed._grid.index(row)\r\n # print row.index(col)\r\n \r\n # solution += solution_greed.solve_interior_tile(solution_greed._grid.index(row) , row.index(col))\r\n # print 'Solution =', solution\r\n # print self \r\n # print solution_greed._grid\r\n # elif col ==row[0]:\r\n # print 'Case when we use just Col0 solution'\r\n\r\n # else:\r\n # print 'Case when we solwing first two rows'\r\n\r\n #return \"\"\r","def create_glider_gun(i, j, grid):\n\n ggun = np.zeros(11*38).reshape(11, 38)\n\n ggun[5][1] = ggun[5][2] = 1\n ggun[6][1] = ggun[6][2] = 1\n\n ggun[3][13] = ggun[3][14] = 1\n ggun[4][12] = ggun[4][16] = 1\n ggun[5][11] = ggun[5][17] = 1\n ggun[6][11] = ggun[6][15] = ggun[6][17] = ggun[6][18] = 1\n ggun[7][11] = ggun[7][17] = 1\n ggun[8][12] = ggun[8][16] = 1\n ggun[9][13] = ggun[9][14] = 1\n\n ggun[1][25] = 1\n ggun[2][23] = ggun[2][25] = 1\n ggun[3][21] = ggun[3][22] = 1\n ggun[4][21] = ggun[4][22] = 1\n ggun[5][21] = ggun[5][22] = 1\n ggun[6][23] = ggun[6][25] = 1\n ggun[7][25] = 1\n\n ggun[3][35] = ggun[3][36] = 1\n ggun[4][35] = ggun[4][36] = 1\n\n grid[i:i+11, j:j+38] = ggun","def _generate_cells(self) -> None:\n for i in range(15):\n for j in range(15):\n c = Cell(x=i, y=j)\n c.answer = self.puzzle.solution[j*self.width+i]\n self.cells[(j, i)] = c # row, col","def view_marginals_cristobal(rep=0, epoch=300, zoom=False):\n samples_path = paths.eICU_synthetic_dir + 'samples_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\n samples = np.load(samples_path)\n labels_path = paths.eICU_synthetic_dir + 'labels_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\n labels = np.load(labels_path)\n real_path = paths.eICU_task_data\n raw_real_train = np.load(real_path).item()['X_train'].reshape(-1, 16, 4)\n real_test = np.load(real_path).item()['X_test'].reshape(-1, 16, 4)\n real_vali = np.load(real_path).item()['X_vali'].reshape(-1, 16, 4)\n # discard vali, test\n real, scaled_vali, scaled_test = scale_data(raw_real_train, real_vali, real_test)\n real = raw_real_train\n view_marginals_raw(raw_real_train, label='raw_real_train')\n view_marginals_raw(real, label='real_train')\n view_marginals_raw(samples, label='synthetic')\n\n variables = ['sao2', 'heartrate', 'respiration', 'systemicmean']\n\n # get the scaling factors\n scaling_factors = {'a': np.zeros(shape=(16, 4)), 'b': np.zeros(shape=(16, 4))}\n ranges = []\n for var in range(4):\n var_min = 100\n var_max = 0\n for timestep in range(16):\n min_val = np.min([np.min(raw_real_train[:, timestep, var]), np.min(real_vali[:, timestep, var])])\n max_val = np.max([np.max(raw_real_train[:, timestep, var]), np.max(real_vali[:, timestep, var])])\n if min_val < var_min:\n var_min = min_val\n if max_val > var_max:\n var_max = max_val\n a = (max_val - min_val)/2\n b = (max_val + min_val)/2\n scaling_factors['a'][timestep, var] = a\n scaling_factors['b'][timestep, var] = b\n ranges.append([var_min, var_max])\n\n # now, scale the synthetic data manually\n samples_scaled = np.zeros_like(samples)\n for var in range(4):\n for timestep in range(16):\n samples_scaled[:, timestep, var] = samples[:, timestep, var]*scaling_factors['a'][timestep, var] + scaling_factors['b'][timestep, var]\n\n if zoom:\n # use modes, skip for now\n modes = False\n if modes:\n # get rough region of interest, then zoom in on it afterwards!\n num_gradations = 5\n gradations = np.linspace(-1, 1, num_gradations)\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\n lower = 0\n real_grid = np.zeros(shape=(16, num_gradations, 4))\n for (i, cutoff) in enumerate(gradations):\n # take the mean over samples\n real_frac = ((real > lower) & (real <= cutoff)).mean(axis=0)\n lower = cutoff\n real_grid[:, i, :] = real_frac\n time_averaged_grid = np.mean(real_grid, axis=0)\n # get the most populated part of the grid for each variable\n grid_modes = np.argmax(time_averaged_grid, axis=0)\n lower = 0\n ranges = []\n for i in grid_modes:\n lower = gradations[i-1]\n upper = gradations[i]\n ranges.append([lower, upper])\n else:\n # hand-crafted ranges\n ranges = [[88, 100], [30, 130], [7, 60], [35, 135]]\n\n num_gradations = 25\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\n grid = np.zeros(shape=(16, num_gradations, 4))\n real_grid = np.zeros(shape=(16, num_gradations, 4))\n assert samples.shape[-1] == 4\n for var in range(4):\n # allow for a different range per variable (if zoom)\n low = ranges[var][0]\n high = ranges[var][1]\n gradations = np.linspace(low, high, num_gradations)\n for (i, cutoff) in enumerate(gradations):\n # take the mean over samples\n frac = ((samples_scaled[:, :, var] > low) & (samples_scaled[:, :, var] <= cutoff)).mean(axis=0)\n real_frac = ((real[:, :, var] > low) & (real[:, :, var] <= cutoff)).mean(axis=0)\n low = cutoff\n grid[:, i, var] = frac\n real_grid[:, i, var] = real_frac\n\n # now plot this as an image\n fig, axarr = plt.subplots(nrows=4, ncols=2, sharey='row', sharex=True)\n axarr[0, 0].imshow(grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[1, 0].imshow(grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[2, 0].imshow(grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[3, 0].imshow(grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[0, 1].imshow(real_grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[1, 1].imshow(real_grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[2, 1].imshow(real_grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\n axarr[3, 1].imshow(real_grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\n\n axarr[0, 0].set_title(\"synthetic\")\n axarr[0, 1].set_title(\"real\")\n for var in range(4):\n low, high = ranges[var]\n labels = np.linspace(low, high, num_gradations)[1::4]\n labels = np.round(labels, 0)\n axarr[var, 0].set_yticklabels(labels)\n axarr[var, 0].set_yticks(np.arange(num_gradations)[1::4])\n axarr[var, 0].set_ylabel(variables[var])\n for ax in axarr[var, :]:\n ax.yaxis.set_ticks_position('none')\n ax.xaxis.set_ticks_position('none')\n ax.set_adjustable('box-forced')\n ax.spines['top'].set_visible(False)\n ax.spines['bottom'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\n\n axarr[-1, 0].set_xticks(np.arange(16)[::2])\n axarr[-1, 1].set_xticks(np.arange(16)[::2])\n\n if zoom:\n plt.suptitle('(zoomed)')\n\n plt.tight_layout(pad=0.0, w_pad=-5.0, h_pad=0.1)\n plt.savefig(\"./experiments/eval/eICU_cristobal_marginals_r\" + str(rep) + \"_epoch\" + str(epoch) + \".png\")\n\n # now make the histograms\n fig, axarr = plt.subplots(nrows=1, ncols=4)\n axarr[0].set_ylabel(\"density\")\n axarr[0].hist(real[:, :, 0].flatten(), normed=True, color='black', alpha=0.8, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='real')\n axarr[1].hist(real[:, :, 1].flatten(), normed=True, color='black', alpha=0.8, range=ranges[1], bins=50)\n axarr[2].hist(real[:, :, 2].flatten(), normed=True, color='black', alpha=0.8, range=ranges[2], bins=50)\n axarr[3].hist(real[:, :, 3].flatten(), normed=True, color='black', alpha=0.8, range=ranges[3], bins=50)\n axarr[0].hist(samples_scaled[:, :, 0].flatten(), normed=True, alpha=0.6, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='synthetic')\n axarr[0].legend()\n axarr[1].hist(samples_scaled[:, :, 1].flatten(), normed=True, alpha=0.6, range=ranges[1], bins=50)\n axarr[2].hist(samples_scaled[:, :, 2].flatten(), normed=True, alpha=0.6, range=ranges[2], bins=50)\n axarr[3].hist(samples_scaled[:, :, 3].flatten(), normed=True, alpha=0.6, range=ranges[3], bins=50)\n for (var, ax) in enumerate(axarr):\n ax.set_xlabel(variables[var])\n ax.yaxis.set_ticks_position('none')\n ax.xaxis.set_ticks_position('none')\n ax.spines['top'].set_visible(False)\n ax.spines['bottom'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\n\n plt.gcf().subplots_adjust(bottom=0.2)\n fig.set_size_inches(10, 3)\n plt.savefig(\"./experiments/eval/eICU_cristobal_hist_r\" + str(rep) + \"_epoch\" + str(epoch) + \".png\")\n\n return True","def abstract(res):\n o = r'\\begin{center}'\n #o += r'\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\n #o += r'\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\n o += r'\\begin{tikzpicture}' + '\\n'\n o += r'\\draw[blue!40!white] (0,0) rectangle (6,4); \\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\n'\n for i in range(res[7]):\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\n o += r'\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\n'\n o += r'\\end{tikzpicture}\\end{center}' + '\\n'\n\n o += r'\\begin{tabular}{|l|l|}' + '\\n' + r'\\hline' + '\\n'\n o += r'Election name& \\texttt{\"%s\"}\\\\'%res[1]\n o += r'Box number& \\texttt{%s}\\\\'%res[2]\n o += r'State& \\texttt{%s}\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\n o += r'Registration end& \\textit{%s}\\\\'%res[3]\n o += r'Vote closing& \\textit{%s}\\\\'%res[4]\n o += r'Casted/registered& $%s/%s$\\\\'%(res[7],res[6]) +'\\n'\n o += r'\\hline\\end{tabular}' + '\\n'\n o += r'\\quad' + '\\n'\n o += r'\\begin{tabular}{|l|l|}\\hline'\n l = res[8].items()\n l.sort(key = operator.itemgetter(1),reverse=True)\n n = 0\n for x in l:\n o += r'%s & %s\\\\'%(r'\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\texttt{%s}'%x[0],x[1]) \n if n == 0:\n o += r'\\hline' + '\\n'\n n += 1\n o += r'\\hline\\end{tabular}' + '\\n'\n\n\n #o += r'\\item The designer\\textquoteright s digital signature of this document (the source file \\texttt{oeu.py}) is: \\tiny $$\\verb!%s!$$ \\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\n'\n\n return r'\\begin{abstract}' + abstract.__doc__ + r'\\end{abstract}' + o","def getInitialObstacles():\n # hardcode number of blocks\n # will account for movemnet\n from random import choice\n from globals import TILEWIDTH, TILEHEIGHT, WINHEIGHT, TILEFLOORHEIGHT, LEVEL, HALFWINWIDTH\n\n no_of_blocks = 50\n for b in range(no_of_blocks // 2):\n # get image\n # image = globals.IMAGESDICT['rock']\n for y in range(1,5):\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\n # make rect\n spaceRect = pygame.Rect((b * TILEWIDTH, y * TILEFLOORHEIGHT, TILEWIDTH, TILEFLOORHEIGHT))\n landscape = Landscape(image, spaceRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n image = globals.IMAGESDICT['corner']\n negativeRect = pygame.Rect([-150, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEHEIGHT])\n landscape = Landscape(image, negativeRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n image = globals.IMAGESDICT['corner']\n positiveRect = pygame.Rect([LEVEL[0] - TILEWIDTH, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\n landscape = Landscape(image, positiveRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n bottomRect = pygame.Rect([HALFWINWIDTH, LEVEL[1] - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\n landscape = Landscape(image, bottomRect)\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n for x in range(0, LEVEL[0], 50):\n for y in range(10):\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\n spaceRect = pygame.Rect((x, LEVEL[1] - (y * TILEHEIGHT), TILEWIDTH, TILEFLOORHEIGHT))\n landscape = Landscape(image, spaceRect)\n if choice([0,1,0]):\n allLandscapeList.add(landscape)\n allSpriteList.add(landscape)\n\n\n return","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def draw_occupied_cells(self):\n reds = [cell for cell in self.game.get_cells() if cell.player == 1]\n blacks = [cell for cell in self.game.get_cells() if cell.player == 2]\n nx.draw_networkx_nodes(self.G, pos=self.positions, nodelist=reds,\n edgecolors='black', node_color='red', linewidths=2)\n nx.draw_networkx_nodes(self.G, pos=self.positions, nodelist=blacks,\n edgecolors='black', node_color='black', linewidths=2)","def gentiles(self):\n \n self.begin()\n \n col_list = list()\n \n start_x, start_y, = self.x(), self.y()\n \n # Assumes square Grid, equal # rows and columns\n self.dim = round(self.w() / self.c)\n \n for y in range(self.r):\n col_list = list()\n for x in range(self.c):\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\n col_list.append(Tile(x_pos, y_pos, self.dim, self.dim, self.gamewin, x, y))\n\n self.tiles.append(col_list)\n\n self.end()","def create_gridworld(self):\n self.num_actions = 4\n self.num_states = self.num_cols * self.num_rows + 1\n self.start_state_seq = row_col_to_seq(self.start_state, self.num_cols)\n self.goal_states_seq = row_col_to_seq(self.goal_states, self.num_cols)\n\n # rewards structure\n self.R = self.r_step * np.ones((self.num_states, 1))\n self.R[self.num_states-1] = 0\n self.R[self.goal_states_seq] = self.r_goal\n for i in range(self.num_bad_states):\n if self.r_bad is None:\n raise Exception(\"Bad state specified but no reward is given\")\n bad_state = row_col_to_seq(self.bad_states[i,:].reshape(1,-1), self.num_cols)\n self.R[bad_state, :] = self.r_bad\n for i in range(self.num_restart_states):\n if self.r_restart is None:\n raise Exception(\"Restart state specified but no reward is given\")\n restart_state = row_col_to_seq(self.restart_states[i,:].reshape(1,-1), self.num_cols)\n self.R[restart_state, :] = self.r_restart\n\n # probability model\n if self.p_good_trans == None:\n raise Exception(\"Must assign probability and bias terms via the add_transition_probability method.\")\n\n self.P = np.zeros((self.num_states,self.num_states,self.num_actions))\n for action in range(self.num_actions):\n for state in range(self.num_states):\n\n # check if state is the fictional end state - self transition\n if state == self.num_states-1:\n self.P[state, state, action] = 1\n continue\n\n # check if the state is the goal state or an obstructed state - transition to end\n row_col = seq_to_col_row(state, self.num_cols)\n if self.obs_states is not None:\n end_states = np.vstack((self.obs_states, self.goal_states))\n else:\n end_states = self.goal_states\n\n if any(np.sum(np.abs(end_states-row_col), 1) == 0):\n self.P[state, self.num_states-1, action] = 1\n\n # else consider stochastic effects of action\n else:\n for dir in range(-1,2,1):\n direction = self._get_direction(action, dir)\n next_state = self._get_state(state, direction)\n if dir == 0:\n prob = self.p_good_trans\n elif dir == -1:\n prob = (1 - self.p_good_trans)*(self.bias)\n elif dir == 1:\n prob = (1 - self.p_good_trans)*(1-self.bias)\n\n self.P[state, next_state, action] += prob\n\n # make restart states transition back to the start state with\n # probability 1\n if self.restart_states is not None:\n if any(np.sum(np.abs(self.restart_states-row_col),1)==0):\n next_state = row_col_to_seq(self.start_state, self.num_cols)\n self.P[state,:,:] = 0\n self.P[state,next_state,:] = 1\n return self","def buildpuzzle(self):\r\n self.puzzle = copy.deepcopy(self.rows)\r\n if self.difficulty == 1:\r\n self.removedigits(1)\r\n if self.difficulty == 2:\r\n self.removedigits(2)\r\n if self.difficulty == 3:\r\n self.removedigits(3)","def main():\n\n cages = [\n \"AABCCD\",\n \"EFBCGD\",\n \"EFFHGI\",\n \"EJJHGI\",\n \"EKJHGL\",\n \"KKJLLL\",\n ]\n\n peaks = [\n (0, 1),\n (0, 2),\n (1, 3),\n (1, 4),\n (1, 5),\n (2, 1),\n (2, 3),\n (3, 0),\n (3, 5),\n (4, 2),\n (5, 1),\n (5, 4),\n ]\n\n extract = {\n \"A\": (5, 2),\n \"B\": (0, 3),\n \"C\": (3, 2),\n \"D\": (1, 4),\n \"E\": (0, 1),\n \"F\": (1, 5),\n \"G\": (4, 2),\n \"H\": (3, 5),\n \"I\": (1, 0),\n \"J\": (5, 5),\n \"K\": (3, 4),\n \"L\": (5, 1),\n \"M\": (0, 5),\n \"N\": (4, 4),\n }\n\n def answer(sg):\n solved_grid = sg.solved_grid()\n s = \"\"\n s += chr(64 + solved_grid[extract[\"A\"]] + solved_grid[extract[\"B\"]])\n s += chr(64 + solved_grid[extract[\"C\"]] + solved_grid[extract[\"D\"]])\n s += chr(64 + solved_grid[extract[\"E\"]] + solved_grid[extract[\"F\"]] + solved_grid[extract[\"G\"]])\n s += chr(64 + solved_grid[extract[\"H\"]] + solved_grid[extract[\"I\"]])\n s += chr(64 + solved_grid[extract[\"J\"]] + solved_grid[extract[\"K\"]] + solved_grid[extract[\"L\"]])\n s += chr(64 + solved_grid[extract[\"M\"]] + solved_grid[extract[\"N\"]])\n return s\n\n sym = grilops.make_number_range_symbol_set(1, 6)\n lattice = grilops.get_square_lattice(6)\n sg = grilops.SymbolGrid(lattice, sym)\n\n add_sudoku_constraints(sg)\n\n # Constrain regions to match the cages and be rooted at the peaks.\n cage_label_to_region_id = {}\n for py, px in peaks:\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\n\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\n for y, x in lattice.points:\n sg.solver.add(\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\n\n # Within each region, a parent cell must have a greater value than a child\n # cell, so that the values increase as you approach the root cell (the peak).\n for p in lattice.points:\n for n in sg.edge_sharing_neighbors(p):\n sg.solver.add(Implies(\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\n n.symbol > sg.grid[p]\n ))\n\n if sg.solve():\n sg.print()\n print()\n print(answer(sg))\n while not sg.is_unique():\n print()\n print(\"Alternate solution\")\n sg.print()\n print()\n print(answer(sg))\n else:\n print(\"No solution\")","def swipeBase (self) :\n grid = self.grid\n\n #we start by putting every tile up\n for columnNbr in range(4) :\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\n\n for lineNbr in range(4) :\n counter = 0\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\n counter += 1\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\n for remainingLine in range (lineNbr, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n #now we do the additions\n for lineNbr in range(3) :\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\n grid[lineNbr, columnNbr] *= 2\n for remainingLine in range (lineNbr+1, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n return (grid)","def go_or_grow(lgca):\n relevant = lgca.cell_density[lgca.nonborder] > 0\n coords = [a[relevant] for a in lgca.nonborder]\n n_m = lgca.nodes[..., :lgca.velocitychannels].sum(-1)\n n_r = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\n M1 = np.minimum(n_m, lgca.restchannels - n_r)\n M2 = np.minimum(n_r, lgca.velocitychannels - n_m)\n for coord in zip(*coords):\n # node = lgca.nodes[coord]\n n = lgca.cell_density[coord]\n\n n_mxy = n_m[coord]\n n_rxy = n_r[coord]\n\n rho = n / lgca.K\n j_1 = npr.binomial(M1[coord], tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\n j_2 = npr.binomial(M2[coord], 1 - tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\n n_mxy += j_2 - j_1\n n_rxy += j_1 - j_2\n n_mxy -= npr.binomial(n_mxy * np.heaviside(n_mxy, 0), lgca.r_d)\n n_rxy -= npr.binomial(n_rxy * np.heaviside(n_rxy, 0), lgca.r_d)\n M = min([n_rxy, lgca.restchannels - n_rxy])\n n_rxy += npr.binomial(M * np.heaviside(M, 0), lgca.r_b)\n\n v_channels = [1] * n_mxy + [0] * (lgca.velocitychannels - n_mxy)\n v_channels = npr.permutation(v_channels)\n r_channels = np.zeros(lgca.restchannels)\n r_channels[:n_rxy] = 1\n node = np.hstack((v_channels, r_channels))\n lgca.nodes[coord] = node","def initialize_grid(self):\r\n for i in range(self.height):\r\n for j in range(self.width):\r\n self.grid[i][j] = 0\r\n \r\n # fill up unvisited cells\r\n for r in range(self.height):\r\n for c in range(self.width):\r\n if r % 2 == 0 and c % 2 == 0:\r\n self.unvisited.append((r,c))\r\n\r\n self.visited = []\r\n self.path = dict()\r\n self.generated = False","def test_multigrid_calculates_neighbours_correctly():\n\n # create a grid which will result in 9 cells\n h = 64\n img_dim = (3 * h + 1, 3 * h + 1)\n amg = mg.MultiGrid(img_dim, h, WS=127)\n\n # check that each cell has the expected neighbours\n print(amg.n_cells)\n\n # expected neieghbours left to right, bottom to top\n cells = [{\"north\": amg.cells[3], \"east\": amg.cells[1], \"south\": None, \"west\": None}, # bl\n {\"north\": amg.cells[4], \"east\": amg.cells[2],\n \"south\": None, \"west\": amg.cells[0]}, # bm\n {\"north\": amg.cells[5], \"east\": None,\n \"south\": None, \"west\": amg.cells[1]}, # br\n {\"north\": amg.cells[6], \"east\": amg.cells[4],\n \"south\": amg.cells[0], \"west\": None}, # ml\n {\"north\": amg.cells[7], \"east\": amg.cells[5],\n \"south\": amg.cells[1], \"west\": amg.cells[3]}, # mm\n {\"north\": amg.cells[8], \"east\": None,\n \"south\": amg.cells[2], \"west\": amg.cells[4]}, # mr\n # tl\n {\"north\": None, \"east\": amg.cells[7],\n \"south\": amg.cells[3], \"west\": None},\n # tm\n {\"north\": None,\n \"east\": amg.cells[8], \"south\": amg.cells[4], \"west\": amg.cells[6]},\n {\"north\": None, \"east\": None,\n \"south\": amg.cells[5], \"west\": amg.cells[7]}, # tr\n ]\n\n for ii, (gc, cell) in enumerate(zip(amg.cells, cells)):\n print(ii)\n assert gc.north == cell['north']\n assert gc.east == cell['east']\n assert gc.south == cell['south']\n assert gc.west == cell['west']","def apply(grid, r, c, action):\n if action == 'suck':\n grid[r, c] = EMPTY\n else:\n print(action)\n new_r = r + OFFSETS[action][0]\n new_c = c + OFFSETS[action][1]\n if 0 <= new_r < WORLD_WIDTH and 0 <= new_c < WORLD_WIDTH and grid[new_r, new_c] != OBSTACLE:\n return new_r, new_c\n return r, c","def six_hundred_cell(self):\n verts = []\n q12 = QQ(1)/2\n base = [q12,q12,q12,q12]\n for i in range(2):\n for j in range(2):\n for k in range(2):\n for l in range(2):\n verts.append([x for x in base])\n base[3] = base[3]*(-1)\n base[2] = base[2]*(-1)\n base[1] = base[1]*(-1)\n base[0] = base[0]*(-1)\n for x in permutations([0,0,0,1]):\n verts.append(x)\n for x in permutations([0,0,0,-1]):\n verts.append(x)\n g = QQ(1618033)/1000000 # Golden ratio approximation\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n return Polyhedron(vertices = verts)","def next_round(self, old_round):\n new_round = np.copy(old_round) #copy of the old grid\n # for each square\n for i in range(Lx):\n for j in range(Ly):\n if old_round[i][j] == 0 : #if the cell is dead, it will live if it has 3 living neighbors.\n if self.sum_living_cell(i, j, old_round) == 3:\n new_round[i][j] = 1\n else:\n new_round[i][j] = 0\n if old_round[i][j] == 1 : #if the cell is alive, it won't dead if it has 2 or 3 living neighors.\n square_score = self.sum_living_cell(i, j, old_round)\n if square_score != 2 and square_score != 3 :\n new_round[i][j] = 0\n else:\n new_round[i][j] = 1\n return new_round","def multi_grid_iou(orig_bed_pcd, cfgs, voxel_size=0.05):\n ious = np.zeros(len(cfgs))\n for i in range(cfgs.shape[0]):\n cfg = cfgs[i]\n bed_pcd = orig_bed_pcd - cfg[:2]\n theta = np.radians(cfg[2])\n rotmat = np.array([\n [np.cos(theta), np.sin(theta)],\n [-np.sin(theta), np.cos(theta)],\n ])\n bed_pcd = bed_pcd@rotmat\n\n bed_pcd = np.round_(bed_pcd/voxel_size, 0, np.zeros_like(bed_pcd))\n bed_pcd_summed = np.unique(1024*bed_pcd[:,0]+bed_pcd[:,1])\n bed_pcd_0 = np.round_(bed_pcd_summed/1024, 0, np.zeros_like(bed_pcd_summed))\n bed_pcd_1 = bed_pcd_summed-bed_pcd_0*1024\n x_ok = (bed_pcd_1*2 <= int(cfg[4]/voxel_size)) & (bed_pcd_1*2 >= int(-cfg[4]/voxel_size))\n y_ok = (bed_pcd_0*2 <= int(cfg[3]/voxel_size)) & (bed_pcd_0*2 >= int(-cfg[3]/voxel_size))\n n_ok = np.sum(x_ok & y_ok)\n n_elem = len(bed_pcd_summed)\n n_grid = (cfg[3]+voxel_size)*(cfg[4]+voxel_size)/(voxel_size*voxel_size)\n ious[i] = n_ok/(n_grid+n_elem-n_ok)\n return ious","def get_others(map_, r, c):\n nums = 0\n # your code here\n if r == 0 and c == 0: #top left corder\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n elif r == 0 and c == len(map_[0])-1: #top right corner\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n elif r == len(map_)-1 and c == 0: #bottom left corder\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif r == len(map_)-1 and c == len(map_[0])-1: #bottom right corner\n nums += 2\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif r == 0: # top edge, excluding corner\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n if len(map_) > r and map_[r+1][c] == 0:\n nums += 1\n elif r == len(map_)-1: # bottom edge, excluding corner\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif c == 0: # left edge, excluding corner\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if len(map_[0]) > c and map_[r][c+1] == 0:\n nums += 1\n elif c == len(map_[0])-1: # right edge. excluding corner\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n else: # the rest, excluding edge and corner\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n return nums","def create_matrices(maze, reward, penalty_s, penalty_l, prob):\n \n r, c = np.shape(maze)\n states = r*c\n p = prob\n q = (1 - prob)*0.5\n \n # Create reward matrix\n path = maze*penalty_s\n walls = (1 - maze)*penalty_l\n combined = path + walls\n \n combined[-1, -1] = reward\n \n R = np.reshape(combined, states)\n \n # Create transition matrix\n T_up = np.zeros((states, states))\n T_left = np.zeros((states, states))\n T_right = np.zeros((states, states))\n T_down = np.zeros((states, states))\n \n wall_ind = np.where(R == penalty_l)[0]\n\n for i in range(states):\n # Up\n if (i - c) < 0 or (i - c) in wall_ind :\n T_up[i, i] += p\n else:\n T_up[i, i - c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_up[i, i] += q\n else:\n T_up[i, i+1] += q\n \n # Down\n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_down[i, i] += p\n else:\n T_down[i, i + c] += p\n \n if i%c == 0 or (i - 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i-1] += q\n \n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_down[i, i] += q\n else:\n T_down[i, i+1] += q\n \n # Left\n if i%c == 0 or (i - 1) in wall_ind:\n T_left[i, i] += p\n else:\n T_left[i, i-1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_left[i, i] += q\n else:\n T_left[i, i + c] += q\n \n # Right\n if i%c == (c - 1) or (i + 1) in wall_ind:\n T_right[i, i] += p\n else:\n T_right[i, i+1] += p\n \n if (i - c) < 0 or (i - c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i - c] += q\n \n if (i + c) > (states - 1) or (i + c) in wall_ind:\n T_right[i, i] += q\n else:\n T_right[i, i + c] += q\n \n T = [T_up, T_left, T_right, T_down] \n \n return T, R","def makeGrid(self, width, height, rewardLocs, exit, nPick=1, nAux=1, walls=[]):\n # Make mapping from coordinate (x, y, (takenreward1, takenreward2, ...))\n # to state number, and vice-versa.\n rTaken = iter([(),])\n for nPicked in range(1, nPick+1):\n rTaken = itertools.chain(rTaken, \n myCombinations(rewardLocs, r=nPicked)\n )\n # Iterators are hard to reset, so we list it.\n rTaken = list(rTaken)\n\n # Mappings from state to coordinates, vice-versa\n coordToState = {}\n stateToCoord = {}\n stateIdx = 0\n for x in range(width):\n for y in range(height):\n for stuff in rTaken:\n for holding in self.holdingPossibilities:\n coordToState[(x, y, stuff, holding)] = stateIdx\n stateToCoord[stateIdx] = (x, y, stuff, holding)\n stateIdx += 1\n self.deadEndState = stateIdx\n\n # Actually make the transition function\n def trans(f, p): \n aux = p\n (x, y, stuff, holding) = stateToCoord[f]\n actionMap = {}\n default = {(f, aux): 1}\n # Make the transition dictionary if the dead-end state (state width*height)\n if f == self.F-1:\n for action in range(5):\n actionMap[action] = default\n return actionMap\n\n # Otherwise, determine directions of motion, etc. \n for i in range(4):\n actionMap[i] = default\n if x != 0 and ((x-1, y) not in walls):\n actionMap[0] = {(coordToState[(x-1,y,stuff, holding)], aux): 1}\n if x < width-1 and ((x+1, y) not in walls):\n actionMap[1] = {(coordToState[(x+1,y,stuff, holding)], aux): 1}\n if y != 0 and ((x, y-1) not in walls):\n actionMap[2] = {(coordToState[(x,y-1,stuff, holding)], aux): 1}\n if y < height-1 and ((x, y+1) not in walls):\n actionMap[3] = {(coordToState[(x,y+1,stuff, holding)], aux): 1}\n # What happens when the agent uses action 4?\n if (x, y) == exit:\n # Some cases, depending on self.oneAtATime\n if not self.oneAtATime:\n # The agent is leaving.\n actionMap[4] = {(self.deadEndState, aux): 1}\n else:\n # The agent is dropping off a reward. holeFiller will\n # take care of the reward value.\n if len(stuff) >= nPick:\n # The agent is not allowed to pick up more stuff\n actionMap[4] = {(self.deadEndState, aux): 1}\n else:\n # The agent drops off the object.\n actionMap[4] = {(coordToState[(x,y,stuff, -1)], aux): 1}\n elif (x, y) not in rewardLocs:\n # No reward to pick up. Do nothing.\n actionMap[4] = default\n elif (x, y) in stuff:\n # This reward has already been used. Do nothing.\n actionMap[4] = default\n elif len(stuff) >= nPick or (holding != -1 and holding < len(stuff)\n and self.oneAtATime):\n # The agent has its hands full.\n actionMap[4] = default\n else:\n # The agent is allowed to pick up an object.\n newStuff = tuple(sorted(list(stuff) + [(x, y)]))\n if self.oneAtATime:\n newHoldingIdx = newStuff.index((x, y))\n else:\n newHoldingIdx = -1\n actionMap[4] = {(coordToState[(x, y, newStuff, newHoldingIdx)], aux): 1}\n return actionMap\n\n # Man, I'm outputting a lot of stuff.\n # coordToState[(x, y, rewardsLeft, holding)] -> index of this state\n # stateToCoord[index] -> (x, y, rewardsLeft, holding)\n # rTaken is a list of all possible combinations of leftover rewards.\n return (trans, coordToState, stateToCoord, rTaken)","def climb_tree():\n global UP_TREE\n westdesc = \"\"\n eastdesc = \"\"\n northdesc = \"\"\n southdesc = \"\"\n UP_TREE = True\n westinvalid = False\n eastinvalid = False\n northinvalid = False\n southinvalid = False\n\n\n printmessage(\"You climb the large tree to get a look at your surroundings.\", 5, MAGENTA, 2)\n\n if ZERO_BASE_PLYR_POS in range(0, 10):\n northinvalid = True\n if ZERO_BASE_PLYR_POS in range(90, 100):\n southinvalid = True\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\n eastinvalid = True\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\n westinvalid = True\n \n if not westinvalid: \n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\n if HAS_COMPASS: \n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \"Y\"\n if westpos == 10: # Water\n westdesc = TREE_VIEWS[2]\n else:\n westdesc = TREE_VIEWS[1]\n\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\n if westpos == 1:\n westdesc = TREE_VIEWS[3]\n elif westpos == 2:\n westdesc = TREE_VIEWS[4]\n else:\n westdesc = TREE_VIEWS[5]\n\n if not eastinvalid:\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \"Y\"\n if eastpos == 10: # Water\n eastdesc = TREE_VIEWS[2]\n else:\n eastdesc = TREE_VIEWS[1]\n\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\n if eastpos == 1:\n eastdesc = TREE_VIEWS[3]\n elif eastpos == 2:\n eastdesc = TREE_VIEWS[4]\n else:\n eastdesc = TREE_VIEWS[6]\n\n\n if not northinvalid:\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \"Y\"\n if northpos == 10: # Water\n northdesc = TREE_VIEWS[2]\n else:\n northdesc = TREE_VIEWS[1]\n\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\n if northpos == 1: # bear\n northdesc = TREE_VIEWS[3]\n elif northpos == 2: # grizzly\n northdesc = TREE_VIEWS[4]\n else:\n northdesc = TREE_VIEWS[7]\n\n\n if not southinvalid:\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\n if HAS_COMPASS:\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \"Y\"\n if southpos == 10: # Water\n southdesc = TREE_VIEWS[2]\n else:\n southdesc = TREE_VIEWS[1]\n\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\n if southpos == 1: # bear\n southdesc = TREE_VIEWS[3]\n elif southpos == 2: # grizzly\n southdesc = TREE_VIEWS[4]\n else:\n southdesc = TREE_VIEWS[8]\n\n clear_messages(0)\n printmessage(\"West: \" + westdesc, 2, GREEN, 0)\n printmessage(\"East: \" + eastdesc, 3, YELLOW, 0)\n printmessage(\"North: \" + northdesc, 4, CYAN, 0)\n printmessage(\"South: \" + southdesc, 5, MAGENTA, 0)\n #show_movement(True, 10)\n update_player_on_map()\n pause_for_keypress()\n clear_messages(0)","def outcome(self):\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\n return self.grid[0][1]\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\n return self.grid[0][2]\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\n return self.grid[1][0]\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\n return self.grid[2][0]\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\n return self.grid[0][0]\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\n return self.grid[0][2]\n return 0","def aging_landscape(self):\n for herb in self.herb_pop:\n herb.aging_animal()\n herb.fitness_animal()\n\n for carn in self.carn_pop:\n carn.aging_animal()\n carn.fitness_animal()","def make_grid_uh_river(t_uh, t_cell, uh, to_y, to_x, pour_point, y_inds,\n x_inds, count_ds):\n log.debug(\"Making uh_river grid.... It takes a while...\")\n y_ind = pour_point.basiny\n x_ind = pour_point.basinx\n\n uh_river = np.zeros((t_uh, uh.shape[1], uh.shape[2]))\n for (y, x, d) in zip(y_inds, x_inds, count_ds):\n if d > 0:\n yy = to_y[y, x]\n xx = to_x[y, x]\n irf_temp = np.zeros(t_uh+t_cell)\n active_timesteps = np.nonzero(uh_river[:, yy, xx] > PRECISION)[0]\n for t in active_timesteps:\n for l in xrange(t_cell):\n irf_temp[t+l] = irf_temp[t + l] + uh[l, y, x] * uh_river[t, yy, xx]\n tot = np.sum(irf_temp[:t_uh])\n if tot > 0:\n uh_river[:, y, x] = irf_temp[:t_uh] / tot\n elif d == 0:\n uh_river[:t_cell, y_ind, x_ind] = uh[:, y_ind, x_ind]\n\n return uh_river","def obstacles_form(self,image):\r\n major_axis=60\r\n minor_axis=30\r\n c_y=246\r\n c_x=145\r\n c_y1=90\r\n c_x1=70\r\n radius=35\r\n for i in range(len(image)):\r\n for j in range(len(image[0])):\r\n\r\n #self.ellipse(image,major_axis,minor_axis,i,j,c_x,c_y)\r\n self.circle(image,100,i,j,200,200)\r\n self.circle(image,100,i,j,800,200)\r\n #self.slanted_rect(image,i,j)\r\n self.boundary(image,i,j)\r\n self.boundary1(image,i,j)\r\n self.boundary2(image,i,j)\r\n self.c_shape(image,i,j)\r\n #exploration.c_shape(image,i,j)\r","def findAstromCorrs(self):\n self.logfile.write(\"Entered findAstromCorrs - will run: \"+\\\n \"makeGSCcat(), makeObjcats(), doMatching().\")\n\n if self.makeGSCcat() != 0:\n return -1\n if self.makeObjcats()!= 0:\n return -1\n if self.doMatching() != 0:\n # here we want to remake the GSCcat using a \"chopSpur\" flag,\n # if the cat has a goodly number of objects\n if(self.Ncull >= 10):\n print \"Retrying matchup with only GSC objs detected in 2 bands...\"\n self.logfile.write(\"Retrying matchup with only GSC objs detected in 2 bands...\")\n if self.makeGSCcat(chopSpur=1) != 0:\n return -1\n if self.makeObjcats()!= 0:\n return -1\n if self.doMatching() != 0:\n return -1\n\n return 0","def ggpl_house():\n\n\t# .lines ogni riga ha due coppie di x/y che costituiscono un segmento\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/muri_esterni.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\texternalWalls = MKPOL([verts,cells,None])\n\tfloor = SOLIDIFY(externalWalls)\n\tfloor = S([1,2,3])([.04,.04,.04])(floor)\n\texternalWalls = S([1,2,3])([.04,.04,.04])(externalWalls)\n\texternalWalls = OFFSET([.2,.2,4])(externalWalls)\n\theightWalls = SIZE([3])(externalWalls)[0]\n\tthicknessWalls = SIZE([2])(externalWalls)[0]\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/muri_interni.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\tinternalWalls = MKPOL([verts,cells,None])\n\tinternalWalls = S([1,2,3])([.04,.04,.04])(internalWalls)\n\tinternalWalls = OFFSET([.2,.2,4])(internalWalls)\n\twalls = STRUCT([externalWalls, internalWalls])\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/porte.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\tdoors = MKPOL([verts,cells,None])\n\tdoors = SOLIDIFY(doors)\n\tdoors = S([1,2,3])([.04,.04,.04])(doors)\n\tdoors = OFFSET([.2,.2,3])(doors)\n\twalls = DIFFERENCE([walls, doors])\n\n\n\tverts = []\n\tcells = []\n\ti = 0\n\treader = csv.reader(open(\"lines/finestre.lines\", 'rb'), delimiter=',') \n\tfor row in reader:\n\t\tverts.append([float(row[0]), float(row[1])])\n\t\tverts.append([float(row[2]), float(row[3])])\n\t\ti+=2\n\t\tcells.append([i-1,i])\n\n\twindows = MKPOL([verts,cells,None])\n\twindows = SOLIDIFY(windows)\n\twindows = S([1,2,3])([.04,.04,.04])(windows)\n\twindows = OFFSET([.2,.2,2])(windows)\n\theightWindows = SIZE([3])(windows)[0]\n\twindows = T(3)((heightWalls-heightWindows)/2.)(windows)\n\twalls = DIFFERENCE([walls, windows])\n\n\tfloor = TEXTURE(\"texture/floor.jpg\")(floor)\n\twalls = TEXTURE(\"texture/wall.jpg\")(walls)\n\thome = STRUCT([floor, walls])\n\treturn home","def Check(self):\n cleared = False\n while not cleared:\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\n x1 = i[0][0]\n y1 = i[0][1]\n r1 = i[0][2] / 2\n idx1 = i[0][3]\n x2 = i[1][0]\n y2 = i[1][1]\n r2 = i[1][2] / 2\n idx1 = i[0][3]\n idx2 = i[1][3]\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\n radii = (r1 + r2) * (r1 + r2)\n if distance == radii:\n cleared = True\n elif distance > radii:\n cleared = True\n else:\n if x1 > x2 and y1 > y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n elif x1 > x2 and y1 < y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n elif x1 < x2 and y1 > y2:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n else:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n _logger.debug(\n f\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\"\n )\n cleared = False\n return","def write_ROMS_grid(grd, visc_factor, diff_factor, filename='roms_grd.nc'):\n\n Mm, Lm = grd.hgrid.x_rho.shape\n\n \n # Write ROMS grid to file\n nc = netCDF.Dataset(filename, 'w', format='NETCDF4')\n nc.Description = 'ROMS grid'\n nc.Author = 'Trond Kristiansen'\n nc.Created = datetime.now().isoformat()\n nc.type = 'ROMS grid file'\n\n nc.createDimension('xi_rho', Lm)\n nc.createDimension('xi_u', Lm-1)\n nc.createDimension('xi_v', Lm)\n nc.createDimension('xi_psi', Lm-1)\n \n nc.createDimension('eta_rho', Mm)\n nc.createDimension('eta_u', Mm)\n nc.createDimension('eta_v', Mm-1)\n nc.createDimension('eta_psi', Mm-1)\n\n nc.createDimension('xi_vert', Lm+1)\n nc.createDimension('eta_vert', Mm+1)\n\n nc.createDimension('bath', None)\n\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\n N, = grd.vgrid.s_rho.shape\n nc.createDimension('s_rho', N)\n nc.createDimension('s_w', N+1)\n\n def write_nc_var(var, name, dimensions, long_name=None, units=None):\n nc.createVariable(name, 'f8', dimensions)\n if long_name is not None:\n nc.variables[name].long_name = long_name\n if units is not None:\n nc.variables[name].units = units\n nc.variables[name][:] = var\n print ' ... wrote ', name\n\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\n write_nc_var(grd.vgrid.theta_s, 'theta_s', (), 'S-coordinate surface control parameter')\n write_nc_var(grd.vgrid.theta_b, 'theta_b', (), 'S-coordinate bottom control parameter')\n write_nc_var(grd.vgrid.Tcline, 'Tcline', (), 'S-coordinate surface/bottom layer width', 'meter')\n write_nc_var(grd.vgrid.hc, 'hc', (), 'S-coordinate parameter, critical depth', 'meter')\n write_nc_var(grd.vgrid.s_rho, 's_rho', ('s_rho'), 'S-coordinate at RHO-points')\n write_nc_var(grd.vgrid.s_w, 's_w', ('s_w'), 'S-coordinate at W-points')\n write_nc_var(grd.vgrid.Cs_r, 'Cs_r', ('s_rho'), 'S-coordinate stretching curves at RHO-points')\n write_nc_var(grd.vgrid.Cs_w, 'Cs_w', ('s_w'), 'S-coordinate stretching curves at W-points')\n\n write_nc_var(grd.vgrid.h, 'h', ('eta_rho', 'xi_rho'), 'bathymetry at RHO-points', 'meter')\n #ensure that we have a bath dependancy for hraw\n if len(grd.vgrid.hraw.shape) == 2:\n hraw = np.zeros((1, grd.vgrid.hraw.shape[0], grd.vgrid.hraw.shape[1]))\n hraw[0,:] = grd.vgrid.hraw\n else:\n hraw = grd.vgrid.hraw\n write_nc_var(hraw, 'hraw', ('bath', 'eta_rho', 'xi_rho'), 'raw bathymetry at RHO-points', 'meter')\n write_nc_var(grd.hgrid.f, 'f', ('eta_rho', 'xi_rho'), 'Coriolis parameter at RHO-points', 'second-1')\n write_nc_var(1./grd.hgrid.dx, 'pm', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in XI', 'meter-1')\n write_nc_var(1./grd.hgrid.dy, 'pn', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in ETA', 'meter-1')\n write_nc_var(grd.hgrid.dmde, 'dmde', ('eta_rho', 'xi_rho'), 'XI derivative of inverse metric factor pn', 'meter')\n write_nc_var(grd.hgrid.dndx, 'dndx', ('eta_rho', 'xi_rho'), 'ETA derivative of inverse metric factor pm', 'meter')\n write_nc_var(grd.hgrid.xl, 'xl', (), 'domain length in the XI-direction', 'meter')\n write_nc_var(grd.hgrid.el, 'el', (), 'domain length in the ETA-direction', 'meter')\n\n write_nc_var(grd.hgrid.x_rho, 'x_rho', ('eta_rho', 'xi_rho'), 'x location of RHO-points', 'meter')\n write_nc_var(grd.hgrid.y_rho, 'y_rho', ('eta_rho', 'xi_rho'), 'y location of RHO-points', 'meter')\n write_nc_var(grd.hgrid.x_u, 'x_u', ('eta_u', 'xi_u'), 'x location of U-points', 'meter')\n write_nc_var(grd.hgrid.y_u, 'y_u', ('eta_u', 'xi_u'), 'y location of U-points', 'meter')\n write_nc_var(grd.hgrid.x_v, 'x_v', ('eta_v', 'xi_v'), 'x location of V-points', 'meter')\n write_nc_var(grd.hgrid.y_v, 'y_v', ('eta_v', 'xi_v'), 'y location of V-points', 'meter')\n write_nc_var(grd.hgrid.x_psi, 'x_psi', ('eta_psi', 'xi_psi'), 'x location of PSI-points', 'meter')\n write_nc_var(grd.hgrid.y_psi, 'y_psi', ('eta_psi', 'xi_psi'), 'y location of PSI-points', 'meter')\n write_nc_var(grd.hgrid.x_vert, 'x_vert', ('eta_vert', 'xi_vert'), 'x location of cell verticies', 'meter')\n write_nc_var(grd.hgrid.y_vert, 'y_vert', ('eta_vert', 'xi_vert'), 'y location of cell verticies', 'meter')\n\n if hasattr(grd.hgrid, 'lon_rho'):\n write_nc_var(grd.hgrid.lon_rho, 'lon_rho', ('eta_rho', 'xi_rho'), 'longitude of RHO-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_rho, 'lat_rho', ('eta_rho', 'xi_rho'), 'latitude of RHO-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_u, 'lon_u', ('eta_u', 'xi_u'), 'longitude of U-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_u, 'lat_u', ('eta_u', 'xi_u'), 'latitude of U-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_v, 'lon_v', ('eta_v', 'xi_v'), 'longitude of V-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_v, 'lat_v', ('eta_v', 'xi_v'), 'latitude of V-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_psi, 'lon_psi', ('eta_psi', 'xi_psi'), 'longitude of PSI-points', 'degree_east')\n write_nc_var(grd.hgrid.lat_psi, 'lat_psi', ('eta_psi', 'xi_psi'), 'latitude of PSI-points', 'degree_north')\n write_nc_var(grd.hgrid.lon_vert, 'lon_vert', ('eta_vert', 'xi_vert'), 'longitude of cell verticies', 'degree_east')\n write_nc_var(grd.hgrid.lat_vert, 'lat_vert', ('eta_vert', 'xi_vert'), 'latitude of cell verticies', 'degree_north')\n\n nc.createVariable('spherical', 'c')\n nc.variables['spherical'].long_name = 'Grid type logical switch'\n nc.variables['spherical'][:] = grd.hgrid.spherical\n print ' ... wrote ', 'spherical'\n\n write_nc_var(grd.hgrid.angle_rho, 'angle', ('eta_rho', 'xi_rho'), 'angle between XI-axis and EAST', 'radians')\n\n write_nc_var(grd.hgrid.mask_rho, 'mask_rho', ('eta_rho', 'xi_rho'), 'mask on RHO-points')\n write_nc_var(grd.hgrid.mask_u, 'mask_u', ('eta_u', 'xi_u'), 'mask on U-points')\n write_nc_var(grd.hgrid.mask_v, 'mask_v', ('eta_v', 'xi_v'), 'mask on V-points')\n write_nc_var(grd.hgrid.mask_psi, 'mask_psi', ('eta_psi', 'xi_psi'), 'mask on psi-points')\n\n if visc_factor != None:\n write_nc_var(visc_factor, 'visc_factor', ('eta_rho', 'xi_rho'), 'horizontal viscosity sponge factor')\n if diff_factor != None:\n write_nc_var(diff_factor, 'diff_factor', ('eta_rho', 'xi_rho'), 'horizontal diffusivity sponge factor')\n \n nc.close()","def draw_cells(cell_list):\n outrage_ratio = [x[4]/x[3] for x in cell_list]\n # print(cell_list)\n # print(outrage_ratio)\n outrage_ratio = [min(x, 1) for x in outrage_ratio] # larger than 1 is outrage, use black color directly\n # print_list = [round(x, 2) for x in outrage_ratio]\n # print(print_list)\n color_index = [int(x * len(COLOR_LIST)) for x in outrage_ratio]\n\n for cell in cell_list:\n this_color_index = color_index[cell[2]-1]\n this_cell_color = [i * 255 for i in list(COLOR_LIST[this_color_index-1].rgb)]\n pygame.draw.rect(DISPLAY_SURF, this_cell_color, (cell[0], cell[1], CELL_SIZE, CELL_SIZE))","def goodnessScore(roombas, obstacles, targeting, C1=3, C2=1, C3=1, C4=1, C5=2):\n\n def headingScore(roomba):\n # print(roomba.visible_location.pose.pose.orientation)\n heading = orientationToHeading(roomba.visible_location.pose.pose.orientation)\n\n return abs(np.sin(heading))\n\n def positionScore(roomba):\n # the closer to the center, the lower the xScore, from 0 to 1\n posX = roomba.visible_location.pose.pose.position.x\n posY = roomba.visible_location.pose.pose.position.y\n if(abs(posX) > 9.95 or abs(posY) > 9.95):\n return -10000\n xScore = abs(posX) / 10\n # the closer to the green zone, the higher the yScore, from 0 to 1\n yScore = posY / 20 + 0.5\n return (xScore + yScore)/2\n\n def distanceFromObstaclesScore(roomba, obstacles):\n \"\"\"\n (-infinity, 0)\n \"\"\"\n\n score = 0\n MIN_OBSTACLE_DISTANCE = 0.5\n for obstacle in obstacles:\n x = roomba.visible_location.pose.pose.position.x - obstacle.visible_location.pose.pose.position.x\n y = roomba.visible_location.pose.pose.position.y - obstacle.visible_location.pose.pose.position.y\n dist = np.sqrt(x ** 2 + y ** 2)\n\n if dist < MIN_OBSTACLE_DISTANCE:\n return -10000\n\n score -= 1 / dist ** 2\n\n return score\n\n def stateQualtityScore(roomba):\n \"\"\"\n How precisely we know the Roombas' state.\n Compare position accuracy to view radius to know if it's possible\n to see the given roomba when drone arrives.\n \"\"\"\n return 0\n\n def sameRoomba(roomba, targeting):\n if(targeting != None and roomba.frame_id == targeting.frame_id):\n return 1\n else:\n return 0\n\n result = []\n\n for i in xrange(0, len(roombas)):\n roomba = roombas[i]\n\n score = C1 * headingScore(roomba) + \\\n C2 * positionScore(roomba) + \\\n C3 * distanceFromObstaclesScore(roomba, obstacles) + \\\n C4 * stateQualtityScore(roomba) + \\\n C5 * sameRoomba(roomba, targeting)\n result.append((roomba, score))\n\n return result","def GetCoastGrids(LandMask):\n \n \"\"\"\n Define a coastline map. This map will be set to 1 on all coast cells.\n \"\"\"\n \n \n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\n \n \"\"\"\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \n \"\"\"\n \n for i in range(LandMask.shape[0]-1):\n for j in range(LandMask.shape[1]-1):\n \n\n \"\"\"\n We have nine if statements, four for the corners, four for the sides and one for the middle\n of the landmask. \n \"\"\"\n\n if i == 0 and j == 0: #upper left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n \n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1, j] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i+1,j+1] = 1\n \n \n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j-1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j-1] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i-1,j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i-1,j] = 1 \n CoastlineMap[i-1, j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i-1, j] = 1\n CoastlineMap[i-1,j-1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n \n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j+1] = 1\n CoastlineMap[i+1,j+1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n else:\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1 #middle\n CoastlineMap[i+1,j] = 1#lowermiddle\n CoastlineMap[i-1,j] = 1#uppermiddle\n \n CoastlineMap[i+1, j-1] = 1\n CoastlineMap[i-1, j-1] = 1\n CoastlineMap[i, j-1] =1\n \n CoastlineMap[i+1, j+1] = 1\n CoastlineMap[i-1, j+1] = 1\n CoastlineMap[i, j+1] = 1\n \n \n \n \"\"\"\n Here we substract the landmaks from the coastline mask, resulting in only\n the coastline. \n \"\"\"\n \n \n Coastgrids = CoastlineMap - LandMask\n \n return Coastgrids, CoastlineMap","def test_res(pad_size = [50, 50],\n num_squares = 1000,\n width = 1,\n res_layer = 0,\n pad_layer = 1,\n gnd_layer = 2):\n x = pad_size[0]\n z = pad_size[1]\n\n # Checking validity of input\n if x <= 0 or z <= 0:\n raise ValueError('Pad must have positive, real dimensions')\n elif width > z:\n raise ValueError('Width of cell cannot be greater than height of pad')\n elif num_squares <= 0:\n raise ValueError('Number of squares must be a positive real number')\n elif width <= 0:\n raise ValueError('Width of cell must be a positive real number')\n\n # Performing preliminary calculations\n num_rows = int(np.floor(z / (2*width)))\n if num_rows % 2 == 0:\n num_rows -= 1\n num_columns = num_rows - 1\n squares_in_row = (num_squares - num_columns - 2)/num_rows\n\n # Compensating for weird edge cases\n if squares_in_row < 1:\n num_rows = int(round(num_rows / 2) - 2)\n squares_in_row = 1\n if width * 2 > z:\n num_rows = 1\n squares_in_row = num_squares - 2\n\n length_row = squares_in_row * width\n\n # Creating row/column corner combination structure\n T = Device()\n Row = rectangle(size = (length_row, width), layer = res_layer)\n Col = rectangle(size = (width, width), layer = res_layer)\n\n row = T.add_ref(Row)\n col = T.add_ref(Col)\n col.move([length_row - width, -width])\n\n # Creating entire waveguide net\n N = Device('net')\n n = 1\n for i in range(num_rows):\n if i != num_rows - 1:\n d = N.add_ref(T)\n else:\n d = N.add_ref(Row)\n if n % 2 == 0:\n d.mirror(p1 = (d.x, d.ymax), p2 = (d.x, d.ymin))\n d.movey(-(n - 1) * T.ysize)\n n += 1\n d = N.add_ref(Col).movex(-width)\n d = N.add_ref(Col).move([length_row, -(n - 2) * T.ysize])\n\n # Creating pads\n P = Device('pads')\n Pad1 = rectangle(size = (x, z), layer = pad_layer)\n Pad2 = rectangle(size = (x + 5, z), layer = pad_layer)\n Gnd1 = offset(Pad1, distance = -5, layer = gnd_layer)\n Gnd2 = offset(Pad2, distance = -5, layer = gnd_layer)\n pad1 = P.add_ref(Pad1).movex(-x - width)\n pad2 = P.add_ref(Pad1).movex(length_row + width)\n gnd1 = P.add_ref(Gnd1).center = pad1.center\n gnd2 = P.add_ref(Gnd2)\n nets = P.add_ref(N).y = pad1.y\n gnd2.center = pad2.center\n gnd2.movex(2.5)\n\n return P","def draw_grid(self) -> None:\n grid = self.life.curr_generation\n for row in range(self.cell_height):\n for column in range(self.cell_width):\n if grid[row][column] == 1:\n color = \"green\"\n else:\n color = \"white\"\n pygame.draw.rect(\n self.screen,\n pygame.Color(color),\n (column * self.cell_size, row * self.cell_size, self.cell_size, self.cell_size),\n )","def game_of_life():\n # 3x3 neighbourhood\n offsets = [[(y, x) for y in range(-1, 2)] for x in range(-1, 2)]\n\n # Create mappings\n mappings = {}\n for i in range(2 ** 9):\n\n # Determine the initial state (key)\n key = f\"{bin(i)[2:]:0>9}\" # As binary string\n key = tuple(k == \"1\" for k in key) # As tuple of bools\n key = tuple(key[i * 3:i * 3 + 3] for i in range(3)) # Reshape into 2D grid\n\n # Alive counts\n centre = key[1][1]\n others = sum(sum(row) for row in key) - centre\n\n # Skip if state does not evaluate to True\n if centre:\n if others not in (2, 3):\n continue\n\n else:\n if others != 3:\n continue\n\n mappings[key] = True\n\n return Mapping2DRuleset(mappings, offsets)","def outcome(self, g):\n if g[0][0] == g[1][0] == g[2][0] and g[0][0] != 0:\n return g[0][0]\n if g[0][1] == g[1][1] == g[2][1] and g[0][1] != 0:\n return g[0][1]\n if g[0][2] == g[1][2] == g[2][2] and g[0][2] != 0:\n return g[0][2]\n if g[0][0] == g[0][1] == g[0][2] and g[0][0] != 0:\n return g[0][0]\n if g[1][0] == g[1][1] == g[1][2] and g[1][0] != 0:\n return g[1][0]\n if g[2][0] == g[2][1] == g[2][2] and g[2][0] != 0:\n return g[2][0]\n if g[0][0] == g[1][1] == g[2][2] and g[0][0] != 0:\n return g[0][0]\n if g[0][2] == g[1][1] == g[2][0] and g[0][2] != 0:\n return g[0][2]\n return 0","def redshift_draws(self, s_grid, num=1000):\n n_obj = len(self)\n z_draws = np.zeros((n_obj, num))\n # i_range = np.random.rand_int(0, n_obj, len(se))\n\n for i in tqdm(range(n_obj)):\n cdf_z = self['cdf_z'][i]\n _, z_draws[i, :] = self.rvs_from_cdf(s_grid, cdf_z, num=num)\n\n return z_draws","def infect(r, c):\n subset = grid[r-1:r+2, c-1:c+2]\n print(f\"Looking at ({r-1}, {c-1}) through ({r+1}, {c+1})\")\n # np.where(subset == 0)\n # subset[subset == 0] = np.fromfunction(calc_infect, shape=())\n #v_calc_infect(subset[subset == 0])\n #for i in np.nditer(subset):\n # if subset[i] == 0:\n # subset[i] = np.random.binomial(1, infect_rate)\n for x in np.nditer(subset, op_flags=['readwrite']):\n if x == 0:\n x[...] = calc_infect()\n\n # for nr in np.arange(-1, 2):\n # for nc in np.arange(-1, 2):\n # try:\n # if grid[r+nr, c+nc] == 0:\n # grid[r+nr, c+nc] = np.random.binomial(1, infect_rate)\n # except IndexError: # Out of bounds, ignore\n # pass","def generate_all_locations(grid, shape):","def triangulos_rectangulos(opcion,b,h):\n x1 =[0,0]\n x2 =[b-1,h-1]\n x3 =[b-1,0]\n if opcion == 1:\n lado1_x,lado1_y = dda_algrithm(x1[0],x1[1],x2[0],x2[1])\n lado2_x,lado2_y = dda_algrithm(x1[0],x1[1],x3[0],x3[1])\n lado3_x,lado3_y = dda_algrithm(x2[0],x2[1],x3[0],x3[1])\n return [lado1_x,lado1_y,lado2_x,lado2_y,lado3_x,lado3_y]\n else:\n lado1_x,lado1_y = bresenham_algrithm(x1[0],x1[1],x2[0],x2[1])\n lado2_x,lado2_y = bresenham_algrithm(x1[0],x1[1],x3[0],x3[1])\n lado3_x,lado3_y = bresenham_algrithm(x2[0],x2[1],x3[0],x3[1])\n return [lado1_x,lado1_y,lado2_x,lado2_y,lado3_x,lado3_y]","def get_obstacles_map(obstacles, placed_pecies):\n \n #create a mask image to draw the obstacles on\n blocks = np.zeros(ARENA_SIZE[::-1], np.uint8)\n\n #get the grid points where the robot needs to placed\n grid = get_grid(ARENA_SIZE)\n\n #draw the obstacles and their safety region on the map\n for i in obstacles.keys():\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\n cv2.rectangle(blocks, (i[0]-int(obstacles[i][0]/4), i[1]-int(obstacles[i][1]/4)), (i[0]+int(obstacles[i][0]/4), i[1]+int(obstacles[i][1]/4)), 255, -1)\n\n #draw the obstacles and their safety region on the map\n for i in placed_pecies.keys():\n try:\n if not i == grid[5]:\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\n else:\n cv2.rectangle(blocks, (int(i[0]-7.4*placed_pecies[i][0]/4), int(i[1]-7.4*placed_pecies[i][1]/4)),\n (int(i[0]+7.4*placed_pecies[i][0]/4), int(i[1]+7.4*placed_pecies[i][1]/4)), 129, -1)\n cv2.rectangle(blocks, (i[0]-int(placed_pecies[i][0]/4), i[1]-int(placed_pecies[i][1]/4)), (i[0]+int(placed_pecies[i][0]/4), i[1]+int(placed_pecies[i][1]/4)), 255, -1)\n except Exception as e:\n print(e)\n\n return cv2.bitwise_not(blocks)","def run_Simulation2(k,N=100,T=10,start = 1,p=0.5,q=0.08,startcenter = False,startcorner=False):\n recover = [0]\n infect = [start]\n suspect = [N-start]\n pop = [Person() for i in range(N)]\n ##we need to change the code for the case start people infected\n for i in range(start):\n pop[i].get_infected();\n if(startcenter):\n resetcenter(start,pop)\n if(startcorner):\n resetcorner(start,pop)\n np.random.seed(10)\n for i in range(T):\n for j in range(N):\n pop[j].movepos(p)\n X = calculatedistance(pop)\n tree = cKDTree(X)\n for j in range(N):\n if pop[j].is_infected():\n addvalue = np.array([X[j]])\n inds = tree.query_ball_point(addvalue, q)\n inds = inds[0]\n #may have problem here\n for l in inds:\n if pop[l].is_willinfected():\n pop[l].get_infected()\n\n for j in range(N):\n if pop[j].is_infected():\n if np.random.rand()< k:\n pop[j].get_recovered()\n\n recover.append(count_recover(pop))\n infect.append(count_infect(pop))\n suspect.append(count_suspectial(pop))\n newrecover = [i/N for i in recover]\n newsuspect = [s/N for s in suspect]\n newinfect = [i/N for i in infect]\n plt.plot(range(T+1),newrecover,label = \"r: percentage of removed \")\n plt.plot(range(T+1),newsuspect,label = \"s: percentage of susceptible\")\n plt.plot(range(T+1),newinfect,label = \"i: percentage of infected\")\n plt.xlabel(\"T\")\n plt.ylabel(\"percentage\")\n plt.title(\"Percentage of Population, Discrete\")\n plt.legend()\n plt.show()","def advance_generation(self):\n self.generation += 1\n next_cells = [[self.cell_state['dead']] * self.cols for x in range(self.lines)]\n for i in range(self.lines):\n for j in range(self.cols):\n neighbors = self.get_neighbors(i, j)\n if self[i][j] == self.cell_state['alive']:\n if neighbors == 2 or neighbors == 3:\n next_cells[i][j] = self.cell_state['alive']\n elif self[i][j] == self.cell_state['dead']:\n if neighbors == 3:\n next_cells[i][j] = self.cell_state['alive']\n super().__init__(next_cells)","def solution(n, m, r, c, k) -> int:\n xs = []\n # Add all the non-zero room widths to xs\n last_column_wall = None\n for col in c:\n if last_column_wall is not None and col - last_column_wall - 1 > 0:\n xs.append(col - last_column_wall - 1)\n last_column_wall = col\n ys = []\n # Add all the non-zero room heights to ys\n last_row_wall = None\n for row in r:\n if last_row_wall is not None and row - last_row_wall - 1 > 0:\n ys.append(row - last_row_wall - 1)\n last_row_wall = row\n return aux(xs, ys, k)","def getGameState(self):\n ### Student code goes here\n row1 = ()\n row2 = ()\n row3 = ()\n for currRow in range(1,4):\n for currCol in range(1,4):\n tileFound = False\n for fact in self.kb.facts:\n if fact.statement.predicate == \"located\":\n tile = fact.statement.terms[0].term.element\n column = fact.statement.terms[1].term.element\n row = fact.statement.terms[2].term.element\n\n tileNumber = int(tile[-1])\n columnNumber = int(column[-1])\n rowNumber = int(row[-1])\n\n if rowNumber == currRow and columnNumber == currCol:\n tileFound = True\n if rowNumber == 1:\n row1 += tuple([tileNumber])\n elif rowNumber == 2:\n row2 += tuple([tileNumber])\n elif rowNumber == 3:\n row3 += tuple([tileNumber])\n \n break\n\n if not tileFound:\n if currRow == 1:\n row1 += tuple([-1])\n elif currRow == 2:\n row2 += tuple([-1])\n elif currRow == 3:\n row3 += tuple([-1])\n\n\n return (row1, row2, row3)","def generation(self,rounds):\n a = []\n b = []\n for i in range(rounds):\n self.fight()\n c = self.avgFitness()\n a.append(c[0])\n b.append(c[1])\n self.sort()\n self.cull()\n self.rePop()\n self.refresh()\n self.fight()\n self.sort()\n print self\n plt.scatter([x for x in range(len(a))],a,color = \"red\")\n plt.scatter([x for x in range(len(b))],b,color = \"green\")\n plt.show()","def generation(self,rounds):\n a = []\n b = []\n for i in range(rounds):\n self.fight()\n c = self.avgFitness()\n a.append(c[0])\n b.append(c[1])\n self.sort()\n self.cull()\n self.rePop()\n self.refresh()\n self.fight()\n self.sort()\n print self\n plt.scatter([x for x in range(len(a))],a,color = \"red\")\n plt.scatter([x for x in range(len(b))],b,color = \"green\")\n plt.show()","def make_n_glycan_neighborhoods():\n neighborhoods = NeighborhoodCollection()\n\n _neuraminic = \"(%s)\" % ' + '.join(map(str, (\n FrozenMonosaccharideResidue.from_iupac_lite(\"NeuAc\"),\n FrozenMonosaccharideResidue.from_iupac_lite(\"NeuGc\")\n )))\n _hexose = \"(%s)\" % ' + '.join(\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['Hex', ])))\n _hexnac = \"(%s)\" % ' + '.join(\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['HexNAc', ])))\n\n high_mannose = CompositionRangeRule(\n _hexose, 3, 12) & CompositionRangeRule(\n _hexnac, 2, 2) & CompositionRangeRule(\n _neuraminic, 0, 0)\n high_mannose.name = \"high-mannose\"\n neighborhoods.add(high_mannose)\n\n base_hexnac = 3\n base_neuac = 2\n for i, spec in enumerate(['hybrid', 'bi', 'tri', 'tetra', 'penta', \"hexa\", \"hepta\"]):\n if i == 0:\n rule = CompositionRangeRule(\n _hexnac, base_hexnac - 1, base_hexnac + 1\n ) & CompositionRangeRule(\n _neuraminic, 0, base_neuac) & CompositionRangeRule(\n _hexose, base_hexnac + i - 1,\n base_hexnac + i + 3)\n rule.name = spec\n neighborhoods.add(rule)\n else:\n sialo = CompositionRangeRule(\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\n ) & CompositionRangeRule(\n _neuraminic, 1, base_neuac + i\n ) & CompositionRangeRule(\n _hexose, base_hexnac + i - 1,\n base_hexnac + i + 2)\n\n sialo.name = \"%s-antennary\" % spec\n asialo = CompositionRangeRule(\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\n ) & CompositionRangeRule(\n _neuraminic, 0, 1 if i < 2 else 0\n ) & CompositionRangeRule(\n _hexose, base_hexnac + i - 1,\n base_hexnac + i + 2)\n\n asialo.name = \"asialo-%s-antennary\" % spec\n neighborhoods.add(sialo)\n neighborhoods.add(asialo)\n return neighborhoods","def draw_grid(self):\n\n screen.fill(GREY)\n\n for row in self.grid:\n for cell in row:\n if cell.root:\n color = GREEN\n elif cell.goal:\n color = RED\n elif cell.value:\n color = DARK_BLUE\n elif cell.visited:\n color = LIGHT_BLUE\n elif cell.f:\n color = LIGHT_GREEN\n elif cell.wall:\n color = GRAY\n else:\n color = WHITE\n\n pygame.draw.rect(screen, color, cell.rect)\n\n x, y = cell.rect.x, cell.rect.y\n\n if cell.g:\n self.draw_score(x + 2, y + 2, cell.g)\n if cell.h:\n self.draw_score(x + 18, y + 2, cell.h)\n if cell.f:\n self.draw_score(x + 2, y + self.cell_size - 10, cell.f)","def pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\n def compute_avec(vec,aaa,bbb,grd):\n\n avec=np.empty(grd.np0,)\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\n avec[grd.vp1] = vec[grd.vp1]\n\n return avec,\n if name_grd is not None:\n if os.path.isfile(name_grd):\n with open(name_grd, 'rb') as f:\n grd = pickle.load(f)\n else:\n grd = Grid(lon,lat)\n with open(name_grd, 'wb') as f:\n pickle.dump(grd, f)\n f.close()\n else:\n grd = Grid(lon,lat)\n\n ny,nx,=np.shape(hg)\n g=grd.g\n\n\n x=hg[grd.indi,grd.indj]\n q1d=q[grd.indi,grd.indj]\n\n aaa=g/grd.f01d\n bbb=-g*grd.f01d/c**2\n ccc=+q1d\n\n aaa[grd.vp1]=0\n bbb[grd.vp1]=1\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\n\n vec=+x\n\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n p=-gg\n\n for itr in range(nitr-1):\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n tmp=np.dot(p,avec)\n\n if tmp!=0. : s=-np.dot(p,gg)/tmp\n else: s=1.\n\n a1=np.dot(gg,gg)\n x=x+s*p\n vec=+x\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n a2=np.dot(gg,gg)\n\n if a1!=0: beta=a2/a1\n else: beta=1.\n\n p=-gg+beta*p\n\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n val1=-np.dot(p,gg)\n val2=np.dot(p,avec)\n if (val2==0.):\n s=1.\n else:\n s=val1/val2\n\n a1=np.dot(gg,gg)\n x=x+s*p\n\n # back to 2D\n h=np.empty((ny,nx))\n h[:,:]=np.NAN\n h[grd.indi,grd.indj]=x[:]\n\n\n return h","def run(self):\n\t\tfrom loc import loc as Loc\n\t\tfor r in range(1,self.size):\n\t\t\tfor c in range(self.size): \n\t\t\t\tthis = Loc(r,c)\n\t\t\t\tself.state.set_cell(this, self.rule(self.neighbor_vals(this), self.__prob))\n\t\tself.__ran = True","def play_round_Conway_Cell(self):\n for x in self.board:\n for f in x:\n f.live_neighbors = 0\n\n for i in range(1, self.cols - 1):\n for j in range(1, self.rows - 1):\n status = self.board[i][j].status\n assert type(status)==int \n\n for m in range(i - 1, i + 2):\n for n in range(j - 1, j + 2):\n self.board[m][n].live_neighbors += status\n self.board[i][j].live_neighbors -= status","def recombination(parents):\n\n # pick 5 random numbers that add up to 1\n random_values = np.random.dirichlet(np.ones(5),size=1)[0]\n\n # those random values will serve as weights for the genes 2 offspring get (whole arithmetic recombination)\n offspring1 = random_values[0] * parents[0] + random_values[1] * parents[1] + random_values[2] * parents[2] + random_values[3] * parents[3] + \\\n random_values[4] * parents[4]\n\n # repeat for offspring 2\n random_values = np.random.dirichlet(np.ones(5),size=1)[0]\n offspring2 = random_values[0] * parents[0] + random_values[1] * parents[1] + random_values[2] * parents[2] + random_values[3] * parents[3] + \\\n random_values[4] * parents[4]\n\n # the other 2 offspring will come from 4-point crossover\n random_points = np.sort(np.random.randint(1, parents[0].shape[0]-2, 4))\n\n # to make it so that it won't always be p1 who gives the first portion of DNA etc, we shuffle the parents\n np.random.shuffle(parents)\n\n # add the genes together\n offspring3 = np.concatenate((parents[0][0:random_points[0]], parents[1][random_points[0]:random_points[1]], parents[2][random_points[1]:random_points[2]],\\\n parents[3][random_points[2]:random_points[3]], parents[4][random_points[3]:]))\n\n # repeat for offspring 4\n random_points = np.sort(np.random.randint(1, parents[0].shape[0]-2, 4))\n np.random.shuffle(parents)\n offspring4 = np.concatenate((parents[0][0:random_points[0]], parents[1][random_points[0]:random_points[1]], parents[2][random_points[1]:random_points[2]],\\\n parents[3][random_points[2]:random_points[3]], parents[4][random_points[3]:]))\n\n # return the offspring\n return np.concatenate(([offspring1], [offspring2], [offspring3], [offspring4]))","def drawValidationNeedles(self): \n #productive #onButton\n profprint()\n # reset report table\n # print \"Draw manually segmented needles...\"\n #self.table =None\n #self.row=0\n self.initTableView()\n self.deleteEvaluationNeedlesFromTable()\n while slicer.util.getNodes('manual-seg*') != {}:\n nodes = slicer.util.getNodes('manual-seg*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)\n \n if self.tableValueCtrPt==[[]]:\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\n nbNode=modelNodes.GetNumberOfItems()\n for nthNode in range(nbNode):\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\n if modelNode.GetAttribute(\"ValidationNeedle\") == \"1\":\n needleNumber = int(modelNode.GetAttribute(\"NeedleNumber\"))\n needleStep = int(modelNode.GetAttribute(\"NeedleStep\"))\n coord=[0,0,0]\n modelNode.GetFiducialCoordinates(coord)\n self.tableValueCtrPt[needleNumber][needleStep]=coord\n print needleNumber,needleStep,coord\n # print self.tableValueCtrPt[needleNumber][needleStep]\n\n for i in range(len(self.tableValueCtrPt)):\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\n colorVar = random.randrange(50,100,1)/float(100)\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\n self.addNeedleToScene(controlPoints,i,'Validation')\n else:\n # print i\n pass","def vision(image):\n vis_map = resize(image, alpha, beta)\n print(\"Resized map from the blue mask\")\n\n world = rotate(vis_map)\n\n plt.figure()\n plt.imshow(world[:, :, ::-1])\n plt.show()\n object_grid, occupancy_grid = detect_object(world)\n print(\"Result of the red mask\")\n plt.figure()\n plt.imshow(occupancy_grid)\n plt.show()\n return object_grid, occupancy_grid, world","def create_grid(self):\n row = 0\n col = 0\n for row in range(self._dim):\n for col in range(self._dim):\n x1 = col*self._cell_dim # bottom left\n y1 = row * self._cell_dim # top left\n x2 = x1 + self._cell_dim # bottom right\n y2 = y1 + self._cell_dim # top right\n self.rect[row,col] = self.canvas.create_rectangle(x1,y1,x2,y2, fill=self._primary_color, outline=self._grid_lines_color, tags=\"rect\")\n self.canvas.tag_bind(self.rect[row, col], '<ButtonPress-1>', self.change_cell)\n col = 0\n row += 1\n if self._dim < 50:\n button_size = int(80*(self._dim/50))\n font_size = int(22*(self._dim/50))\n else:\n button_size = 80\n font_size = 18\n x1 = col * self._cell_dim + (((self._dim*self._cell_dim) - button_size*3)//2)\n y1 = row * self._cell_dim + 5\n x2 = x1 + button_size\n y2 = y1 + 20\n self.canvas.create_oval(x1,y1,x2,y2, tags=\"toggle\", fill=self._primary_color)\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\"toggle-text\", fill=self._secondary_color, text=\"Start\", font=(\"Courier\", font_size))\n self.canvas.tag_bind(\"toggle\", '<ButtonPress-1>', self.toggle_refresh)\n self.canvas.tag_bind(\"toggle-text\", '<ButtonPress-1>', self.toggle_refresh)\n x1 = x2 + 5 # padding between buttons\n x2 = x1 + button_size\n self.canvas.create_oval(x1,y1,x2,y2, tags=\"next\", fill=self._primary_color)\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\"next-text\", fill=self._secondary_color, text=\"Next\", font=(\"Courier\", font_size))\n self.canvas.tag_bind(\"next\", '<ButtonPress-1>', self.one_step)\n self.canvas.tag_bind(\"next-text\", '<ButtonPress-1>', self.one_step)\n x1 = x2 + 5 # padding between buttons\n x2 = x1 + button_size\n self.canvas.create_oval(x1,y1,x2,y2, tags=\"clear\", fill=self._primary_color)\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\"clear-text\", fill=self._secondary_color, text=\"Clear\", font=(\"Courier\", font_size))\n self.canvas.tag_bind(\"clear\", '<ButtonPress-1>', self.clear_board)\n self.canvas.tag_bind(\"clear-text\", '<ButtonPress-1>', self.clear_board)\n self.model_refresh()","def make_game_grid(self):\n return numpy.array([[random.choice(string.ascii_uppercase) for breath in range(self.grid_size)] for depth in\n range(self.grid_size)])","def gen_static_landscape(pop,conc):\n # get final landscape and seascape\n landscape = np.zeros(pop.n_genotype)\n for kk in range(pop.n_genotype):\n landscape[kk] = gen_fitness(pop,\n kk,\n pop.static_topo_dose,\n pop.drugless_rates,\n pop.ic50)\n \n if min(landscape) == 0:\n zero_indx_land = np.argwhere(landscape==0)\n landscape_t = np.delete(landscape,zero_indx_land)\n min_landscape = min(landscape_t)\n else:\n min_landscape = min(landscape)\n zero_indx_land = []\n \n seascape = np.zeros(pop.n_genotype)\n for gen in range(pop.n_genotype):\n seascape[gen] = gen_fitness(gen,conc,pop.drugless_rates,pop.ic50,pop=pop)\n \n if min(seascape) == 0:\n zero_indx_sea = np.argwhere(seascape==0)\n seascape_t = np.delete(seascape,zero_indx_sea)\n min_seascape = min(seascape_t)\n else:\n min_seascape = min(seascape)\n \n landscape = landscape - min_landscape\n landscape = landscape/max(landscape)\n \n rng = max(seascape) - min_seascape\n \n landscape = landscape*rng + min_seascape\n \n landscape[zero_indx_land] = 0\n return landscape","def refresh_view(self):\n if self._step_number % 2 == 0:\n self._view.draw_enemies(self._game.enemies)\n self._view.draw_towers(self._game.towers)\n self._view.draw_obstacles(self._game.obstacles)","def make_grid(m, n, k):\n \n grid = np.zeros(m*n)\n \n mine_indecies = np.arange(m*n)\n np.random.shuffle(mine_indecies)\n mine_indecies = mine_indecies[:k]\n \n #print('mine_indecies:', mine_indecies)\n #print(np.arange(m*n).reshape((m,n)))\n \n for i in mine_indecies:\n mask = get_mask(m, n, i)\n #print(mask.reshape((m,n)))\n grid = grid + mask\n \n grid[mine_indecies] = -1\n grid.resize((m,n))\n return grid","def get_obstacles(image):\n\n ih, iw = image.shape[:2]\n image_copy = image.copy()\n\n #resize the image to the size of arena\n image = cv2.resize(image, ARENA_SIZE, interpolation=cv2.INTER_CUBIC)\n gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\n\n #replace all black pixels to white pixels\n gray[np.where(gray == 0)]= 255\n\n #get the thresholded binary image\n ret,threshold = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)\n\n #find all the countours in the binary image\n _, contours, heiarchy = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n cont = []\n\n #create a mask to draw contours on\n blocks = mask = np.zeros(threshold.shape[:2], np.uint8)\n\n #create a dictionary to hold image roi of all puzzle peices\n blocks_roi = {}\n\n #iterate through all contours\n for i, c in enumerate(contours[1:]):\n\n #find the minimum area fitting rectangle of the contour\n rect = cv2.minAreaRect(c)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n\n #create the copy of the mask\n mask_copy = mask.copy()\n\n #draw the rectangle on the mask\n cv2.drawContours(mask_copy, [box], -1, (255,255,255), 3)\n\n #floodfill the rectangle\n cv2.floodFill(mask_copy, None, (0,0), 255)\n mask_inv = cv2.bitwise_not(mask_copy)\n blocks = cv2.add(blocks, mask_inv)\n\n _, contours, heiarchy = cv2.findContours(blocks, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n obstacles = {}\n\n for c in contours:\n x,y,w,h = cv2.boundingRect(c)\n obstacles.update({(int(x+w/2), int(y+h/2)): BLOCK_SIZE})\n #obstacles.update({(int(x+w/2), int(y+h/2)): (w, h)}) # for unknown block sizes\n bottom_r = remap((x+w, y+h), ARENA_SIZE, (iw,ih))\n top_l = remap((x, y), ARENA_SIZE, (iw,ih))\n blocks_roi.update({(int(x+w/2), int(y+h/2)): image_copy[top_l[1]:bottom_r[1], top_l[0]:bottom_r[0]]})\n\n return obstacles, blocks_roi","def rectangular(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):\n\n from anuga.config import epsilon\n\n delta1 = float(len1)/m\n delta2 = float(len2)/n\n\n #Calculate number of points\n Np = (m+1)*(n+1)\n\n class Index(object):\n\n def __init__(self, n,m):\n self.n = n\n self.m = m\n\n def __call__(self, i,j):\n return j+i*(self.n+1)\n\n\n index = Index(n,m)\n\n points = num.zeros((Np, 2), float)\n\n for i in range(m+1):\n for j in range(n+1):\n\n points[index(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\n\n #Construct 2 triangles per rectangular element and assign tags to boundary\n #Calculate number of triangles\n Nt = 2*m*n\n\n\n elements = num.zeros((Nt, 3), int)\n boundary = {}\n nt = -1\n for i in range(m):\n for j in range(n):\n nt = nt + 1\n i1 = index(i,j+1)\n i2 = index(i,j)\n i3 = index(i+1,j+1)\n i4 = index(i+1,j)\n\n\n #Update boundary dictionary and create elements\n if i == m-1:\n boundary[nt, 2] = 'right'\n if j == 0:\n boundary[nt, 1] = 'bottom'\n elements[nt,:] = [i4,i3,i2] #Lower element\n nt = nt + 1\n\n if i == 0:\n boundary[nt, 2] = 'left'\n if j == n-1:\n boundary[nt, 1] = 'top'\n elements[nt,:] = [i1,i2,i3] #Upper element\n\n return points, elements, boundary","def evaluate(self, state):\n\t\ttranspose = state.board.transpose()\t\t# columns in state.board = rows in transpose\n\t\tcount = []\n\t\topponentcount = []\n\t\tfor row, column in zip(state.board, transpose):\n\t\t\trowcounter = collections.Counter(row)\n\t\t\tcolumncounter = collections.Counter(column)\n\t\t\tcount.append(rowcounter.get(state.current_player, 0))\n\t\t\tcount.append(columncounter.get(state.current_player, 0))\n\t\t\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\n\t\t\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\n\n\t\tY = state.board[:, ::-1]\n\t\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\n\t\tmain_diagonal_count = collections.Counter(diagonals[0])\n\t\tsecond_diagonal_count = collections.Counter(diagonals[1])\n\t\tcount.append(main_diagonal_count.get(state.current_player, 0))\n\t\tcount.append(second_diagonal_count.get(state.current_player, 0))\n\t\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\n\t\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\n\n\t\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\tscoremax = 5 ** max(count)\n\t\tscoremin = 5 ** max(opponentcount)\n\n\t\treturn scoremax - scoremin","def show_possibles(self):\n for row in range(self.board_size):\n for col in range(self.board_size):\n poss = list(self.possibles[row][col])\n if poss:\n teil = qbwrdd.Tile(poss, self.board.scene)\n teil.cell = \"poss\"\n cell = row * self.board_size + col\n pos_x, pos_y = self.board.cells[cell].x(), self.board.cells[cell].y()\n if col % 3 > 0:\n pos_x += 2\n self.poss_tiles[row][col] = teil\n teil.draw_tile_at(pos_x, pos_y)","def make_board(self):\n generate = lambda: random.randint(1, 100) in range(1, self.p_pit+1)\n some_number = self.some_number\n agent = Agent(some_number)\n agent.program = Oozeplorer_Percept(agent)\n self.add_agent(agent)\n gold = Gold()\n self.add_thing(gold, None)\n for row in range(1, some_number + 1):\n for col in range(1, some_number + 1):\n valid_spot = (row, col) != gold.location and (row, col) != (1, 1)\n if valid_spot and generate():\n t_pt = Pit()\n t_pt.location = (row, col)\n self.things.append(t_pt)","def create_glider(i, j, grid):\n\n glider = np.array([[0, 0, 1],\n [1, 0, 1],\n [0, 1, 1]])\n grid[i:i+3:, j:j+3] = glider","def table_cells_cropper(img_path=DEFAULT_IMAGE_PATH, cropped_img_dir=\"/home/denny_k/Documents/work/puller_blueprints_ocr/needed_tables/cropped/\"):\n\n # Image preparation\n img = cv2.imread(img_path)\n img_height = img.shape[0]\n img_width = img.shape[1]\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n gray = cv2.GaussianBlur(gray, (7, 7), 0)\n gray = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 75, 10)\n\n gray = cv2.erode(gray, (3, 3), iterations=1)\n bw = cv2.bitwise_not(gray)\n bw = cv2.adaptiveThreshold(bw, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 15, -2)\n circle_result = deepcopy(img)\n\n # Finding all vertical and horizontal lines\n horizontal = bw\n vertical = bw\n\n horizontal_scale = 10\n vertical_scale = 10\n\n horizontalsize = int(horizontal.shape[1] / horizontal_scale)\n\n horizontal_structure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontalsize, 1))\n\n horizontal = cv2.erode(horizontal, horizontal_structure, (-1, -1))\n horizontal = cv2.dilate(horizontal, horizontal_structure, (-1, -1))\n\n vertical_size = int(vertical.shape[0] / vertical_scale)\n\n vertical_structure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, vertical_size))\n\n vertical = cv2.erode(vertical, vertical_structure, (-1, -1))\n vertical = cv2.dilate(vertical, vertical_structure, (-1, -1))\n\n img_without_lines = img\n\n mask = horizontal + vertical\n\n # Using mask to remove all lines from image\n whiteImg = np.zeros(img_without_lines.shape, img_without_lines.dtype)\n whiteImg[:, :] = (255, 255, 255)\n whiteMask = cv2.bitwise_and(whiteImg, whiteImg, mask=mask)\n\n kernel = np.ones((5, 5), np.uint8)\n whiteMask = cv2.dilate(whiteMask, kernel, iterations=1)\n\n cv2.addWeighted(whiteMask, 1, img_without_lines, 1, 0, img_without_lines)\n\n corners = cv2.bitwise_and(horizontal, vertical)\n\n points = list()\n point = dict()\n lines = list()\n\n # Filters points in line intersections and save them as dict's using horizontal axis\n for y in range(img_height):\n for x in range(img_width):\n point['x'] = int()\n point['y'] = int()\n if corners[y][x]:\n point_control = True\n point['x'] = x\n point['y'] = y\n if points:\n for comp_point in points:\n if point['x'] - 25 < comp_point['x'] < point['x'] + 25 and \\\n point['y'] - 25 < comp_point['y'] < point['y'] + 25:\n point_control = False\n if point_control:\n points.append(deepcopy(point))\n else:\n points.append(deepcopy(point))\n\n if points:\n # Same filter as previous, but using other vertical axis\n points.sort(key=lambda x: x['y'])\n lines = list()\n current_line = dict()\n current_line['points'] = list()\n current_point = points[0]\n for point_counter in range(len(points)):\n if points[point_counter]['y'] <= current_point['y'] + 15:\n current_line['points'].append(points[point_counter])\n else:\n if current_line['points']:\n lines.append(current_line)\n current_point = points[point_counter]\n current_line = dict()\n current_line['points'] = list()\n current_line['points'].append(points[point_counter])\n\n if current_line:\n lines.append(current_line)\n\n cropped_img_list = list()\n\n # Removing emply lines and calculate horizontal line width\n if lines:\n for line in lines:\n if len(line['points']) <= 1:\n lines.remove(line)\n continue\n line['points'].sort(key=lambda x: x['x'])\n\n line['line_length'] = 0\n start_point = line['points'][0]\n end_point = line['points'][0]\n for point_counter in range(len(line['points'])):\n if point_counter == len(line['points']) - 1:\n end_point = line['points'][point_counter]\n line['line_length'] = int(end_point['x'] - start_point['x'])\n cv2.circle(circle_result, (line['points'][point_counter]['x'], line['points'][point_counter]['y']), 25, (0, 255, 0), thickness=5)\n\n # Page segmentation using points\n img_num = 1\n if len(lines) > 1:\n row = 1\n for line_counter in range(len(lines) - 1):\n\n if abs(lines[line_counter]['line_length'] - lines[line_counter + 1]['line_length']) \\\n < 0.5 * lines[line_counter]['line_length']:\n for point_counter1 in range(len(lines[line_counter]['points']) - 1):\n\n point_a = lines[line_counter]['points'][point_counter1]\n point_b = dict()\n point_c = dict()\n point_d = dict()\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\n point_d = lines[line_counter + 1]['points'][point_counter2]\n point_b = lines[line_counter]['points'][point_counter1 + 1]\n for point_counter2 in range(len(lines[line_counter + 1]['points'])):\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\n point_c = lines[line_counter + 1]['points'][point_counter2]\n\n if point_a and point_b and point_d and not point_c:\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\n if point_d == lines[line_counter + 1]['points'][point_counter2]:\n point_c = lines[line_counter + 1]['points'][point_counter2 + 1]\n\n for point_counter2 in range(len(lines[line_counter]['points'])):\n if lines[line_counter]['points'][point_counter2]['x'] - 15 < point_c['x'] < \\\n lines[line_counter]['points'][point_counter2]['x'] + 15:\n point_b = lines[line_counter]['points'][point_counter2]\n if point_a and point_b and point_c and point_d:\n is_subline = False\n cropped_img_params = dict()\n crop_img = img[point_a['y']: point_d['y'],\n point_a['x']: point_b['x']]\n\n full_path = cropped_img_dir + \"img_%s.png\" % (img_num)\n cv2.imwrite(full_path, crop_img)\n\n subprocess.call(\n 'convert -density 300x300 -units PixelsPerInch \"%(file)s\" \"%(file)s\"' % (\n {\"file\": full_path}),\n shell=True, executable='/bin/bash')\n\n cropped_img_params['img_path'] = full_path\n cropped_img_params['x_topleft'] = point_a['x']\n cropped_img_params['y_topleft'] = point_a['y']\n cropped_img_params['width'] = point_b['x'] - point_a['x']\n cropped_img_params['height'] = point_d['y'] - point_a['y']\n cropped_img_params['row_num'] = row\n\n if lines[line_counter]['line_length'] < 0.6 * lines[line_counter + 1]['line_length']:\n is_subline = True\n cropped_img_params['is_subline'] = is_subline\n\n cropped_img_list.append(cropped_img_params)\n\n img_num += 1\n\n\n else:\n for point_counter1 in range(len(lines[line_counter]['points']) - 1):\n point_a = lines[line_counter]['points'][point_counter1]\n point_b = dict()\n point_c = dict()\n point_d = dict()\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\n point_d = lines[line_counter + 1]['points'][point_counter2]\n\n if not point_d:\n for point_counter2 in range(len(lines[line_counter + 2]['points']) - 1):\n if lines[line_counter + 2]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\n lines[line_counter + 2]['points'][point_counter2]['x'] + 15:\n point_d = lines[line_counter + 2]['points'][point_counter2]\n\n point_b = lines[line_counter]['points'][point_counter1 + 1]\n\n for point_counter2 in range(len(lines[line_counter + 1]['points'])):\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\n point_c = lines[line_counter + 1]['points'][point_counter2]\n\n if not point_c:\n for point_counter2 in range(len(lines[line_counter + 2]['points'])):\n if lines[line_counter + 2]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\n lines[line_counter + 2]['points'][point_counter2]['x'] + 15:\n point_c = lines[line_counter + 2]['points'][point_counter2]\n\n if point_a and point_b and point_c and point_d:\n cropped_img_params = dict()\n is_subline = False\n crop_img = img_without_lines[point_a['y']: point_d['y'],\n point_a['x']: point_b['x']]\n\n full_path = cropped_img_dir + \"img_%s.png\" % (img_num)\n cv2.imwrite(full_path, crop_img)\n\n subprocess.call(\n 'convert -density 300x300 -units PixelsPerInch \"%(file)s\" \"%(file)s\"' % (\n {\"file\": full_path}),\n shell=True, executable='/bin/bash')\n\n cropped_img_params['img_path'] = full_path\n cropped_img_params['x_topleft'] = point_a['x']\n cropped_img_params['y_topleft'] = point_a['y']\n cropped_img_params['width'] = point_b['x'] - point_a['x']\n cropped_img_params['height'] = point_d['y'] - point_a['y']\n cropped_img_params['row_num'] = row\n\n\n if lines[line_counter]['line_length'] < 0.6 * lines[line_counter + 1]['line_length']:\n is_subline = True\n cropped_img_params['is_subline'] = is_subline\n\n cropped_img_list.append(cropped_img_params)\n img_num += 1\n row += 1\n\n return cropped_img_list","def global_analysis(tomo, b_th, c=18):\n\n ## Thesholding and Volume analysis\n if c == 6:\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\n elif c == 18:\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\n elif c == 26:\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\n else:\n raise ValueError\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\n lut = np.zeros(shape=num_lbls+1, dtype=int)\n\n ## COUNTING REGIONS METHODS\n # import time\n # hold_t = time.time()\n # for lbl in range(1, num_lbls + 1):\n # ids = tomo == lbl\n # feat_sz = len(ids)\n # tomo_out[ids] = feat_sz\n # # print('[1]:', lbl, 'of', num_lbls)\n # print time.time() - hold_t\n\n ## COUNTING PIXELS METHOD\n ## Count loop\n # cont, total = 0, np.prod(tomo.shape)\n # import time\n # hold_t = time.time()\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n lut[id] += 1\n # cont += 1\n # print('[1]:', cont, 'of', total)\n #\n ## Write loop\n # cont, total = 0, np.prod(tomo.shape)\n\n for x in range(tomo.shape[0]):\n for y in range(tomo.shape[1]):\n for z in range(tomo.shape[2]):\n id = tomo_lbl[x, y, z]\n if id > 0:\n tomo_out[x, y, z] = lut[id]\n # cont += 1\n # print('[1]:', cont, 'of', total)\n # print time.time() - hold_t\n\n return tomo_out","def create_grids(self):\n \n par = self.par\n\n # a. retirement\n \n # pre-decision states\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\n \n # post-decision states\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\n \n # b. working: state space (m,n,k) \n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\n\n par.Nn = par.Nm\n par.n_max = par.m_max + par.n_add\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\n\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\n\n # c. working: w interpolant (and wa and wb and wq)\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\n par.a_max = par.m_max + par.a_add\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\n \n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\n par.b_max = par.n_max + par.b_add\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\n \n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\n \n # d. working: egm (seperate grids for each segment)\n \n if par.solmethod == 'G2EGM':\n\n # i. dcon\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\n \n # ii. acon\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\n par.a_acon = np.zeros(par.grid_b_acon.shape)\n par.b_acon = par.grid_b_acon\n\n # iii. con\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\n \n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\n\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\n par.a_con = np.zeros(par.c_con.shape)\n par.d_con = np.zeros(par.c_con.shape)\n \n elif par.solmethod == 'NEGM':\n\n par.grid_l = par.grid_m\n\n # e. shocks\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\n\n if par.Neta > 1:\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\n else:\n par.eta = np.ones(1)\n par.w_eta = np.ones(1)\n\n # f. timings\n par.time_work = np.zeros(par.T)\n par.time_w = np.zeros(par.T)\n par.time_egm = np.zeros(par.T)\n par.time_vfi = np.zeros(par.T)","def robotGridSummaryDict(self):\n rgd = self.robotGridDict(incRobotDict=False)\n robotDict = {}\n for rid, robot in self.robotDict.items():\n r = {}\n # print(\"rid\", robot.id, robot.alpha, robot.beta)\n r[\"id\"] = robot.id\n r[\"nDecollide\"] = robot.nDecollide\n r[\"lastStepNum\"] = robot.lastStepNum\n r[\"assignedTargetID\"] = robot.assignedTargetID\n r[\"hasApogee\"] = robot.hasApogee\n r[\"hasBoss\"] = robot.hasBoss\n r[\"xPos\"] = robot.xPos\n r[\"yPos\"] = robot.yPos\n r[\"alpha\"] = robot.alpha\n r[\"beta\"] = robot.beta\n r[\"destinationAlpha\"] = robot.destinationAlpha\n r[\"desstinationBeta\"] = robot.destinationBeta\n r[\"angStep\"] = robot.angStep\n r[\"collisionBuffer\"] = robot.collisionBuffer\n\n # convert from numpy arrays to lists\n r[\"metFiberPos\"] = list(robot.metFiberPos)\n r[\"bossFiberPos\"] = list(robot.bossFiberPos)\n r[\"apFiberPos\"] = list(robot.apFiberPos)\n r[\"roughAlphaX\"] = robot.roughAlphaX[-1][-1]\n r[\"roughAlphaY\"] = robot.roughAlphaY[-1][-1]\n r[\"roughBetaX\"] = robot.roughBetaX[-1][-1]\n r[\"roughBetaY\"] = robot.roughBetaY[-1][-1]\n # find the step at which this\n # guy found its target\n # otv = np.array(robot.onTargetVec)\n # print(\"otargvec\", otv)\n # r[\"onTargetVec\"] = robot.onTargetVec[-1]\n # # find last False (after which must be true)\n # # +1 because step numbers start from 1 and indices start from 0\n # whereFalse = np.argwhere(otv==False).flatten()\n # if not whereFalse:\n # # empty list started on target? thats crazy\n # lastFalse = 0\n # else:\n # lastFalse = int(whereFalse[-1] + 1)\n # if lastFalse == len(otv):\n # # last step was false robot never got there\n # r[\"stepConverged\"] = str(-1 )# -1 incicates never got to target\n # else:\n # r[\"stepConverged\"] = str(lastFalse)\n robotDict[robot.id] = r\n\n rgd[\"robotDict\"] = robotDict\n return rgd"],"string":"[\n \"def gen_obs_grid(self):\\n\\n topX, topY, botX, botY = self.get_view_exts()\\n\\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\\n\\n # for i in range(self.agent_dir + 1):\\n # grid = grid.rotate_left()\\n\\n # Process occluders and visibility\\n # Note that this incurs some performance cost\\n if not self.see_through_walls:\\n vis_mask = grid.process_vis(agent_pos=(self.agent_view_size // 2,\\n self.agent_view_size // 2))\\n else:\\n vis_mask = np.ones(shape=(grid.width, grid.height), dtype=np.bool)\\n\\n # Make it so the agent sees what it's carrying\\n # We do this by placing the carried object at the agent's position\\n # in the agent's partially observable view\\n agent_pos = grid.width // 2, grid.height // 2\\n if self.carrying:\\n grid.set(*agent_pos, self.carrying)\\n else:\\n grid.set(*agent_pos, None)\\n\\n return grid, vis_mask\",\n \"def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\\n\\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\\n \\n \\n for i in np.arange(0,SHP[0],1):\\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\\n \\n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\\n \\n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\\n\\n # normalise lateral flow so that -ve= flow out of cells towards edges\\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\\n # fluxes if not normalised in this way.\\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\\n\\n # nabla is the inverted delta operator used to denote the divergence \\n # of a vector field, here applied to hydrological flow in m3/d \\n # calculated as dx/dt + dy/dt + dz/dt\\n\\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\\n \\n # divergence gives net in/outflow in m3/t\\n # cells/m3 = cells/mL *1000\\n\\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\\n\\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \\n\\n Cells[Cells<0] = 0\\n \\n CellColumnTot = Cells.sum(axis=1)\\n \\n\\n return Cells, CellColumnTot\",\n \"def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\\n\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n\\n #this is just printing stuff for easier terminal reading\\n if h_agent is not None:\\n hstr = \\\"Specialized Human\\\"\\n else:\\n hstr = \\\"Random Human\\\"\\n if coagent is not None:\\n coagenthelp = True\\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\\n else:\\n coagenthelp = False\\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\\n\\n liRewards = []\\n liRewardsPenalized = []\\n actionsctli =[]\\n heatmap = np.zeros((7, 7))\\n for i in range(episodes):\\n grid.reset()\\n actionct = 0\\n misstepct = 0\\n heatmap[0,0] += 1\\n while (not grid.isEnd) and (grid.numSteps <=200):\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n state_ind = state[1]*(width+1)+state[0]\\n\\n if 'disjoint' in mode:\\n actions = [0, 1, 2, 3]\\n else:\\n #'up','right','down','left','upri','dori','dole','uple'\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n #if we have a special human agent use it, if not use random human\\n if h_agent is None:\\n action = np.random.choice(actions, 1)[0]\\n h_action = action\\n else:\\n action = h_agent.get_action(state_ind)\\n h_action = action\\n if coagenthelp:\\n q_vals = coagent.get_q_values(state_ind)\\n best_action = coagent.get_action(state_ind)\\n best_q = q_vals[best_action]\\n min_q = min(q_vals)\\n human_q = q_vals[action]\\n\\n #closest actions dictionary\\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\\n #value = action index if radial\\n #key = actual action index\\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\\n #actions in order of circle\\n a_radial = [0,4,1,5,2,6,3,7]\\n #co-pilot action choices\\n #override to optimal if suboptimal action selected\\n if \\\"override\\\" in mode:\\n #random percent to decide when to help if wrong action taken\\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\\n actionct += 1\\n action = best_action\\n #select best closest action if human action q-value is negative\\n elif mode == \\\"q-neg\\\" and human_q < 0:\\n actionct += 1\\n a_li = closest_a[action]\\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\\n #Shared Autonomy\\n #select better closest action if difference between best q and human q is past some threshold\\n elif mode == \\\"q-diff\\\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\\n actionct += 1\\n for i in range(1,5):\\n radial_a = a_dist_ind[action]\\n ccw_ra = (radial_a - i) % len(actions)\\n ccw_a = a_radial[ccw_ra]\\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = ccw_a\\n break\\n cw_ra = (radial_a + i) % len(actions)\\n cw_a = a_radial[cw_ra]\\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = cw_a\\n break\\n #take the potentiallny new action\\n grid.step(action)\\n\\n if h_agent is not None:\\n heatmap[grid.state[1],grid.state[0]] += 1\\n\\n #add metrics to their respective lists\\n liRewards.append(grid.reward)\\n liRewardsPenalized.append(grid.reward-actionct)\\n actionsctli.append(actionct)\\n #convert lists to numpy arrays\\n rewards = np.array(liRewards)\\n rewards_penalized = np.array(liRewardsPenalized)\\n actionsctli = np.array(actionsctli)\\n #print some metrics if we want to\\n if verbose:\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\\n if h_agent is not None:\\n plt.figure()\\n print(heatmap)\\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\\n plt.savefig('two.png')\\n\\n return rewards, actionsctli, rewards_penalized\",\n \"def occam_razor() -> None:\\r\\n print(\\\"WARNING! Mode three activated. Time to complete may be several minutes\\\")\\r\\n temp = [] # x-y-conflicts\\r\\n global example\\r\\n backup = example.copy() # Backup so it can backtrack through solutions\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n conflict_counter = 0\\r\\n for z in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n if conflict_space[x, y] == conflict_space[x, z] and z != y:\\r\\n conflict_counter += 1\\r\\n if conflict_space[x, y] == conflict_space[z, y] and z != x:\\r\\n conflict_counter += 1\\r\\n if conflict_counter > 0 and no_neighbour(x, y):\\r\\n temp.append([x, y, conflict_counter])\\r\\n threshold = [0, 0, 0]\\r\\n \\\"\\\"\\\"Takes an educated guess on the node in most conflict in case it's one move away from being solved\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n if temp[x][2] > threshold[2]:\\r\\n threshold = temp[x]\\r\\n if threshold[2] > 0:\\r\\n example[threshold[0], threshold[1]] = 0\\r\\n shade_neighbours(threshold[0], threshold[1])\\r\\n if not victory_checker():\\r\\n \\\"\\\"\\\"code now begins guessing\\\"\\\"\\\"\\r\\n for x in range(len(temp)):\\r\\n example = backup.copy()\\r\\n if no_neighbour(temp[x][0], temp[x][1]):\\r\\n example[temp[x][0], temp[x][1]] = 0\\r\\n else:\\r\\n continue\\r\\n progress_handler(False, True)\\r\\n while progress_handler(True, False):\\r\\n print_debug(\\\"itteration\\\")\\r\\n progress_handler(False, False)\\r\\n mark_check()\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n if not progress_handler(True, False):\\r\\n special_corner()\\r\\n if not progress_handler(True, False):\\r\\n separation_crawler(True)\\r\\n if not progress_handler(True, False):\\r\\n occam_razor() # Recursive\\r\\n if not progress_handler(True, False):\\r\\n if victory_checker():\\r\\n completion(True)\\r\\n else:\\r\\n print(\\\"Searching...\\\")\\r\\n continue\\r\\n conflict_check()\",\n \"def increased_obstacles_map(occupancy_grid):\\n\\n nb_rows = len(occupancy_grid)\\n nb_cols = len(occupancy_grid[0])\\n increased_occupancy_grid = np.zeros([nb_rows + 6, nb_cols + 6])\\n\\n for i in range(nb_rows):\\n for j in range(nb_cols):\\n\\n if occupancy_grid[i, j] == OCCUPIED:\\n increased_occupancy_grid[i:i + 7, j:j + 7] = np.ones([7, 7])\\n\\n final_occupancy_grid = increased_occupancy_grid[3:(LENGTH_case + 3), 3:(WIDTH_case + 3)]\\n return final_occupancy_grid\",\n \"def rectangulization(nL, indices, indices_agg, ML_iot_0, ML_iot_coeff_0, agg_level, rect_level):\\r\\n \\r\\n nI_agg = len(list(set(indices['ind'][agg_level])))\\r\\n nP_agg = len(list(set(indices['prod'][agg_level])))\\r\\n nW_agg = len(list(set(indices['vadd'][agg_level])))\\r\\n nM_agg = len(list(set(indices['imp'][agg_level])))\\r\\n nY_agg = len(list(set(indices['fd'][agg_level])))\\r\\n nR_agg = len(list(set(indices['exog'][agg_level])))\\r\\n\\r\\n nI_rcot = len(list(set(indices['ind'][rect_level])))\\r\\n nP_rcot = len(list(set(indices['prod'][rect_level])))\\r\\n nW_rcot = len(list(set(indices['vadd'][rect_level])))\\r\\n nM_rcot = len(list(set(indices['imp'][rect_level])))\\r\\n nY_rcot = len(list(set(indices['fd'][rect_level])))\\r\\n nR_rcot = len(list(set(indices['exog'][rect_level])))\\r\\n\\r\\n \\r\\n ZR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n WR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n MR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n YR_0 = np.zeros((nL,nP_rcot+nI_agg,nY_agg)) # Initialising an empty multi-layer final demand matrices\\r\\n RR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n AR_0 = np.zeros((nL,nP_rcot+nI_agg,nP_agg+nI_agg)) # Initialising an empty multi-layer endogenous transactions matrices\\r\\n wR_0 = np.zeros((nL,nW_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer value added matrices\\r\\n mR_0 = np.zeros((nL,nM_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer imports matrices\\r\\n BR_0 = np.zeros((nL,nR_rcot,nP_agg+nI_agg)) # Initialising an empty multi-layer exogenous transactions matrices\\r\\n\\r\\n \\r\\n indInd = indices_agg['ind']\\r\\n prodInd = indices_agg['prod']\\r\\n vaddInd = indices_agg['vadd']\\r\\n impInd = indices_agg['imp']\\r\\n fdInd = indices_agg['fd']\\r\\n exogInd = indices_agg['exog']\\r\\n\\r\\n zInd = prodInd.append(indInd)\\r\\n zInd = zInd.swaplevel(0,1)\\r\\n \\r\\n\\r\\n for l in range(nL):\\r\\n Z = pd.DataFrame(ML_iot_0['Z'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n W = pd.DataFrame(ML_iot_0['W'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n M = pd.DataFrame(ML_iot_0['M'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n Y = pd.DataFrame(ML_iot_0['Y'][l,:,:], index=zInd, columns=fdInd).groupby(level=rect_level,axis=0).sum().groupby(level=rect_level,axis=1).sum()\\r\\n\\r\\n A = pd.DataFrame(ML_iot_coeff_0['A'][l,:,:], index=zInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n w = pd.DataFrame(ML_iot_coeff_0['w'][l,:,:], index=vaddInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n m = pd.DataFrame(ML_iot_coeff_0['m'][l,:,:], index=impInd, columns=zInd).groupby(level=agg_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n ZR_0[l] = Z.values\\r\\n WR_0[l] = W.values\\r\\n MR_0[l] = M.values\\r\\n YR_0[l] = Y.values\\r\\n \\r\\n AR_0[l] = A.values\\r\\n wR_0[l] = w.values\\r\\n mR_0[l] = m.values\\r\\n\\r\\n \\r\\n RR_0 = pd.DataFrame(ML_iot_0['R'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n BR_0 = pd.DataFrame(ML_iot_coeff_0['B'], index=exogInd, columns=zInd).groupby(level=rect_level,axis=0).sum().groupby(level=agg_level,axis=1).sum()\\r\\n \\r\\n\\r\\n ML_RCOT_0 = {\\r\\n 'Z' : ZR_0,\\r\\n 'W' : WR_0,\\r\\n 'M' : MR_0,\\r\\n 'Y' : YR_0,\\r\\n 'R' : RR_0,\\r\\n }\\r\\n\\r\\n ML_RCOT_coeff_0 = {\\r\\n 'A' : AR_0,\\r\\n 'w' : wR_0,\\r\\n 'm' : mR_0,\\r\\n 'Y' : YR_0,\\r\\n 'B' : BR_0,\\r\\n }\\r\\n\\r\\n \\r\\n indices_RCOT = {\\r\\n 'prod/ind' : zInd,\\r\\n 'vadd' : vaddInd,\\r\\n 'imp' : impInd,\\r\\n 'fd' : fdInd,\\r\\n 'exog' : exogInd,\\r\\n 'headers' : indices['headers']\\r\\n }\\r\\n \\r\\n \\r\\n return(ML_RCOT_0, ML_RCOT_coeff_0, indices_RCOT)\",\n \"def build_occupancy_map(human : Human, other_agents : np.array, cell_num : int, cell_size : float, om_channel_size : int) -> np.array:\\n other_px = other_agents[:, 0] - human.px\\n other_py = other_agents[:, 1] - human.py\\n\\n # new x-axis is in the direction of human's velocity\\n human_velocity_angle = np.arctan2(human.vy, human.vx)\\n other_human_orientation = np.arctan2(other_py, other_px)\\n rotation = other_human_orientation - human_velocity_angle\\n distance = np.linalg.norm([other_px, other_py], axis=0)\\n other_px = np.cos(rotation) * distance\\n other_py = np.sin(rotation) * distance\\n\\n # compute indices of humans in the grid\\n other_x_index = np.floor(other_px / cell_size + cell_num / 2)\\n other_y_index = np.floor(other_py / cell_size + cell_num / 2)\\n other_x_index[other_x_index < 0] = float('-inf')\\n other_x_index[other_x_index >= cell_num] = float('-inf')\\n other_y_index[other_y_index < 0] = float('-inf')\\n other_y_index[other_y_index >= cell_num] = float('-inf')\\n grid_indices = cell_num * other_y_index + other_x_index\\n occupancy_map = np.isin(range(cell_num ** 2), grid_indices)\\n if om_channel_size == 1:\\n return occupancy_map.astype(int)\\n else:\\n # calculate relative velocity for other agents\\n other_human_velocity_angles = np.arctan2(other_agents[:, 3], other_agents[:, 2])\\n rotation = other_human_velocity_angles - human_velocity_angle\\n speed = np.linalg.norm(other_agents[:, 2:4], axis=1)\\n other_vx = np.cos(rotation) * speed\\n other_vy = np.sin(rotation) * speed\\n dm = [list() for _ in range(cell_num ** 2 * om_channel_size)]\\n for i, index in np.ndenumerate(grid_indices):\\n if index in range(cell_num ** 2):\\n if om_channel_size == 2:\\n dm[2 * int(index)].append(other_vx[i])\\n dm[2 * int(index) + 1].append(other_vy[i])\\n elif om_channel_size == 3:\\n dm[int(index)].append(1)\\n dm[int(index) + cell_num ** 2].append(other_vx[i])\\n dm[int(index) + cell_num ** 2 * 2].append(other_vy[i])\\n else:\\n raise NotImplementedError\\n for i, cell in enumerate(dm):\\n dm[i] = sum(dm[i]) / len(dm[i]) if len(dm[i]) != 0 else 0\\n return dm\",\n \"def showNonOpponency(C,theta):\\n GI = retina.gauss_norm_img(x, y, dcoeff[i], dloc[i], imsize=imgsize,rgb=False)\\n # Sample using the other recepetive field, note there is no temporal response with still images\\n S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True)\\n #backproject the imagevectors\\n ncentreV,nsurrV = rgc.nonopponency(C,S,theta)\\n ninverse = retina.inverse(ncentreV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\\n ninv_crop = retina.crop(ninverse,x,y,dloc[i])\\n ninverse2 = retina.inverse(nsurrV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\\n ninv_crop2 = retina.crop(ninverse2,x,y,dloc[i])\\n # place descriptive text onto generated images\\n cv2.putText(ninv_crop,\\\"R+G + \\\",(xx,yy), font, 1,(255,255,255),2)\\n cv2.putText(ninv_crop2,\\\"R+G - \\\",(xx,yy), font, 1,(255,255,255),2)\\n merged = np.concatenate((ninv_crop, ninv_crop2),axis=1)\\n \\n # create cortical maps of the imagevectors\\n lposnon, rposnon = cortex.cort_img(ncentreV, L, L_loc, R, R_loc, cort_size, G)\\n lnegnon, rnegnon = cortex.cort_img(nsurrV, L, L_loc, R, R_loc, cort_size, G)\\n pos_cort_img = np.concatenate((np.rot90(lposnon),np.rot90(rposnon,k=3)),axis=1)\\n neg_cort_img = np.concatenate((np.rot90(lnegnon),np.rot90(rnegnon,k=3)),axis=1)\\n mergecort = np.concatenate((pos_cort_img,neg_cort_img),axis=1)\\n return merged, mergecort\",\n \"def _get_observations(self):\\n food = np.array(self.game.state.data.food.data)\\n walls = np.array(self.game.state.data.layout.walls.data)\\n map_shape = walls.shape\\n capsules = self.game.state.data.capsules\\n pacman_pos = self.game.state.data.agentStates[0].configuration.pos\\n\\n gosts_pos = list(map(lambda agent: agent.configuration.pos,\\n self.game.state.data.agentStates[1:]))\\n gosts_scared = list(\\n map(lambda agent: agent.scaredTimer > 0, self.game.state.data.agentStates[1:]))\\n\\n \\\"\\\"\\\"\\n 0: empty,\\n 1: wall,\\n 2: food,\\n 3: capsules,\\n 4: ghost,\\n 5: scared ghost,\\n 6: pacman\\n \\\"\\\"\\\"\\n\\n view_slices = ((max(pacman_pos[0]-self.view_distance[0], 0), min(pacman_pos[0]+self.view_distance[0]+1, map_shape[0])),\\n (max(pacman_pos[1]-self.view_distance[1], 0), min(pacman_pos[1]+self.view_distance[1]+1, map_shape[1])))\\n\\n def select(l):\\n return l[view_slices[0][0]:view_slices[0][1], view_slices[1][0]:view_slices[1][1]]\\n\\n obs = np.vectorize(lambda v: 1 if v else 0)(select(walls))\\n obs = obs + np.vectorize(lambda v: 2 if v else 0)(select(food))\\n\\n def pos_to_relative_pos(pos):\\n if (pos[0] < view_slices[0][0] or view_slices[0][1] <= pos[0]\\n or pos[1] < view_slices[1][0] or view_slices[1][1] <= pos[1]):\\n return None\\n else:\\n return pos[0]-view_slices[0][0], pos[1]-view_slices[1][0]\\n\\n for c_relative_pos in filter(lambda x: x is not None, map(pos_to_relative_pos, capsules)):\\n obs[c_relative_pos[0], c_relative_pos[1]] = 3\\n\\n for i, g_relative_pos in enumerate(map(pos_to_relative_pos, gosts_pos)):\\n if (g_relative_pos is not None):\\n obs[int(g_relative_pos[0]), int(g_relative_pos[1])\\n ] = 5 if gosts_scared[i] else 4\\n\\n pacman_relative_pos = pos_to_relative_pos(pacman_pos)\\n\\n obs[pacman_relative_pos[0], pacman_relative_pos[1]] = 6\\n\\n obs[0, 0] = 2 if np.any(\\n food[0:pacman_pos[0]+1, 0:pacman_pos[1]+1]) else 0\\n obs[obs.shape[0]-1,\\n 0] = 2 if np.any(food[pacman_pos[0]:map_shape[0], 0:pacman_pos[1]+1])else 0\\n\\n obs[0, obs.shape[1] -\\n 1] = 2 if np.any(food[0:pacman_pos[0]+1, pacman_pos[1]:map_shape[0]]) else 0\\n obs[obs.shape[0]-1, obs.shape[1]-1] = 2 if np.any(\\n food[pacman_pos[0]:map_shape[0], pacman_pos[1]:map_shape[0]]) else 0\\n\\n # print(np.transpose(obs)[::-1, :])\\n\\n return obs\",\n \"def generate_grains(self, cells):\\n\\t\\tfor cell_num in range(cells):\\n\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\twhile sample_cell.state != 0:\\n\\t\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\tsample_cell.change_state(self.init_time ,cell_num)\",\n \"def reduce_possibilities_by_box(self):\\n x = self.targetCell.x\\n y = self.targetCell.y\\n if x < 3 and y < 3: #top left\\n self.check_box1()\\n if x > 2 and x < 6 and y < 3: #middle left\\n self.check_box2()\\n if x > 5 and y < 3: #bottom left\\n self.check_box3()\\n if x < 3 and y > 2 and y < 6: #top middle\\n self.check_box4()\\n if x > 2 and x < 6 and y > 2 and y < 6: #center\\n self.check_box5()\\n if x > 5 and y > 2 and y < 6: #bottom middle\\n self.check_box6()\\n if x < 3 and y > 5: #top right\\n self.check_box7()\\n if x > 2 and x < 6 and y > 5: #middle right\\n self.check_box8()\\n if x > 5 and y > 5: #bottom right\\n self.check_box9()\\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)\",\n \"def make_move(grid, n_columns, n_rows):\\r\\n # Generate the game grid to be manipulated\\r\\n new_grid = [[0] * (n_columns + 1) for i in range(n_rows + 1)]\\r\\n\\r\\n\\r\\n for i in range(n_rows):\\r\\n for j in range(n_columns):\\r\\n upper_left = grid[i-1][j-1] # neighbor to upper left of cell of interest\\r\\n upper = grid[i-1][j] # neighbor above cell of interest\\r\\n upper_right = grid[i-1][j+1] # neighbor to upper right of cell of interest\\r\\n left = grid[i][j-1] # neighbor to left of cell of interest\\r\\n right = grid[i][j+1] # neighbor to right of cell of interest\\r\\n bot_left = grid[i+1][j-1] # neighbor to bottom left cell of interest\\r\\n bot = grid[i+1][j] # neighbor below cell of interest\\r\\n bot_right = grid[i+1][j+1] # neighbor to bottom right of cell of interest\\r\\n\\r\\n # sum of the state of all neighbors\\r\\n on_neighbors = upper_left + upper + upper_right + left + right + bot_left + bot + bot_right\\r\\n\\r\\n # Any ON cell with fewer than two ON neighbors turns OFF\\r\\n if grid[i][j] == 1 and on_neighbors < 2:\\r\\n new_grid[i][j] = 0\\r\\n\\r\\n # Any ON cell with two or three ON neighbours stays ON\\r\\n elif grid[i][j] == 1 and (on_neighbors == 2 or on_neighbors == 3):\\r\\n new_grid[i][j] = 1\\r\\n\\r\\n # Any ON cell with more than three ON neighbors turns OFF\\r\\n elif grid[i][j] == 1 and on_neighbors > 3:\\r\\n new_grid[i][j] = 0\\r\\n\\r\\n # Any OFF cell with three ON neighbors turns ON\\r\\n elif grid[i][j] == 0 and on_neighbors == 3:\\r\\n new_grid[i][j] = 1\\r\\n\\r\\n return new_grid #manipulated game grid\\r\",\n \"def get_grasp_vis(predictions,\\n color_heightmap,\\n action_rot,\\n action_position,\\n num_rotations=16):\\n canvas = None\\n for canvas_row in range(4):\\n tmp_row_canvas = None\\n for canvas_col in range(int(num_rotations / 4)):\\n rotate_idx = int(canvas_row * num_rotations / 4 + canvas_col)\\n prediction = predictions[rotate_idx, :, :].copy()\\n if rotate_idx == action_rot:\\n position = action_position\\n else:\\n position = None\\n prediction_vis = get_workspace_vis(prediction,\\n color_heightmap,\\n action_position=position)\\n if tmp_row_canvas is None:\\n tmp_row_canvas = prediction_vis\\n else:\\n tmp_row_canvas = np.concatenate((tmp_row_canvas,prediction_vis), axis=1)\\n if canvas is None:\\n canvas = tmp_row_canvas\\n else:\\n canvas = np.concatenate((canvas,tmp_row_canvas), axis=0)\\n return canvas\",\n \"def run_pass_2():\\n global live_cells\\n global cell_count\\n global attempts\\n global cell_age\\n \\n print(\\\"Live Cells : \\\" + str(len(live_cells)))\\n \\n live_cell_scores = [get_cart_score(c) for c in live_cells]\\n live_cells_sorted = [x for _,x in sorted(zip(live_cell_scores,live_cells))]\\n del live_cells[:]\\n live_cells = live_cells + live_cells_sorted\\n \\n cell = live_cells.pop(0)\\n if check_cart(c) and check_dead(c):\\n voxel_data[cart_to_loc(cell)] = 1\\n \\n cell_age[cart_to_loc(c)] = cell_count\\n \\n \\n cell_count += 1\\n \\n neighbors = [get_cart_neighbor(c,i) for i in range(6)]\\n \\n for n in neighbors:\\n if check_cart(n) and check_dead(c) and not n in live_cells:\\n live_cells.append(n)\",\n \"def examineMaze(self, gameState):\\n w = self.walls.width\\n h = self.walls.height\\n walls = self.walls.deepCopy()\\n food1 = self.getFoodYouAreDefending(gameState)\\n food2 = self.getFood(gameState)\\n\\n # Save map as 0, 1, 2 and 3 (0:walls, 1:spaces, 2:babies, 3:food)\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y]:\\n walls[x][y] = 0\\n elif food1[x][y]:\\n walls[x][y] = 2\\n elif food2[x][y]:\\n walls[x][y] = 2\\n else:\\n walls[x][y] = 1\\n\\n roomsDisplay = []\\n # Detect doors and spaces. Spaces are now negative\\n for x in range(w):\\n for y in range(h):\\n if walls[x][y] > 0:\\n exitsNum = 0\\n if walls[x][y - 1] != 0:\\n exitsNum += 1\\n if walls[x][y + 1] != 0:\\n exitsNum += 1\\n if walls[x - 1][y] != 0:\\n exitsNum += 1\\n if walls[x + 1][y] != 0:\\n exitsNum += 1\\n if exitsNum == 1 or exitsNum == 2:\\n walls[x][y] = -1 * walls[x][y]\\n roomsDisplay.append((x, y))\\n elif exitsNum == 0:\\n # We erase unaccessible cells\\n walls[x][y] = 0\\n else:\\n # These are doors or big rooms, we leave them positive\\n pass\\n\\n # Create roomsGraph: every room has a number, some cells and some doors\\n roomsGraph = []\\n doorsGraph = []\\n for x in range(1, w - 1):\\n for y in range(1, h - 1):\\n if walls[x][y] < 0:\\n spacesNum = 0\\n if walls[x][y - 1] < 0:\\n spacesNum += 1\\n if walls[x][y + 1] < 0:\\n spacesNum += 1\\n if walls[x - 1][y] < 0:\\n spacesNum += 1\\n if walls[x + 1][y] < 0:\\n spacesNum += 1\\n if spacesNum < 2:\\n endOfPath = False\\n graphNode = {\\\"path\\\": [], \\\"doors\\\": [], \\\"food\\\": 0, \\\"isBig\\\": False}\\n auxx = x\\n auxy = y\\n while not endOfPath:\\n graphNode[\\\"path\\\"].append((x, y))\\n graphNode[\\\"food\\\"] += -walls[x][y] - 1\\n walls[x][y] = 0\\n xx = x\\n yy = y\\n if walls[x][y - 1] < 0:\\n yy = y - 1\\n elif walls[x][y + 1] < 0:\\n yy = y + 1\\n elif walls[x - 1][y] < 0:\\n xx = x - 1\\n elif walls[x + 1][y] < 0:\\n xx = x + 1\\n else:\\n endOfPath = True\\n if walls[x][y - 1] > 0:\\n if [(x, y - 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y - 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y - 1), []]))\\n if walls[x][y + 1] > 0:\\n if [(x, y + 1), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x, y + 1), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x, y + 1), []]))\\n if walls[x - 1][y] > 0:\\n if [(x - 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x - 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x - 1, y), []]))\\n if walls[x + 1][y] > 0:\\n if [(x + 1, y), []] not in doorsGraph:\\n graphNode[\\\"doors\\\"].append(len(doorsGraph))\\n doorsGraph.append([(x + 1, y), []])\\n else:\\n graphNode[\\\"doors\\\"].append(doorsGraph.index([(x + 1, y), []]))\\n x = xx\\n y = yy\\n roomsGraph.append(graphNode)\\n x = auxx\\n y = auxy\\n\\n # Create doorsGraph: every door has a number, and goes to other rooms or other doors\\n for j, door in enumerate(doorsGraph):\\n for i, room in enumerate(roomsGraph):\\n for aDoor in room[\\\"doors\\\"]:\\n if aDoor == j:\\n doorsGraph[j][1] = doorsGraph[j][1] + [i]\\n (x, y) = doorsGraph[j][0]\\n adjacentCells = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]\\n adjacentDoors = []\\n # Check adjacent doors and add them to the current door (door structure is [pos, adjRooms, adjDoors]\\n for p in adjacentCells:\\n # Skip if wall\\n if self.walls[p[0]][p[1]]:\\n continue\\n # Skip if door\\n isRoom = False\\n for room in doorsGraph[j][1]:\\n if p in roomsGraph[room][\\\"path\\\"]:\\n isRoom = True\\n break\\n if not isRoom:\\n # Add if existing door\\n doorFound = False\\n for i, neighborDoor in enumerate(doorsGraph):\\n if neighborDoor[0] == p:\\n adjacentDoors.append(i)\\n doorFound = True\\n break\\n # Create if non existing door and add\\n if not doorFound:\\n adjacentDoors.append(len(doorsGraph))\\n doorsGraph.append([p, []])\\n doorsGraph[j].append(adjacentDoors)\\n\\n # Create doorsDistance: maps what doors can be accessed from other doors\\n roomsMapper = {}\\n doorsMapper = {}\\n isRoom = util.Counter()\\n for i, door in enumerate(doorsGraph):\\n doorsMapper[door[0]] = i\\n isRoom[door[0]] = 0\\n for i, room in enumerate(roomsGraph):\\n for p in room[\\\"path\\\"]:\\n roomsMapper[p] = i\\n isRoom[p] = 1\\n\\n # Create self variables\\n self.doorsGraph = doorsGraph\\n self.roomsGraph = roomsGraph\\n self.roomsMapper = roomsMapper\\n self.doorsMapper = doorsMapper\\n self.isRoom = isRoom\\n\\n # # Find dead ends (rooms with only one door)\\n # deadRooms = {}\\n # deadDoors = {}\\n # # deaderDoors = {}\\n # # deaderRooms = {}\\n # for i, room in enumerate(roomsGraph):\\n # if len(room[\\\"doors\\\"]) == 1:\\n # deadRooms[i] = room[\\\"doors\\\"][0]\\n # deadDoors[room[\\\"doors\\\"][0]] = 1\\n # numdR = 0\\n # aliveR = -1\\n # for adjRoom in doorsGraph[room[\\\"doors\\\"][0]][1]:\\n # if adjRoom not in deadRooms:\\n # numdR += 1\\n # aliveR = adjRoom\\n # if numdR + len(doorsGraph[room[\\\"doors\\\"][0]][2]) == 1:\\n # if aliveR >= 0:\\n # deaderRooms[aliveR] = room[\\\"doors\\\"][0]\\n # for adjDoor in roomsGraph[aliveR][\\\"doors\\\"]:\\n # if adjDoor == room[\\\"doors\\\"][0]:\\n # continue\\n # deaderDoors[adjDoor] = 1.0\\n # else:\\n # deaderDoors[doorsGraph[room[\\\"doors\\\"][0]][2][0]] = 1.0\\n\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deaderRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deaderDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, room in enumerate(roomsGraph):\\n # numAliveDoors = 0\\n # aliveDoor = 0\\n # deadDoor = []\\n # for door in room[\\\"doors\\\"]:\\n # if door not in deadDoors:\\n # numAliveDoors += 1\\n # aliveDoor = door\\n # else:\\n # deadDoor.append(door)\\n # if numAliveDoors == 1:\\n # aliveRoom = 0\\n # aliveNeighborDoor = 0\\n # for door in deadDoor:\\n # # aliveNeighborDoor += len(doorsGraph[door][2])\\n # for neighborRoom in doorsGraph[door][1]:\\n # if neighborRoom not in deadRooms:\\n # aliveRoom += 1\\n # if aliveRoom == len(deadDoor):\\n # deadRooms[i] = aliveDoor\\n # deadDoors[aliveDoor] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][doorsGraph[aliveDoor][0]] = 1\\n # for p in room[\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # for p in deadDoor:\\n # roomsCounter[2][doorsGraph[p][0]] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n\\n # Find dead ends (rooms with doors that only go to other dead ends, except one)\\n # Danger, it is theoretically possible to have a map only with dead ends, which may make this crash\\n # deadEndsChanged = True\\n # while deadEndsChanged:\\n # deadEndsChanged = False\\n # for i, door in enumerate(doorsGraph):\\n # if i not in deadDoors:\\n # numOpenRooms = 0\\n # openRoom = 0\\n # for j, room in enumerate(door[1]):\\n # if room not in deadRooms:\\n # numOpenRooms += 1\\n # openRoom = j\\n # if numOpenRooms + len(door[2]) == 1:\\n # for room in door[1]:\\n # if room != openRoom:\\n # deadRooms[room] = i\\n # deadDoors[j] = 1\\n # deadEndsChanged = True\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[0][door[0]] = 1\\n # for rr in door[1]:\\n # print rr\\n # if rr in deadRooms:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[1][p] = 1\\n # else:\\n # for p in roomsGraph[rr][\\\"path\\\"]:\\n # roomsCounter[3][p] = 1\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # print deadDoors\\n # print\\n # print deadRooms\\n # print \\\"-----------------\\\"\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # roomsCounter[1][(6, 9)] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n # for r in deadRooms:\\n # for p in roomsGraph[r][\\\"path\\\"]:\\n # roomsCounter[0][p] = 0.4\\n # for d in deadDoors:\\n # roomsCounter[1][doorsGraph[d][0]] = 0.4\\n # self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\\n\\n # Show every room\\n roomsCounter = [util.Counter(), util.Counter(), util.Counter(), util.Counter()]\\n for room in roomsGraph:\\n for p in room[\\\"path\\\"]:\\n if len(room[\\\"doors\\\"]) > 1:\\n roomsCounter[0][p] = 0.4\\n else:\\n roomsCounter[2][p] = 0.4\\n # Show every door\\n for door in doorsGraph:\\n roomsCounter[1][door[0]] = 0.4\\n # Display rooms and doors (red: rooms with at least one exit; orange: rooms with 1 exit; blue: doors\\n self.displayDistributionsOverPositions(roomsCounter)\\n # raw_input(\\\"Press Enter to continue ...\\\")\",\n \"def __checkvictory__(self,playerchar):\\n\\t\\tvictory = False\\n\\t\\tboardx = deepcopy(self.board)\\n\\t\\trow = 5\\n\\t\\tcolumn = 6\\n\\t\\tstarburst_bag = []\\n\\t\\tcats_game = True\\n\\t\\tfor a in range(row+1):\\n\\t\\t\\tfor b in range(column+1):\\n\\t\\t\\t\\tstarburst = []\\n\\t\\t\\t\\tstarburst.append((a,b))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif self.__checkplace__(a,b) is True:\\n\\t\\t\\t\\t\\tcats_game = False\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.__checkplace__(a,b) == playerchar:\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a-starburst[1] < 0:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a-starburst[1],b) == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[1] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a-starburst[2] < 0:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif b+starburst[2] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a-starburst[2],b+starburst[2])\\\\\\n\\t\\t\\t\\t\\t\\t == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[2] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif b+starburst[3] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a,b+starburst[3]) == playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[3] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst.append(1)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\t\\tif a+starburst[4] > 5:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif b+starburst[4] > 6:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\tif self.__checkplace__(a+starburst[4],b+starburst[4])\\\\\\n\\t\\t\\t\\t\\t\\t== playerchar:\\n\\t\\t\\t\\t\\t\\t\\tstarburst[4] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstarburst_bag.append(starburst)\\n\\t\\t\\n\\t\\tfor starburst in starburst_bag:\\n\\t\\t\\t\\n\\t\\t\\ta = starburst[0][0]\\n\\t\\t\\tb = starburst[0][1]\\n\\t\\t\\t\\n\\t\\t\\tif starburst[1] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[1]):\\n\\t\\t\\t\\t\\tboardx[a-i][b] = boardx[a-i][b].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[2] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[2]):\\n\\t\\t\\t\\t\\tboardx[a-i][b+i] = boardx[a-i][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[3] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[3]):\\n\\t\\t\\t\\t\\tboardx[a][b+i] = boardx[a][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\tif starburst[4] > 3:\\n\\t\\t\\t\\tvictory = True\\n\\t\\t\\t\\tfor i in range(starburst[4]):\\n\\t\\t\\t\\t\\tboardx[a+i][b+i] = boardx[a+i][b+i].\\\\\\n\\t\\t\\t\\t\\treplace(playerchar,playerchar.upper())\\n\\t\\t\\t\\n\\t\\tif cats_game:\\n\\t\\t\\treturn None\\n\\t\\tif victory:\\n\\t\\t\\treturn boardx\\n\\t\\telse:\\n\\t\\t\\treturn False\",\n \"def build_grains(self):\\n\\t\\ttime = datetime.datetime.now()\\n\\t\\tif self.probability == 0:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\t\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\telse:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,5, time):\\n\\t\\t\\t\\t\\t\\tneighbours = self.get_nearest_neighbours(cell)\\n\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_further_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\t\\t\\t\\trandom_number = random.random() * 100\\n\\t\\t\\t\\t\\t\\t\\t\\tif random_number <= self.probability:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def main_loop(self):\\n for iteration in xrange(1, self.num_iterations + 1):\\n print \\\"At iteration %d\\\" % iteration\\n self.it_num = iteration\\n \\n ### Select cells randomly without replacement\\n x, y = np.meshgrid(np.arange(self.x_len), np.arange(self.y_len))\\n \\n x = x.flat\\n y = y.flat\\n \\n shuffled_indices = np.random.permutation(np.arange(self.x_len * self.y_len))\\n \\n for index in shuffled_indices:\\n # Get the current y and x indices\\n cur_y, cur_x = y[index], x[index]\\n \\n \\n if self.altered == False:\\n # Use the standard version\\n if self.grid[cur_y, cur_x] == 0:\\n # If there's no slab there then we can't erode it!\\n continue\\n else:\\n # Use the altered version of checking if we can erde\\n if self.grid[cur_y, cur_x] == self.depth[cur_y, cur_x]:\\n # We can't erode it, so continue\\n continue\\n \\n # Check to see if the cell is in shadow.\\n if self.cell_in_shadow(cur_y, cur_x):\\n # If it's in shadow then we can't erode it, so go to the next random cell \\n continue\\n \\n if True:\\n # Move a slab\\n self.grid[cur_y, cur_x] -= 1\\n \\n orig_y, orig_x = cur_y, cur_x\\n \\n # Loop forever - until we break out of it\\n while True:\\n new_y, new_x = cur_y, self.add_x(cur_x, self.jump_length)\\n \\n if self.grid[new_y, new_x] == 0:\\n prob = self.pd_ns\\n else:\\n prob = self.pd_s\\n \\n if np.random.random_sample() <= prob:\\n # Drop cell\\n break\\n else:\\n cur_y, cur_x = new_y, new_x\\n \\n #print \\\"Dropping on cell\\\"\\n #print new_y, new_x\\n # Drop the slab on the cell we've got to\\n self.grid[new_y, new_x] += 1\\n \\n self.do_repose(orig_y, orig_x)\\n \\n self.do_repose(new_y, new_x)\\n \\n self.write_file()\",\n \"def build_occupancy_map_torch(human: torch.Tensor, other_agents: torch.Tensor, cell_num: int, cell_size: float,\\n om_channel_size: int) -> torch.Tensor:\\n other_px = other_agents[:, 0] - human[0]\\n other_py = other_agents[:, 1] - human[1]\\n\\n # new x-axis is in the direction of human's velocity\\n human_velocity_angle = torch.atan2(human[1], human[0])\\n other_human_orientation = torch.atan2(other_py, other_px)\\n rotation = other_human_orientation - human_velocity_angle\\n distance = torch.norm(torch.cat([other_px.view(-1, 1), other_py.view(-1, 1)], axis=1), dim=1)\\n other_px = torch.cos(rotation) * distance\\n other_py = torch.sin(rotation) * distance\\n\\n # compute indices of humans in the grid\\n other_x_index = torch.floor(other_px / cell_size + cell_num / 2)\\n other_y_index = torch.floor(other_py / cell_size + cell_num / 2)\\n other_x_index[other_x_index < 0] = float('-inf')\\n other_x_index[other_x_index >= cell_num] = float('-inf')\\n other_y_index[other_y_index < 0] = float('-inf')\\n other_y_index[other_y_index >= cell_num] = float('-inf')\\n grid_indices = cell_num * other_y_index + other_x_index\\n\\n # calculate relative velocity for other agents\\n other_human_velocity_angles = torch.atan2(other_agents[:, 3], other_agents[:, 2])\\n rotation = other_human_velocity_angles - human_velocity_angle\\n speed = torch.norm(other_agents[:, 2:4],dim=1)\\n other_vx = torch.cos(rotation) * speed\\n other_vy = torch.sin(rotation) * speed\\n\\n # occupy map\\n dm = torch.zeros(3, cell_num ** 2)\\n for i, index in np.ndenumerate(grid_indices):\\n if index in range(cell_num ** 2):\\n dm[0, int(index)] += 1\\n dm[1, int(index)] += other_vx[i]\\n dm[2, int(index)] += other_vy[i]\\n\\n mask = dm[0, :] != 0\\n count = dm[0, mask]\\n dm[0:3, mask] /= count\\n\\n if om_channel_size == 1:\\n return dm[0, :].view(-1)\\n elif om_channel_size == 2:\\n return dm[1:3, :].view(-1)\\n else:\\n return dm.view(-1)\",\n \"def init(self, windowsize:tuple):\\r\\n y_count, x_count = 3, 0 #< Set the starting counter for the look_up_table. y starts with three because the first three lines are just Nones\\r\\n # Creating the constant maze \\r\\n maze_size = windowsize[0], windowsize[1] - 2 * self.grid_size\\r\\n self.maze = pg.Surface(maze_size) \\r\\n \\r\\n \\r\\n \\r\\n # Draw the outermost rectangles on self.maze\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0, 3 * self.grid_size), (28 * self.grid_size, 31 * self.grid_size)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((0 + self.grid_size // 2, 3 * self.grid_size + self.grid_size // 2),(27 * self.grid_size, 30 * self.grid_size)), 4) \\r\\n # Draw the inner rectangles\\r\\n for y in self.look_up_table[3 : -2]: #< y is a list of one row from the maze\\r\\n for x in y: #< x is a string that is decoded as already explained\\r\\n pos = [self.grid_size * x_count, self.grid_size * y_count]\\r\\n # Set reference position in the middle of one square\\r\\n pos[0] += self.grid_size // 2\\r\\n pos[1] += self.grid_size // 2\\r\\n x_count += 1\\r\\n # Check if x is rectangle\\r\\n if x != None and x[0] == 'r':\\r\\n # When the size of the string is equal or greater than 4 it's rectangle with a specific size and not just a border.\\r\\n if len(x) >= 4:\\r\\n # get the x and y size of the rectangle. x will be something like 'rx1_y1' x1 resprestens the size in x direction and y1 in y direction.\\r\\n xy_dim = x[1:].split(\\\"_\\\") \\r\\n xy_dim[0] = int(xy_dim[0])\\r\\n xy_dim[1] = int(xy_dim[1])\\r\\n rect = tuple(pos), (xy_dim[0] * self.grid_size , xy_dim[1] * self.grid_size )\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], rect, self.width)\\r\\n # If the last char is a w (white), u (up) or l (left) a line gets draw one a specific position \\r\\n if x[-1] == 'w':\\r\\n self.draw_line(self.maze, 'u', (x_count,y_count), True)\\r\\n if x[-1] == 'u' or x[-1] == 'l':\\r\\n if x_count == 0:\\r\\n self.draw_line(self.maze, x[-1], (len(y), y_count))\\r\\n else:\\r\\n self.draw_line(self.maze, x[-1], (x_count, y_count))\\r\\n \\r\\n y_count += 1\\r\\n x_count = 0\\r\\n # Just some cosmetic drawing\\r\\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((0, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLACK'], ((28 * self.grid_size - self.grid_size // 2 - 1, 12 * self.grid_size + self.grid_size // 2 + 4), (self.grid_size // 2 + 1, 10 * self.grid_size - 4)), 4)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 13 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((-self.width, 19 * self.grid_size), (5 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 13 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((23 * self.grid_size, 19 * self.grid_size), (5 * self.grid_size + 10, 3 * self.grid_size)), self.width)\\r\\n pg.draw.rect(self.maze, Colors.colors['BLUE'], ((11 * self.grid_size, 16 * self.grid_size), (6 * self.grid_size, 3 * self.grid_size)), self.width)\\r\\n \\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size // 2 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (0, 18 * self.grid_size + self.grid_size // 2), (self.grid_size // 2 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 16 * self.grid_size + self.grid_size // 2 - 1), (self.grid_size * 28 + self.width, 16 * self.grid_size + self.grid_size // 2 - 1), self.width)\\r\\n pg.draw.line(self.maze, Colors.colors['BLUE'], (self.grid_size * 28 - self.grid_size, 18 * self.grid_size + self.grid_size // 2), (self.grid_size * 28 + self.width, 18 * self.grid_size + self.grid_size // 2), self.width)\\r\\n self.is_init = True\",\n \"def __init__(self, \\n nd = 2, \\n goal = np.array([1.0,1.0]),\\n state_bound = [[0,1],[0,1]],\\n nA = 4,\\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\\n<<<<<<< HEAD:archive-code/puddleworld.py\\n ngrid = [10.0,10.0],\\n maxStep = 40):\\n ngrid = [40, 40]\\n x_vec = np.linspace(0,1,ngrid[0])\\n y_vec = np.linspace(0,1,ngrid[1])\\n for x in x_vec:\\n for y in y_vec:\\n if ~self.inPuddle([x,y]):\\n puddle.append([x,y])\\n # puddle is a closed loop \\n outpuddlepts = np.asarray(puddle)\\n \\\"\\\"\\\"\\n\\n\\n # Horizontal wing of puddle consists of \\n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\\n # (xchi,ychi) is the center points (h ==> horizantal)\\n # x, y = state[0], state[1]\\n xch1, ych1 = 0.3, 0.7\\n xch2, ych2 = 0.65, ych1\\n radius = 0.1\\n\\n\\n #Vertical wing of puddle consists of \\n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\\n # where (xcvi,ycvi) is the center points (v ==> vertical)\\n xcv1 = 0.45; ycv1=0.4;\\n xcv2 = xcv1; ycv2 = 0.8;\\n\\n # % 2) two half-circle at end edges of rectangle\\n \\n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n puddle.append([xcv1-radius,ych1-radius])\\n \\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n \\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n \\n puddle.append([xcv1-radius,ych1+radius])\\n\\n\\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n\\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1-radius,y])\\n \\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1+radius,y])\\n \\\"\\\"\\\"\\n for y in np.arrange():\\n puddle.append([])\\n \\n for y in np.arrange():\\n puddle.append([])\\n \\\"\\\"\\\"\\n\\n # HALF CIRCLES\\n ngridTheta = 10\\n thetaVec = np.linspace(0,pi,ngridTheta)\\n\\n for t in thetaVec:\\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\\n\\n \\n outpuddlepts = np.asarray(puddle)\\n return outpuddlepts\",\n \"def big_tiling():\\n t = Tiling(\\n obstructions=(\\n GriddedPerm(Perm((0,)), ((0, 1),)),\\n GriddedPerm(Perm((0,)), ((0, 2),)),\\n GriddedPerm(Perm((0,)), ((0, 3),)),\\n GriddedPerm(Perm((0,)), ((1, 2),)),\\n GriddedPerm(Perm((0,)), ((1, 3),)),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (0, 0))),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((0, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 0), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (1, 1))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((1, 1), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 0), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 1), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 0))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 1))),\\n GriddedPerm(Perm((1, 0)), ((2, 2), (2, 2))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 0))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 1))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 2))),\\n GriddedPerm(Perm((2, 1, 0)), ((2, 3), (2, 3), (2, 3))),\\n ),\\n requirements=(),\\n )\\n return t\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if rooms==[]: return\\n xcord=len(rooms)\\n ycord=len(rooms[0])\\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\\n gatenum=1\\n while indexstack != []:\\n newindex=[]\\n for item in indexstack:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=gatenum\\n newindex.append((xpoint,ypoint))\\n indexstack=newindex\\n gatenum+=1\\n ''''\\n for item in index_0:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=1\\n index_1.append((xpoint,ypoint))\\n for item in index_1:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=2\\n index_2.append((xpoint,ypoint))\\n for item in index_2:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=3\\n index_3.append((xpoint,ypoint))\\n for item in index_3:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=4\\n #index_3.append((xpoint,ypoint))'''\",\n \"def challenge2(self):\\n # Let's try an octree-type approach\\n # For each grid cube we should be able to find whether a nanobot:\\n # 1) is not in range (is outside grid cube and not in range of nearest face)\\n # 2) is in range of whole cube (all 8 corners are in range)\\n # 3) is in range of part of the cube (i.e. not 1 or 2)\\n # Root node: figure out extent of whole space\\n mins = []\\n maxs = []\\n for axis in range(3):\\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n\\n for count in range(len(self.nanobots), 0, -1):\\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\\n if results and results[0].count >= count:\\n break\\n\\n print(f\\\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\\\")\\n\\n # Find result coord closest to origin\\n closest_dist = np.iinfo(np.int32).max\\n best_coord = None\\n for result in results:\\n for corner in itertools.product(*zip(result.mins, result.maxs)):\\n d = manhattan_dist(corner, (0, 0, 0))\\n if d < closest_dist:\\n closest_dist = d\\n best_coord = corner\\n\\n print(f\\\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\\\")\",\n \"def gru_cell(self, Xt, h_t_minus_1):\\n # 1.update gate: decides how much past information is kept and how much new information is added.\\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\\n # 2.reset gate: controls how much the past state contributes to the candidate state.\\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\\n # candiate state h_t~\\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\\n # new state: a linear combine of pervious hidden state and the current new state h_t~\\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\\n return h_t\",\n \"def solve_puzzle(self):\\r\\n \\r\\n counter = 0\\r\\n rows = self._height-1\\r\\n cols = self._width-1\\r\\n # print rows, cols\\r\\n # print 'The greed has %s rows and %s coloumn indexes' %(rows, cols) \\r\\n solution_move = ''\\r\\n if self.get_number(0,0) == 0 and \\\\\\r\\n self.get_number(0,1) == 1:\\r\\n # print 'Congrads Puxxle is Aolved at start!!!!!'\\r\\n return ''\\r\\n #appropriate_number = (self._height * self._width) - 1\\r\\n appropriate_number = (rows+1) * (cols+1) -1\\r\\n # print 'First appropriate_number=',appropriate_number\\r\\n # print \\\"Grid first tile that we will solwing has value =\\\", self._grid[rows][cols]\\r\\n \\r\\n while counter < 300:\\r\\n counter +=1\\r\\n # print self\\r\\n #appropriate_number = (rows+1) * (cols+1) -1\\r\\n # print 'Appropriate number in loop=',appropriate_number\\r\\n # print 'We are solving %s index_row and %s index_col' %(rows, cols) \\r\\n ####Case when we use solve_interior_tile\\r\\n if rows > 1 and cols > 0:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n cols -= 1\\r\\n appropriate_number -=1\\r\\n else:\\r\\n # print 'We are solving interior tile', (rows, cols)\\r\\n solution_move += self.solve_interior_tile(rows, cols)\\r\\n # print 'Solution move=', solution_move\\r\\n cols -= 1\\r\\n #### Case when we use solve_col0_tile\\r\\n elif rows > 1 and cols == 0:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows -= 1\\r\\n cols = self._width-1\\r\\n appropriate_number -=1\\r\\n else:\\r\\n # print 'We are solwing tile 0 in row', rows\\r\\n # print 'Appropriate number here ='\\r\\n solution_move += self.solve_col0_tile(rows)\\r\\n # print 'Solution move=', solution_move\\r\\n rows -=1\\r\\n cols = self._width-1\\r\\n\\r\\n\\r\\n #### Cases when we use solve_row0_tile\\r\\n elif rows == 1 and cols > 1:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows -= 1\\r\\n #cols = self._width-1\\r\\n appropriate_number -= self._width\\r\\n\\r\\n else:\\r\\n # print 'Solving upper 2 rows right side'\\r\\n solution_move += self.solve_row1_tile(cols)\\r\\n rows -=1\\r\\n appropriate_number -= self._width\\r\\n #### Cases when we use solve_row1_tile \\r\\n if rows < 1 and cols > 1:\\r\\n if self._grid[rows][cols] == appropriate_number:\\r\\n # print 'This tile is already solved!!!'\\r\\n rows += 1\\r\\n cols -= 1\\r\\n appropriate_number +=self._width-1\\r\\n else:\\r\\n # print '(1,J) tile solved, lets solwe tile (0,j) in tile',(rows,cols)\\r\\n # print 'Greed after move solve_row1_tile'\\r\\n # print self\\r\\n solution_move += self.solve_row0_tile(cols)\\r\\n rows +=1\\r\\n cols -=1\\r\\n appropriate_number +=self._width-1\\r\\n\\r\\n\\r\\n #### Case when we use solve_2x2\\r\\n elif rows <= 1 and cols <= 1:\\r\\n # print 'We are solving 2x2 puzzle'\\r\\n solution_move += self.solve_2x2()\\r\\n if self._grid[0][0] == 0 and \\\\\\r\\n self._grid[0][1] == 1:\\r\\n # print 'Congrads Puxxle is SOLVED!!!!!'\\r\\n break\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n if counter > 100:\\r\\n # print 'COUNTER BREAK'\\r\\n break\\r\\n # print solution_move, len(solution_move)\\r\\n return solution_move\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n # for row in solution_greed._grid[::-1]:\\r\\n # print solution_greed._grid\\r\\n # print 'Row =',row\\r\\n \\r\\n # if solution_greed._grid.index(row) > 1:\\r\\n # print \\\"Case when we solwing Interior and Tile0 part\\\"\\r\\n \\r\\n\\r\\n # for col in solution_greed._grid[solution_greed._grid.index(row)][::-1]:\\r\\n # print 'Coloumn value=', col\\r\\n #print row[0]\\r\\n # if col !=row[0]:\\r\\n # print 'Case when we use just Interior tile solution'\\r\\n # print solution_greed._grid.index(row)\\r\\n # print row.index(col)\\r\\n \\r\\n # solution += solution_greed.solve_interior_tile(solution_greed._grid.index(row) , row.index(col))\\r\\n # print 'Solution =', solution\\r\\n # print self \\r\\n # print solution_greed._grid\\r\\n # elif col ==row[0]:\\r\\n # print 'Case when we use just Col0 solution'\\r\\n\\r\\n # else:\\r\\n # print 'Case when we solwing first two rows'\\r\\n\\r\\n #return \\\"\\\"\\r\",\n \"def create_glider_gun(i, j, grid):\\n\\n ggun = np.zeros(11*38).reshape(11, 38)\\n\\n ggun[5][1] = ggun[5][2] = 1\\n ggun[6][1] = ggun[6][2] = 1\\n\\n ggun[3][13] = ggun[3][14] = 1\\n ggun[4][12] = ggun[4][16] = 1\\n ggun[5][11] = ggun[5][17] = 1\\n ggun[6][11] = ggun[6][15] = ggun[6][17] = ggun[6][18] = 1\\n ggun[7][11] = ggun[7][17] = 1\\n ggun[8][12] = ggun[8][16] = 1\\n ggun[9][13] = ggun[9][14] = 1\\n\\n ggun[1][25] = 1\\n ggun[2][23] = ggun[2][25] = 1\\n ggun[3][21] = ggun[3][22] = 1\\n ggun[4][21] = ggun[4][22] = 1\\n ggun[5][21] = ggun[5][22] = 1\\n ggun[6][23] = ggun[6][25] = 1\\n ggun[7][25] = 1\\n\\n ggun[3][35] = ggun[3][36] = 1\\n ggun[4][35] = ggun[4][36] = 1\\n\\n grid[i:i+11, j:j+38] = ggun\",\n \"def _generate_cells(self) -> None:\\n for i in range(15):\\n for j in range(15):\\n c = Cell(x=i, y=j)\\n c.answer = self.puzzle.solution[j*self.width+i]\\n self.cells[(j, i)] = c # row, col\",\n \"def view_marginals_cristobal(rep=0, epoch=300, zoom=False):\\n samples_path = paths.eICU_synthetic_dir + 'samples_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\\n samples = np.load(samples_path)\\n labels_path = paths.eICU_synthetic_dir + 'labels_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\\n labels = np.load(labels_path)\\n real_path = paths.eICU_task_data\\n raw_real_train = np.load(real_path).item()['X_train'].reshape(-1, 16, 4)\\n real_test = np.load(real_path).item()['X_test'].reshape(-1, 16, 4)\\n real_vali = np.load(real_path).item()['X_vali'].reshape(-1, 16, 4)\\n # discard vali, test\\n real, scaled_vali, scaled_test = scale_data(raw_real_train, real_vali, real_test)\\n real = raw_real_train\\n view_marginals_raw(raw_real_train, label='raw_real_train')\\n view_marginals_raw(real, label='real_train')\\n view_marginals_raw(samples, label='synthetic')\\n\\n variables = ['sao2', 'heartrate', 'respiration', 'systemicmean']\\n\\n # get the scaling factors\\n scaling_factors = {'a': np.zeros(shape=(16, 4)), 'b': np.zeros(shape=(16, 4))}\\n ranges = []\\n for var in range(4):\\n var_min = 100\\n var_max = 0\\n for timestep in range(16):\\n min_val = np.min([np.min(raw_real_train[:, timestep, var]), np.min(real_vali[:, timestep, var])])\\n max_val = np.max([np.max(raw_real_train[:, timestep, var]), np.max(real_vali[:, timestep, var])])\\n if min_val < var_min:\\n var_min = min_val\\n if max_val > var_max:\\n var_max = max_val\\n a = (max_val - min_val)/2\\n b = (max_val + min_val)/2\\n scaling_factors['a'][timestep, var] = a\\n scaling_factors['b'][timestep, var] = b\\n ranges.append([var_min, var_max])\\n\\n # now, scale the synthetic data manually\\n samples_scaled = np.zeros_like(samples)\\n for var in range(4):\\n for timestep in range(16):\\n samples_scaled[:, timestep, var] = samples[:, timestep, var]*scaling_factors['a'][timestep, var] + scaling_factors['b'][timestep, var]\\n\\n if zoom:\\n # use modes, skip for now\\n modes = False\\n if modes:\\n # get rough region of interest, then zoom in on it afterwards!\\n num_gradations = 5\\n gradations = np.linspace(-1, 1, num_gradations)\\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\\n lower = 0\\n real_grid = np.zeros(shape=(16, num_gradations, 4))\\n for (i, cutoff) in enumerate(gradations):\\n # take the mean over samples\\n real_frac = ((real > lower) & (real <= cutoff)).mean(axis=0)\\n lower = cutoff\\n real_grid[:, i, :] = real_frac\\n time_averaged_grid = np.mean(real_grid, axis=0)\\n # get the most populated part of the grid for each variable\\n grid_modes = np.argmax(time_averaged_grid, axis=0)\\n lower = 0\\n ranges = []\\n for i in grid_modes:\\n lower = gradations[i-1]\\n upper = gradations[i]\\n ranges.append([lower, upper])\\n else:\\n # hand-crafted ranges\\n ranges = [[88, 100], [30, 130], [7, 60], [35, 135]]\\n\\n num_gradations = 25\\n # for cutoff in the gradations, what fraction of samples (at a given time point) fall into that cutoff bracket?\\n grid = np.zeros(shape=(16, num_gradations, 4))\\n real_grid = np.zeros(shape=(16, num_gradations, 4))\\n assert samples.shape[-1] == 4\\n for var in range(4):\\n # allow for a different range per variable (if zoom)\\n low = ranges[var][0]\\n high = ranges[var][1]\\n gradations = np.linspace(low, high, num_gradations)\\n for (i, cutoff) in enumerate(gradations):\\n # take the mean over samples\\n frac = ((samples_scaled[:, :, var] > low) & (samples_scaled[:, :, var] <= cutoff)).mean(axis=0)\\n real_frac = ((real[:, :, var] > low) & (real[:, :, var] <= cutoff)).mean(axis=0)\\n low = cutoff\\n grid[:, i, var] = frac\\n real_grid[:, i, var] = real_frac\\n\\n # now plot this as an image\\n fig, axarr = plt.subplots(nrows=4, ncols=2, sharey='row', sharex=True)\\n axarr[0, 0].imshow(grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[1, 0].imshow(grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[2, 0].imshow(grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[3, 0].imshow(grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[0, 1].imshow(real_grid[:, :, 0].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[1, 1].imshow(real_grid[:, :, 1].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[2, 1].imshow(real_grid[:, :, 2].T, origin='lower', aspect=0.5, cmap='magma_r')\\n axarr[3, 1].imshow(real_grid[:, :, 3].T, origin='lower', aspect=0.5, cmap='magma_r')\\n\\n axarr[0, 0].set_title(\\\"synthetic\\\")\\n axarr[0, 1].set_title(\\\"real\\\")\\n for var in range(4):\\n low, high = ranges[var]\\n labels = np.linspace(low, high, num_gradations)[1::4]\\n labels = np.round(labels, 0)\\n axarr[var, 0].set_yticklabels(labels)\\n axarr[var, 0].set_yticks(np.arange(num_gradations)[1::4])\\n axarr[var, 0].set_ylabel(variables[var])\\n for ax in axarr[var, :]:\\n ax.yaxis.set_ticks_position('none')\\n ax.xaxis.set_ticks_position('none')\\n ax.set_adjustable('box-forced')\\n ax.spines['top'].set_visible(False)\\n ax.spines['bottom'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.spines['left'].set_visible(False)\\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\\n\\n axarr[-1, 0].set_xticks(np.arange(16)[::2])\\n axarr[-1, 1].set_xticks(np.arange(16)[::2])\\n\\n if zoom:\\n plt.suptitle('(zoomed)')\\n\\n plt.tight_layout(pad=0.0, w_pad=-5.0, h_pad=0.1)\\n plt.savefig(\\\"./experiments/eval/eICU_cristobal_marginals_r\\\" + str(rep) + \\\"_epoch\\\" + str(epoch) + \\\".png\\\")\\n\\n # now make the histograms\\n fig, axarr = plt.subplots(nrows=1, ncols=4)\\n axarr[0].set_ylabel(\\\"density\\\")\\n axarr[0].hist(real[:, :, 0].flatten(), normed=True, color='black', alpha=0.8, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='real')\\n axarr[1].hist(real[:, :, 1].flatten(), normed=True, color='black', alpha=0.8, range=ranges[1], bins=50)\\n axarr[2].hist(real[:, :, 2].flatten(), normed=True, color='black', alpha=0.8, range=ranges[2], bins=50)\\n axarr[3].hist(real[:, :, 3].flatten(), normed=True, color='black', alpha=0.8, range=ranges[3], bins=50)\\n axarr[0].hist(samples_scaled[:, :, 0].flatten(), normed=True, alpha=0.6, range=ranges[0], bins=min(50, (ranges[0][1] - ranges[0][0])), label='synthetic')\\n axarr[0].legend()\\n axarr[1].hist(samples_scaled[:, :, 1].flatten(), normed=True, alpha=0.6, range=ranges[1], bins=50)\\n axarr[2].hist(samples_scaled[:, :, 2].flatten(), normed=True, alpha=0.6, range=ranges[2], bins=50)\\n axarr[3].hist(samples_scaled[:, :, 3].flatten(), normed=True, alpha=0.6, range=ranges[3], bins=50)\\n for (var, ax) in enumerate(axarr):\\n ax.set_xlabel(variables[var])\\n ax.yaxis.set_ticks_position('none')\\n ax.xaxis.set_ticks_position('none')\\n ax.spines['top'].set_visible(False)\\n ax.spines['bottom'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.spines['left'].set_visible(False)\\n ax.grid(b=True, color='black', alpha=0.2, linestyle='--')\\n\\n plt.gcf().subplots_adjust(bottom=0.2)\\n fig.set_size_inches(10, 3)\\n plt.savefig(\\\"./experiments/eval/eICU_cristobal_hist_r\\\" + str(rep) + \\\"_epoch\\\" + str(epoch) + \\\".png\\\")\\n\\n return True\",\n \"def abstract(res):\\n o = r'\\\\begin{center}'\\n #o += r'\\\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\\n #o += r'\\\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\\n o += r'\\\\begin{tikzpicture}' + '\\\\n'\\n o += r'\\\\draw[blue!40!white] (0,0) rectangle (6,4); \\\\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\\\n'\\n for i in range(res[7]):\\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\\n o += r'\\\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\\\n'\\n o += r'\\\\end{tikzpicture}\\\\end{center}' + '\\\\n'\\n\\n o += r'\\\\begin{tabular}{|l|l|}' + '\\\\n' + r'\\\\hline' + '\\\\n'\\n o += r'Election name& \\\\texttt{\\\"%s\\\"}\\\\\\\\'%res[1]\\n o += r'Box number& \\\\texttt{%s}\\\\\\\\'%res[2]\\n o += r'State& \\\\texttt{%s}\\\\\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\\n o += r'Registration end& \\\\textit{%s}\\\\\\\\'%res[3]\\n o += r'Vote closing& \\\\textit{%s}\\\\\\\\'%res[4]\\n o += r'Casted/registered& $%s/%s$\\\\\\\\'%(res[7],res[6]) +'\\\\n'\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n o += r'\\\\quad' + '\\\\n'\\n o += r'\\\\begin{tabular}{|l|l|}\\\\hline'\\n l = res[8].items()\\n l.sort(key = operator.itemgetter(1),reverse=True)\\n n = 0\\n for x in l:\\n o += r'%s & %s\\\\\\\\'%(r'\\\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\\\texttt{%s}'%x[0],x[1]) \\n if n == 0:\\n o += r'\\\\hline' + '\\\\n'\\n n += 1\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n\\n\\n #o += r'\\\\item The designer\\\\textquoteright s digital signature of this document (the source file \\\\texttt{oeu.py}) is: \\\\tiny $$\\\\verb!%s!$$ \\\\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\\\n'\\n\\n return r'\\\\begin{abstract}' + abstract.__doc__ + r'\\\\end{abstract}' + o\",\n \"def getInitialObstacles():\\n # hardcode number of blocks\\n # will account for movemnet\\n from random import choice\\n from globals import TILEWIDTH, TILEHEIGHT, WINHEIGHT, TILEFLOORHEIGHT, LEVEL, HALFWINWIDTH\\n\\n no_of_blocks = 50\\n for b in range(no_of_blocks // 2):\\n # get image\\n # image = globals.IMAGESDICT['rock']\\n for y in range(1,5):\\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\\n # make rect\\n spaceRect = pygame.Rect((b * TILEWIDTH, y * TILEFLOORHEIGHT, TILEWIDTH, TILEFLOORHEIGHT))\\n landscape = Landscape(image, spaceRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n image = globals.IMAGESDICT['corner']\\n negativeRect = pygame.Rect([-150, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEHEIGHT])\\n landscape = Landscape(image, negativeRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n image = globals.IMAGESDICT['corner']\\n positiveRect = pygame.Rect([LEVEL[0] - TILEWIDTH, WINHEIGHT - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\\n landscape = Landscape(image, positiveRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n bottomRect = pygame.Rect([HALFWINWIDTH, LEVEL[1] - TILEHEIGHT, TILEWIDTH, TILEFLOORHEIGHT])\\n landscape = Landscape(image, bottomRect)\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n for x in range(0, LEVEL[0], 50):\\n for y in range(10):\\n image = globals.IMAGESDICT[choice(['ugly tree', 'rock', 'tall tree'])]\\n spaceRect = pygame.Rect((x, LEVEL[1] - (y * TILEHEIGHT), TILEWIDTH, TILEFLOORHEIGHT))\\n landscape = Landscape(image, spaceRect)\\n if choice([0,1,0]):\\n allLandscapeList.add(landscape)\\n allSpriteList.add(landscape)\\n\\n\\n return\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def draw_occupied_cells(self):\\n reds = [cell for cell in self.game.get_cells() if cell.player == 1]\\n blacks = [cell for cell in self.game.get_cells() if cell.player == 2]\\n nx.draw_networkx_nodes(self.G, pos=self.positions, nodelist=reds,\\n edgecolors='black', node_color='red', linewidths=2)\\n nx.draw_networkx_nodes(self.G, pos=self.positions, nodelist=blacks,\\n edgecolors='black', node_color='black', linewidths=2)\",\n \"def gentiles(self):\\n \\n self.begin()\\n \\n col_list = list()\\n \\n start_x, start_y, = self.x(), self.y()\\n \\n # Assumes square Grid, equal # rows and columns\\n self.dim = round(self.w() / self.c)\\n \\n for y in range(self.r):\\n col_list = list()\\n for x in range(self.c):\\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\\n col_list.append(Tile(x_pos, y_pos, self.dim, self.dim, self.gamewin, x, y))\\n\\n self.tiles.append(col_list)\\n\\n self.end()\",\n \"def create_gridworld(self):\\n self.num_actions = 4\\n self.num_states = self.num_cols * self.num_rows + 1\\n self.start_state_seq = row_col_to_seq(self.start_state, self.num_cols)\\n self.goal_states_seq = row_col_to_seq(self.goal_states, self.num_cols)\\n\\n # rewards structure\\n self.R = self.r_step * np.ones((self.num_states, 1))\\n self.R[self.num_states-1] = 0\\n self.R[self.goal_states_seq] = self.r_goal\\n for i in range(self.num_bad_states):\\n if self.r_bad is None:\\n raise Exception(\\\"Bad state specified but no reward is given\\\")\\n bad_state = row_col_to_seq(self.bad_states[i,:].reshape(1,-1), self.num_cols)\\n self.R[bad_state, :] = self.r_bad\\n for i in range(self.num_restart_states):\\n if self.r_restart is None:\\n raise Exception(\\\"Restart state specified but no reward is given\\\")\\n restart_state = row_col_to_seq(self.restart_states[i,:].reshape(1,-1), self.num_cols)\\n self.R[restart_state, :] = self.r_restart\\n\\n # probability model\\n if self.p_good_trans == None:\\n raise Exception(\\\"Must assign probability and bias terms via the add_transition_probability method.\\\")\\n\\n self.P = np.zeros((self.num_states,self.num_states,self.num_actions))\\n for action in range(self.num_actions):\\n for state in range(self.num_states):\\n\\n # check if state is the fictional end state - self transition\\n if state == self.num_states-1:\\n self.P[state, state, action] = 1\\n continue\\n\\n # check if the state is the goal state or an obstructed state - transition to end\\n row_col = seq_to_col_row(state, self.num_cols)\\n if self.obs_states is not None:\\n end_states = np.vstack((self.obs_states, self.goal_states))\\n else:\\n end_states = self.goal_states\\n\\n if any(np.sum(np.abs(end_states-row_col), 1) == 0):\\n self.P[state, self.num_states-1, action] = 1\\n\\n # else consider stochastic effects of action\\n else:\\n for dir in range(-1,2,1):\\n direction = self._get_direction(action, dir)\\n next_state = self._get_state(state, direction)\\n if dir == 0:\\n prob = self.p_good_trans\\n elif dir == -1:\\n prob = (1 - self.p_good_trans)*(self.bias)\\n elif dir == 1:\\n prob = (1 - self.p_good_trans)*(1-self.bias)\\n\\n self.P[state, next_state, action] += prob\\n\\n # make restart states transition back to the start state with\\n # probability 1\\n if self.restart_states is not None:\\n if any(np.sum(np.abs(self.restart_states-row_col),1)==0):\\n next_state = row_col_to_seq(self.start_state, self.num_cols)\\n self.P[state,:,:] = 0\\n self.P[state,next_state,:] = 1\\n return self\",\n \"def buildpuzzle(self):\\r\\n self.puzzle = copy.deepcopy(self.rows)\\r\\n if self.difficulty == 1:\\r\\n self.removedigits(1)\\r\\n if self.difficulty == 2:\\r\\n self.removedigits(2)\\r\\n if self.difficulty == 3:\\r\\n self.removedigits(3)\",\n \"def main():\\n\\n cages = [\\n \\\"AABCCD\\\",\\n \\\"EFBCGD\\\",\\n \\\"EFFHGI\\\",\\n \\\"EJJHGI\\\",\\n \\\"EKJHGL\\\",\\n \\\"KKJLLL\\\",\\n ]\\n\\n peaks = [\\n (0, 1),\\n (0, 2),\\n (1, 3),\\n (1, 4),\\n (1, 5),\\n (2, 1),\\n (2, 3),\\n (3, 0),\\n (3, 5),\\n (4, 2),\\n (5, 1),\\n (5, 4),\\n ]\\n\\n extract = {\\n \\\"A\\\": (5, 2),\\n \\\"B\\\": (0, 3),\\n \\\"C\\\": (3, 2),\\n \\\"D\\\": (1, 4),\\n \\\"E\\\": (0, 1),\\n \\\"F\\\": (1, 5),\\n \\\"G\\\": (4, 2),\\n \\\"H\\\": (3, 5),\\n \\\"I\\\": (1, 0),\\n \\\"J\\\": (5, 5),\\n \\\"K\\\": (3, 4),\\n \\\"L\\\": (5, 1),\\n \\\"M\\\": (0, 5),\\n \\\"N\\\": (4, 4),\\n }\\n\\n def answer(sg):\\n solved_grid = sg.solved_grid()\\n s = \\\"\\\"\\n s += chr(64 + solved_grid[extract[\\\"A\\\"]] + solved_grid[extract[\\\"B\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"C\\\"]] + solved_grid[extract[\\\"D\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"E\\\"]] + solved_grid[extract[\\\"F\\\"]] + solved_grid[extract[\\\"G\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"H\\\"]] + solved_grid[extract[\\\"I\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"J\\\"]] + solved_grid[extract[\\\"K\\\"]] + solved_grid[extract[\\\"L\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"M\\\"]] + solved_grid[extract[\\\"N\\\"]])\\n return s\\n\\n sym = grilops.make_number_range_symbol_set(1, 6)\\n lattice = grilops.get_square_lattice(6)\\n sg = grilops.SymbolGrid(lattice, sym)\\n\\n add_sudoku_constraints(sg)\\n\\n # Constrain regions to match the cages and be rooted at the peaks.\\n cage_label_to_region_id = {}\\n for py, px in peaks:\\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\\n\\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\\n for y, x in lattice.points:\\n sg.solver.add(\\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\\n\\n # Within each region, a parent cell must have a greater value than a child\\n # cell, so that the values increase as you approach the root cell (the peak).\\n for p in lattice.points:\\n for n in sg.edge_sharing_neighbors(p):\\n sg.solver.add(Implies(\\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\\n n.symbol > sg.grid[p]\\n ))\\n\\n if sg.solve():\\n sg.print()\\n print()\\n print(answer(sg))\\n while not sg.is_unique():\\n print()\\n print(\\\"Alternate solution\\\")\\n sg.print()\\n print()\\n print(answer(sg))\\n else:\\n print(\\\"No solution\\\")\",\n \"def swipeBase (self) :\\n grid = self.grid\\n\\n #we start by putting every tile up\\n for columnNbr in range(4) :\\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\\n\\n for lineNbr in range(4) :\\n counter = 0\\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\\n counter += 1\\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\\n for remainingLine in range (lineNbr, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n #now we do the additions\\n for lineNbr in range(3) :\\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\\n grid[lineNbr, columnNbr] *= 2\\n for remainingLine in range (lineNbr+1, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n return (grid)\",\n \"def go_or_grow(lgca):\\n relevant = lgca.cell_density[lgca.nonborder] > 0\\n coords = [a[relevant] for a in lgca.nonborder]\\n n_m = lgca.nodes[..., :lgca.velocitychannels].sum(-1)\\n n_r = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\\n M1 = np.minimum(n_m, lgca.restchannels - n_r)\\n M2 = np.minimum(n_r, lgca.velocitychannels - n_m)\\n for coord in zip(*coords):\\n # node = lgca.nodes[coord]\\n n = lgca.cell_density[coord]\\n\\n n_mxy = n_m[coord]\\n n_rxy = n_r[coord]\\n\\n rho = n / lgca.K\\n j_1 = npr.binomial(M1[coord], tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\\n j_2 = npr.binomial(M2[coord], 1 - tanh_switch(rho, kappa=lgca.kappa, theta=lgca.theta))\\n n_mxy += j_2 - j_1\\n n_rxy += j_1 - j_2\\n n_mxy -= npr.binomial(n_mxy * np.heaviside(n_mxy, 0), lgca.r_d)\\n n_rxy -= npr.binomial(n_rxy * np.heaviside(n_rxy, 0), lgca.r_d)\\n M = min([n_rxy, lgca.restchannels - n_rxy])\\n n_rxy += npr.binomial(M * np.heaviside(M, 0), lgca.r_b)\\n\\n v_channels = [1] * n_mxy + [0] * (lgca.velocitychannels - n_mxy)\\n v_channels = npr.permutation(v_channels)\\n r_channels = np.zeros(lgca.restchannels)\\n r_channels[:n_rxy] = 1\\n node = np.hstack((v_channels, r_channels))\\n lgca.nodes[coord] = node\",\n \"def initialize_grid(self):\\r\\n for i in range(self.height):\\r\\n for j in range(self.width):\\r\\n self.grid[i][j] = 0\\r\\n \\r\\n # fill up unvisited cells\\r\\n for r in range(self.height):\\r\\n for c in range(self.width):\\r\\n if r % 2 == 0 and c % 2 == 0:\\r\\n self.unvisited.append((r,c))\\r\\n\\r\\n self.visited = []\\r\\n self.path = dict()\\r\\n self.generated = False\",\n \"def test_multigrid_calculates_neighbours_correctly():\\n\\n # create a grid which will result in 9 cells\\n h = 64\\n img_dim = (3 * h + 1, 3 * h + 1)\\n amg = mg.MultiGrid(img_dim, h, WS=127)\\n\\n # check that each cell has the expected neighbours\\n print(amg.n_cells)\\n\\n # expected neieghbours left to right, bottom to top\\n cells = [{\\\"north\\\": amg.cells[3], \\\"east\\\": amg.cells[1], \\\"south\\\": None, \\\"west\\\": None}, # bl\\n {\\\"north\\\": amg.cells[4], \\\"east\\\": amg.cells[2],\\n \\\"south\\\": None, \\\"west\\\": amg.cells[0]}, # bm\\n {\\\"north\\\": amg.cells[5], \\\"east\\\": None,\\n \\\"south\\\": None, \\\"west\\\": amg.cells[1]}, # br\\n {\\\"north\\\": amg.cells[6], \\\"east\\\": amg.cells[4],\\n \\\"south\\\": amg.cells[0], \\\"west\\\": None}, # ml\\n {\\\"north\\\": amg.cells[7], \\\"east\\\": amg.cells[5],\\n \\\"south\\\": amg.cells[1], \\\"west\\\": amg.cells[3]}, # mm\\n {\\\"north\\\": amg.cells[8], \\\"east\\\": None,\\n \\\"south\\\": amg.cells[2], \\\"west\\\": amg.cells[4]}, # mr\\n # tl\\n {\\\"north\\\": None, \\\"east\\\": amg.cells[7],\\n \\\"south\\\": amg.cells[3], \\\"west\\\": None},\\n # tm\\n {\\\"north\\\": None,\\n \\\"east\\\": amg.cells[8], \\\"south\\\": amg.cells[4], \\\"west\\\": amg.cells[6]},\\n {\\\"north\\\": None, \\\"east\\\": None,\\n \\\"south\\\": amg.cells[5], \\\"west\\\": amg.cells[7]}, # tr\\n ]\\n\\n for ii, (gc, cell) in enumerate(zip(amg.cells, cells)):\\n print(ii)\\n assert gc.north == cell['north']\\n assert gc.east == cell['east']\\n assert gc.south == cell['south']\\n assert gc.west == cell['west']\",\n \"def apply(grid, r, c, action):\\n if action == 'suck':\\n grid[r, c] = EMPTY\\n else:\\n print(action)\\n new_r = r + OFFSETS[action][0]\\n new_c = c + OFFSETS[action][1]\\n if 0 <= new_r < WORLD_WIDTH and 0 <= new_c < WORLD_WIDTH and grid[new_r, new_c] != OBSTACLE:\\n return new_r, new_c\\n return r, c\",\n \"def six_hundred_cell(self):\\n verts = []\\n q12 = QQ(1)/2\\n base = [q12,q12,q12,q12]\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n for l in range(2):\\n verts.append([x for x in base])\\n base[3] = base[3]*(-1)\\n base[2] = base[2]*(-1)\\n base[1] = base[1]*(-1)\\n base[0] = base[0]*(-1)\\n for x in permutations([0,0,0,1]):\\n verts.append(x)\\n for x in permutations([0,0,0,-1]):\\n verts.append(x)\\n g = QQ(1618033)/1000000 # Golden ratio approximation\\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n return Polyhedron(vertices = verts)\",\n \"def next_round(self, old_round):\\n new_round = np.copy(old_round) #copy of the old grid\\n # for each square\\n for i in range(Lx):\\n for j in range(Ly):\\n if old_round[i][j] == 0 : #if the cell is dead, it will live if it has 3 living neighbors.\\n if self.sum_living_cell(i, j, old_round) == 3:\\n new_round[i][j] = 1\\n else:\\n new_round[i][j] = 0\\n if old_round[i][j] == 1 : #if the cell is alive, it won't dead if it has 2 or 3 living neighors.\\n square_score = self.sum_living_cell(i, j, old_round)\\n if square_score != 2 and square_score != 3 :\\n new_round[i][j] = 0\\n else:\\n new_round[i][j] = 1\\n return new_round\",\n \"def multi_grid_iou(orig_bed_pcd, cfgs, voxel_size=0.05):\\n ious = np.zeros(len(cfgs))\\n for i in range(cfgs.shape[0]):\\n cfg = cfgs[i]\\n bed_pcd = orig_bed_pcd - cfg[:2]\\n theta = np.radians(cfg[2])\\n rotmat = np.array([\\n [np.cos(theta), np.sin(theta)],\\n [-np.sin(theta), np.cos(theta)],\\n ])\\n bed_pcd = bed_pcd@rotmat\\n\\n bed_pcd = np.round_(bed_pcd/voxel_size, 0, np.zeros_like(bed_pcd))\\n bed_pcd_summed = np.unique(1024*bed_pcd[:,0]+bed_pcd[:,1])\\n bed_pcd_0 = np.round_(bed_pcd_summed/1024, 0, np.zeros_like(bed_pcd_summed))\\n bed_pcd_1 = bed_pcd_summed-bed_pcd_0*1024\\n x_ok = (bed_pcd_1*2 <= int(cfg[4]/voxel_size)) & (bed_pcd_1*2 >= int(-cfg[4]/voxel_size))\\n y_ok = (bed_pcd_0*2 <= int(cfg[3]/voxel_size)) & (bed_pcd_0*2 >= int(-cfg[3]/voxel_size))\\n n_ok = np.sum(x_ok & y_ok)\\n n_elem = len(bed_pcd_summed)\\n n_grid = (cfg[3]+voxel_size)*(cfg[4]+voxel_size)/(voxel_size*voxel_size)\\n ious[i] = n_ok/(n_grid+n_elem-n_ok)\\n return ious\",\n \"def get_others(map_, r, c):\\n nums = 0\\n # your code here\\n if r == 0 and c == 0: #top left corder\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n elif r == 0 and c == len(map_[0])-1: #top right corner\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1 and c == 0: #bottom left corder\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1 and c == len(map_[0])-1: #bottom right corner\\n nums += 2\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif r == 0: # top edge, excluding corner\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n if len(map_) > r and map_[r+1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1: # bottom edge, excluding corner\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif c == 0: # left edge, excluding corner\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if len(map_[0]) > c and map_[r][c+1] == 0:\\n nums += 1\\n elif c == len(map_[0])-1: # right edge. excluding corner\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n else: # the rest, excluding edge and corner\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n return nums\",\n \"def create_matrices(maze, reward, penalty_s, penalty_l, prob):\\n \\n r, c = np.shape(maze)\\n states = r*c\\n p = prob\\n q = (1 - prob)*0.5\\n \\n # Create reward matrix\\n path = maze*penalty_s\\n walls = (1 - maze)*penalty_l\\n combined = path + walls\\n \\n combined[-1, -1] = reward\\n \\n R = np.reshape(combined, states)\\n \\n # Create transition matrix\\n T_up = np.zeros((states, states))\\n T_left = np.zeros((states, states))\\n T_right = np.zeros((states, states))\\n T_down = np.zeros((states, states))\\n \\n wall_ind = np.where(R == penalty_l)[0]\\n\\n for i in range(states):\\n # Up\\n if (i - c) < 0 or (i - c) in wall_ind :\\n T_up[i, i] += p\\n else:\\n T_up[i, i - c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_up[i, i] += q\\n else:\\n T_up[i, i+1] += q\\n \\n # Down\\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_down[i, i] += p\\n else:\\n T_down[i, i + c] += p\\n \\n if i%c == 0 or (i - 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i-1] += q\\n \\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_down[i, i] += q\\n else:\\n T_down[i, i+1] += q\\n \\n # Left\\n if i%c == 0 or (i - 1) in wall_ind:\\n T_left[i, i] += p\\n else:\\n T_left[i, i-1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_left[i, i] += q\\n else:\\n T_left[i, i + c] += q\\n \\n # Right\\n if i%c == (c - 1) or (i + 1) in wall_ind:\\n T_right[i, i] += p\\n else:\\n T_right[i, i+1] += p\\n \\n if (i - c) < 0 or (i - c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i - c] += q\\n \\n if (i + c) > (states - 1) or (i + c) in wall_ind:\\n T_right[i, i] += q\\n else:\\n T_right[i, i + c] += q\\n \\n T = [T_up, T_left, T_right, T_down] \\n \\n return T, R\",\n \"def makeGrid(self, width, height, rewardLocs, exit, nPick=1, nAux=1, walls=[]):\\n # Make mapping from coordinate (x, y, (takenreward1, takenreward2, ...))\\n # to state number, and vice-versa.\\n rTaken = iter([(),])\\n for nPicked in range(1, nPick+1):\\n rTaken = itertools.chain(rTaken, \\n myCombinations(rewardLocs, r=nPicked)\\n )\\n # Iterators are hard to reset, so we list it.\\n rTaken = list(rTaken)\\n\\n # Mappings from state to coordinates, vice-versa\\n coordToState = {}\\n stateToCoord = {}\\n stateIdx = 0\\n for x in range(width):\\n for y in range(height):\\n for stuff in rTaken:\\n for holding in self.holdingPossibilities:\\n coordToState[(x, y, stuff, holding)] = stateIdx\\n stateToCoord[stateIdx] = (x, y, stuff, holding)\\n stateIdx += 1\\n self.deadEndState = stateIdx\\n\\n # Actually make the transition function\\n def trans(f, p): \\n aux = p\\n (x, y, stuff, holding) = stateToCoord[f]\\n actionMap = {}\\n default = {(f, aux): 1}\\n # Make the transition dictionary if the dead-end state (state width*height)\\n if f == self.F-1:\\n for action in range(5):\\n actionMap[action] = default\\n return actionMap\\n\\n # Otherwise, determine directions of motion, etc. \\n for i in range(4):\\n actionMap[i] = default\\n if x != 0 and ((x-1, y) not in walls):\\n actionMap[0] = {(coordToState[(x-1,y,stuff, holding)], aux): 1}\\n if x < width-1 and ((x+1, y) not in walls):\\n actionMap[1] = {(coordToState[(x+1,y,stuff, holding)], aux): 1}\\n if y != 0 and ((x, y-1) not in walls):\\n actionMap[2] = {(coordToState[(x,y-1,stuff, holding)], aux): 1}\\n if y < height-1 and ((x, y+1) not in walls):\\n actionMap[3] = {(coordToState[(x,y+1,stuff, holding)], aux): 1}\\n # What happens when the agent uses action 4?\\n if (x, y) == exit:\\n # Some cases, depending on self.oneAtATime\\n if not self.oneAtATime:\\n # The agent is leaving.\\n actionMap[4] = {(self.deadEndState, aux): 1}\\n else:\\n # The agent is dropping off a reward. holeFiller will\\n # take care of the reward value.\\n if len(stuff) >= nPick:\\n # The agent is not allowed to pick up more stuff\\n actionMap[4] = {(self.deadEndState, aux): 1}\\n else:\\n # The agent drops off the object.\\n actionMap[4] = {(coordToState[(x,y,stuff, -1)], aux): 1}\\n elif (x, y) not in rewardLocs:\\n # No reward to pick up. Do nothing.\\n actionMap[4] = default\\n elif (x, y) in stuff:\\n # This reward has already been used. Do nothing.\\n actionMap[4] = default\\n elif len(stuff) >= nPick or (holding != -1 and holding < len(stuff)\\n and self.oneAtATime):\\n # The agent has its hands full.\\n actionMap[4] = default\\n else:\\n # The agent is allowed to pick up an object.\\n newStuff = tuple(sorted(list(stuff) + [(x, y)]))\\n if self.oneAtATime:\\n newHoldingIdx = newStuff.index((x, y))\\n else:\\n newHoldingIdx = -1\\n actionMap[4] = {(coordToState[(x, y, newStuff, newHoldingIdx)], aux): 1}\\n return actionMap\\n\\n # Man, I'm outputting a lot of stuff.\\n # coordToState[(x, y, rewardsLeft, holding)] -> index of this state\\n # stateToCoord[index] -> (x, y, rewardsLeft, holding)\\n # rTaken is a list of all possible combinations of leftover rewards.\\n return (trans, coordToState, stateToCoord, rTaken)\",\n \"def climb_tree():\\n global UP_TREE\\n westdesc = \\\"\\\"\\n eastdesc = \\\"\\\"\\n northdesc = \\\"\\\"\\n southdesc = \\\"\\\"\\n UP_TREE = True\\n westinvalid = False\\n eastinvalid = False\\n northinvalid = False\\n southinvalid = False\\n\\n\\n printmessage(\\\"You climb the large tree to get a look at your surroundings.\\\", 5, MAGENTA, 2)\\n\\n if ZERO_BASE_PLYR_POS in range(0, 10):\\n northinvalid = True\\n if ZERO_BASE_PLYR_POS in range(90, 100):\\n southinvalid = True\\n if ZERO_BASE_PLYR_POS in range(0, 91, 10):\\n eastinvalid = True\\n if ZERO_BASE_PLYR_POS in range(9, 100, 10):\\n westinvalid = True\\n \\n if not westinvalid: \\n westpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 1]\\n if HAS_COMPASS: \\n DISCOVERED[ZERO_BASE_PLYR_POS + 1] = \\\"Y\\\"\\n if westpos == 10: # Water\\n westdesc = TREE_VIEWS[2]\\n else:\\n westdesc = TREE_VIEWS[1]\\n\\n westpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 1]\\n if westpos == 1:\\n westdesc = TREE_VIEWS[3]\\n elif westpos == 2:\\n westdesc = TREE_VIEWS[4]\\n else:\\n westdesc = TREE_VIEWS[5]\\n\\n if not eastinvalid:\\n eastpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 1]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 1] = \\\"Y\\\"\\n if eastpos == 10: # Water\\n eastdesc = TREE_VIEWS[2]\\n else:\\n eastdesc = TREE_VIEWS[1]\\n\\n eastpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 1]\\n if eastpos == 1:\\n eastdesc = TREE_VIEWS[3]\\n elif eastpos == 2:\\n eastdesc = TREE_VIEWS[4]\\n else:\\n eastdesc = TREE_VIEWS[6]\\n\\n\\n if not northinvalid:\\n northpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS - 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS - 10] = \\\"Y\\\"\\n if northpos == 10: # Water\\n northdesc = TREE_VIEWS[2]\\n else:\\n northdesc = TREE_VIEWS[1]\\n\\n northpos = ENEMY_LIST[ZERO_BASE_PLYR_POS - 10]\\n if northpos == 1: # bear\\n northdesc = TREE_VIEWS[3]\\n elif northpos == 2: # grizzly\\n northdesc = TREE_VIEWS[4]\\n else:\\n northdesc = TREE_VIEWS[7]\\n\\n\\n if not southinvalid:\\n southpos = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS + 10]\\n if HAS_COMPASS:\\n DISCOVERED[ZERO_BASE_PLYR_POS + 10] = \\\"Y\\\"\\n if southpos == 10: # Water\\n southdesc = TREE_VIEWS[2]\\n else:\\n southdesc = TREE_VIEWS[1]\\n\\n southpos = ENEMY_LIST[ZERO_BASE_PLYR_POS + 10]\\n if southpos == 1: # bear\\n southdesc = TREE_VIEWS[3]\\n elif southpos == 2: # grizzly\\n southdesc = TREE_VIEWS[4]\\n else:\\n southdesc = TREE_VIEWS[8]\\n\\n clear_messages(0)\\n printmessage(\\\"West: \\\" + westdesc, 2, GREEN, 0)\\n printmessage(\\\"East: \\\" + eastdesc, 3, YELLOW, 0)\\n printmessage(\\\"North: \\\" + northdesc, 4, CYAN, 0)\\n printmessage(\\\"South: \\\" + southdesc, 5, MAGENTA, 0)\\n #show_movement(True, 10)\\n update_player_on_map()\\n pause_for_keypress()\\n clear_messages(0)\",\n \"def outcome(self):\\n if self.grid[0][0] == self.grid[1][0] == self.grid[2][0] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][1] == self.grid[1][1] == self.grid[2][1] and self.grid[0][1] != 0:\\n return self.grid[0][1]\\n if self.grid[0][2] == self.grid[1][2] == self.grid[2][2] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n if self.grid[0][0] == self.grid[0][1] == self.grid[0][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[1][0] == self.grid[1][1] == self.grid[1][2] and self.grid[1][0] != 0:\\n return self.grid[1][0]\\n if self.grid[2][0] == self.grid[2][1] == self.grid[2][2] and self.grid[2][0] != 0:\\n return self.grid[2][0]\\n if self.grid[0][0] == self.grid[1][1] == self.grid[2][2] and self.grid[0][0] != 0:\\n return self.grid[0][0]\\n if self.grid[0][2] == self.grid[1][1] == self.grid[2][0] and self.grid[0][2] != 0:\\n return self.grid[0][2]\\n return 0\",\n \"def aging_landscape(self):\\n for herb in self.herb_pop:\\n herb.aging_animal()\\n herb.fitness_animal()\\n\\n for carn in self.carn_pop:\\n carn.aging_animal()\\n carn.fitness_animal()\",\n \"def make_grid_uh_river(t_uh, t_cell, uh, to_y, to_x, pour_point, y_inds,\\n x_inds, count_ds):\\n log.debug(\\\"Making uh_river grid.... It takes a while...\\\")\\n y_ind = pour_point.basiny\\n x_ind = pour_point.basinx\\n\\n uh_river = np.zeros((t_uh, uh.shape[1], uh.shape[2]))\\n for (y, x, d) in zip(y_inds, x_inds, count_ds):\\n if d > 0:\\n yy = to_y[y, x]\\n xx = to_x[y, x]\\n irf_temp = np.zeros(t_uh+t_cell)\\n active_timesteps = np.nonzero(uh_river[:, yy, xx] > PRECISION)[0]\\n for t in active_timesteps:\\n for l in xrange(t_cell):\\n irf_temp[t+l] = irf_temp[t + l] + uh[l, y, x] * uh_river[t, yy, xx]\\n tot = np.sum(irf_temp[:t_uh])\\n if tot > 0:\\n uh_river[:, y, x] = irf_temp[:t_uh] / tot\\n elif d == 0:\\n uh_river[:t_cell, y_ind, x_ind] = uh[:, y_ind, x_ind]\\n\\n return uh_river\",\n \"def obstacles_form(self,image):\\r\\n major_axis=60\\r\\n minor_axis=30\\r\\n c_y=246\\r\\n c_x=145\\r\\n c_y1=90\\r\\n c_x1=70\\r\\n radius=35\\r\\n for i in range(len(image)):\\r\\n for j in range(len(image[0])):\\r\\n\\r\\n #self.ellipse(image,major_axis,minor_axis,i,j,c_x,c_y)\\r\\n self.circle(image,100,i,j,200,200)\\r\\n self.circle(image,100,i,j,800,200)\\r\\n #self.slanted_rect(image,i,j)\\r\\n self.boundary(image,i,j)\\r\\n self.boundary1(image,i,j)\\r\\n self.boundary2(image,i,j)\\r\\n self.c_shape(image,i,j)\\r\\n #exploration.c_shape(image,i,j)\\r\",\n \"def findAstromCorrs(self):\\n self.logfile.write(\\\"Entered findAstromCorrs - will run: \\\"+\\\\\\n \\\"makeGSCcat(), makeObjcats(), doMatching().\\\")\\n\\n if self.makeGSCcat() != 0:\\n return -1\\n if self.makeObjcats()!= 0:\\n return -1\\n if self.doMatching() != 0:\\n # here we want to remake the GSCcat using a \\\"chopSpur\\\" flag,\\n # if the cat has a goodly number of objects\\n if(self.Ncull >= 10):\\n print \\\"Retrying matchup with only GSC objs detected in 2 bands...\\\"\\n self.logfile.write(\\\"Retrying matchup with only GSC objs detected in 2 bands...\\\")\\n if self.makeGSCcat(chopSpur=1) != 0:\\n return -1\\n if self.makeObjcats()!= 0:\\n return -1\\n if self.doMatching() != 0:\\n return -1\\n\\n return 0\",\n \"def ggpl_house():\\n\\n\\t# .lines ogni riga ha due coppie di x/y che costituiscono un segmento\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/muri_esterni.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\texternalWalls = MKPOL([verts,cells,None])\\n\\tfloor = SOLIDIFY(externalWalls)\\n\\tfloor = S([1,2,3])([.04,.04,.04])(floor)\\n\\texternalWalls = S([1,2,3])([.04,.04,.04])(externalWalls)\\n\\texternalWalls = OFFSET([.2,.2,4])(externalWalls)\\n\\theightWalls = SIZE([3])(externalWalls)[0]\\n\\tthicknessWalls = SIZE([2])(externalWalls)[0]\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/muri_interni.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\tinternalWalls = MKPOL([verts,cells,None])\\n\\tinternalWalls = S([1,2,3])([.04,.04,.04])(internalWalls)\\n\\tinternalWalls = OFFSET([.2,.2,4])(internalWalls)\\n\\twalls = STRUCT([externalWalls, internalWalls])\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/porte.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\tdoors = MKPOL([verts,cells,None])\\n\\tdoors = SOLIDIFY(doors)\\n\\tdoors = S([1,2,3])([.04,.04,.04])(doors)\\n\\tdoors = OFFSET([.2,.2,3])(doors)\\n\\twalls = DIFFERENCE([walls, doors])\\n\\n\\n\\tverts = []\\n\\tcells = []\\n\\ti = 0\\n\\treader = csv.reader(open(\\\"lines/finestre.lines\\\", 'rb'), delimiter=',') \\n\\tfor row in reader:\\n\\t\\tverts.append([float(row[0]), float(row[1])])\\n\\t\\tverts.append([float(row[2]), float(row[3])])\\n\\t\\ti+=2\\n\\t\\tcells.append([i-1,i])\\n\\n\\twindows = MKPOL([verts,cells,None])\\n\\twindows = SOLIDIFY(windows)\\n\\twindows = S([1,2,3])([.04,.04,.04])(windows)\\n\\twindows = OFFSET([.2,.2,2])(windows)\\n\\theightWindows = SIZE([3])(windows)[0]\\n\\twindows = T(3)((heightWalls-heightWindows)/2.)(windows)\\n\\twalls = DIFFERENCE([walls, windows])\\n\\n\\tfloor = TEXTURE(\\\"texture/floor.jpg\\\")(floor)\\n\\twalls = TEXTURE(\\\"texture/wall.jpg\\\")(walls)\\n\\thome = STRUCT([floor, walls])\\n\\treturn home\",\n \"def Check(self):\\n cleared = False\\n while not cleared:\\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\\n x1 = i[0][0]\\n y1 = i[0][1]\\n r1 = i[0][2] / 2\\n idx1 = i[0][3]\\n x2 = i[1][0]\\n y2 = i[1][1]\\n r2 = i[1][2] / 2\\n idx1 = i[0][3]\\n idx2 = i[1][3]\\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\\n radii = (r1 + r2) * (r1 + r2)\\n if distance == radii:\\n cleared = True\\n elif distance > radii:\\n cleared = True\\n else:\\n if x1 > x2 and y1 > y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n elif x1 > x2 and y1 < y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n elif x1 < x2 and y1 > y2:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n else:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n _logger.debug(\\n f\\\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\\\"\\n )\\n cleared = False\\n return\",\n \"def write_ROMS_grid(grd, visc_factor, diff_factor, filename='roms_grd.nc'):\\n\\n Mm, Lm = grd.hgrid.x_rho.shape\\n\\n \\n # Write ROMS grid to file\\n nc = netCDF.Dataset(filename, 'w', format='NETCDF4')\\n nc.Description = 'ROMS grid'\\n nc.Author = 'Trond Kristiansen'\\n nc.Created = datetime.now().isoformat()\\n nc.type = 'ROMS grid file'\\n\\n nc.createDimension('xi_rho', Lm)\\n nc.createDimension('xi_u', Lm-1)\\n nc.createDimension('xi_v', Lm)\\n nc.createDimension('xi_psi', Lm-1)\\n \\n nc.createDimension('eta_rho', Mm)\\n nc.createDimension('eta_u', Mm)\\n nc.createDimension('eta_v', Mm-1)\\n nc.createDimension('eta_psi', Mm-1)\\n\\n nc.createDimension('xi_vert', Lm+1)\\n nc.createDimension('eta_vert', Mm+1)\\n\\n nc.createDimension('bath', None)\\n\\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\\n N, = grd.vgrid.s_rho.shape\\n nc.createDimension('s_rho', N)\\n nc.createDimension('s_w', N+1)\\n\\n def write_nc_var(var, name, dimensions, long_name=None, units=None):\\n nc.createVariable(name, 'f8', dimensions)\\n if long_name is not None:\\n nc.variables[name].long_name = long_name\\n if units is not None:\\n nc.variables[name].units = units\\n nc.variables[name][:] = var\\n print ' ... wrote ', name\\n\\n if hasattr(grd.vgrid, 's_rho') is True and grd.vgrid.s_rho is not None:\\n write_nc_var(grd.vgrid.theta_s, 'theta_s', (), 'S-coordinate surface control parameter')\\n write_nc_var(grd.vgrid.theta_b, 'theta_b', (), 'S-coordinate bottom control parameter')\\n write_nc_var(grd.vgrid.Tcline, 'Tcline', (), 'S-coordinate surface/bottom layer width', 'meter')\\n write_nc_var(grd.vgrid.hc, 'hc', (), 'S-coordinate parameter, critical depth', 'meter')\\n write_nc_var(grd.vgrid.s_rho, 's_rho', ('s_rho'), 'S-coordinate at RHO-points')\\n write_nc_var(grd.vgrid.s_w, 's_w', ('s_w'), 'S-coordinate at W-points')\\n write_nc_var(grd.vgrid.Cs_r, 'Cs_r', ('s_rho'), 'S-coordinate stretching curves at RHO-points')\\n write_nc_var(grd.vgrid.Cs_w, 'Cs_w', ('s_w'), 'S-coordinate stretching curves at W-points')\\n\\n write_nc_var(grd.vgrid.h, 'h', ('eta_rho', 'xi_rho'), 'bathymetry at RHO-points', 'meter')\\n #ensure that we have a bath dependancy for hraw\\n if len(grd.vgrid.hraw.shape) == 2:\\n hraw = np.zeros((1, grd.vgrid.hraw.shape[0], grd.vgrid.hraw.shape[1]))\\n hraw[0,:] = grd.vgrid.hraw\\n else:\\n hraw = grd.vgrid.hraw\\n write_nc_var(hraw, 'hraw', ('bath', 'eta_rho', 'xi_rho'), 'raw bathymetry at RHO-points', 'meter')\\n write_nc_var(grd.hgrid.f, 'f', ('eta_rho', 'xi_rho'), 'Coriolis parameter at RHO-points', 'second-1')\\n write_nc_var(1./grd.hgrid.dx, 'pm', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in XI', 'meter-1')\\n write_nc_var(1./grd.hgrid.dy, 'pn', ('eta_rho', 'xi_rho'), 'curvilinear coordinate metric in ETA', 'meter-1')\\n write_nc_var(grd.hgrid.dmde, 'dmde', ('eta_rho', 'xi_rho'), 'XI derivative of inverse metric factor pn', 'meter')\\n write_nc_var(grd.hgrid.dndx, 'dndx', ('eta_rho', 'xi_rho'), 'ETA derivative of inverse metric factor pm', 'meter')\\n write_nc_var(grd.hgrid.xl, 'xl', (), 'domain length in the XI-direction', 'meter')\\n write_nc_var(grd.hgrid.el, 'el', (), 'domain length in the ETA-direction', 'meter')\\n\\n write_nc_var(grd.hgrid.x_rho, 'x_rho', ('eta_rho', 'xi_rho'), 'x location of RHO-points', 'meter')\\n write_nc_var(grd.hgrid.y_rho, 'y_rho', ('eta_rho', 'xi_rho'), 'y location of RHO-points', 'meter')\\n write_nc_var(grd.hgrid.x_u, 'x_u', ('eta_u', 'xi_u'), 'x location of U-points', 'meter')\\n write_nc_var(grd.hgrid.y_u, 'y_u', ('eta_u', 'xi_u'), 'y location of U-points', 'meter')\\n write_nc_var(grd.hgrid.x_v, 'x_v', ('eta_v', 'xi_v'), 'x location of V-points', 'meter')\\n write_nc_var(grd.hgrid.y_v, 'y_v', ('eta_v', 'xi_v'), 'y location of V-points', 'meter')\\n write_nc_var(grd.hgrid.x_psi, 'x_psi', ('eta_psi', 'xi_psi'), 'x location of PSI-points', 'meter')\\n write_nc_var(grd.hgrid.y_psi, 'y_psi', ('eta_psi', 'xi_psi'), 'y location of PSI-points', 'meter')\\n write_nc_var(grd.hgrid.x_vert, 'x_vert', ('eta_vert', 'xi_vert'), 'x location of cell verticies', 'meter')\\n write_nc_var(grd.hgrid.y_vert, 'y_vert', ('eta_vert', 'xi_vert'), 'y location of cell verticies', 'meter')\\n\\n if hasattr(grd.hgrid, 'lon_rho'):\\n write_nc_var(grd.hgrid.lon_rho, 'lon_rho', ('eta_rho', 'xi_rho'), 'longitude of RHO-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_rho, 'lat_rho', ('eta_rho', 'xi_rho'), 'latitude of RHO-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_u, 'lon_u', ('eta_u', 'xi_u'), 'longitude of U-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_u, 'lat_u', ('eta_u', 'xi_u'), 'latitude of U-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_v, 'lon_v', ('eta_v', 'xi_v'), 'longitude of V-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_v, 'lat_v', ('eta_v', 'xi_v'), 'latitude of V-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_psi, 'lon_psi', ('eta_psi', 'xi_psi'), 'longitude of PSI-points', 'degree_east')\\n write_nc_var(grd.hgrid.lat_psi, 'lat_psi', ('eta_psi', 'xi_psi'), 'latitude of PSI-points', 'degree_north')\\n write_nc_var(grd.hgrid.lon_vert, 'lon_vert', ('eta_vert', 'xi_vert'), 'longitude of cell verticies', 'degree_east')\\n write_nc_var(grd.hgrid.lat_vert, 'lat_vert', ('eta_vert', 'xi_vert'), 'latitude of cell verticies', 'degree_north')\\n\\n nc.createVariable('spherical', 'c')\\n nc.variables['spherical'].long_name = 'Grid type logical switch'\\n nc.variables['spherical'][:] = grd.hgrid.spherical\\n print ' ... wrote ', 'spherical'\\n\\n write_nc_var(grd.hgrid.angle_rho, 'angle', ('eta_rho', 'xi_rho'), 'angle between XI-axis and EAST', 'radians')\\n\\n write_nc_var(grd.hgrid.mask_rho, 'mask_rho', ('eta_rho', 'xi_rho'), 'mask on RHO-points')\\n write_nc_var(grd.hgrid.mask_u, 'mask_u', ('eta_u', 'xi_u'), 'mask on U-points')\\n write_nc_var(grd.hgrid.mask_v, 'mask_v', ('eta_v', 'xi_v'), 'mask on V-points')\\n write_nc_var(grd.hgrid.mask_psi, 'mask_psi', ('eta_psi', 'xi_psi'), 'mask on psi-points')\\n\\n if visc_factor != None:\\n write_nc_var(visc_factor, 'visc_factor', ('eta_rho', 'xi_rho'), 'horizontal viscosity sponge factor')\\n if diff_factor != None:\\n write_nc_var(diff_factor, 'diff_factor', ('eta_rho', 'xi_rho'), 'horizontal diffusivity sponge factor')\\n \\n nc.close()\",\n \"def draw_cells(cell_list):\\n outrage_ratio = [x[4]/x[3] for x in cell_list]\\n # print(cell_list)\\n # print(outrage_ratio)\\n outrage_ratio = [min(x, 1) for x in outrage_ratio] # larger than 1 is outrage, use black color directly\\n # print_list = [round(x, 2) for x in outrage_ratio]\\n # print(print_list)\\n color_index = [int(x * len(COLOR_LIST)) for x in outrage_ratio]\\n\\n for cell in cell_list:\\n this_color_index = color_index[cell[2]-1]\\n this_cell_color = [i * 255 for i in list(COLOR_LIST[this_color_index-1].rgb)]\\n pygame.draw.rect(DISPLAY_SURF, this_cell_color, (cell[0], cell[1], CELL_SIZE, CELL_SIZE))\",\n \"def goodnessScore(roombas, obstacles, targeting, C1=3, C2=1, C3=1, C4=1, C5=2):\\n\\n def headingScore(roomba):\\n # print(roomba.visible_location.pose.pose.orientation)\\n heading = orientationToHeading(roomba.visible_location.pose.pose.orientation)\\n\\n return abs(np.sin(heading))\\n\\n def positionScore(roomba):\\n # the closer to the center, the lower the xScore, from 0 to 1\\n posX = roomba.visible_location.pose.pose.position.x\\n posY = roomba.visible_location.pose.pose.position.y\\n if(abs(posX) > 9.95 or abs(posY) > 9.95):\\n return -10000\\n xScore = abs(posX) / 10\\n # the closer to the green zone, the higher the yScore, from 0 to 1\\n yScore = posY / 20 + 0.5\\n return (xScore + yScore)/2\\n\\n def distanceFromObstaclesScore(roomba, obstacles):\\n \\\"\\\"\\\"\\n (-infinity, 0)\\n \\\"\\\"\\\"\\n\\n score = 0\\n MIN_OBSTACLE_DISTANCE = 0.5\\n for obstacle in obstacles:\\n x = roomba.visible_location.pose.pose.position.x - obstacle.visible_location.pose.pose.position.x\\n y = roomba.visible_location.pose.pose.position.y - obstacle.visible_location.pose.pose.position.y\\n dist = np.sqrt(x ** 2 + y ** 2)\\n\\n if dist < MIN_OBSTACLE_DISTANCE:\\n return -10000\\n\\n score -= 1 / dist ** 2\\n\\n return score\\n\\n def stateQualtityScore(roomba):\\n \\\"\\\"\\\"\\n How precisely we know the Roombas' state.\\n Compare position accuracy to view radius to know if it's possible\\n to see the given roomba when drone arrives.\\n \\\"\\\"\\\"\\n return 0\\n\\n def sameRoomba(roomba, targeting):\\n if(targeting != None and roomba.frame_id == targeting.frame_id):\\n return 1\\n else:\\n return 0\\n\\n result = []\\n\\n for i in xrange(0, len(roombas)):\\n roomba = roombas[i]\\n\\n score = C1 * headingScore(roomba) + \\\\\\n C2 * positionScore(roomba) + \\\\\\n C3 * distanceFromObstaclesScore(roomba, obstacles) + \\\\\\n C4 * stateQualtityScore(roomba) + \\\\\\n C5 * sameRoomba(roomba, targeting)\\n result.append((roomba, score))\\n\\n return result\",\n \"def GetCoastGrids(LandMask):\\n \\n \\\"\\\"\\\"\\n Define a coastline map. This map will be set to 1 on all coast cells.\\n \\\"\\\"\\\"\\n \\n \\n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\\n \\n \\\"\\\"\\\"\\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \\n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \\n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \\n \\\"\\\"\\\"\\n \\n for i in range(LandMask.shape[0]-1):\\n for j in range(LandMask.shape[1]-1):\\n \\n\\n \\\"\\\"\\\"\\n We have nine if statements, four for the corners, four for the sides and one for the middle\\n of the landmask. \\n \\\"\\\"\\\"\\n\\n if i == 0 and j == 0: #upper left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n \\n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1, j] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n \\n \\n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j-1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j-1] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i-1,j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i-1,j] = 1 \\n CoastlineMap[i-1, j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i-1, j] = 1\\n CoastlineMap[i-1,j-1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n \\n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j+1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n else:\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1 #middle\\n CoastlineMap[i+1,j] = 1#lowermiddle\\n CoastlineMap[i-1,j] = 1#uppermiddle\\n \\n CoastlineMap[i+1, j-1] = 1\\n CoastlineMap[i-1, j-1] = 1\\n CoastlineMap[i, j-1] =1\\n \\n CoastlineMap[i+1, j+1] = 1\\n CoastlineMap[i-1, j+1] = 1\\n CoastlineMap[i, j+1] = 1\\n \\n \\n \\n \\\"\\\"\\\"\\n Here we substract the landmaks from the coastline mask, resulting in only\\n the coastline. \\n \\\"\\\"\\\"\\n \\n \\n Coastgrids = CoastlineMap - LandMask\\n \\n return Coastgrids, CoastlineMap\",\n \"def test_res(pad_size = [50, 50],\\n num_squares = 1000,\\n width = 1,\\n res_layer = 0,\\n pad_layer = 1,\\n gnd_layer = 2):\\n x = pad_size[0]\\n z = pad_size[1]\\n\\n # Checking validity of input\\n if x <= 0 or z <= 0:\\n raise ValueError('Pad must have positive, real dimensions')\\n elif width > z:\\n raise ValueError('Width of cell cannot be greater than height of pad')\\n elif num_squares <= 0:\\n raise ValueError('Number of squares must be a positive real number')\\n elif width <= 0:\\n raise ValueError('Width of cell must be a positive real number')\\n\\n # Performing preliminary calculations\\n num_rows = int(np.floor(z / (2*width)))\\n if num_rows % 2 == 0:\\n num_rows -= 1\\n num_columns = num_rows - 1\\n squares_in_row = (num_squares - num_columns - 2)/num_rows\\n\\n # Compensating for weird edge cases\\n if squares_in_row < 1:\\n num_rows = int(round(num_rows / 2) - 2)\\n squares_in_row = 1\\n if width * 2 > z:\\n num_rows = 1\\n squares_in_row = num_squares - 2\\n\\n length_row = squares_in_row * width\\n\\n # Creating row/column corner combination structure\\n T = Device()\\n Row = rectangle(size = (length_row, width), layer = res_layer)\\n Col = rectangle(size = (width, width), layer = res_layer)\\n\\n row = T.add_ref(Row)\\n col = T.add_ref(Col)\\n col.move([length_row - width, -width])\\n\\n # Creating entire waveguide net\\n N = Device('net')\\n n = 1\\n for i in range(num_rows):\\n if i != num_rows - 1:\\n d = N.add_ref(T)\\n else:\\n d = N.add_ref(Row)\\n if n % 2 == 0:\\n d.mirror(p1 = (d.x, d.ymax), p2 = (d.x, d.ymin))\\n d.movey(-(n - 1) * T.ysize)\\n n += 1\\n d = N.add_ref(Col).movex(-width)\\n d = N.add_ref(Col).move([length_row, -(n - 2) * T.ysize])\\n\\n # Creating pads\\n P = Device('pads')\\n Pad1 = rectangle(size = (x, z), layer = pad_layer)\\n Pad2 = rectangle(size = (x + 5, z), layer = pad_layer)\\n Gnd1 = offset(Pad1, distance = -5, layer = gnd_layer)\\n Gnd2 = offset(Pad2, distance = -5, layer = gnd_layer)\\n pad1 = P.add_ref(Pad1).movex(-x - width)\\n pad2 = P.add_ref(Pad1).movex(length_row + width)\\n gnd1 = P.add_ref(Gnd1).center = pad1.center\\n gnd2 = P.add_ref(Gnd2)\\n nets = P.add_ref(N).y = pad1.y\\n gnd2.center = pad2.center\\n gnd2.movex(2.5)\\n\\n return P\",\n \"def draw_grid(self) -> None:\\n grid = self.life.curr_generation\\n for row in range(self.cell_height):\\n for column in range(self.cell_width):\\n if grid[row][column] == 1:\\n color = \\\"green\\\"\\n else:\\n color = \\\"white\\\"\\n pygame.draw.rect(\\n self.screen,\\n pygame.Color(color),\\n (column * self.cell_size, row * self.cell_size, self.cell_size, self.cell_size),\\n )\",\n \"def game_of_life():\\n # 3x3 neighbourhood\\n offsets = [[(y, x) for y in range(-1, 2)] for x in range(-1, 2)]\\n\\n # Create mappings\\n mappings = {}\\n for i in range(2 ** 9):\\n\\n # Determine the initial state (key)\\n key = f\\\"{bin(i)[2:]:0>9}\\\" # As binary string\\n key = tuple(k == \\\"1\\\" for k in key) # As tuple of bools\\n key = tuple(key[i * 3:i * 3 + 3] for i in range(3)) # Reshape into 2D grid\\n\\n # Alive counts\\n centre = key[1][1]\\n others = sum(sum(row) for row in key) - centre\\n\\n # Skip if state does not evaluate to True\\n if centre:\\n if others not in (2, 3):\\n continue\\n\\n else:\\n if others != 3:\\n continue\\n\\n mappings[key] = True\\n\\n return Mapping2DRuleset(mappings, offsets)\",\n \"def outcome(self, g):\\n if g[0][0] == g[1][0] == g[2][0] and g[0][0] != 0:\\n return g[0][0]\\n if g[0][1] == g[1][1] == g[2][1] and g[0][1] != 0:\\n return g[0][1]\\n if g[0][2] == g[1][2] == g[2][2] and g[0][2] != 0:\\n return g[0][2]\\n if g[0][0] == g[0][1] == g[0][2] and g[0][0] != 0:\\n return g[0][0]\\n if g[1][0] == g[1][1] == g[1][2] and g[1][0] != 0:\\n return g[1][0]\\n if g[2][0] == g[2][1] == g[2][2] and g[2][0] != 0:\\n return g[2][0]\\n if g[0][0] == g[1][1] == g[2][2] and g[0][0] != 0:\\n return g[0][0]\\n if g[0][2] == g[1][1] == g[2][0] and g[0][2] != 0:\\n return g[0][2]\\n return 0\",\n \"def redshift_draws(self, s_grid, num=1000):\\n n_obj = len(self)\\n z_draws = np.zeros((n_obj, num))\\n # i_range = np.random.rand_int(0, n_obj, len(se))\\n\\n for i in tqdm(range(n_obj)):\\n cdf_z = self['cdf_z'][i]\\n _, z_draws[i, :] = self.rvs_from_cdf(s_grid, cdf_z, num=num)\\n\\n return z_draws\",\n \"def infect(r, c):\\n subset = grid[r-1:r+2, c-1:c+2]\\n print(f\\\"Looking at ({r-1}, {c-1}) through ({r+1}, {c+1})\\\")\\n # np.where(subset == 0)\\n # subset[subset == 0] = np.fromfunction(calc_infect, shape=())\\n #v_calc_infect(subset[subset == 0])\\n #for i in np.nditer(subset):\\n # if subset[i] == 0:\\n # subset[i] = np.random.binomial(1, infect_rate)\\n for x in np.nditer(subset, op_flags=['readwrite']):\\n if x == 0:\\n x[...] = calc_infect()\\n\\n # for nr in np.arange(-1, 2):\\n # for nc in np.arange(-1, 2):\\n # try:\\n # if grid[r+nr, c+nc] == 0:\\n # grid[r+nr, c+nc] = np.random.binomial(1, infect_rate)\\n # except IndexError: # Out of bounds, ignore\\n # pass\",\n \"def generate_all_locations(grid, shape):\",\n \"def triangulos_rectangulos(opcion,b,h):\\n x1 =[0,0]\\n x2 =[b-1,h-1]\\n x3 =[b-1,0]\\n if opcion == 1:\\n lado1_x,lado1_y = dda_algrithm(x1[0],x1[1],x2[0],x2[1])\\n lado2_x,lado2_y = dda_algrithm(x1[0],x1[1],x3[0],x3[1])\\n lado3_x,lado3_y = dda_algrithm(x2[0],x2[1],x3[0],x3[1])\\n return [lado1_x,lado1_y,lado2_x,lado2_y,lado3_x,lado3_y]\\n else:\\n lado1_x,lado1_y = bresenham_algrithm(x1[0],x1[1],x2[0],x2[1])\\n lado2_x,lado2_y = bresenham_algrithm(x1[0],x1[1],x3[0],x3[1])\\n lado3_x,lado3_y = bresenham_algrithm(x2[0],x2[1],x3[0],x3[1])\\n return [lado1_x,lado1_y,lado2_x,lado2_y,lado3_x,lado3_y]\",\n \"def get_obstacles_map(obstacles, placed_pecies):\\n \\n #create a mask image to draw the obstacles on\\n blocks = np.zeros(ARENA_SIZE[::-1], np.uint8)\\n\\n #get the grid points where the robot needs to placed\\n grid = get_grid(ARENA_SIZE)\\n\\n #draw the obstacles and their safety region on the map\\n for i in obstacles.keys():\\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\\n cv2.rectangle(blocks, (i[0]-int(obstacles[i][0]/4), i[1]-int(obstacles[i][1]/4)), (i[0]+int(obstacles[i][0]/4), i[1]+int(obstacles[i][1]/4)), 255, -1)\\n\\n #draw the obstacles and their safety region on the map\\n for i in placed_pecies.keys():\\n try:\\n if not i == grid[5]:\\n cv2.circle(blocks, i, int(CIRCULAR_SAFETY_FACTOR*BLOCK_SIZE[0]), 129, -1)\\n else:\\n cv2.rectangle(blocks, (int(i[0]-7.4*placed_pecies[i][0]/4), int(i[1]-7.4*placed_pecies[i][1]/4)),\\n (int(i[0]+7.4*placed_pecies[i][0]/4), int(i[1]+7.4*placed_pecies[i][1]/4)), 129, -1)\\n cv2.rectangle(blocks, (i[0]-int(placed_pecies[i][0]/4), i[1]-int(placed_pecies[i][1]/4)), (i[0]+int(placed_pecies[i][0]/4), i[1]+int(placed_pecies[i][1]/4)), 255, -1)\\n except Exception as e:\\n print(e)\\n\\n return cv2.bitwise_not(blocks)\",\n \"def run_Simulation2(k,N=100,T=10,start = 1,p=0.5,q=0.08,startcenter = False,startcorner=False):\\n recover = [0]\\n infect = [start]\\n suspect = [N-start]\\n pop = [Person() for i in range(N)]\\n ##we need to change the code for the case start people infected\\n for i in range(start):\\n pop[i].get_infected();\\n if(startcenter):\\n resetcenter(start,pop)\\n if(startcorner):\\n resetcorner(start,pop)\\n np.random.seed(10)\\n for i in range(T):\\n for j in range(N):\\n pop[j].movepos(p)\\n X = calculatedistance(pop)\\n tree = cKDTree(X)\\n for j in range(N):\\n if pop[j].is_infected():\\n addvalue = np.array([X[j]])\\n inds = tree.query_ball_point(addvalue, q)\\n inds = inds[0]\\n #may have problem here\\n for l in inds:\\n if pop[l].is_willinfected():\\n pop[l].get_infected()\\n\\n for j in range(N):\\n if pop[j].is_infected():\\n if np.random.rand()< k:\\n pop[j].get_recovered()\\n\\n recover.append(count_recover(pop))\\n infect.append(count_infect(pop))\\n suspect.append(count_suspectial(pop))\\n newrecover = [i/N for i in recover]\\n newsuspect = [s/N for s in suspect]\\n newinfect = [i/N for i in infect]\\n plt.plot(range(T+1),newrecover,label = \\\"r: percentage of removed \\\")\\n plt.plot(range(T+1),newsuspect,label = \\\"s: percentage of susceptible\\\")\\n plt.plot(range(T+1),newinfect,label = \\\"i: percentage of infected\\\")\\n plt.xlabel(\\\"T\\\")\\n plt.ylabel(\\\"percentage\\\")\\n plt.title(\\\"Percentage of Population, Discrete\\\")\\n plt.legend()\\n plt.show()\",\n \"def advance_generation(self):\\n self.generation += 1\\n next_cells = [[self.cell_state['dead']] * self.cols for x in range(self.lines)]\\n for i in range(self.lines):\\n for j in range(self.cols):\\n neighbors = self.get_neighbors(i, j)\\n if self[i][j] == self.cell_state['alive']:\\n if neighbors == 2 or neighbors == 3:\\n next_cells[i][j] = self.cell_state['alive']\\n elif self[i][j] == self.cell_state['dead']:\\n if neighbors == 3:\\n next_cells[i][j] = self.cell_state['alive']\\n super().__init__(next_cells)\",\n \"def solution(n, m, r, c, k) -> int:\\n xs = []\\n # Add all the non-zero room widths to xs\\n last_column_wall = None\\n for col in c:\\n if last_column_wall is not None and col - last_column_wall - 1 > 0:\\n xs.append(col - last_column_wall - 1)\\n last_column_wall = col\\n ys = []\\n # Add all the non-zero room heights to ys\\n last_row_wall = None\\n for row in r:\\n if last_row_wall is not None and row - last_row_wall - 1 > 0:\\n ys.append(row - last_row_wall - 1)\\n last_row_wall = row\\n return aux(xs, ys, k)\",\n \"def getGameState(self):\\n ### Student code goes here\\n row1 = ()\\n row2 = ()\\n row3 = ()\\n for currRow in range(1,4):\\n for currCol in range(1,4):\\n tileFound = False\\n for fact in self.kb.facts:\\n if fact.statement.predicate == \\\"located\\\":\\n tile = fact.statement.terms[0].term.element\\n column = fact.statement.terms[1].term.element\\n row = fact.statement.terms[2].term.element\\n\\n tileNumber = int(tile[-1])\\n columnNumber = int(column[-1])\\n rowNumber = int(row[-1])\\n\\n if rowNumber == currRow and columnNumber == currCol:\\n tileFound = True\\n if rowNumber == 1:\\n row1 += tuple([tileNumber])\\n elif rowNumber == 2:\\n row2 += tuple([tileNumber])\\n elif rowNumber == 3:\\n row3 += tuple([tileNumber])\\n \\n break\\n\\n if not tileFound:\\n if currRow == 1:\\n row1 += tuple([-1])\\n elif currRow == 2:\\n row2 += tuple([-1])\\n elif currRow == 3:\\n row3 += tuple([-1])\\n\\n\\n return (row1, row2, row3)\",\n \"def generation(self,rounds):\\n a = []\\n b = []\\n for i in range(rounds):\\n self.fight()\\n c = self.avgFitness()\\n a.append(c[0])\\n b.append(c[1])\\n self.sort()\\n self.cull()\\n self.rePop()\\n self.refresh()\\n self.fight()\\n self.sort()\\n print self\\n plt.scatter([x for x in range(len(a))],a,color = \\\"red\\\")\\n plt.scatter([x for x in range(len(b))],b,color = \\\"green\\\")\\n plt.show()\",\n \"def generation(self,rounds):\\n a = []\\n b = []\\n for i in range(rounds):\\n self.fight()\\n c = self.avgFitness()\\n a.append(c[0])\\n b.append(c[1])\\n self.sort()\\n self.cull()\\n self.rePop()\\n self.refresh()\\n self.fight()\\n self.sort()\\n print self\\n plt.scatter([x for x in range(len(a))],a,color = \\\"red\\\")\\n plt.scatter([x for x in range(len(b))],b,color = \\\"green\\\")\\n plt.show()\",\n \"def make_n_glycan_neighborhoods():\\n neighborhoods = NeighborhoodCollection()\\n\\n _neuraminic = \\\"(%s)\\\" % ' + '.join(map(str, (\\n FrozenMonosaccharideResidue.from_iupac_lite(\\\"NeuAc\\\"),\\n FrozenMonosaccharideResidue.from_iupac_lite(\\\"NeuGc\\\")\\n )))\\n _hexose = \\\"(%s)\\\" % ' + '.join(\\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['Hex', ])))\\n _hexnac = \\\"(%s)\\\" % ' + '.join(\\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['HexNAc', ])))\\n\\n high_mannose = CompositionRangeRule(\\n _hexose, 3, 12) & CompositionRangeRule(\\n _hexnac, 2, 2) & CompositionRangeRule(\\n _neuraminic, 0, 0)\\n high_mannose.name = \\\"high-mannose\\\"\\n neighborhoods.add(high_mannose)\\n\\n base_hexnac = 3\\n base_neuac = 2\\n for i, spec in enumerate(['hybrid', 'bi', 'tri', 'tetra', 'penta', \\\"hexa\\\", \\\"hepta\\\"]):\\n if i == 0:\\n rule = CompositionRangeRule(\\n _hexnac, base_hexnac - 1, base_hexnac + 1\\n ) & CompositionRangeRule(\\n _neuraminic, 0, base_neuac) & CompositionRangeRule(\\n _hexose, base_hexnac + i - 1,\\n base_hexnac + i + 3)\\n rule.name = spec\\n neighborhoods.add(rule)\\n else:\\n sialo = CompositionRangeRule(\\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\\n ) & CompositionRangeRule(\\n _neuraminic, 1, base_neuac + i\\n ) & CompositionRangeRule(\\n _hexose, base_hexnac + i - 1,\\n base_hexnac + i + 2)\\n\\n sialo.name = \\\"%s-antennary\\\" % spec\\n asialo = CompositionRangeRule(\\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\\n ) & CompositionRangeRule(\\n _neuraminic, 0, 1 if i < 2 else 0\\n ) & CompositionRangeRule(\\n _hexose, base_hexnac + i - 1,\\n base_hexnac + i + 2)\\n\\n asialo.name = \\\"asialo-%s-antennary\\\" % spec\\n neighborhoods.add(sialo)\\n neighborhoods.add(asialo)\\n return neighborhoods\",\n \"def draw_grid(self):\\n\\n screen.fill(GREY)\\n\\n for row in self.grid:\\n for cell in row:\\n if cell.root:\\n color = GREEN\\n elif cell.goal:\\n color = RED\\n elif cell.value:\\n color = DARK_BLUE\\n elif cell.visited:\\n color = LIGHT_BLUE\\n elif cell.f:\\n color = LIGHT_GREEN\\n elif cell.wall:\\n color = GRAY\\n else:\\n color = WHITE\\n\\n pygame.draw.rect(screen, color, cell.rect)\\n\\n x, y = cell.rect.x, cell.rect.y\\n\\n if cell.g:\\n self.draw_score(x + 2, y + 2, cell.g)\\n if cell.h:\\n self.draw_score(x + 18, y + 2, cell.h)\\n if cell.f:\\n self.draw_score(x + 2, y + self.cell_size - 10, cell.f)\",\n \"def pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\\n def compute_avec(vec,aaa,bbb,grd):\\n\\n avec=np.empty(grd.np0,)\\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\\n avec[grd.vp1] = vec[grd.vp1]\\n\\n return avec,\\n if name_grd is not None:\\n if os.path.isfile(name_grd):\\n with open(name_grd, 'rb') as f:\\n grd = pickle.load(f)\\n else:\\n grd = Grid(lon,lat)\\n with open(name_grd, 'wb') as f:\\n pickle.dump(grd, f)\\n f.close()\\n else:\\n grd = Grid(lon,lat)\\n\\n ny,nx,=np.shape(hg)\\n g=grd.g\\n\\n\\n x=hg[grd.indi,grd.indj]\\n q1d=q[grd.indi,grd.indj]\\n\\n aaa=g/grd.f01d\\n bbb=-g*grd.f01d/c**2\\n ccc=+q1d\\n\\n aaa[grd.vp1]=0\\n bbb[grd.vp1]=1\\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\\n\\n vec=+x\\n\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n p=-gg\\n\\n for itr in range(nitr-1):\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n tmp=np.dot(p,avec)\\n\\n if tmp!=0. : s=-np.dot(p,gg)/tmp\\n else: s=1.\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n vec=+x\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n a2=np.dot(gg,gg)\\n\\n if a1!=0: beta=a2/a1\\n else: beta=1.\\n\\n p=-gg+beta*p\\n\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n val1=-np.dot(p,gg)\\n val2=np.dot(p,avec)\\n if (val2==0.):\\n s=1.\\n else:\\n s=val1/val2\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n\\n # back to 2D\\n h=np.empty((ny,nx))\\n h[:,:]=np.NAN\\n h[grd.indi,grd.indj]=x[:]\\n\\n\\n return h\",\n \"def run(self):\\n\\t\\tfrom loc import loc as Loc\\n\\t\\tfor r in range(1,self.size):\\n\\t\\t\\tfor c in range(self.size): \\n\\t\\t\\t\\tthis = Loc(r,c)\\n\\t\\t\\t\\tself.state.set_cell(this, self.rule(self.neighbor_vals(this), self.__prob))\\n\\t\\tself.__ran = True\",\n \"def play_round_Conway_Cell(self):\\n for x in self.board:\\n for f in x:\\n f.live_neighbors = 0\\n\\n for i in range(1, self.cols - 1):\\n for j in range(1, self.rows - 1):\\n status = self.board[i][j].status\\n assert type(status)==int \\n\\n for m in range(i - 1, i + 2):\\n for n in range(j - 1, j + 2):\\n self.board[m][n].live_neighbors += status\\n self.board[i][j].live_neighbors -= status\",\n \"def recombination(parents):\\n\\n # pick 5 random numbers that add up to 1\\n random_values = np.random.dirichlet(np.ones(5),size=1)[0]\\n\\n # those random values will serve as weights for the genes 2 offspring get (whole arithmetic recombination)\\n offspring1 = random_values[0] * parents[0] + random_values[1] * parents[1] + random_values[2] * parents[2] + random_values[3] * parents[3] + \\\\\\n random_values[4] * parents[4]\\n\\n # repeat for offspring 2\\n random_values = np.random.dirichlet(np.ones(5),size=1)[0]\\n offspring2 = random_values[0] * parents[0] + random_values[1] * parents[1] + random_values[2] * parents[2] + random_values[3] * parents[3] + \\\\\\n random_values[4] * parents[4]\\n\\n # the other 2 offspring will come from 4-point crossover\\n random_points = np.sort(np.random.randint(1, parents[0].shape[0]-2, 4))\\n\\n # to make it so that it won't always be p1 who gives the first portion of DNA etc, we shuffle the parents\\n np.random.shuffle(parents)\\n\\n # add the genes together\\n offspring3 = np.concatenate((parents[0][0:random_points[0]], parents[1][random_points[0]:random_points[1]], parents[2][random_points[1]:random_points[2]],\\\\\\n parents[3][random_points[2]:random_points[3]], parents[4][random_points[3]:]))\\n\\n # repeat for offspring 4\\n random_points = np.sort(np.random.randint(1, parents[0].shape[0]-2, 4))\\n np.random.shuffle(parents)\\n offspring4 = np.concatenate((parents[0][0:random_points[0]], parents[1][random_points[0]:random_points[1]], parents[2][random_points[1]:random_points[2]],\\\\\\n parents[3][random_points[2]:random_points[3]], parents[4][random_points[3]:]))\\n\\n # return the offspring\\n return np.concatenate(([offspring1], [offspring2], [offspring3], [offspring4]))\",\n \"def drawValidationNeedles(self): \\n #productive #onButton\\n profprint()\\n # reset report table\\n # print \\\"Draw manually segmented needles...\\\"\\n #self.table =None\\n #self.row=0\\n self.initTableView()\\n self.deleteEvaluationNeedlesFromTable()\\n while slicer.util.getNodes('manual-seg*') != {}:\\n nodes = slicer.util.getNodes('manual-seg*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\\n \\n if self.tableValueCtrPt==[[]]:\\n self.tableValueCtrPt = [[[999,999,999] for i in range(100)] for j in range(100)]\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLAnnotationFiducialNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n for nthNode in range(nbNode):\\n modelNode=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLAnnotationFiducialNode')\\n if modelNode.GetAttribute(\\\"ValidationNeedle\\\") == \\\"1\\\":\\n needleNumber = int(modelNode.GetAttribute(\\\"NeedleNumber\\\"))\\n needleStep = int(modelNode.GetAttribute(\\\"NeedleStep\\\"))\\n coord=[0,0,0]\\n modelNode.GetFiducialCoordinates(coord)\\n self.tableValueCtrPt[needleNumber][needleStep]=coord\\n print needleNumber,needleStep,coord\\n # print self.tableValueCtrPt[needleNumber][needleStep]\\n\\n for i in range(len(self.tableValueCtrPt)):\\n if self.tableValueCtrPt[i][1]!=[999,999,999]:\\n colorVar = random.randrange(50,100,1)/float(100)\\n controlPointsUnsorted = [val for val in self.tableValueCtrPt[i] if val !=[999,999,999]]\\n controlPoints=self.sortTable(controlPointsUnsorted,(2,1,0))\\n self.addNeedleToScene(controlPoints,i,'Validation')\\n else:\\n # print i\\n pass\",\n \"def vision(image):\\n vis_map = resize(image, alpha, beta)\\n print(\\\"Resized map from the blue mask\\\")\\n\\n world = rotate(vis_map)\\n\\n plt.figure()\\n plt.imshow(world[:, :, ::-1])\\n plt.show()\\n object_grid, occupancy_grid = detect_object(world)\\n print(\\\"Result of the red mask\\\")\\n plt.figure()\\n plt.imshow(occupancy_grid)\\n plt.show()\\n return object_grid, occupancy_grid, world\",\n \"def create_grid(self):\\n row = 0\\n col = 0\\n for row in range(self._dim):\\n for col in range(self._dim):\\n x1 = col*self._cell_dim # bottom left\\n y1 = row * self._cell_dim # top left\\n x2 = x1 + self._cell_dim # bottom right\\n y2 = y1 + self._cell_dim # top right\\n self.rect[row,col] = self.canvas.create_rectangle(x1,y1,x2,y2, fill=self._primary_color, outline=self._grid_lines_color, tags=\\\"rect\\\")\\n self.canvas.tag_bind(self.rect[row, col], '<ButtonPress-1>', self.change_cell)\\n col = 0\\n row += 1\\n if self._dim < 50:\\n button_size = int(80*(self._dim/50))\\n font_size = int(22*(self._dim/50))\\n else:\\n button_size = 80\\n font_size = 18\\n x1 = col * self._cell_dim + (((self._dim*self._cell_dim) - button_size*3)//2)\\n y1 = row * self._cell_dim + 5\\n x2 = x1 + button_size\\n y2 = y1 + 20\\n self.canvas.create_oval(x1,y1,x2,y2, tags=\\\"toggle\\\", fill=self._primary_color)\\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\\\"toggle-text\\\", fill=self._secondary_color, text=\\\"Start\\\", font=(\\\"Courier\\\", font_size))\\n self.canvas.tag_bind(\\\"toggle\\\", '<ButtonPress-1>', self.toggle_refresh)\\n self.canvas.tag_bind(\\\"toggle-text\\\", '<ButtonPress-1>', self.toggle_refresh)\\n x1 = x2 + 5 # padding between buttons\\n x2 = x1 + button_size\\n self.canvas.create_oval(x1,y1,x2,y2, tags=\\\"next\\\", fill=self._primary_color)\\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\\\"next-text\\\", fill=self._secondary_color, text=\\\"Next\\\", font=(\\\"Courier\\\", font_size))\\n self.canvas.tag_bind(\\\"next\\\", '<ButtonPress-1>', self.one_step)\\n self.canvas.tag_bind(\\\"next-text\\\", '<ButtonPress-1>', self.one_step)\\n x1 = x2 + 5 # padding between buttons\\n x2 = x1 + button_size\\n self.canvas.create_oval(x1,y1,x2,y2, tags=\\\"clear\\\", fill=self._primary_color)\\n self.canvas.create_text(x1+(button_size//2), y1+10, tags=\\\"clear-text\\\", fill=self._secondary_color, text=\\\"Clear\\\", font=(\\\"Courier\\\", font_size))\\n self.canvas.tag_bind(\\\"clear\\\", '<ButtonPress-1>', self.clear_board)\\n self.canvas.tag_bind(\\\"clear-text\\\", '<ButtonPress-1>', self.clear_board)\\n self.model_refresh()\",\n \"def make_game_grid(self):\\n return numpy.array([[random.choice(string.ascii_uppercase) for breath in range(self.grid_size)] for depth in\\n range(self.grid_size)])\",\n \"def gen_static_landscape(pop,conc):\\n # get final landscape and seascape\\n landscape = np.zeros(pop.n_genotype)\\n for kk in range(pop.n_genotype):\\n landscape[kk] = gen_fitness(pop,\\n kk,\\n pop.static_topo_dose,\\n pop.drugless_rates,\\n pop.ic50)\\n \\n if min(landscape) == 0:\\n zero_indx_land = np.argwhere(landscape==0)\\n landscape_t = np.delete(landscape,zero_indx_land)\\n min_landscape = min(landscape_t)\\n else:\\n min_landscape = min(landscape)\\n zero_indx_land = []\\n \\n seascape = np.zeros(pop.n_genotype)\\n for gen in range(pop.n_genotype):\\n seascape[gen] = gen_fitness(gen,conc,pop.drugless_rates,pop.ic50,pop=pop)\\n \\n if min(seascape) == 0:\\n zero_indx_sea = np.argwhere(seascape==0)\\n seascape_t = np.delete(seascape,zero_indx_sea)\\n min_seascape = min(seascape_t)\\n else:\\n min_seascape = min(seascape)\\n \\n landscape = landscape - min_landscape\\n landscape = landscape/max(landscape)\\n \\n rng = max(seascape) - min_seascape\\n \\n landscape = landscape*rng + min_seascape\\n \\n landscape[zero_indx_land] = 0\\n return landscape\",\n \"def refresh_view(self):\\n if self._step_number % 2 == 0:\\n self._view.draw_enemies(self._game.enemies)\\n self._view.draw_towers(self._game.towers)\\n self._view.draw_obstacles(self._game.obstacles)\",\n \"def make_grid(m, n, k):\\n \\n grid = np.zeros(m*n)\\n \\n mine_indecies = np.arange(m*n)\\n np.random.shuffle(mine_indecies)\\n mine_indecies = mine_indecies[:k]\\n \\n #print('mine_indecies:', mine_indecies)\\n #print(np.arange(m*n).reshape((m,n)))\\n \\n for i in mine_indecies:\\n mask = get_mask(m, n, i)\\n #print(mask.reshape((m,n)))\\n grid = grid + mask\\n \\n grid[mine_indecies] = -1\\n grid.resize((m,n))\\n return grid\",\n \"def get_obstacles(image):\\n\\n ih, iw = image.shape[:2]\\n image_copy = image.copy()\\n\\n #resize the image to the size of arena\\n image = cv2.resize(image, ARENA_SIZE, interpolation=cv2.INTER_CUBIC)\\n gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\n\\n #replace all black pixels to white pixels\\n gray[np.where(gray == 0)]= 255\\n\\n #get the thresholded binary image\\n ret,threshold = cv2.threshold(gray,200,255,cv2.THRESH_BINARY_INV)\\n\\n #find all the countours in the binary image\\n _, contours, heiarchy = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n cont = []\\n\\n #create a mask to draw contours on\\n blocks = mask = np.zeros(threshold.shape[:2], np.uint8)\\n\\n #create a dictionary to hold image roi of all puzzle peices\\n blocks_roi = {}\\n\\n #iterate through all contours\\n for i, c in enumerate(contours[1:]):\\n\\n #find the minimum area fitting rectangle of the contour\\n rect = cv2.minAreaRect(c)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n\\n #create the copy of the mask\\n mask_copy = mask.copy()\\n\\n #draw the rectangle on the mask\\n cv2.drawContours(mask_copy, [box], -1, (255,255,255), 3)\\n\\n #floodfill the rectangle\\n cv2.floodFill(mask_copy, None, (0,0), 255)\\n mask_inv = cv2.bitwise_not(mask_copy)\\n blocks = cv2.add(blocks, mask_inv)\\n\\n _, contours, heiarchy = cv2.findContours(blocks, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n obstacles = {}\\n\\n for c in contours:\\n x,y,w,h = cv2.boundingRect(c)\\n obstacles.update({(int(x+w/2), int(y+h/2)): BLOCK_SIZE})\\n #obstacles.update({(int(x+w/2), int(y+h/2)): (w, h)}) # for unknown block sizes\\n bottom_r = remap((x+w, y+h), ARENA_SIZE, (iw,ih))\\n top_l = remap((x, y), ARENA_SIZE, (iw,ih))\\n blocks_roi.update({(int(x+w/2), int(y+h/2)): image_copy[top_l[1]:bottom_r[1], top_l[0]:bottom_r[0]]})\\n\\n return obstacles, blocks_roi\",\n \"def rectangular(m, n, len1=1.0, len2=1.0, origin = (0.0, 0.0)):\\n\\n from anuga.config import epsilon\\n\\n delta1 = float(len1)/m\\n delta2 = float(len2)/n\\n\\n #Calculate number of points\\n Np = (m+1)*(n+1)\\n\\n class Index(object):\\n\\n def __init__(self, n,m):\\n self.n = n\\n self.m = m\\n\\n def __call__(self, i,j):\\n return j+i*(self.n+1)\\n\\n\\n index = Index(n,m)\\n\\n points = num.zeros((Np, 2), float)\\n\\n for i in range(m+1):\\n for j in range(n+1):\\n\\n points[index(i,j),:] = [i*delta1 + origin[0], j*delta2 + origin[1]]\\n\\n #Construct 2 triangles per rectangular element and assign tags to boundary\\n #Calculate number of triangles\\n Nt = 2*m*n\\n\\n\\n elements = num.zeros((Nt, 3), int)\\n boundary = {}\\n nt = -1\\n for i in range(m):\\n for j in range(n):\\n nt = nt + 1\\n i1 = index(i,j+1)\\n i2 = index(i,j)\\n i3 = index(i+1,j+1)\\n i4 = index(i+1,j)\\n\\n\\n #Update boundary dictionary and create elements\\n if i == m-1:\\n boundary[nt, 2] = 'right'\\n if j == 0:\\n boundary[nt, 1] = 'bottom'\\n elements[nt,:] = [i4,i3,i2] #Lower element\\n nt = nt + 1\\n\\n if i == 0:\\n boundary[nt, 2] = 'left'\\n if j == n-1:\\n boundary[nt, 1] = 'top'\\n elements[nt,:] = [i1,i2,i3] #Upper element\\n\\n return points, elements, boundary\",\n \"def evaluate(self, state):\\n\\t\\ttranspose = state.board.transpose()\\t\\t# columns in state.board = rows in transpose\\n\\t\\tcount = []\\n\\t\\topponentcount = []\\n\\t\\tfor row, column in zip(state.board, transpose):\\n\\t\\t\\trowcounter = collections.Counter(row)\\n\\t\\t\\tcolumncounter = collections.Counter(column)\\n\\t\\t\\tcount.append(rowcounter.get(state.current_player, 0))\\n\\t\\t\\tcount.append(columncounter.get(state.current_player, 0))\\n\\t\\t\\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\\n\\t\\t\\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\\n\\n\\t\\tY = state.board[:, ::-1]\\n\\t\\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\\n\\t\\tmain_diagonal_count = collections.Counter(diagonals[0])\\n\\t\\tsecond_diagonal_count = collections.Counter(diagonals[1])\\n\\t\\tcount.append(main_diagonal_count.get(state.current_player, 0))\\n\\t\\tcount.append(second_diagonal_count.get(state.current_player, 0))\\n\\t\\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\\n\\t\\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\\n\\n\\t\\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\tscoremax = 5 ** max(count)\\n\\t\\tscoremin = 5 ** max(opponentcount)\\n\\n\\t\\treturn scoremax - scoremin\",\n \"def show_possibles(self):\\n for row in range(self.board_size):\\n for col in range(self.board_size):\\n poss = list(self.possibles[row][col])\\n if poss:\\n teil = qbwrdd.Tile(poss, self.board.scene)\\n teil.cell = \\\"poss\\\"\\n cell = row * self.board_size + col\\n pos_x, pos_y = self.board.cells[cell].x(), self.board.cells[cell].y()\\n if col % 3 > 0:\\n pos_x += 2\\n self.poss_tiles[row][col] = teil\\n teil.draw_tile_at(pos_x, pos_y)\",\n \"def make_board(self):\\n generate = lambda: random.randint(1, 100) in range(1, self.p_pit+1)\\n some_number = self.some_number\\n agent = Agent(some_number)\\n agent.program = Oozeplorer_Percept(agent)\\n self.add_agent(agent)\\n gold = Gold()\\n self.add_thing(gold, None)\\n for row in range(1, some_number + 1):\\n for col in range(1, some_number + 1):\\n valid_spot = (row, col) != gold.location and (row, col) != (1, 1)\\n if valid_spot and generate():\\n t_pt = Pit()\\n t_pt.location = (row, col)\\n self.things.append(t_pt)\",\n \"def create_glider(i, j, grid):\\n\\n glider = np.array([[0, 0, 1],\\n [1, 0, 1],\\n [0, 1, 1]])\\n grid[i:i+3:, j:j+3] = glider\",\n \"def table_cells_cropper(img_path=DEFAULT_IMAGE_PATH, cropped_img_dir=\\\"/home/denny_k/Documents/work/puller_blueprints_ocr/needed_tables/cropped/\\\"):\\n\\n # Image preparation\\n img = cv2.imread(img_path)\\n img_height = img.shape[0]\\n img_width = img.shape[1]\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n gray = cv2.GaussianBlur(gray, (7, 7), 0)\\n gray = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 75, 10)\\n\\n gray = cv2.erode(gray, (3, 3), iterations=1)\\n bw = cv2.bitwise_not(gray)\\n bw = cv2.adaptiveThreshold(bw, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 15, -2)\\n circle_result = deepcopy(img)\\n\\n # Finding all vertical and horizontal lines\\n horizontal = bw\\n vertical = bw\\n\\n horizontal_scale = 10\\n vertical_scale = 10\\n\\n horizontalsize = int(horizontal.shape[1] / horizontal_scale)\\n\\n horizontal_structure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontalsize, 1))\\n\\n horizontal = cv2.erode(horizontal, horizontal_structure, (-1, -1))\\n horizontal = cv2.dilate(horizontal, horizontal_structure, (-1, -1))\\n\\n vertical_size = int(vertical.shape[0] / vertical_scale)\\n\\n vertical_structure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, vertical_size))\\n\\n vertical = cv2.erode(vertical, vertical_structure, (-1, -1))\\n vertical = cv2.dilate(vertical, vertical_structure, (-1, -1))\\n\\n img_without_lines = img\\n\\n mask = horizontal + vertical\\n\\n # Using mask to remove all lines from image\\n whiteImg = np.zeros(img_without_lines.shape, img_without_lines.dtype)\\n whiteImg[:, :] = (255, 255, 255)\\n whiteMask = cv2.bitwise_and(whiteImg, whiteImg, mask=mask)\\n\\n kernel = np.ones((5, 5), np.uint8)\\n whiteMask = cv2.dilate(whiteMask, kernel, iterations=1)\\n\\n cv2.addWeighted(whiteMask, 1, img_without_lines, 1, 0, img_without_lines)\\n\\n corners = cv2.bitwise_and(horizontal, vertical)\\n\\n points = list()\\n point = dict()\\n lines = list()\\n\\n # Filters points in line intersections and save them as dict's using horizontal axis\\n for y in range(img_height):\\n for x in range(img_width):\\n point['x'] = int()\\n point['y'] = int()\\n if corners[y][x]:\\n point_control = True\\n point['x'] = x\\n point['y'] = y\\n if points:\\n for comp_point in points:\\n if point['x'] - 25 < comp_point['x'] < point['x'] + 25 and \\\\\\n point['y'] - 25 < comp_point['y'] < point['y'] + 25:\\n point_control = False\\n if point_control:\\n points.append(deepcopy(point))\\n else:\\n points.append(deepcopy(point))\\n\\n if points:\\n # Same filter as previous, but using other vertical axis\\n points.sort(key=lambda x: x['y'])\\n lines = list()\\n current_line = dict()\\n current_line['points'] = list()\\n current_point = points[0]\\n for point_counter in range(len(points)):\\n if points[point_counter]['y'] <= current_point['y'] + 15:\\n current_line['points'].append(points[point_counter])\\n else:\\n if current_line['points']:\\n lines.append(current_line)\\n current_point = points[point_counter]\\n current_line = dict()\\n current_line['points'] = list()\\n current_line['points'].append(points[point_counter])\\n\\n if current_line:\\n lines.append(current_line)\\n\\n cropped_img_list = list()\\n\\n # Removing emply lines and calculate horizontal line width\\n if lines:\\n for line in lines:\\n if len(line['points']) <= 1:\\n lines.remove(line)\\n continue\\n line['points'].sort(key=lambda x: x['x'])\\n\\n line['line_length'] = 0\\n start_point = line['points'][0]\\n end_point = line['points'][0]\\n for point_counter in range(len(line['points'])):\\n if point_counter == len(line['points']) - 1:\\n end_point = line['points'][point_counter]\\n line['line_length'] = int(end_point['x'] - start_point['x'])\\n cv2.circle(circle_result, (line['points'][point_counter]['x'], line['points'][point_counter]['y']), 25, (0, 255, 0), thickness=5)\\n\\n # Page segmentation using points\\n img_num = 1\\n if len(lines) > 1:\\n row = 1\\n for line_counter in range(len(lines) - 1):\\n\\n if abs(lines[line_counter]['line_length'] - lines[line_counter + 1]['line_length']) \\\\\\n < 0.5 * lines[line_counter]['line_length']:\\n for point_counter1 in range(len(lines[line_counter]['points']) - 1):\\n\\n point_a = lines[line_counter]['points'][point_counter1]\\n point_b = dict()\\n point_c = dict()\\n point_d = dict()\\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\\\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\\n point_d = lines[line_counter + 1]['points'][point_counter2]\\n point_b = lines[line_counter]['points'][point_counter1 + 1]\\n for point_counter2 in range(len(lines[line_counter + 1]['points'])):\\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\\\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\\n point_c = lines[line_counter + 1]['points'][point_counter2]\\n\\n if point_a and point_b and point_d and not point_c:\\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\\n if point_d == lines[line_counter + 1]['points'][point_counter2]:\\n point_c = lines[line_counter + 1]['points'][point_counter2 + 1]\\n\\n for point_counter2 in range(len(lines[line_counter]['points'])):\\n if lines[line_counter]['points'][point_counter2]['x'] - 15 < point_c['x'] < \\\\\\n lines[line_counter]['points'][point_counter2]['x'] + 15:\\n point_b = lines[line_counter]['points'][point_counter2]\\n if point_a and point_b and point_c and point_d:\\n is_subline = False\\n cropped_img_params = dict()\\n crop_img = img[point_a['y']: point_d['y'],\\n point_a['x']: point_b['x']]\\n\\n full_path = cropped_img_dir + \\\"img_%s.png\\\" % (img_num)\\n cv2.imwrite(full_path, crop_img)\\n\\n subprocess.call(\\n 'convert -density 300x300 -units PixelsPerInch \\\"%(file)s\\\" \\\"%(file)s\\\"' % (\\n {\\\"file\\\": full_path}),\\n shell=True, executable='/bin/bash')\\n\\n cropped_img_params['img_path'] = full_path\\n cropped_img_params['x_topleft'] = point_a['x']\\n cropped_img_params['y_topleft'] = point_a['y']\\n cropped_img_params['width'] = point_b['x'] - point_a['x']\\n cropped_img_params['height'] = point_d['y'] - point_a['y']\\n cropped_img_params['row_num'] = row\\n\\n if lines[line_counter]['line_length'] < 0.6 * lines[line_counter + 1]['line_length']:\\n is_subline = True\\n cropped_img_params['is_subline'] = is_subline\\n\\n cropped_img_list.append(cropped_img_params)\\n\\n img_num += 1\\n\\n\\n else:\\n for point_counter1 in range(len(lines[line_counter]['points']) - 1):\\n point_a = lines[line_counter]['points'][point_counter1]\\n point_b = dict()\\n point_c = dict()\\n point_d = dict()\\n for point_counter2 in range(len(lines[line_counter + 1]['points']) - 1):\\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\\\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\\n point_d = lines[line_counter + 1]['points'][point_counter2]\\n\\n if not point_d:\\n for point_counter2 in range(len(lines[line_counter + 2]['points']) - 1):\\n if lines[line_counter + 2]['points'][point_counter2]['x'] - 15 < point_a['x'] < \\\\\\n lines[line_counter + 2]['points'][point_counter2]['x'] + 15:\\n point_d = lines[line_counter + 2]['points'][point_counter2]\\n\\n point_b = lines[line_counter]['points'][point_counter1 + 1]\\n\\n for point_counter2 in range(len(lines[line_counter + 1]['points'])):\\n if lines[line_counter + 1]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\\\\n lines[line_counter + 1]['points'][point_counter2]['x'] + 15:\\n point_c = lines[line_counter + 1]['points'][point_counter2]\\n\\n if not point_c:\\n for point_counter2 in range(len(lines[line_counter + 2]['points'])):\\n if lines[line_counter + 2]['points'][point_counter2]['x'] - 15 < point_b['x'] < \\\\\\n lines[line_counter + 2]['points'][point_counter2]['x'] + 15:\\n point_c = lines[line_counter + 2]['points'][point_counter2]\\n\\n if point_a and point_b and point_c and point_d:\\n cropped_img_params = dict()\\n is_subline = False\\n crop_img = img_without_lines[point_a['y']: point_d['y'],\\n point_a['x']: point_b['x']]\\n\\n full_path = cropped_img_dir + \\\"img_%s.png\\\" % (img_num)\\n cv2.imwrite(full_path, crop_img)\\n\\n subprocess.call(\\n 'convert -density 300x300 -units PixelsPerInch \\\"%(file)s\\\" \\\"%(file)s\\\"' % (\\n {\\\"file\\\": full_path}),\\n shell=True, executable='/bin/bash')\\n\\n cropped_img_params['img_path'] = full_path\\n cropped_img_params['x_topleft'] = point_a['x']\\n cropped_img_params['y_topleft'] = point_a['y']\\n cropped_img_params['width'] = point_b['x'] - point_a['x']\\n cropped_img_params['height'] = point_d['y'] - point_a['y']\\n cropped_img_params['row_num'] = row\\n\\n\\n if lines[line_counter]['line_length'] < 0.6 * lines[line_counter + 1]['line_length']:\\n is_subline = True\\n cropped_img_params['is_subline'] = is_subline\\n\\n cropped_img_list.append(cropped_img_params)\\n img_num += 1\\n row += 1\\n\\n return cropped_img_list\",\n \"def global_analysis(tomo, b_th, c=18):\\n\\n ## Thesholding and Volume analysis\\n if c == 6:\\n con_mat = [ [[0, 0, 0], [0, 1, 0], [0, 0, 0]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[0, 0, 0], [0, 1, 0], [0, 0, 0]] ]\\n elif c == 18:\\n con_mat = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[0, 1, 0], [1, 1, 1], [0, 1, 0]]]\\n elif c == 26:\\n con_mat = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]],\\n [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]\\n else:\\n raise ValueError\\n tomo_lbl, num_lbls = sp.ndimage.label(tomo >= b_th, structure=np.ones(shape=[3, 3, 3]))\\n tomo_out = np.zeros(shape=tomo.shape, dtype=int)\\n lut = np.zeros(shape=num_lbls+1, dtype=int)\\n\\n ## COUNTING REGIONS METHODS\\n # import time\\n # hold_t = time.time()\\n # for lbl in range(1, num_lbls + 1):\\n # ids = tomo == lbl\\n # feat_sz = len(ids)\\n # tomo_out[ids] = feat_sz\\n # # print('[1]:', lbl, 'of', num_lbls)\\n # print time.time() - hold_t\\n\\n ## COUNTING PIXELS METHOD\\n ## Count loop\\n # cont, total = 0, np.prod(tomo.shape)\\n # import time\\n # hold_t = time.time()\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n lut[id] += 1\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n #\\n ## Write loop\\n # cont, total = 0, np.prod(tomo.shape)\\n\\n for x in range(tomo.shape[0]):\\n for y in range(tomo.shape[1]):\\n for z in range(tomo.shape[2]):\\n id = tomo_lbl[x, y, z]\\n if id > 0:\\n tomo_out[x, y, z] = lut[id]\\n # cont += 1\\n # print('[1]:', cont, 'of', total)\\n # print time.time() - hold_t\\n\\n return tomo_out\",\n \"def create_grids(self):\\n \\n par = self.par\\n\\n # a. retirement\\n \\n # pre-decision states\\n par.grid_m_ret = nonlinspace(par.eps,par.m_max_ret,par.Nm_ret,par.phi_m)\\n par.Nmcon_ret = par.Nm_ret - par.Na_ret\\n \\n # post-decision states\\n par.grid_a_ret = nonlinspace(0,par.a_max_ret,par.Na_ret,par.phi_m)\\n \\n # b. working: state space (m,n,k) \\n par.grid_m = nonlinspace(par.eps,par.m_max,par.Nm,par.phi_m)\\n\\n par.Nn = par.Nm\\n par.n_max = par.m_max + par.n_add\\n par.grid_n = nonlinspace(0,par.n_max,par.Nn,par.phi_n)\\n\\n par.grid_n_nd, par.grid_m_nd = np.meshgrid(par.grid_n,par.grid_m,indexing='ij')\\n\\n # c. working: w interpolant (and wa and wb and wq)\\n par.Na_pd = np.int_(np.floor(par.pd_fac*par.Nm))\\n par.a_max = par.m_max + par.a_add\\n par.grid_a_pd = nonlinspace(0,par.a_max,par.Na_pd,par.phi_m)\\n \\n par.Nb_pd = np.int_(np.floor(par.pd_fac*par.Nn))\\n par.b_max = par.n_max + par.b_add\\n par.grid_b_pd = nonlinspace(0,par.b_max,par.Nb_pd,par.phi_n)\\n \\n par.grid_b_pd_nd, par.grid_a_pd_nd = np.meshgrid(par.grid_b_pd,par.grid_a_pd,indexing='ij')\\n \\n # d. working: egm (seperate grids for each segment)\\n \\n if par.solmethod == 'G2EGM':\\n\\n # i. dcon\\n par.d_dcon = np.zeros((par.Na_pd,par.Nb_pd),dtype=np.float_,order='C')\\n \\n # ii. acon\\n par.Nc_acon = np.int_(np.floor(par.Na_pd*par.acon_fac))\\n par.Nb_acon = np.int_(np.floor(par.Nb_pd*par.acon_fac))\\n par.grid_b_acon = nonlinspace(0,par.b_max,par.Nb_acon,par.phi_n)\\n par.a_acon = np.zeros(par.grid_b_acon.shape)\\n par.b_acon = par.grid_b_acon\\n\\n # iii. con\\n par.Nc_con = np.int_(np.floor(par.Na_pd*par.con_fac))\\n par.Nb_con = np.int_(np.floor(par.Nb_pd*par.con_fac))\\n \\n par.grid_c_con = nonlinspace(par.eps,par.m_max,par.Nc_con,par.phi_m)\\n par.grid_b_con = nonlinspace(0,par.b_max,par.Nb_con,par.phi_n)\\n\\n par.b_con,par.c_con = np.meshgrid(par.grid_b_con,par.grid_c_con,indexing='ij')\\n par.a_con = np.zeros(par.c_con.shape)\\n par.d_con = np.zeros(par.c_con.shape)\\n \\n elif par.solmethod == 'NEGM':\\n\\n par.grid_l = par.grid_m\\n\\n # e. shocks\\n assert (par.Neta == 1 and par.var_eta == 0) or (par.Neta > 1 and par.var_eta > 0)\\n\\n if par.Neta > 1:\\n par.eta,par.w_eta = log_normal_gauss_hermite(np.sqrt(par.var_eta), par.Neta)\\n else:\\n par.eta = np.ones(1)\\n par.w_eta = np.ones(1)\\n\\n # f. timings\\n par.time_work = np.zeros(par.T)\\n par.time_w = np.zeros(par.T)\\n par.time_egm = np.zeros(par.T)\\n par.time_vfi = np.zeros(par.T)\",\n \"def robotGridSummaryDict(self):\\n rgd = self.robotGridDict(incRobotDict=False)\\n robotDict = {}\\n for rid, robot in self.robotDict.items():\\n r = {}\\n # print(\\\"rid\\\", robot.id, robot.alpha, robot.beta)\\n r[\\\"id\\\"] = robot.id\\n r[\\\"nDecollide\\\"] = robot.nDecollide\\n r[\\\"lastStepNum\\\"] = robot.lastStepNum\\n r[\\\"assignedTargetID\\\"] = robot.assignedTargetID\\n r[\\\"hasApogee\\\"] = robot.hasApogee\\n r[\\\"hasBoss\\\"] = robot.hasBoss\\n r[\\\"xPos\\\"] = robot.xPos\\n r[\\\"yPos\\\"] = robot.yPos\\n r[\\\"alpha\\\"] = robot.alpha\\n r[\\\"beta\\\"] = robot.beta\\n r[\\\"destinationAlpha\\\"] = robot.destinationAlpha\\n r[\\\"desstinationBeta\\\"] = robot.destinationBeta\\n r[\\\"angStep\\\"] = robot.angStep\\n r[\\\"collisionBuffer\\\"] = robot.collisionBuffer\\n\\n # convert from numpy arrays to lists\\n r[\\\"metFiberPos\\\"] = list(robot.metFiberPos)\\n r[\\\"bossFiberPos\\\"] = list(robot.bossFiberPos)\\n r[\\\"apFiberPos\\\"] = list(robot.apFiberPos)\\n r[\\\"roughAlphaX\\\"] = robot.roughAlphaX[-1][-1]\\n r[\\\"roughAlphaY\\\"] = robot.roughAlphaY[-1][-1]\\n r[\\\"roughBetaX\\\"] = robot.roughBetaX[-1][-1]\\n r[\\\"roughBetaY\\\"] = robot.roughBetaY[-1][-1]\\n # find the step at which this\\n # guy found its target\\n # otv = np.array(robot.onTargetVec)\\n # print(\\\"otargvec\\\", otv)\\n # r[\\\"onTargetVec\\\"] = robot.onTargetVec[-1]\\n # # find last False (after which must be true)\\n # # +1 because step numbers start from 1 and indices start from 0\\n # whereFalse = np.argwhere(otv==False).flatten()\\n # if not whereFalse:\\n # # empty list started on target? thats crazy\\n # lastFalse = 0\\n # else:\\n # lastFalse = int(whereFalse[-1] + 1)\\n # if lastFalse == len(otv):\\n # # last step was false robot never got there\\n # r[\\\"stepConverged\\\"] = str(-1 )# -1 incicates never got to target\\n # else:\\n # r[\\\"stepConverged\\\"] = str(lastFalse)\\n robotDict[robot.id] = r\\n\\n rgd[\\\"robotDict\\\"] = robotDict\\n return rgd\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60586804","0.59049714","0.58672416","0.58215404","0.5733954","0.5612951","0.55945617","0.55556804","0.5546608","0.55396324","0.5498219","0.5490474","0.54275817","0.54215384","0.54196","0.54184324","0.5405503","0.53821653","0.53821653","0.537462","0.5356651","0.5348837","0.5346475","0.5336974","0.5331376","0.5327409","0.5322127","0.53163546","0.5308762","0.5306954","0.52885306","0.52807146","0.5260626","0.52560955","0.5238154","0.5234305","0.5228547","0.52076095","0.5203164","0.5200106","0.5194138","0.51873726","0.51800555","0.5176399","0.5175308","0.5174418","0.5167856","0.5159552","0.5118984","0.51170605","0.5115771","0.51125497","0.5111321","0.5105827","0.5099809","0.5096137","0.50930804","0.50929266","0.5092645","0.50900203","0.508744","0.50865775","0.5080366","0.5079987","0.5079281","0.50575703","0.5057185","0.5049935","0.50493985","0.5048617","0.50466985","0.5046677","0.50464165","0.5043966","0.50432444","0.5040366","0.5040366","0.503828","0.5035988","0.5034496","0.50341034","0.50340784","0.50293064","0.5025816","0.5025692","0.50228906","0.50214756","0.50196934","0.5019241","0.5015653","0.50140375","0.50128376","0.5011377","0.5011371","0.5010595","0.50071603","0.50066465","0.5004086","0.5003392","0.4998603"],"string":"[\n \"0.60586804\",\n \"0.59049714\",\n \"0.58672416\",\n \"0.58215404\",\n \"0.5733954\",\n \"0.5612951\",\n \"0.55945617\",\n \"0.55556804\",\n \"0.5546608\",\n \"0.55396324\",\n \"0.5498219\",\n \"0.5490474\",\n \"0.54275817\",\n \"0.54215384\",\n \"0.54196\",\n \"0.54184324\",\n \"0.5405503\",\n \"0.53821653\",\n \"0.53821653\",\n \"0.537462\",\n \"0.5356651\",\n \"0.5348837\",\n \"0.5346475\",\n \"0.5336974\",\n \"0.5331376\",\n \"0.5327409\",\n \"0.5322127\",\n \"0.53163546\",\n \"0.5308762\",\n \"0.5306954\",\n \"0.52885306\",\n \"0.52807146\",\n \"0.5260626\",\n \"0.52560955\",\n \"0.5238154\",\n \"0.5234305\",\n \"0.5228547\",\n \"0.52076095\",\n \"0.5203164\",\n \"0.5200106\",\n \"0.5194138\",\n \"0.51873726\",\n \"0.51800555\",\n \"0.5176399\",\n \"0.5175308\",\n \"0.5174418\",\n \"0.5167856\",\n \"0.5159552\",\n \"0.5118984\",\n \"0.51170605\",\n \"0.5115771\",\n \"0.51125497\",\n \"0.5111321\",\n \"0.5105827\",\n \"0.5099809\",\n \"0.5096137\",\n \"0.50930804\",\n \"0.50929266\",\n \"0.5092645\",\n \"0.50900203\",\n \"0.508744\",\n \"0.50865775\",\n \"0.5080366\",\n \"0.5079987\",\n \"0.5079281\",\n \"0.50575703\",\n \"0.5057185\",\n \"0.5049935\",\n \"0.50493985\",\n \"0.5048617\",\n \"0.50466985\",\n \"0.5046677\",\n \"0.50464165\",\n \"0.5043966\",\n \"0.50432444\",\n \"0.5040366\",\n \"0.5040366\",\n \"0.503828\",\n \"0.5035988\",\n \"0.5034496\",\n \"0.50341034\",\n \"0.50340784\",\n \"0.50293064\",\n \"0.5025816\",\n \"0.5025692\",\n \"0.50228906\",\n \"0.50214756\",\n \"0.50196934\",\n \"0.5019241\",\n \"0.5015653\",\n \"0.50140375\",\n \"0.50128376\",\n \"0.5011377\",\n \"0.5011371\",\n \"0.5010595\",\n \"0.50071603\",\n \"0.50066465\",\n \"0.5004086\",\n \"0.5003392\",\n \"0.4998603\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5189932"},"document_rank":{"kind":"string","value":"41"}}},{"rowIdx":9298,"cells":{"query":{"kind":"string","value":"Summary Display function that generates the final output images using opencv windows"},"document":{"kind":"string","value":"def imagetest(thetainput,doubleopponencyinput):\n theta = thetainput\n rgcMode = doubleopponencyinput\n\n\n C = retina.sample(img,x,y,coeff[i],loc[i],rgb=True) # CENTRE\n S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True) # SURROUND\n \n if rgcMode == 0:\n \tpV,nV = rgc.opponency(C,S,theta)\n else:\n \tpV,nV = rgc.doubleopponency(C,S,theta)\n cv2.namedWindow(\"Input\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"Input\", img)\n rIntensity,cIntensity = showNonOpponency(C,theta)\n cv2.namedWindow(\"Intensity Responses\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"Intensity Responses\", rIntensity)\n cv2.namedWindow(\"Intensity Responses Cortex\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"Intensity Responses Cortex\", cIntensity)\n cv2.waitKey(0)\n #Generate backprojected images\n if showInverse:\n rOpponent = showBPImg(pV,nV)\n cv2.namedWindow(\"Backprojected Opponent Cells Output\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"Backprojected Opponent Cells Output\", rOpponent)\n cv2.waitKey(0)\n # Cortex\n if showCortex:\n cOpponent = showCortexImg(pV,nV)\n cv2.namedWindow(\"Cortex Opponent Cells Output\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"Cortex Opponent Cells Output\", cOpponent)\n cv2.waitKey(0)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def show(self, name='Detections'):\n cv2.imshow(name, self.get_image())\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def show(self) -> None:\n cv.imshow(str(self.__class__), self.output_image)","def display_img(title,img):\r\n cv2.namedWindow('img', cv2.WINDOW_NORMAL)\r\n cv2.setWindowTitle('img',title)\r\n cv2.resizeWindow('img',600,400)\r\n\r\n #Display Image on screen\r\n cv2.imshow('img',img)\r\n\r\n #Mantain output until user presses a key\r\n cv2.waitKey(0)\r\n\r\n #Destroy windows when user presses a key\r\n cv2.destroyAllWindows()","def display_images():\n vc = cv2.VideoCapture(0) # Open webcam\n figure, ax = plt.subplots(1, 2, figsize=(10, 5)) # Intiialise plot\n\n count = 0 # Counter for number of aquired frames\n intensity = [] # Append intensity across time\n\n # For loop over generator here\n intensity.append(imageintensity)\n plot_image_and_brightness() # Call plot function\n count += 1\n\n # This triggers exit sequences when user presses q\n if cv2.waitKey(1) & 0xFF == ord('q'):\n # Clean up here\n plt.close('all') # close plots\n generator.close() # Use generator exit for clean up,\n break # break loop","def display_image(img, label):\n cv2.imshow(label,img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def display_data():\n data = read_data_from_file()\n data_size = len(data)\n print('Data size - ' + str(data_size))\n\n\n for i in range(data_size-1, 0, -1):\n image = data[i]\n cv2.imshow('window', image[0])\n print(str(image[1]))\n cv2.waitKey(50)","def displayImg(self):\r\n\r\n\t# If you want to skip n frames, set value to 0 to see all images\r\n\tSKIP = 4500\r\n for idx in range(len(self.centers)):\r\n\t if idx < SKIP:\r\n\t\tcontinue\r\n file_left = self.lefts[idx][5]\r\n file_center = self.centers[idx][5]\r\n file_right = self.rights[idx][5]\r\n\r\n img_left = cv2.imread(os.path.join(self.pathDir, file_left), \\\r\n cv2.IMREAD_COLOR)\r\n img_center = cv2.imread(os.path.join(self.pathDir, file_center), \\\r\n cv2.IMREAD_COLOR)\r\n img_right = cv2.imread(os.path.join(self.pathDir, file_right), \\\r\n cv2.IMREAD_COLOR)\r\n\r\n\t #Resize the image to 50%\r\n img_l = cv2.resize(img_left, None, fx=0.5, fy=0.5, \\\r\n interpolation = cv2.INTER_LINEAR)\r\n img_c = cv2.resize(img_center, None, fx=0.5, fy=0.5, \\\r\n interpolation = cv2.INTER_LINEAR)\r\n img_r = cv2.resize(img_right, None, fx=0.5, fy=0.5, \\\r\n interpolation = cv2.INTER_LINEAR)\r\n \r\n height, width = img_c.shape[:2]\r\n new_img = np.zeros((height, width*3, img_c.shape[2]),\r\n np.uint8)\r\n\r\n #Adding sequence numbers and Time\r\n\t #Left\r\n strTime = self.timestampToStr(self.lefts[idx][1])\r\n\t self.putTextToImg(img_l, self.lefts[idx][0], strTime, height)\r\n\t #Center\r\n\t strTime = self.timestampToStr(self.centers[idx][1])\r\n\t self.putTextToImg(img_c, self.centers[idx][0], strTime, height)\r\n\t #Right\r\n\t strTime = self.timestampToStr(self.rights[idx][1])\r\n\t self.putTextToImg(img_r, self.rights[idx][0], strTime, height)\r\n\t \r\n\t angle = float(self.angles_at_timestamps[idx])\r\n\t speed = float(self.speed_at_timestamps[idx])\r\n\r\n\t print \"speed: %f - angle: %f\" % (speed, angle)\r\n\r\n\t self.draw_path_on(img_c, speed, angle)\r\n\r\n\t #Generate the new image\r\n for i in range(height):\r\n new_img[i] = np.concatenate((img_l[i, : ], img_c[i, : ], \\\r\n img_r[i, : ]))\r\n \r\n\r\n cv2.imshow('Udacity Challenge 2 - Viewer', new_img)\r\n key = cv2.waitKey(30)\r\n\r\n # Press q to exit\r\n if key == ord('q'):\r\n break\r\n\r\n cv2.destroyAllWindows()","def view(self, name_of_window=\"Image\") -> None:\n cv2.namedWindow(name_of_window, cv2.WINDOW_NORMAL)\n cv2.imshow(name_of_window, self.img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def displayImage(winName, img):\n cv.imshow(winName, img)\n cv.waitKey(0)","def view(self):\n\t\tfigure_out = self.figure.copy()\n\t\timage_pairs = np.unique(self.local_matches[\"image_pairs\"][0])\n\t\tfor i in image_pairs:\n\t\t\t# draw bounding box\n\t\t\ti_loc = self.local_database[\"image_locs\"][np.where(self.local_database[\"image_idx\"] == i)[0][0]]\n\t\t\tcv2.rectangle(figure_out, (int(i_loc[0]), int(i_loc[1])), (int(i_loc[0]+i_loc[2]), int(i_loc[1]+i_loc[3])),\n\t\t\t\t\t\t color = (255,0,0), thickness=5)\n\t\t\t# label matches text\n\t\t\tcv2.putText(figure_out, str(i), (int(i_loc[0]-50), int(i_loc[1] + 50)), cv2.FONT_HERSHEY_SIMPLEX, 2,\n\t\t\t\t\t color=(255,0,0), thickness=7)\n\t\tself.save_figure(figure_out)","def show(type,img):\n # print(img)\n cv2.imshow(type, img)\n cv2.waitKey()","def showImage(self, img):\n cv2.namedWindow(self.NAME_WINDOW,cv2.WINDOW_NORMAL)\n cv2.resizeWindow(self.NAME_WINDOW, 300, 700)\n cv2.imshow(self.NAME_WINDOW , img)\n cv2.waitKey(0)","def show_results(datapath,nImg,mods,input_data=None,loop=True,fn=None,start_frame=None,frame_ids=None):\n cap = cv2.VideoCapture(datapath);\n cont = True;\n #Write the results to video if filename is provided\n if fn is not None:\n out = cv2.VideoWriter('..\\\\'+fn,cv2.VideoWriter_fourcc(*'mjpa'), 10, (768*2,768));\n out_vid = True;\n else:\n out_vid = False;\n\n while cont:\n #Set the video to the correct start frame\n if start_frame is not None:\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame);\n for i in range(nImg):\n #If the frames aren't sequential, jump to correct next frame\n if frame_ids is not None:\n cap.set(cv2.CAP_PROP_POS_FRAMES,frame_ids[i]);\n \n #Get the next frame and the rendered image for that frame\n _,frame = cap.read();\n crop = ut.crop(frame,256,320);\n render = cv2.imread(cf.renders_path + \"{:04d}.png\".format(i+1));\n \n #Add the images to the data dict or create it if needed\n data = {'frame':frame,'crop':crop,'render':render,'i':i};\n if input_data is not None:\n data.update(input_data);\n \n #Apply each module's function to the data to get the images\n frames = [];\n for m in mods:\n frames.append(m(data));\n \n # Display the resulting frame\n row1 = np.concatenate(frames[0:3],axis=1);\n row2 = np.concatenate(frames[3:6],axis=1);\n row3 = np.concatenate(frames[6:9],axis=1); \n grid = np.concatenate([row1,row2,row3]);\n \n out_frame = np.concatenate([grid,render],axis=1);\n cv2.imshow('frame',out_frame);\n \n if out_vid:\n out.write(out_frame);\n \n if cv2.waitKey(40) & 0xFF == ord('q'):\n cont = False;\n break;\n if not loop:\n cont = False;\n cv2.destroyAllWindows();\n cap.release();\n if out_vid:\n out.release();","def display_image(window_name, img):\n cv2.imshow(window_name, img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def show_image(self):\n cv2.imshow(self.config.DISPLAY_NAME, self.image)","def display_image(self, window_title: str = 'Drone Camera'):\n cv2.imshow(window_title, self.output)\n cv2.waitKey(1)","def show_image(self):\n cv2.imshow('Image', self.__diff_image())\n cv2.waitKey()","def img_disp(name,img):\n cv2.imshow(name,img.astype(int)/255.0)\n cv2.waitKey()","def display(image, name=\"Image\"):\n cv2.imshow(name, image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n cv2.imwrite(\"{}.png\".format(name), image)","def print_images_in_statistics(self):\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)","def show_images(images):\n for name, img in images:\n cv2.imshow(name, img)\n\n cv2.waitKey(0)","def show_image(self, idx):\n image, target = self.__getitem__(self, idx)\n im_h, im_w, _ = image.size()\n labels_num = target['labels']\n rescale = torch.tensor([[im_w, im_h, im_w, im_h]])\n bboxs = target['boxes'] * rescale\n img = image.permute(1, 2, 0).numpy()\n for i, bboxe in enumerate(bboxs):\n x, y, xm, ym = bboxe\n label = class_name[int(labels_num[i])]\n plot_one_box((int(x), int(y), int(xm), int(ym)), img, label=label, line_thickness=3)\n cv2.imshow('image', img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def print_images_out_statistics(self):\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)","def show_img(graphs = False):\n while True:\n screen = (yield)\n window_title = \"logs\" if graphs else \"game_play\"\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL) \n imS = cv2.resize(screen, (800, 400)) \n cv2.imshow(window_title, screen)\n if (cv2.waitKey(1) & 0xFF == ord('q')):\n cv2.destroyAllWindows()\n break","def _state_main(self, gui):\n gui.entry.wait_variable(gui.entry_sv)\n\n '''Clean string'''\n files = literal_eval(gui.entry_sv.get())\n\n '''Remove previous images'''\n if hasattr(gui, \"panel\"):\n gui.panel.destroy()\n\n '''Load each image'''\n for file_name in files:\n file_name = file_name.replace(\"{\", \"\").replace(\"}\", \"\")\n # image = tk.PhotoImage(file=file_name)\n if \".CR2\" in file_name:\n '''Rawpy implementation'''\n file_image = rawpy.imread(file_name)\n file_image = file_image.postprocess()\n '''Rawkit implementation'''\n '''file_image = Raw(file_name)\n file_image = np.array(file_image.to_buffer())'''\n '''OpenCV implementation'''\n '''file_image = cv2.imread(file_name)'''\n else:\n file_image = Image.open(file_name)\n '''image = file_image.resize((500, 500), Image.ANTIALIAS)\n image = ImageTk.PhotoImage(image)\n gui.panel = tk.Label(gui.root, image=image)\n gui.panel.image = image\n gui.panel.pack()'''\n # panel.grid(row=2)\n\n image_data = np.array(file_image)\n image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY)\n '''print(image_data.shape)\n print(image_data)\n print(len(image_data))\n print(len(image_data[0]))'''\n returned_image = Image.fromarray(image_data)\n '''cv2.imshow(\"Gray\", image_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Gray\")'''\n\n '''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image))\n enhanced_image = enhanced_contrast.enhance(255)\n enhanced_data = np.array(enhanced_image)\n plot_functions.imshow(enhanced_image)\n plot_functions.show()'''\n\n # color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV)\n # print(color_space)\n \n '''Create mask for white-ish pixels'''\n '''lower_background = np.array([150, 150, 150])\n upper_background = np.array([255, 255, 255])\n print(image_data)\n white_mask = cv2.inRange(image_data, lower_background, upper_background)\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8))\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\n white_mask = white_mask / 255'''\n\n '''Create mask for black-ish pixels'''\n '''lower_background = np.array([0, 0, 0])\n upper_background = np.array([25, 25, 25])\n black_mask = cv2.inRange(image_data, lower_background, upper_background)\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\n black_mask = black_mask / 255'''\n\n '''Add masks together'''\n '''background_mask = white_mask\n # Ensure no value is above 1\n background_mask = np.clip(background_mask, 0, 1)'''\n \n copied_image_data = np.asarray(returned_image).copy()\n # background_mask = np.logical_not(background_mask)\n '''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)):\n # place black pixel on corresponding masked pixels\n # copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))])\n # make pixel fully white on corresponding masked pixels\n copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])'''\n\n '''Turn removed pixels red'''\n '''mask_image = Image.fromarray(copied_image_data)\n plot_functions.imshow(mask_image)\n plot_functions.show()'''\n trapezoid_data = copied_image_data.copy()\n\n enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(trapezoid_data))\n enhanced_image = enhanced_contrast.enhance(255)\n trapezoid_data = np.array(enhanced_image)\n\n '''Detect lines'''\n edges = cv2.Canny(trapezoid_data, 75, 150)\n lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, maxLineGap=1000)\n # print(lines)\n for line in lines:\n x1, y1, x2, y2 = line[0]\n if y1 == y2:\n cv2.line(copied_image_data, (x1, y1), (x2, y2), (255, 255, 255), 1)\n\n '''Trapezoid attempt'''\n\n # filters image bilaterally and displays it\n bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175)\n\n # finds edges of bilaterally filtered image and displays it\n edgeImg = cv2.Canny(bilatImg, 75, 200)\n\n # gets contours (outlines) for shapes and sorts from largest area to smallest area\n contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\n\n # drawing red contours on the image\n for con in contours:\n cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3)\n\n '''Detect corners'''\n dst = cv2.cornerHarris(edges, 30, 31, 0.001)\n dst = cv2.dilate(dst, None)\n ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)\n dst = np.uint8(dst)\n\n # find centroids\n ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)\n # define the criteria to stop and refine the corners\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,\n 0.001)\n corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5),\n (-1, -1), criteria)\n\n good_corners = []\n for corner in corners:\n if (corner[1] < 1000) & (corner[1] > 650) & (corner[0] > 250) & (corner[0] < 2250):\n good_corners.append(corner)\n cv2.circle(edges, (corner[0], corner[1]), 10, (255, 255, 255))\n\n print(good_corners)\n if len(good_corners) >= 3:\n corner_combos = itertools.combinations(good_corners, 3)\n elif len(good_corners) > 1:\n corner_combos = itertools.combinations(good_corners, 2)\n\n best_corner_combo = None\n best_coef = np.inf\n for corner_combo in corner_combos:\n regression = LinearRegression().fit(np.array([corner[0] for corner in corner_combo]).reshape(-1, 1),\n np.array([corner[1] for corner in corner_combo]))\n if np.abs(regression.coef_) < best_coef:\n best_coef = np.abs(regression.coef_)\n best_corner_combo = np.array([corner[1] for corner in corner_combo])\n\n y_edge = int(round(np.mean(best_corner_combo)))\n edges = edges[y_edge:3000, 200:2200]\n copied_image_data = copied_image_data[y_edge:2500, 200:2200]\n trapezoid_data = trapezoid_data[y_edge:2500, 200:2200]\n\n # and double-checking the outcome\n cv2.imshow(\"linesEdges\", edges)\n cv2.imshow(\"linesDetected\", copied_image_data)\n cv2.imshow(\"Contours check\", trapezoid_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Contours check\")\n\n # find the perimeter of the first closed contour\n perim = cv2.arcLength(contours[0], True)\n # setting the precision\n epsilon = 0.02 * perim\n # approximating the contour with a polygon\n approxCorners = cv2.approxPolyDP(contours[0], epsilon, True)\n # check how many vertices has the approximate polygon\n approxCornersNumber = len(approxCorners)\n\n for corners in approxCorners:\n cv2.circle(trapezoid_data, (corners[0], corners[1]), radius=10, color=(255, 255, 255), thickness=-1)\n cv2.imshow(\"Vertex position\", trapezoid_data)\n cv2.waitKey()\n cv2.destroyWindow(\"Vertex position\")\n cv2.imshow(\"linesEdges\", edges)\n cv2.imshow(\"linesDetected\", copied_image_data)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def show_image(window_title = ''):\n while True:\n screen = (yield)\n window_title = window_title\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL)\n \n # stack each of the provided greyscale images horizontally.\n img = None\n for s in range(screen.shape[2]):\n if img is None:\n img = screen[:, :, s]\n else:\n img = np.hstack((img, screen[:, :, s]))\n \n cv2.imshow(window_title, img)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n cv2.destroyAllWindows()\n break","def show(img, name=\"img\"):\n cv2.imshow(name, img)\n cv2.waitKey(0)\n cv2.destroyWindow(name)","def display_image(self, window_name, image):\n cv2.namedWindow(window_name)\n cv2.imshow(window_name, image)\n cv2.waitKey(0)","def display_sample(display_list):\n plt.figure(figsize=(18, 18))\n\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n\n for i in range(len(display_list)):\n plt.subplot(1, len(display_list), i+1)\n plt.title(title[i])\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n plt.axis('off')\n plt.show()","def show(img, win_name='qr code'):\n cv2.imshow(win_name, img)\n cv2.waitKey(0)","def run_ML_onImg_and_display(self):\r\n self.Matdisplay_Figure.clear()\r\n ax1 = self.Matdisplay_Figure.add_subplot(111)\r\n \r\n # Depends on show_mask or not, the returned figure will be input raw image with mask or not.\r\n self.MLresults, self.Matdisplay_Figure_axis, self.unmasked_fig = self.ProcessML.DetectionOnImage(self.MLtargetedImg, axis = ax1, show_mask=False, show_bbox=False) \r\n self.Mask = self.MLresults['masks']\r\n self.Label = self.MLresults['class_ids']\r\n self.Score = self.MLresults['scores']\r\n self.Bbox = self.MLresults['rois']\r\n\r\n self.SelectedCellIndex = 0\r\n self.NumCells = int(len(self.Label))\r\n self.selected_ML_Index = []\r\n self.selected_cells_infor_dict = {}\r\n \r\n self.Matdisplay_Figure_axis.imshow(self.unmasked_fig.astype(np.uint8))\r\n \r\n self.Matdisplay_Figure.tight_layout()\r\n self.Matdisplay_Canvas.draw()","def display_image(window_name, image):\n cv2.namedWindow(window_name)\n cv2.imshow(window_name, image)\n cv2.waitKey(0)","def main():\n \n # for inserting other images, add tem to /input folder and list them here\n images = (\n 'image-0',\n 'image-1',\n 'image-2'\n )\n\n for image_name in images:\n print(image_name, \"image:\")\n\n image = open_image(image_name)\n display_image(image, \"Original input \" + image_name)\n\n grayscale_v = transform_colors(image)\n display_image(grayscale_v[:,:,0], \"Grayscale \" + image_name)\n save_image(image_name + \"-grayscale\", grayscale_v[:,:,0])\n\n contours_v, contours = get_contours(grayscale_v)\n display_image(contours_v, \"Contours \" + image_name)\n save_image(image_name + \"-contours\", contours_v)\n\n labeled_img, areas = get_measures(image, contours[1:])\n display_image(labeled_img, \"Labeled \" + image_name)\n save_image(image_name + \"-labeled\", labeled_img)\n\n areas_histogram(areas, image_name)","def visualize_output(\n self,\n img: np.ndarray,\n output_data: List[DetectObject]) -> np.ndarray:\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n self.layer = dpg.add_draw_layer(\n parent=f'main_window_{self.id}',\n tag=draw_layer_tag,\n show=False\n )\n for out in output_data:\n description = f'{out.clsname} [{out.score*100:.2f}%]'\n # add alpha and convert to RGB\n color = np.array(self.class_colors[out.clsname])\n color = tuple((255*color).astype(np.uint8))\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=(out.xmin*self.width,\n out.ymin*self.height),\n pmax=(out.xmax*self.width,\n out.ymax*self.height),\n color=color,\n thickness=2\n )\n dpg.draw_text(\n parent=draw_layer_tag,\n text=description,\n pos=(out.xmin*self.width + _PADDING,\n out.ymin*self.height + _PADDING),\n color=color,\n size=_FONT_SIZE\n )\n\n return img","def display(self):\n display(self.image)","def display(img, name=\"IMAGE\", wait=0):\n\tcv2.namedWindow(name, cv2.WINDOW_NORMAL)\n\tcv2.imshow(name, img)\n\tcv2.waitKey(wait) & 0xFF\n\tcv2.destroyAllWindows()","def visualize(image, preds, fps):\n # show inference info\n fps_text = \"FPS : {:.2f}\".format(fps)\n cv2.putText(image, fps_text, (11, 40), cv2.FONT_HERSHEY_PLAIN, 4.0, (238, 130, 238), 4, cv2.LINE_AA)\n\n if preds.shape[0] != 0:\n for box in preds:\n (x1, y1, x2, y2) = box.astype(np.int)\n cv2.rectangle(image, (x1, y1), (x2, y2), (255, 255, 0), 2)\n\n return image","def display_images(digits_im):\n i = 0\n\n for img in digits_im:\n if i < N_NEIGHBOURS:\n # Visualize your data\n im_max = np.max(img)\n img = PIXELS * (np.abs(im_max - img) / im_max)\n res = cv2.resize(img, (DIM, DIM), interpolation=cv2.INTER_CUBIC)\n cv2.imwrite('digit ' + str(i) + '.png', res)\n i += 1\n else:\n break","def run_visualization(image):\n # for image in images:\n try:\n with tf.gfile.FastGFile(image, 'rb') as f:\n jpeg_str = f.read()\n original_im = Image.open(BytesIO(jpeg_str))\n except IOError:\n print('Cannot retrieve image')\n return\n\n # print('running deeplab on image {0}'.format(image))\n resized_im, seg_map = MODEL.run(original_im)\n seg_map = seg_map.astype(np.uint8) * 255\n resized_im = np.array(resized_im, dtype=np.uint8)\n resized_im = cv2.cvtColor(resized_im, cv2.COLOR_BGR2RGB)\n # vis_segmentation(resized_im, seg_map,FULL_COLOR_MAP ,LABEL_NAMES)\n overlay_image = cv2.addWeighted(resized_im, 0.8, cv2.merge((seg_map * 0, seg_map, seg_map * 0)), 0.2, 0)\n # time.sleep(params.SEC_BETWEEN_PREDICTION)\n\n return resized_im, seg_map, overlay_image.astype(np.uint8)","def show_to_window(self):\n if self.normal_mode:\n self.show_image.show_original_image(\n self.image, self.width_original_image)\n self.show_image.show_result_image(\n self.image, self.width_result_image, self.angle)\n\n else:\n if self.panorama_mode:\n image = draw_polygon(\n self.image.copy(),\n self.mapX_pano,\n self.mapY_pano)\n mapX = np.load(\n './plugins/Thread_inspection/view_image/maps_pano/mapX.npy')\n mapY = np.load(\n './plugins/Thread_inspection/view_image/maps_pano/mapY.npy')\n rho = self.panorama.rho\n\n self.result_image = cv2.remap(\n self.image,\n mapX,\n mapY,\n cv2.INTER_CUBIC)\n self.result_image = self.result_image[round(\n rho + round(self.moildev.getRhoFromAlpha(30))):self.h, 0:self.w]\n # print(self.width_result_image)\n else:\n image = draw_polygon(self.image.copy(), self.mapX, self.mapY)\n self.result_image = cv2.remap(\n self.image,\n self.mapX,\n self.mapY,\n cv2.INTER_CUBIC)\n self.show_image.show_original_image(\n image, self.width_original_image)\n self.show_image.show_result_image(\n self.result_image, self.width_result_image, self.angle)","def visual_image(img, annos, save_path, ratio=None, height=None, width=None, name=None, score_threshold=0.01):\n # annos: list type, in which all the element is dict\n h, w = img.shape[0], img.shape[1]\n if height is not None and width is not None and (height != h or width != w):\n img, annos = resize_image(img, annos, width, height)\n elif ratio not in (None, 1):\n img, annos = resize_image(img, annos, w * ratio, h * ratio)\n\n h, w = img.shape[0], img.shape[1]\n num_objects = len(annos)\n num = 0\n\n def define_color(pair):\n \"\"\"define line color\"\"\"\n left_part = [0, 1, 3, 5, 7, 9, 11, 13, 15]\n right_part = [0, 2, 4, 6, 8, 10, 12, 14, 16]\n if pair[0] in left_part and pair[1] in left_part:\n color = (255, 0, 0)\n elif pair[0] in right_part and pair[1] in right_part:\n color = (0, 0, 255)\n else:\n color = (139, 0, 255)\n return color\n\n def visible(a, w, h):\n return a[0] >= 0 and a[0] < w and a[1] >= 0 and a[1] < h\n\n for i in range(num_objects):\n ann = annos[i]\n bbox = coco_box_to_bbox(ann['bbox'])\n if \"score\" in ann and (ann[\"score\"] >= score_threshold or num == 0):\n num += 1\n txt = (\"p\" + \"{:.2f}\".format(ann[\"score\"]))\n cv2.putText(img, txt, (bbox[0], bbox[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)\n\n ct = (int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2))\n cv2.circle(img, ct, 2, (0, 255, 0), thickness=-1, lineType=cv2.FILLED)\n bbox = np.array(bbox, dtype=np.int32).tolist()\n cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)\n\n keypoints = ann[\"keypoints\"]\n keypoints = np.array(keypoints, dtype=np.int32).reshape(_NUM_JOINTS, 3).tolist()\n\n for pair in data_cfg.edges:\n partA = pair[0]\n partB = pair[1]\n color = define_color(pair)\n p_a = tuple(keypoints[partA][:2])\n p_b = tuple(keypoints[partB][:2])\n mask_a = keypoints[partA][2]\n mask_b = keypoints[partB][2]\n if (visible(p_a, w, h) and visible(p_b, w, h) and mask_a * mask_b > 0):\n cv2.line(img, p_a, p_b, color, 2)\n cv2.circle(img, p_a, 3, color, thickness=-1, lineType=cv2.FILLED)\n cv2.circle(img, p_b, 3, color, thickness=-1, lineType=cv2.FILLED)\n\n img_id = annos[0][\"image_id\"] if annos and \"image_id\" in annos[0] else random.randint(0, 9999999)\n image_name = \"cv_image_\" + str(img_id) + \".png\" if name is None else \"cv_image_\" + str(img_id) + name + \".png\"\n cv2.imwrite(\"{}/{}\".format(save_path, image_name), img)","def print_images(i, df):\n \n images_folder_path = \"dataset/petfinder-adoption-prediction/train_images/\"\n plt.imshow(cv2.cvtColor(cv2.imread(images_folder_path+df.filename[i]), cv2.COLOR_BGR2RGB),);\n plt.axis(\"off\");\n plt.show()","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def displayImgs(imgs, titles = None, wait=0):\n\tif len(imgs) > 100:\n\t\tprint \"WARNING: DisplayImgs: List is of length \" + str(len(imgs))\n\t\tprint \"Please reduce list size to avoid improper display\"\n\t\treturn\n\tif titles is None:\n\t\tcount = 1\n\t\tfor i in imgs:\n\t\t\tcv2.namedWindow(\"IMAGE\" + str(count), cv2.WINDOW_NORMAL)\n\t\t\tcv2.imshow(\"IMAGE\" + str(count), i)\n\t\t\tcount += 1\n\telse:\n\t\tcount = 0\n\t\tfor i in imgs:\n\t\t\tcv2.namedWindow(titles[count], cv2.WINDOW_NORMAL)\n\t\t\tcv2.imshow(titles[count], i)\n\t\t\tcount += 1\n\tcv2.waitKey(wait) & 0xFF\n\tcv2.destroyAllWindows()","def visualize_output(\n self,\n img: np.ndarray,\n output_data: List[SegmObject]) -> np.ndarray:\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n mix_factor = .3\n\n self.layer = dpg.add_draw_layer(\n parent=f'main_window_{self.id}',\n tag=draw_layer_tag,\n show=False\n )\n\n for out in output_data:\n if out.score < self.score_threshold:\n continue\n\n mask = cv2.resize(\n out.mask,\n (self.width, self.height),\n cv2.INTER_NEAREST\n ).astype(np.uint8)\n color_mask = np.tile(mask[..., None]/255., [1, 1, 4])\n color_image = np.tile(\n self.class_colors[out.clsname],\n [self.height, self.width, 1]\n )\n img += color_image * color_mask * mix_factor\n contour, _ = cv2.findContours(\n mask.astype(np.uint8),\n cv2.RETR_CCOMP,\n cv2.CHAIN_APPROX_NONE\n )\n color = np.array(self.class_colors[out.clsname])\n color = tuple((255*color).astype(np.uint8))\n for c in contour:\n dpg.draw_polyline(\n parent=draw_layer_tag,\n points=list(c[:, 0, :]),\n color=color,\n thickness=2\n )\n description = f'{out.clsname} [{out.score * 100:.2f}%]'\n dpg.draw_text(\n parent=draw_layer_tag,\n text=description,\n pos=(c[:, 0, 0].min() + _PADDING,\n c[:, 0, 1].min() + _PADDING),\n color=color,\n size=_FONT_SIZE\n )\n\n return img","def show_visuals(self, objects_in_scene, image, axe_pred):\n image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)\n\n # draw grid (slow)\n #image = self.draw_grid(image)\n\n # add axe bounding box\n #image = self.return_bbox_image(image, objects_in_scene.axes, \"Axe\", AXE_COLOR)\n\n # add mundo bounding box\n #image = self.return_bbox_image(image, objects_in_scene.mundos, \"Mundo\", MUNDO_COLOR)\n\n # add a circle/dot at the centre of the axe bbox\n image = self.show_centre_of_bbox(image, objects_in_scene.axes)\n\n # if there is a prediction made in the current frame, draw an arrow graphic to highlight\n # where the program predicts the axe will go\n if axe_pred:\n image = self.draw_pred_arrows(image, axe_pred, 1)\n\n\n\n\n # open live capture window with new shapes\n try:\n image = cv2.resize(image, (960, 540)) \n cv2.imshow(\"visualisation\", image)\n\n if cv2.waitKey(25) & 0xFF == ord('q'):\n cv2.destroyAllWindows()\n exit()\n\n except:\n pass","def yolo_show(image_path_list, batch_list):\n font = cv2.FONT_HERSHEY_SIMPLEX\n for img_path, batch in zip(image_path_list, batch_list):\n result_list = batch.tolist()\n img = cv2.imread(img_path)\n for result in result_list:\n cls = int(result[0])\n bbox = result[1:-1]\n score = result[-1]\n print('img_file:', img_path)\n print('cls:', cls)\n print('bbox:', bbox)\n c = ((int(bbox[0]) + int(bbox[2])) / 2, (int(bbox[1] + int(bbox[3])) / 2))\n cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 255), 1)\n cv2.putText(img, str(cls), (int(c[0]), int(c[1])), font, 1, (0, 0, 255), 1)\n result_name = img_path.split('/')[-1]\n cv2.imwrite(\"constant/results/\" + result_name, img)","def show(self):\n if self.video:\n self.video.write(self.img)\n cv2.imshow('Simpy', self.img)\n cv2.waitKey(1000 // self.fps)","def Show(orignal_img, sobel_image):\n # use imshow() function to show the images\n # syntax : cv2.imshow(winname, mat)\n cv2.imshow(\"Original_Image\", orignal_img)\n cv2.imshow(\"Sobel_Image\", sobel_image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def draw_ui(img, vehicle_count, capacity, exit_masks=[]):\r\n # EXIT MASKS\r\n cv2.line(img, (0,400),(645,400),(0,255,0),2)\r\n cv2.line(img, (732,590),(1280,500),(0,255,0),2)\r\n \r\n # STATS\r\n cv2.rectangle(img, (0, 0), (img.shape[1], 50), (0, 0, 0), cv2.FILLED)\r\n cv2.putText(img, (\"Density: {cur_left}% Vehicles passed: {left} \\\r\n Density: {cur_right}% Vehicles passed: {right}\".format(\\\r\n left=vehicle_count[0], right=vehicle_count[1], \\\r\n cur_right=round(capacity[1]*100,3),\\\r\n cur_left=round(capacity[0]*100,3))), (30, 30),\\\r\n cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1)\r\n \r\n return img","def popup(self):\n opencv.imshow('dbg', self.img)\n opencv.waitKey(0)","def visualize(self):\n colors = {'outline': (220, 220, 220),\n 'inlier': (0, 255, 0),\n 'outlier': (0, 0, 255),\n 'lines': (128, 220, 128)}\n # Create output image for visualization\n gap = 5\n h1, w1 = self.target.image.shape[:2]\n h2, w2 = self.image.shape[:2]\n vis = np.zeros((max(h1, h2), w1 + w2 + gap, 3), np.uint8)\n vis[:h1, :w1, :] = self.target.image\n w1 += gap\n vis[:h2, w1:w1+w2, :] = self.image\n \n # Draw the located object \n quad = np.float32(self.quad) + np.float32([w1, 0])\n self.draw(vis, colors['outline'], 2, quad)\n \n # draw point details\n inliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.inliers]\n outliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.outliers]\n if colors['outlier'] is not None: # draw x on each point\n r = 2 # radius\n thickness = 2\n for x0, y0, x1, y1 in outliers:\n cv2.line(vis, (x0 - r, y0 - r), (x0 + r, y0 + r), colors['outlier'], thickness)\n cv2.line(vis, (x0 + r, y0 - r), (x0 - r, y0 + r), colors['outlier'], thickness)\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), colors['outlier'], thickness)\n cv2.line(vis, (x1 + r, y1 - r), (x1 - r, y1 + r), colors['outlier'], thickness)\n if colors['lines'] is not None:\n for x0, y0, x1, y1 in inliers:\n cv2.line(vis, (x0, y0), (x1, y1), colors['lines'], 1)\n if colors['inlier'] is not None:\n for x0, y0, x1, y1 in inliers:\n cv2.circle(vis, (x0, y0), 2, colors['inlier'], -1)\n cv2.circle(vis, (x1, y1), 2, colors['inlier'], -1)\n return vis","def demo(sess, net, image_name):\n # Load the demo image\n global CLASS_NAME\n global CHECK\n CHECK = 0\n # 读取的截图所在的位置\n # im_file = Cnn_path + \"data/VOCdevkit2007/VOC2007/JPEGImages/\" + image_name\n curpath = os.path.dirname(os.path.realpath(__file__))\n im_file = curpath + \"\\\\data\\\\VOCdevkit2007\\\\VOC2007\\\\JPEGImages\\\\\" + image_name\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(sess, net, im)\n timer.toc()\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\n\n # Visualize detections for each class\n # score 阈值，最后画出候选框时需要，>thresh才会被画出\n CONF_THRESH = 0.5\n # 非极大值抑制的阈值，剔除重复候选框\n NMS_THRESH = 0.3\n # 利用enumerate函数，获得CLASSES中 类别的下标cls_ind和类别名cls\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 # because we skipped background\n # 取出bbox ,score\n cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n # 将bbox,score 一起存入dets\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n # 进行非极大值抑制，得到抑制后的 dets\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n # 画框\n vis_detections(im, cls, dets, thresh=CONF_THRESH)\n if CHECK == 0:\n CLASS_NAME = \"None\"\n # im = im[:, :, (2, 1, 0)]\n # fig, ax = plt.subplots()\n # ax.imshow(im, aspect='equal')\n # ax.set_title(\"None\",fontsize=10)\n # plt.axis('off')\n # plt.tight_layout()\n # plt.draw()\n # RES[INDS.__getitem__(image_name.split(\"_\")[0])][INDS.__getitem__(CLASS_NAME)]+=1\n # plt.savefig(\"./output/\"+CLASS_NAME+\"_\" + image_name)\n # plt.savefig(\"./output/\" + image_name)\n MAX_SCORE[0] = 0.0","def run(self):\n r = rospy.Rate(10)\n while not rospy.is_shutdown():\n\n if not self.cv_image is None:\n #cv2.imshow('video_window', self.cv_image)\n cv2.imshow('video_window2', self.contour_image)\n cv2.waitKey(10)\n r.sleep()","def _visualize_cam_w_s(self, imgs, names=\"2DPositions\"):\n feed_dict = {}\n feed_dict[self.images_tf] = imgs\n conv6_val, output_val = self.sess.run([self.conv6, self.output],feed_dict=feed_dict)\n preds = output_val\n preds_order = preds.argsort( axis=1 )[:,::-1]\n best_preds = preds.argmax( axis=1 )\n\n\n if names == \"Predictions\":\n self.classmap = self.detector.get_classmap( self.labels_tf, self.conv6, list(imgs.shape[1:3]), eval_all=False )\n classmap_vals = self.sess.run(\n self.classmap,\n feed_dict={\n self.labels_tf: best_preds,\n self.conv6: conv6_val\n })\n \n classmap_vis = map(lambda x: ((x-x.min())/(x.max()-x.min())), classmap_vals)\n self.classmap_vis = classmap_vis # for Debug\n named_preds = map(self.to_named_pred, preds)\n\n if names == \"BoundingBoxes\":\n softmaxs = f_sotfmax(preds)\n self.classmap = self.detector.get_classmap( self.labels_tf, self.conv6, list(imgs.shape[1:3]), eval_all=True )\n classmap_vals = self.sess.run(\n self.classmap,\n feed_dict={\n self.labels_tf: best_preds*0-1,\n self.conv6: conv6_val\n })\n classmap_vis = classmap_vals\n ls,ts,rs,bs = self._get_bounding_boxes(imgs, classmap_vals, threshold_value=.8)\n named_preds = map(self.to_named_pred, softmaxs, ls, ts, rs, bs)\n\n\n return named_preds, np.array(classmap_vis)[0]","def update(self):\n cv2.imshow(self.window_name, self.map.get_crop())","def main(image_path):\n temp_dir = tempfile.mkdtemp()\n print('Saving output to {}'.format(temp_dir))\n estimator = run_image(image_path)\n visualize(estimator, image_path, temp_dir)","def show(title, img, write = False, wait = False):\n cv2.namedWindow(title, flags = cv2.WINDOW_NORMAL)\n cv2.imshow(title, img)\n cv2.resizeWindow(title, 1200, 900)\n if write:\n cv2.imwrite(title + \".png\", img)\n if wait:\n cv2.waitKey(1)","def demo(net, data_dir, imgfile, out_dir):\n\n # Load the demo image\n im_file = os.path.join(data_dir, imgfile)\n im = cv2.imread(im_file)\n\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(net, im)\n scores = np.squeeze(scores)\n timer.toc()\n print ('Detection took {:.3f}s for '\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n # Visualize detections for each class\n CONF_THRESH = 0.12\n NMS_THRESH = 0.3\n color_white = (0, 0, 0)\n for cls_ind, cls in enumerate(CLASSES[1:]):\n cls_ind += 1 \n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n color = (random.randint(0, 256), random.randint(0, 256), random.randint(0, 256))\n inds = np.where(dets[:, -1] >= CONF_THRESH)[0]\n for i in inds:\n bbox = dets[i, :4]\n score = dets[i, -1]\n bbox = map(int, bbox)\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=4)\n cv2.putText(im, '%s %.3f' % (cls, score), (bbox[0], bbox[1] + 15),\n color=color_white, fontFace=cv2.FONT_HERSHEY_COMPLEX, fontScale=0.5)\n return im","def yolo_show_img(image, class_ids, boxes, labels, confidences, colors):\n for i, box in enumerate(boxes):\n # extract the bounding box coordinates\n (x, y) = (box[0], box[1])\n (w, h) = (box[2], box[3])\n\n # draw a bounding box rectangle and label on the image\n color = [int(c) for c in colors[class_ids[i]]]\n cv2.rectangle(image, (x, y), (x + w, y + h), color, 3)\n text = '{}: {:.4f}'.format(labels[i], confidences[i])\n print(text)\n\n font_scale = 1.3\n # set the rectangle background to white\n rectangle_bgr = color\n # set some text\n # get the width and height of the text box\n (text_width, text_height) = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=font_scale, thickness=1)[0]\n # set the text start position\n text_offset_x = x\n text_offset_y = y - 3 \n # make the coords of the box with a small padding of two pixels\n box_coords = ((text_offset_x, text_offset_y), (text_offset_x + text_width + 10, text_offset_y - text_height - 10 ))\n cv2.rectangle(image, box_coords[0], box_coords[1], rectangle_bgr, cv2.FILLED)\n cv2.putText(image, text, (text_offset_x, text_offset_y), cv2.FONT_HERSHEY_SIMPLEX, \n fontScale=font_scale, color=(255, 255, 255), thickness=2)\n\n cv2.imshow('yolo prediction', image)\n cv2.waitKey(0)","def figshow(img,hsize=400,title='hoge'):\n shape = img.shape\n ratio=shape[0]/shape[1]\n img2= cv2.resize(img,(hsize,int(hsize*ratio)))\n cv2.imshow(title,img2)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def showWait(img, title):\r\n cv2.imshow(title, img)\r\n cv2.waitKey(0)\r\n cv2.destroyAllWindows()","def display(self):\n nrow = 2\n ncol = len(self.views) + 1\n rows = [(self.views[0].original, len(self.views)),\n (self.views[0].image, len(self.views) + 1)]\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\n figsize=self._figsize(rows),\n squeeze=True)\n originals = [(v.position.id, v.original) for v in self.views] + [\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\n warped = [(v.position.id, v.image) for v in self.views] + [\n ('combined', self.image)]\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\n ax.imshow(img)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=title)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def show_img(self):\n if self.image is not None:\n cv2.imshow(self.image_window, self.image)\n cv2.waitKey(1)\n else:\n rospy.loginfo(\"No image to show yet\")","def visualize_output(\n self,\n img: np.ndarray,\n output_data: np.ndarray) -> np.ndarray:\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n self.layer = dpg.add_draw_layer(\n parent=f'main_window_{self.id}',\n tag=draw_layer_tag,\n show=False\n )\n\n best_k = np.argsort(output_data)[-self.top_n:][::-1]\n class_names = np.array(self.class_names)[best_k]\n percentages = softmax(output_data[best_k])\n\n for i, (name, perc) in enumerate(zip(class_names, percentages)):\n label_pos = dpg.get_item_pos(f'cell_bar_{i}_{self.id}')\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=label_pos,\n pmax=(\n label_pos[0] + _SCORE_COLUMN_WIDTH*perc,\n label_pos[1] + _FONT_SIZE),\n color=(0, 255, 0),\n fill=(0, 255, 0)\n )\n dpg.set_value(f'cell_perc_{i}_{self.id}', f'{perc*100:.2f}%')\n dpg.set_value(f'cell_name_{i}_{self.id}', name)\n\n return img","def im_show(img_list,title=['']):\n Error = False\n if title == ['']:\n title=[f'Image {i+1}' for i in range(len(img_list))]\n if len(title) != len(img_list):\n print('ERROR 1 (im_show)')\n Error = True\n if not Error:\n for i,img in enumerate(img_list):\n cv2.imshow(title[i],img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def display(image, fx=1, fy=1):\n image = cv2.resize(image, (0, 0), fx=fx, fy=fy)\n cv2.imshow('Image', image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def displayImages(self):\n\n plt.figure(figsize=(8,6))\n plt.subplot(1,2,1)\n plt.imshow( self.original_image, cmap=\"gray\")\n plt.title(\"Original Image\")\n plt.subplot(1,2,2)\n plt.imshow( self.blurred_image, cmap=\"gray\")\n plt.title(\"Blurred Image\")","def display_sample(display_list):\n fig, axs = plt.subplots(1, len(display_list), figsize=(18, 18))\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n for i in range(len(display_list)):\n axs[i].set_title(title[i])\n axs[i].imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n axs[i].axis('off')","def display_img_opencv_full_size(img_name, img):\n cv2.imshow(img_name, img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def demo(net, image_name, conf_thres, nms_thres, resDir, bShow=False):\n global CLASSES\n\n # Load the demo image\n im_file = image_name\n im = cv2.imread(im_file)\n fname = os.path.basename(image_name)\n\n # Detect all object classes and regress object bounds\n # timers\n _t = {'im_detect' : Timer(), 'misc' : Timer(), 'save' : Timer()}\n\n _t['im_detect'].tic()\n scores, boxes = im_detect(net, im)\n _t['im_detect'].toc()\n \n \n _t['misc'].tic() \n results = np.zeros((0, 6), dtype=np.float32)\n # Visualize detections for each class\n # for cls_ind, cls in enumerate(CLASSES[1:5]):\n for cls_ind, cls in enumerate(CLASSES[1:]): \n cls_ind += 1 # because we skipped background\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n \n # CPU NMS is much faster than GPU NMS when the number of boxes\n # is relative small (e.g., < 10k)\n # TODO(rbg): autotune NMS dispatch\n keep = nms(dets, nms_thres, force_cpu=True)\n dets = dets[keep, :]\n results = np.vstack( (results, np.insert(dets, 0, cls_ind, axis=1)) ) \n _t['misc'].toc() \n \n if bShow:\n plt.figure(1, figsize=(15,10))\n plt.clf()\n axe = plt.gca()\n axe.imshow(im[:,:,(2,1,0)])\n\n clrs = sns.color_palette(\"Set2\", len(CLASSES))\n for det in results:\n cls_ind, box, score = det[0], det[1:5], det[5]\n if score < 0.8: continue\n clr = clrs[int(cls_ind)]\n rect = plt.Rectangle( (box[0], box[1]), box[2]-box[0], box[3]-box[1], fill=False, edgecolor=clr, linewidth=2.5)\n axe.add_patch(rect)\n axe.text(box[0], box[1]-2, '{:.3f}'.format(score), bbox=dict(facecolor=clr, alpha=0.5), fontsize=14, color='white')\n\n axe.axis('off')\n save_name = os.path.basename(im_file)\n plt.savefig('[DEMO]'+save_name, dpi=200) \n\n else:\n _t['save'].tic()\n with open( os.path.join(resDir, fname.split('.')[0] + '.txt'), 'w') as fp: \n for det in results:\n if len(det) == 0: continue \n if det[5] < 0.01: continue\n\n resStr = '{:s} -1 -1 -10 '.format(CLASSES[int(det[0])]) \n resStr += '{:.2f} {:.2f} {:.2f} {:.2f} '.format(det[1],det[2],det[3],det[4]) # x1 y1 x2 y2\n resStr += '-1 -1 -1 -1000 -1000 -1000 -10 {:.4f}\\n'.format(det[5])\n fp.write( resStr ) \n _t['save'].toc()\n\n return _t","def printMat(image):\n for row in range(image.rows):\n print \"[\",\n for col in range(image.cols):\n print cv.mGet(image, row, col),\n print \"]\"\n print \"\"","def display_gui_window(self, window_title):\r\n cv2.imshow(window_title, self.image)","def show_result(inputs, labels, outputs):\n num_classes = outputs.size(1)\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\n if num_classes == 2:\n outputs *= 255\n mask = outputs[0].reshape((360, 640))\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\n ax[0].set_title('Image')\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\n ax[1].set_title('gt')\n plt.show()\n plt.figure()\n plt.imshow(mask, cmap='gray')\n plt.title('Pred')\n plt.show()","def show_four_images(img1, img2, img3, img4, title):\n shape = (460, 250)\n # Get all images in same size for better display\n img1 = cv2.resize(img1, shape)\n img2 = cv2.resize(img2, shape)\n img3 = cv2.resize(img3, shape)\n img4 = cv2.resize(img4, shape)\n # combined 2 images horizontally\n numpy_horizontal1 = np.hstack((img1, img2))\n # combined the rest 2 images horizontally\n numpy_horizontal2 = np.hstack((img3, img4))\n # now combined all vertically to 1 image and display\n numpy_vertical = np.vstack((numpy_horizontal1, numpy_horizontal2))\n # final thing - show the output:\n show_image(numpy_vertical, title)","def show(image):\n cv2.imshow('press ENTER to close', image)\n cv2.waitKey(0)","def showImages(images):\n idx = 0\n\n while True:\n\n cv2.imshow(\"Image\", images[idx])\n\n if cv2.waitKey(15) & 0xFF == ord(\"d\"):\n if idx+1 >= len(images):\n print(\"This is the last image in the set.\")\n else:\n idx += 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"a\"):\n if idx-1 < 0:\n print(\"This is the first image in the set.\")\n else:\n idx -= 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"q\"):\n break","def visualize_output(\n self,\n img: np.ndarray,\n output_data: Any):\n raise NotImplementedError","def display(self, image):\n raise NotImplementedError()","def display(self):\n\t\t# print len(self.visibleFaceList)\n\t\t# print \"not visible: \"\n\t\t# for face in self.notVisibleFaceList:\n\t\t# \tprint face.id\n\t\t# print \"visibel: \"\n\t\tfor i in range(len(self.visibleFaceList)):\n\t\t\t# print self.visibleFaceList[i].id\n\t\t\tself.showRectangle(self.visibleFaceList[i].getPosition(),self.visibleFaceList[i].id)\n\t\tcv2.imshow(\"show\", self.frameImage)","def imshow(img):\n imadd(img)\n plt.ion()\n plt.show()","def showBPImg(pV,nV):\n # object arrays of the positive and negative images\n inv_crop = np.empty(8, dtype=object)\n inv_crop2 = np.empty(8, dtype=object)\n for t in range(8):\n # backprojection functions\n inverse = retina.inverse(pV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n inv_crop[t] = retina.crop(inverse,x,y,dloc[i])\n inverse2 = retina.inverse(nV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\n inv_crop2[t] = retina.crop(inverse2,x,y,dloc[i])\n # place descriptions\n cv2.putText(inv_crop[t],types[t] + \" + \",(xx,yy), font, 1,(0,255,255),2)\n cv2.putText(inv_crop2[t],types[t] + \" - \",(xx,yy), font, 1,(0,255,255),2)\n # stack all images into a grid\n posRG = np.vstack((inv_crop[:4]))\n negRG = np.vstack((inv_crop2[:4]))\n posYB = np.vstack((inv_crop[4:]))\n negYB = np.vstack((inv_crop2[4:]))\n merge = np.concatenate((posRG,negRG,posYB,negYB),axis=1)\n return merge","def vis_all_detection(im_array, detections, class_names, scale):\n import matplotlib \n matplotlib.use('Agg') \n import matplotlib.pyplot as plt\n from matplotlib.pyplot import savefig \n import random\n a = [103.06 ,115.9 ,123.15]\n a = np.array(a)\n im = image.transform_inverse(im_array,a)\n plt.imshow(im)\n for j in range(len(class_names)):\n if class_names[j] == 0:\n continue\n color = (random.random(), random.random(), random.random()) # generate a random color\n dets = detections[j]\n det =dets\n bbox = det[0:] \n score = det[0]\n rect = plt.Rectangle((bbox[0], bbox[1]),\n bbox[2] - bbox[0],\n bbox[3] - bbox[1], fill=False,\n edgecolor=color, linewidth=3.5)\n plt.gca().add_patch(rect)\n plt.gca().text(bbox[0], bbox[1] - 2,\n '{:s} {:.3f}'.format(str(class_names[j]), score),\n bbox=dict(facecolor=color, alpha=0.5), fontsize=12, color='white')\n plt.show()\n name = np.mean(im)\n savefig ('vis/'+str(name)+'.png')\n plt.clf()\n plt.cla()\n\n plt. close(0)","def show_result(self,\n img,\n result,\n palette=None,\n win_name='',\n show=False,\n wait_time=0,\n out_file=None,\n opacity=0.5):\n img = mmcv.imread(img)\n img = img.copy()\n seg = result[0]\n if palette is None:\n if self.PALETTE is None:\n # Get random state before set seed,\n # and restore random state later.\n # It will prevent loss of randomness, as the palette\n # may be different in each iteration if not specified.\n # See: https://github.com/open-mmlab/mmdetection/issues/5844\n state = np.random.get_state()\n np.random.seed(42)\n # random palette\n palette = np.random.randint(\n 0, 255, size=(len(self.CLASSES), 3))\n np.random.set_state(state)\n else:\n palette = self.PALETTE\n palette = np.array(palette)\n assert palette.shape[0] == len(self.CLASSES)\n assert palette.shape[1] == 3\n assert len(palette.shape) == 2\n assert 0 < opacity <= 1.0\n color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)\n for label, color in enumerate(palette):\n color_seg[seg == label, :] = color\n # convert to BGR\n color_seg = color_seg[..., ::-1]\n\n img = img * (1 - opacity) + color_seg * opacity\n img = img.astype(np.uint8)\n # if out_file specified, do not show image in window\n if out_file is not None:\n show = False\n\n if show:\n mmcv.imshow(img, win_name, wait_time)\n if out_file is not None:\n mmcv.imwrite(img, out_file)\n\n if not (show or out_file):\n warnings.warn('show==False and out_file is not specified, only '\n 'result image will be returned')\n return img","def display_sample_images(self):\n if self.train_dataset is None:\n self.init_datasets()\n\n images, labels = next(self.train_dataset)\n plt.figure(figsize=(5,5))\n for n in range(min(25, images.shape[0])):\n ax = plt.subplot(5,5,n+1)\n plt.imshow(images[n])\n if len(labels.shape) == 1:\n plt.title(self.class_names[int(labels[n])].title())\n else:\n m = np.argmax(labels[n])\n plt.title(self.class_names[int(labels[n, m])].title())\n plt.axis('off')\n\n plt.tight_layout()\n plt.show()","def print_stats(cars, notcars):\n print(\"Number of car samples: {0}\".format(len(cars)))\n print(\"Number of non car samples: {0}\".format(len(notcars)))\n img = cv2.imread(cars[0])\n print(\"Image shape: {0}x{1}\".format(img.shape[0], img.shape[1]))\n print(\"Image datatype: {}\".format(img.dtype))","def demo(net, image_name, classes):\n\n # Load pre-computed Selected Search object proposals\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\n obj_proposals = sio.loadmat(box_file)['boxes']\n\n # Load the demo image\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\n im_file = os.path.join(test_images_path, image_name + '.jpg')\n im = cv2.imread(im_file)\n\n # Detect all object classes and regress object bounds\n timer = Timer()\n timer.tic()\n scores, boxes = im_detect(net, im, obj_proposals)\n timer.toc()\n # print ('Detection took {:.3f}s for '\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\n\n # Visualize detections for each class\n CONF_THRESH = 0\n NMS_THRESH = 0.3\n max_inds = 0\n max_score = 0.0\n for cls in classes:\n cls_ind = CLASSES.index(cls)\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\n cls_scores = scores[:, cls_ind]\n keep = np.where(cls_scores >= CONF_THRESH)[0]\n cls_boxes = cls_boxes[keep, :]\n cls_scores = cls_scores[keep]\n dets = np.hstack((cls_boxes,\n cls_scores[:, np.newaxis])).astype(np.float32)\n keep = nms(dets, NMS_THRESH)\n dets = dets[keep, :]\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\n # CONF_THRESH, image_name)\n #if get_max!=[]: \n\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\n #print image_name,cls,tmp\n\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\n #print dets[:,-1]\n #print image_name,max_score\n file.writelines([image_name,'\\t',cls,'\\t',str(tmp),'\\n'])\n if(max_score<tmp):\n max_score=tmp\n cls_max=cls\n print image_name,cls_max,max_score","def show_images_opencv(images, titles):\n assert len(images) == len(titles), 'Every image should have unique title!'\n for img, title in zip(images, titles):\n cv2.imshow(title, img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()","def update_image(self, cv_img):\n qt_img = self.convert_cv_qt(cv_img)\n if(self.iscapture):\n print(\"update\")\n direct = self.label1.text()\n if direct == \"~default\":\n direct = \"face_dataframes\"\n else:\n direct = direct + \"/face_dataframes\"\n \n if (not os.path.exists(direct)):\n os.mkdir(direct)\n cv2.imwrite(\"{1}/{2}{0}.jpeg\".format(self.count, direct,self.textbox.text()), cv_img)\n self.iscapture = False\n self.label2.setText(\"Image # 0{0} Saved\".format(self.count))\n self.pushButton0.setEnabled(False)\n self.count += 1\n \n \n if(self.count == 6):\n #print(\"greater\")\n self.pushButton.setEnabled(False)\n self.pushButton2.setDisabled(False)\n\n\n self.image_label.setPixmap(qt_img)","def im_show(image_path):\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\n cv.namedWindow('image', cv.WINDOW_NORMAL)\n ret, threshed = cv.threshold(img, 0, 2 ** 16, cv.THRESH_BINARY)\n print(ret)\n print(threshed.shape, threshed.dtype)\n cv.imshow('image', threshed)\n cv.waitKey(0)\n cv.destroyAllWindows()","def display_image(mat):\n\timg = Image.fromarray(mat)\n\timg.show()","def visualize(self,\n model: torch.nn.Module,\n image: Union[str, np.ndarray],\n result: list,\n output_file: str,\n window_name: str = '',\n show_result: bool = False):\n show_img = mmcv.imread(image) if isinstance(image, str) else image\n output_file = None if show_result else output_file\n pred_score = np.max(result)\n pred_label = np.argmax(result)\n result = {'pred_label': pred_label, 'pred_score': float(pred_score)}\n result['pred_class'] = model.CLASSES[result['pred_label']]\n return model.show_result(\n show_img,\n result,\n show=show_result,\n win_name=window_name,\n out_file=output_file)","def show_plot(img, title):\n plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\n plt.title(\"Hand Number: \" + title)\n plt.show()","def visualizer(FRAME_STATS, save_image=True, image_dir='images'):\r\n frame = FRAME_STATS['frame'].copy()\r\n frame_number = FRAME_STATS['frame_number']\r\n paths = FRAME_STATS['paths']\r\n exit_masks = FRAME_STATS['exit_masks']\r\n vehicle_count = FRAME_STATS['vehicle_count']\r\n capacity = FRAME_STATS['capacity']\r\n\r\n frame = draw_ui(frame, vehicle_count, capacity, exit_masks)\r\n frame = draw_boxes(frame, paths, exit_masks)\r\n \r\n if save_image: cv2.imwrite(image_dir + \"/processed_%04d.png\" % frame_number, np.flip(frame,2))","def fileCmd(self):\n filename = askopenfilename() \n self.cnvImgOrig.displayImage(filename)\n self.cnvImgTest.displayImage(filename)","def show_rgbd(self):\n while self.depth_data is None:\n pass\n\n while not rospy.is_shutdown():\n rospy.Rate(10).sleep()\n d = self.depth_data * self.cam.DEPTH_UNIT\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\n dc = np.concatenate((d, self.rgb_data), axis=1)\n cv2.imshow('RGB & Depth Image', dc)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n cv2.destroyAllWindows()","def draw_on_image(D):\n \n #Set up rectangle's position within window\n lower_left_x = 20 \n lower_left_y = 42\n dx = 5\n dy = 5\n\n #Display border for rectangle\n #Border is a black rectangle under white text rectangle\n bord_upper_left = (lower_left_x-dx-3, lower_left_y-dy-20-3)\n bord_lower_right = (lower_left_x+dx+160+3, lower_left_y+dy+50+3)\n cv.Rectangle(D.image, bord_upper_left, bord_lower_right, D.black, cv.CV_FILLED)\n \n #Display white rectangle under text\n rect_upper_left = (lower_left_x-dx, lower_left_y-dy-20)\n rect_lower_right = (lower_left_x+dx+160, lower_left_y+dy+50)\n cv.Rectangle(D.image, rect_upper_left, rect_lower_right, D.white, cv.CV_FILLED)\n \n ####\n hive = \"hi!\"\n hiveStat = \"hive\"\n \n #Build Strings\n robotAssignment = (\"Assignment #: %.lf\"%R.assignment)\n robotConverged = (\"Converged: %s\"%R.converged)\n robotStatus = (\"Robot Status: \" + R.status)\n hiveCommand = (\"Hive Command: \" + hive)\n hiveStatus = (\"Hive Status: \" + hiveStat)\n \n # Position strings in a box so they won't overlap\n firstLineString = (lower_left_x,lower_left_y) \n secondLineString = (lower_left_x, lower_left_y + 20) \n thirdLineString = (lower_left_x, lower_left_y + 40)\n fourthLineString = (lower_left_x, lower_left_y + 60)\n fifthLineString = (lower_left_x, lower_left_y + 80)\n\n #Display strings in window\n cv.PutText(D.image, robotAssignment, firstLineString, D.font, cv.RGB(0,0,255)) \n cv.PutText(D.image, robotConverged, secondLineString, D.font, cv.RGB(0,0,255))\n cv.PutText(D.image, robotStatus, thirdLineString, D.font, cv.RGB(0,0,255))\n cv.PutText(D.image, hiveCommand, fourthLineString, D.font, cv.RGB(0,0,255))\n cv.PutText(D.image, hiveStatus, fifthLineString, D.font, cv.RGB(0,0,255))","def viz_pipeline(self, img):\n y_fit, x_fit_left, x_fit_right = self.find_lines(img, ['all'])\n dynamic_subplot = DynamicSubplot(3, 4)\n dynamic_subplot.imshow(self.visuals['dash_undistorted'], \"Undistorted Road\")\n dynamic_subplot.imshow(self.visuals['overhead'], \"Overhead\", cmap='gray')\n dynamic_subplot.imshow(self.visuals['lightness'], \"Lightness\", cmap='gray')\n dynamic_subplot.imshow(self.visuals['lightness_binary'], \"Binary Lightness\", cmap='gray')\n dynamic_subplot.skip_plot()\n dynamic_subplot.skip_plot()\n dynamic_subplot.imshow(self.visuals['value'], \"Value\", cmap='gray')\n dynamic_subplot.imshow(self.visuals['value_binary'], \"Binary Value\", cmap='gray')\n dynamic_subplot.imshow(self.visuals['pixel_scores'], \"Scores\", cmap='gray')\n dynamic_subplot.imshow(self.visuals['windows_raw'], \"Selected Windows\")\n dynamic_subplot.imshow(self.visuals['windows_raw'], \"Fitted Lines\", cmap='gray')\n dynamic_subplot.modify_plot('plot', x_fit_left, y_fit)\n dynamic_subplot.modify_plot('plot', x_fit_right, y_fit)\n dynamic_subplot.modify_plot('set_xlim', 0, camera.img_width)\n dynamic_subplot.modify_plot('set_ylim', camera.img_height, 0)\n dynamic_subplot.imshow(self.visuals['highlighted_lane'], \"Highlighted Lane\")","def demo(net, image_name,num_class,save_ff):\r\n\r\n # Load the demo image\r\n #im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\r\n im_file=image_name\r\n im = cv2.imread(im_file)\r\n\r\n # Detect all object classes and regress object bounds\r\n timer = Timer()\r\n timer.tic()\r\n #for zzz in range(100):\r\n scores, boxes = im_detect(net, im)\r\n timer.toc()\r\n print ('Detection took {:.3f}s for '\r\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\r\n\r\n # Visualize detections for each class\r\n CONF_THRESH = 0.35\r\n NMS_THRESH = 0.3\r\n thresh=CONF_THRESH\r\n for cls_ind, cls in enumerate(range(num_class)):#CLASSES[1:]\r\n cls_ind += 1 # because we skipped background\r\n # cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\r\n # cls_scores = scores[:, cls_ind]\r\n # dets = np.hstack((cls_boxes,\r\n # cls_scores[:, np.newaxis])).astype(np.float32)\r\n inds = np.where(scores[:, cls_ind] > thresh)[0]\r\n cls_scores = scores[inds, cls_ind]\r\n if cfg.TEST.AGNOSTIC:\r\n cls_boxes = boxes[inds, 4:8]\r\n else:\r\n cls_boxes = boxes[inds, cls_ind*4:(cls_ind+1)*4]\r\n dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \\\r\n .astype(np.float32, copy=False)\r\n keep = nms(dets, NMS_THRESH)\r\n dets = dets[keep, :]\r\n #vis_detections(im, cls, dets, thresh=CONF_THRESH)\r\n inds = np.where(dets[:, -1] >= thresh)[0]\r\n if len(inds) == 0:\r\n continue\r\n\r\n im_tmp = im#im[:, :, (2, 1, 0)]\r\n for i in inds:\r\n bbox = dets[i, :4]\r\n score = dets[i, -1]\r\n print bbox,score,cls\r\n cv2.rectangle(im_tmp, (bbox[0],bbox[1]), (bbox[2],bbox[3]), (0,0,255),2)\r\n #save_ff=\"/storage2/liushuai/faster_rcnn/FasterRCNN-Encapsulation-Cplusplus/faster_cxx_lib_ev2641/test_result.jpg\"\r\n im_tmp = im#im[:, :, (2, 1, 0)]\r\n cv2.imwrite(save_ff,im_tmp)\r\n #save_pic(im, cls, dets, thresh=CONF_THRESH,save_ff)\r","def _visualize_cam_s(self, imgs, summed_filters=True, names=\"2DPositions\"):\n feed_dict = {}\n feed_dict[self.images_tf] = imgs\n conv6_val, output_val = self.sess.run([self.conv6, self.output],feed_dict=feed_dict)\n preds = output_val\n\n # <preds> to confidence (to softmax)\n softmaxs = f_sotfmax(preds)\n \n # Computes the position of the max per axis [-1;1]\n summed_viz = self.summed_vis(conv6_val)\n if names == \"2DPositions\":\n max_pos = lambda arr: (arr.argmax(axis=1) / float(arr.shape[-2]) *2)-1\n xxs = max_pos( summed_viz.sum(axis=1) )\n yys = max_pos( summed_viz.sum(axis=2) )\n named_preds = map(self.to_named_pred, preds, xxs, yys)\n \n # Computes the bounding boxes coordinates of classes\n if names == \"BoundingBoxes\":\n ls,ts,rs,bs = self._get_bounding_boxes(imgs, summed_viz)\n named_preds = map(self.to_named_pred, softmaxs, ls, ts, rs, bs)\n \n if summed_filters == True:\n conv6_val = summed_viz \n \n return named_preds, conv6_val"],"string":"[\n \"def show(self, name='Detections'):\\n cv2.imshow(name, self.get_image())\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def show(self) -> None:\\n cv.imshow(str(self.__class__), self.output_image)\",\n \"def display_img(title,img):\\r\\n cv2.namedWindow('img', cv2.WINDOW_NORMAL)\\r\\n cv2.setWindowTitle('img',title)\\r\\n cv2.resizeWindow('img',600,400)\\r\\n\\r\\n #Display Image on screen\\r\\n cv2.imshow('img',img)\\r\\n\\r\\n #Mantain output until user presses a key\\r\\n cv2.waitKey(0)\\r\\n\\r\\n #Destroy windows when user presses a key\\r\\n cv2.destroyAllWindows()\",\n \"def display_images():\\n vc = cv2.VideoCapture(0) # Open webcam\\n figure, ax = plt.subplots(1, 2, figsize=(10, 5)) # Intiialise plot\\n\\n count = 0 # Counter for number of aquired frames\\n intensity = [] # Append intensity across time\\n\\n # For loop over generator here\\n intensity.append(imageintensity)\\n plot_image_and_brightness() # Call plot function\\n count += 1\\n\\n # This triggers exit sequences when user presses q\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n # Clean up here\\n plt.close('all') # close plots\\n generator.close() # Use generator exit for clean up,\\n break # break loop\",\n \"def display_image(img, label):\\n cv2.imshow(label,img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def display_data():\\n data = read_data_from_file()\\n data_size = len(data)\\n print('Data size - ' + str(data_size))\\n\\n\\n for i in range(data_size-1, 0, -1):\\n image = data[i]\\n cv2.imshow('window', image[0])\\n print(str(image[1]))\\n cv2.waitKey(50)\",\n \"def displayImg(self):\\r\\n\\r\\n\\t# If you want to skip n frames, set value to 0 to see all images\\r\\n\\tSKIP = 4500\\r\\n for idx in range(len(self.centers)):\\r\\n\\t if idx < SKIP:\\r\\n\\t\\tcontinue\\r\\n file_left = self.lefts[idx][5]\\r\\n file_center = self.centers[idx][5]\\r\\n file_right = self.rights[idx][5]\\r\\n\\r\\n img_left = cv2.imread(os.path.join(self.pathDir, file_left), \\\\\\r\\n cv2.IMREAD_COLOR)\\r\\n img_center = cv2.imread(os.path.join(self.pathDir, file_center), \\\\\\r\\n cv2.IMREAD_COLOR)\\r\\n img_right = cv2.imread(os.path.join(self.pathDir, file_right), \\\\\\r\\n cv2.IMREAD_COLOR)\\r\\n\\r\\n\\t #Resize the image to 50%\\r\\n img_l = cv2.resize(img_left, None, fx=0.5, fy=0.5, \\\\\\r\\n interpolation = cv2.INTER_LINEAR)\\r\\n img_c = cv2.resize(img_center, None, fx=0.5, fy=0.5, \\\\\\r\\n interpolation = cv2.INTER_LINEAR)\\r\\n img_r = cv2.resize(img_right, None, fx=0.5, fy=0.5, \\\\\\r\\n interpolation = cv2.INTER_LINEAR)\\r\\n \\r\\n height, width = img_c.shape[:2]\\r\\n new_img = np.zeros((height, width*3, img_c.shape[2]),\\r\\n np.uint8)\\r\\n\\r\\n #Adding sequence numbers and Time\\r\\n\\t #Left\\r\\n strTime = self.timestampToStr(self.lefts[idx][1])\\r\\n\\t self.putTextToImg(img_l, self.lefts[idx][0], strTime, height)\\r\\n\\t #Center\\r\\n\\t strTime = self.timestampToStr(self.centers[idx][1])\\r\\n\\t self.putTextToImg(img_c, self.centers[idx][0], strTime, height)\\r\\n\\t #Right\\r\\n\\t strTime = self.timestampToStr(self.rights[idx][1])\\r\\n\\t self.putTextToImg(img_r, self.rights[idx][0], strTime, height)\\r\\n\\t \\r\\n\\t angle = float(self.angles_at_timestamps[idx])\\r\\n\\t speed = float(self.speed_at_timestamps[idx])\\r\\n\\r\\n\\t print \\\"speed: %f - angle: %f\\\" % (speed, angle)\\r\\n\\r\\n\\t self.draw_path_on(img_c, speed, angle)\\r\\n\\r\\n\\t #Generate the new image\\r\\n for i in range(height):\\r\\n new_img[i] = np.concatenate((img_l[i, : ], img_c[i, : ], \\\\\\r\\n img_r[i, : ]))\\r\\n \\r\\n\\r\\n cv2.imshow('Udacity Challenge 2 - Viewer', new_img)\\r\\n key = cv2.waitKey(30)\\r\\n\\r\\n # Press q to exit\\r\\n if key == ord('q'):\\r\\n break\\r\\n\\r\\n cv2.destroyAllWindows()\",\n \"def view(self, name_of_window=\\\"Image\\\") -> None:\\n cv2.namedWindow(name_of_window, cv2.WINDOW_NORMAL)\\n cv2.imshow(name_of_window, self.img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def displayImage(winName, img):\\n cv.imshow(winName, img)\\n cv.waitKey(0)\",\n \"def view(self):\\n\\t\\tfigure_out = self.figure.copy()\\n\\t\\timage_pairs = np.unique(self.local_matches[\\\"image_pairs\\\"][0])\\n\\t\\tfor i in image_pairs:\\n\\t\\t\\t# draw bounding box\\n\\t\\t\\ti_loc = self.local_database[\\\"image_locs\\\"][np.where(self.local_database[\\\"image_idx\\\"] == i)[0][0]]\\n\\t\\t\\tcv2.rectangle(figure_out, (int(i_loc[0]), int(i_loc[1])), (int(i_loc[0]+i_loc[2]), int(i_loc[1]+i_loc[3])),\\n\\t\\t\\t\\t\\t\\t color = (255,0,0), thickness=5)\\n\\t\\t\\t# label matches text\\n\\t\\t\\tcv2.putText(figure_out, str(i), (int(i_loc[0]-50), int(i_loc[1] + 50)), cv2.FONT_HERSHEY_SIMPLEX, 2,\\n\\t\\t\\t\\t\\t color=(255,0,0), thickness=7)\\n\\t\\tself.save_figure(figure_out)\",\n \"def show(type,img):\\n # print(img)\\n cv2.imshow(type, img)\\n cv2.waitKey()\",\n \"def showImage(self, img):\\n cv2.namedWindow(self.NAME_WINDOW,cv2.WINDOW_NORMAL)\\n cv2.resizeWindow(self.NAME_WINDOW, 300, 700)\\n cv2.imshow(self.NAME_WINDOW , img)\\n cv2.waitKey(0)\",\n \"def show_results(datapath,nImg,mods,input_data=None,loop=True,fn=None,start_frame=None,frame_ids=None):\\n cap = cv2.VideoCapture(datapath);\\n cont = True;\\n #Write the results to video if filename is provided\\n if fn is not None:\\n out = cv2.VideoWriter('..\\\\\\\\'+fn,cv2.VideoWriter_fourcc(*'mjpa'), 10, (768*2,768));\\n out_vid = True;\\n else:\\n out_vid = False;\\n\\n while cont:\\n #Set the video to the correct start frame\\n if start_frame is not None:\\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame);\\n for i in range(nImg):\\n #If the frames aren't sequential, jump to correct next frame\\n if frame_ids is not None:\\n cap.set(cv2.CAP_PROP_POS_FRAMES,frame_ids[i]);\\n \\n #Get the next frame and the rendered image for that frame\\n _,frame = cap.read();\\n crop = ut.crop(frame,256,320);\\n render = cv2.imread(cf.renders_path + \\\"{:04d}.png\\\".format(i+1));\\n \\n #Add the images to the data dict or create it if needed\\n data = {'frame':frame,'crop':crop,'render':render,'i':i};\\n if input_data is not None:\\n data.update(input_data);\\n \\n #Apply each module's function to the data to get the images\\n frames = [];\\n for m in mods:\\n frames.append(m(data));\\n \\n # Display the resulting frame\\n row1 = np.concatenate(frames[0:3],axis=1);\\n row2 = np.concatenate(frames[3:6],axis=1);\\n row3 = np.concatenate(frames[6:9],axis=1); \\n grid = np.concatenate([row1,row2,row3]);\\n \\n out_frame = np.concatenate([grid,render],axis=1);\\n cv2.imshow('frame',out_frame);\\n \\n if out_vid:\\n out.write(out_frame);\\n \\n if cv2.waitKey(40) & 0xFF == ord('q'):\\n cont = False;\\n break;\\n if not loop:\\n cont = False;\\n cv2.destroyAllWindows();\\n cap.release();\\n if out_vid:\\n out.release();\",\n \"def display_image(window_name, img):\\n cv2.imshow(window_name, img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def show_image(self):\\n cv2.imshow(self.config.DISPLAY_NAME, self.image)\",\n \"def display_image(self, window_title: str = 'Drone Camera'):\\n cv2.imshow(window_title, self.output)\\n cv2.waitKey(1)\",\n \"def show_image(self):\\n cv2.imshow('Image', self.__diff_image())\\n cv2.waitKey()\",\n \"def img_disp(name,img):\\n cv2.imshow(name,img.astype(int)/255.0)\\n cv2.waitKey()\",\n \"def display(image, name=\\\"Image\\\"):\\n cv2.imshow(name, image)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n cv2.imwrite(\\\"{}.png\\\".format(name), image)\",\n \"def print_images_in_statistics(self):\\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)\",\n \"def show_images(images):\\n for name, img in images:\\n cv2.imshow(name, img)\\n\\n cv2.waitKey(0)\",\n \"def show_image(self, idx):\\n image, target = self.__getitem__(self, idx)\\n im_h, im_w, _ = image.size()\\n labels_num = target['labels']\\n rescale = torch.tensor([[im_w, im_h, im_w, im_h]])\\n bboxs = target['boxes'] * rescale\\n img = image.permute(1, 2, 0).numpy()\\n for i, bboxe in enumerate(bboxs):\\n x, y, xm, ym = bboxe\\n label = class_name[int(labels_num[i])]\\n plot_one_box((int(x), int(y), int(xm), int(ym)), img, label=label, line_thickness=3)\\n cv2.imshow('image', img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def print_images_out_statistics(self):\\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)\",\n \"def show_img(graphs = False):\\n while True:\\n screen = (yield)\\n window_title = \\\"logs\\\" if graphs else \\\"game_play\\\"\\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL) \\n imS = cv2.resize(screen, (800, 400)) \\n cv2.imshow(window_title, screen)\\n if (cv2.waitKey(1) & 0xFF == ord('q')):\\n cv2.destroyAllWindows()\\n break\",\n \"def _state_main(self, gui):\\n gui.entry.wait_variable(gui.entry_sv)\\n\\n '''Clean string'''\\n files = literal_eval(gui.entry_sv.get())\\n\\n '''Remove previous images'''\\n if hasattr(gui, \\\"panel\\\"):\\n gui.panel.destroy()\\n\\n '''Load each image'''\\n for file_name in files:\\n file_name = file_name.replace(\\\"{\\\", \\\"\\\").replace(\\\"}\\\", \\\"\\\")\\n # image = tk.PhotoImage(file=file_name)\\n if \\\".CR2\\\" in file_name:\\n '''Rawpy implementation'''\\n file_image = rawpy.imread(file_name)\\n file_image = file_image.postprocess()\\n '''Rawkit implementation'''\\n '''file_image = Raw(file_name)\\n file_image = np.array(file_image.to_buffer())'''\\n '''OpenCV implementation'''\\n '''file_image = cv2.imread(file_name)'''\\n else:\\n file_image = Image.open(file_name)\\n '''image = file_image.resize((500, 500), Image.ANTIALIAS)\\n image = ImageTk.PhotoImage(image)\\n gui.panel = tk.Label(gui.root, image=image)\\n gui.panel.image = image\\n gui.panel.pack()'''\\n # panel.grid(row=2)\\n\\n image_data = np.array(file_image)\\n image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY)\\n '''print(image_data.shape)\\n print(image_data)\\n print(len(image_data))\\n print(len(image_data[0]))'''\\n returned_image = Image.fromarray(image_data)\\n '''cv2.imshow(\\\"Gray\\\", image_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Gray\\\")'''\\n\\n '''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image))\\n enhanced_image = enhanced_contrast.enhance(255)\\n enhanced_data = np.array(enhanced_image)\\n plot_functions.imshow(enhanced_image)\\n plot_functions.show()'''\\n\\n # color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV)\\n # print(color_space)\\n \\n '''Create mask for white-ish pixels'''\\n '''lower_background = np.array([150, 150, 150])\\n upper_background = np.array([255, 255, 255])\\n print(image_data)\\n white_mask = cv2.inRange(image_data, lower_background, upper_background)\\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8))\\n white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\\n white_mask = white_mask / 255'''\\n\\n '''Create mask for black-ish pixels'''\\n '''lower_background = np.array([0, 0, 0])\\n upper_background = np.array([25, 25, 25])\\n black_mask = cv2.inRange(image_data, lower_background, upper_background)\\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))\\n black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))\\n black_mask = black_mask / 255'''\\n\\n '''Add masks together'''\\n '''background_mask = white_mask\\n # Ensure no value is above 1\\n background_mask = np.clip(background_mask, 0, 1)'''\\n \\n copied_image_data = np.asarray(returned_image).copy()\\n # background_mask = np.logical_not(background_mask)\\n '''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)):\\n # place black pixel on corresponding masked pixels\\n # copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))])\\n # make pixel fully white on corresponding masked pixels\\n copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])'''\\n\\n '''Turn removed pixels red'''\\n '''mask_image = Image.fromarray(copied_image_data)\\n plot_functions.imshow(mask_image)\\n plot_functions.show()'''\\n trapezoid_data = copied_image_data.copy()\\n\\n enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(trapezoid_data))\\n enhanced_image = enhanced_contrast.enhance(255)\\n trapezoid_data = np.array(enhanced_image)\\n\\n '''Detect lines'''\\n edges = cv2.Canny(trapezoid_data, 75, 150)\\n lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, maxLineGap=1000)\\n # print(lines)\\n for line in lines:\\n x1, y1, x2, y2 = line[0]\\n if y1 == y2:\\n cv2.line(copied_image_data, (x1, y1), (x2, y2), (255, 255, 255), 1)\\n\\n '''Trapezoid attempt'''\\n\\n # filters image bilaterally and displays it\\n bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175)\\n\\n # finds edges of bilaterally filtered image and displays it\\n edgeImg = cv2.Canny(bilatImg, 75, 200)\\n\\n # gets contours (outlines) for shapes and sorts from largest area to smallest area\\n contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\\n\\n # drawing red contours on the image\\n for con in contours:\\n cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3)\\n\\n '''Detect corners'''\\n dst = cv2.cornerHarris(edges, 30, 31, 0.001)\\n dst = cv2.dilate(dst, None)\\n ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)\\n dst = np.uint8(dst)\\n\\n # find centroids\\n ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)\\n # define the criteria to stop and refine the corners\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,\\n 0.001)\\n corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5),\\n (-1, -1), criteria)\\n\\n good_corners = []\\n for corner in corners:\\n if (corner[1] < 1000) & (corner[1] > 650) & (corner[0] > 250) & (corner[0] < 2250):\\n good_corners.append(corner)\\n cv2.circle(edges, (corner[0], corner[1]), 10, (255, 255, 255))\\n\\n print(good_corners)\\n if len(good_corners) >= 3:\\n corner_combos = itertools.combinations(good_corners, 3)\\n elif len(good_corners) > 1:\\n corner_combos = itertools.combinations(good_corners, 2)\\n\\n best_corner_combo = None\\n best_coef = np.inf\\n for corner_combo in corner_combos:\\n regression = LinearRegression().fit(np.array([corner[0] for corner in corner_combo]).reshape(-1, 1),\\n np.array([corner[1] for corner in corner_combo]))\\n if np.abs(regression.coef_) < best_coef:\\n best_coef = np.abs(regression.coef_)\\n best_corner_combo = np.array([corner[1] for corner in corner_combo])\\n\\n y_edge = int(round(np.mean(best_corner_combo)))\\n edges = edges[y_edge:3000, 200:2200]\\n copied_image_data = copied_image_data[y_edge:2500, 200:2200]\\n trapezoid_data = trapezoid_data[y_edge:2500, 200:2200]\\n\\n # and double-checking the outcome\\n cv2.imshow(\\\"linesEdges\\\", edges)\\n cv2.imshow(\\\"linesDetected\\\", copied_image_data)\\n cv2.imshow(\\\"Contours check\\\", trapezoid_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Contours check\\\")\\n\\n # find the perimeter of the first closed contour\\n perim = cv2.arcLength(contours[0], True)\\n # setting the precision\\n epsilon = 0.02 * perim\\n # approximating the contour with a polygon\\n approxCorners = cv2.approxPolyDP(contours[0], epsilon, True)\\n # check how many vertices has the approximate polygon\\n approxCornersNumber = len(approxCorners)\\n\\n for corners in approxCorners:\\n cv2.circle(trapezoid_data, (corners[0], corners[1]), radius=10, color=(255, 255, 255), thickness=-1)\\n cv2.imshow(\\\"Vertex position\\\", trapezoid_data)\\n cv2.waitKey()\\n cv2.destroyWindow(\\\"Vertex position\\\")\\n cv2.imshow(\\\"linesEdges\\\", edges)\\n cv2.imshow(\\\"linesDetected\\\", copied_image_data)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def show_image(window_title = ''):\\n while True:\\n screen = (yield)\\n window_title = window_title\\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL)\\n \\n # stack each of the provided greyscale images horizontally.\\n img = None\\n for s in range(screen.shape[2]):\\n if img is None:\\n img = screen[:, :, s]\\n else:\\n img = np.hstack((img, screen[:, :, s]))\\n \\n cv2.imshow(window_title, img)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n cv2.destroyAllWindows()\\n break\",\n \"def show(img, name=\\\"img\\\"):\\n cv2.imshow(name, img)\\n cv2.waitKey(0)\\n cv2.destroyWindow(name)\",\n \"def display_image(self, window_name, image):\\n cv2.namedWindow(window_name)\\n cv2.imshow(window_name, image)\\n cv2.waitKey(0)\",\n \"def display_sample(display_list):\\n plt.figure(figsize=(18, 18))\\n\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n\\n for i in range(len(display_list)):\\n plt.subplot(1, len(display_list), i+1)\\n plt.title(title[i])\\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\\n plt.axis('off')\\n plt.show()\",\n \"def show(img, win_name='qr code'):\\n cv2.imshow(win_name, img)\\n cv2.waitKey(0)\",\n \"def run_ML_onImg_and_display(self):\\r\\n self.Matdisplay_Figure.clear()\\r\\n ax1 = self.Matdisplay_Figure.add_subplot(111)\\r\\n \\r\\n # Depends on show_mask or not, the returned figure will be input raw image with mask or not.\\r\\n self.MLresults, self.Matdisplay_Figure_axis, self.unmasked_fig = self.ProcessML.DetectionOnImage(self.MLtargetedImg, axis = ax1, show_mask=False, show_bbox=False) \\r\\n self.Mask = self.MLresults['masks']\\r\\n self.Label = self.MLresults['class_ids']\\r\\n self.Score = self.MLresults['scores']\\r\\n self.Bbox = self.MLresults['rois']\\r\\n\\r\\n self.SelectedCellIndex = 0\\r\\n self.NumCells = int(len(self.Label))\\r\\n self.selected_ML_Index = []\\r\\n self.selected_cells_infor_dict = {}\\r\\n \\r\\n self.Matdisplay_Figure_axis.imshow(self.unmasked_fig.astype(np.uint8))\\r\\n \\r\\n self.Matdisplay_Figure.tight_layout()\\r\\n self.Matdisplay_Canvas.draw()\",\n \"def display_image(window_name, image):\\n cv2.namedWindow(window_name)\\n cv2.imshow(window_name, image)\\n cv2.waitKey(0)\",\n \"def main():\\n \\n # for inserting other images, add tem to /input folder and list them here\\n images = (\\n 'image-0',\\n 'image-1',\\n 'image-2'\\n )\\n\\n for image_name in images:\\n print(image_name, \\\"image:\\\")\\n\\n image = open_image(image_name)\\n display_image(image, \\\"Original input \\\" + image_name)\\n\\n grayscale_v = transform_colors(image)\\n display_image(grayscale_v[:,:,0], \\\"Grayscale \\\" + image_name)\\n save_image(image_name + \\\"-grayscale\\\", grayscale_v[:,:,0])\\n\\n contours_v, contours = get_contours(grayscale_v)\\n display_image(contours_v, \\\"Contours \\\" + image_name)\\n save_image(image_name + \\\"-contours\\\", contours_v)\\n\\n labeled_img, areas = get_measures(image, contours[1:])\\n display_image(labeled_img, \\\"Labeled \\\" + image_name)\\n save_image(image_name + \\\"-labeled\\\", labeled_img)\\n\\n areas_histogram(areas, image_name)\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: List[DetectObject]) -> np.ndarray:\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n self.layer = dpg.add_draw_layer(\\n parent=f'main_window_{self.id}',\\n tag=draw_layer_tag,\\n show=False\\n )\\n for out in output_data:\\n description = f'{out.clsname} [{out.score*100:.2f}%]'\\n # add alpha and convert to RGB\\n color = np.array(self.class_colors[out.clsname])\\n color = tuple((255*color).astype(np.uint8))\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=(out.xmin*self.width,\\n out.ymin*self.height),\\n pmax=(out.xmax*self.width,\\n out.ymax*self.height),\\n color=color,\\n thickness=2\\n )\\n dpg.draw_text(\\n parent=draw_layer_tag,\\n text=description,\\n pos=(out.xmin*self.width + _PADDING,\\n out.ymin*self.height + _PADDING),\\n color=color,\\n size=_FONT_SIZE\\n )\\n\\n return img\",\n \"def display(self):\\n display(self.image)\",\n \"def display(img, name=\\\"IMAGE\\\", wait=0):\\n\\tcv2.namedWindow(name, cv2.WINDOW_NORMAL)\\n\\tcv2.imshow(name, img)\\n\\tcv2.waitKey(wait) & 0xFF\\n\\tcv2.destroyAllWindows()\",\n \"def visualize(image, preds, fps):\\n # show inference info\\n fps_text = \\\"FPS : {:.2f}\\\".format(fps)\\n cv2.putText(image, fps_text, (11, 40), cv2.FONT_HERSHEY_PLAIN, 4.0, (238, 130, 238), 4, cv2.LINE_AA)\\n\\n if preds.shape[0] != 0:\\n for box in preds:\\n (x1, y1, x2, y2) = box.astype(np.int)\\n cv2.rectangle(image, (x1, y1), (x2, y2), (255, 255, 0), 2)\\n\\n return image\",\n \"def display_images(digits_im):\\n i = 0\\n\\n for img in digits_im:\\n if i < N_NEIGHBOURS:\\n # Visualize your data\\n im_max = np.max(img)\\n img = PIXELS * (np.abs(im_max - img) / im_max)\\n res = cv2.resize(img, (DIM, DIM), interpolation=cv2.INTER_CUBIC)\\n cv2.imwrite('digit ' + str(i) + '.png', res)\\n i += 1\\n else:\\n break\",\n \"def run_visualization(image):\\n # for image in images:\\n try:\\n with tf.gfile.FastGFile(image, 'rb') as f:\\n jpeg_str = f.read()\\n original_im = Image.open(BytesIO(jpeg_str))\\n except IOError:\\n print('Cannot retrieve image')\\n return\\n\\n # print('running deeplab on image {0}'.format(image))\\n resized_im, seg_map = MODEL.run(original_im)\\n seg_map = seg_map.astype(np.uint8) * 255\\n resized_im = np.array(resized_im, dtype=np.uint8)\\n resized_im = cv2.cvtColor(resized_im, cv2.COLOR_BGR2RGB)\\n # vis_segmentation(resized_im, seg_map,FULL_COLOR_MAP ,LABEL_NAMES)\\n overlay_image = cv2.addWeighted(resized_im, 0.8, cv2.merge((seg_map * 0, seg_map, seg_map * 0)), 0.2, 0)\\n # time.sleep(params.SEC_BETWEEN_PREDICTION)\\n\\n return resized_im, seg_map, overlay_image.astype(np.uint8)\",\n \"def show_to_window(self):\\n if self.normal_mode:\\n self.show_image.show_original_image(\\n self.image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.image, self.width_result_image, self.angle)\\n\\n else:\\n if self.panorama_mode:\\n image = draw_polygon(\\n self.image.copy(),\\n self.mapX_pano,\\n self.mapY_pano)\\n mapX = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapX.npy')\\n mapY = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapY.npy')\\n rho = self.panorama.rho\\n\\n self.result_image = cv2.remap(\\n self.image,\\n mapX,\\n mapY,\\n cv2.INTER_CUBIC)\\n self.result_image = self.result_image[round(\\n rho + round(self.moildev.getRhoFromAlpha(30))):self.h, 0:self.w]\\n # print(self.width_result_image)\\n else:\\n image = draw_polygon(self.image.copy(), self.mapX, self.mapY)\\n self.result_image = cv2.remap(\\n self.image,\\n self.mapX,\\n self.mapY,\\n cv2.INTER_CUBIC)\\n self.show_image.show_original_image(\\n image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.result_image, self.width_result_image, self.angle)\",\n \"def visual_image(img, annos, save_path, ratio=None, height=None, width=None, name=None, score_threshold=0.01):\\n # annos: list type, in which all the element is dict\\n h, w = img.shape[0], img.shape[1]\\n if height is not None and width is not None and (height != h or width != w):\\n img, annos = resize_image(img, annos, width, height)\\n elif ratio not in (None, 1):\\n img, annos = resize_image(img, annos, w * ratio, h * ratio)\\n\\n h, w = img.shape[0], img.shape[1]\\n num_objects = len(annos)\\n num = 0\\n\\n def define_color(pair):\\n \\\"\\\"\\\"define line color\\\"\\\"\\\"\\n left_part = [0, 1, 3, 5, 7, 9, 11, 13, 15]\\n right_part = [0, 2, 4, 6, 8, 10, 12, 14, 16]\\n if pair[0] in left_part and pair[1] in left_part:\\n color = (255, 0, 0)\\n elif pair[0] in right_part and pair[1] in right_part:\\n color = (0, 0, 255)\\n else:\\n color = (139, 0, 255)\\n return color\\n\\n def visible(a, w, h):\\n return a[0] >= 0 and a[0] < w and a[1] >= 0 and a[1] < h\\n\\n for i in range(num_objects):\\n ann = annos[i]\\n bbox = coco_box_to_bbox(ann['bbox'])\\n if \\\"score\\\" in ann and (ann[\\\"score\\\"] >= score_threshold or num == 0):\\n num += 1\\n txt = (\\\"p\\\" + \\\"{:.2f}\\\".format(ann[\\\"score\\\"]))\\n cv2.putText(img, txt, (bbox[0], bbox[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)\\n\\n ct = (int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2))\\n cv2.circle(img, ct, 2, (0, 255, 0), thickness=-1, lineType=cv2.FILLED)\\n bbox = np.array(bbox, dtype=np.int32).tolist()\\n cv2.rectangle(img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)\\n\\n keypoints = ann[\\\"keypoints\\\"]\\n keypoints = np.array(keypoints, dtype=np.int32).reshape(_NUM_JOINTS, 3).tolist()\\n\\n for pair in data_cfg.edges:\\n partA = pair[0]\\n partB = pair[1]\\n color = define_color(pair)\\n p_a = tuple(keypoints[partA][:2])\\n p_b = tuple(keypoints[partB][:2])\\n mask_a = keypoints[partA][2]\\n mask_b = keypoints[partB][2]\\n if (visible(p_a, w, h) and visible(p_b, w, h) and mask_a * mask_b > 0):\\n cv2.line(img, p_a, p_b, color, 2)\\n cv2.circle(img, p_a, 3, color, thickness=-1, lineType=cv2.FILLED)\\n cv2.circle(img, p_b, 3, color, thickness=-1, lineType=cv2.FILLED)\\n\\n img_id = annos[0][\\\"image_id\\\"] if annos and \\\"image_id\\\" in annos[0] else random.randint(0, 9999999)\\n image_name = \\\"cv_image_\\\" + str(img_id) + \\\".png\\\" if name is None else \\\"cv_image_\\\" + str(img_id) + name + \\\".png\\\"\\n cv2.imwrite(\\\"{}/{}\\\".format(save_path, image_name), img)\",\n \"def print_images(i, df):\\n \\n images_folder_path = \\\"dataset/petfinder-adoption-prediction/train_images/\\\"\\n plt.imshow(cv2.cvtColor(cv2.imread(images_folder_path+df.filename[i]), cv2.COLOR_BGR2RGB),);\\n plt.axis(\\\"off\\\");\\n plt.show()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def displayImgs(imgs, titles = None, wait=0):\\n\\tif len(imgs) > 100:\\n\\t\\tprint \\\"WARNING: DisplayImgs: List is of length \\\" + str(len(imgs))\\n\\t\\tprint \\\"Please reduce list size to avoid improper display\\\"\\n\\t\\treturn\\n\\tif titles is None:\\n\\t\\tcount = 1\\n\\t\\tfor i in imgs:\\n\\t\\t\\tcv2.namedWindow(\\\"IMAGE\\\" + str(count), cv2.WINDOW_NORMAL)\\n\\t\\t\\tcv2.imshow(\\\"IMAGE\\\" + str(count), i)\\n\\t\\t\\tcount += 1\\n\\telse:\\n\\t\\tcount = 0\\n\\t\\tfor i in imgs:\\n\\t\\t\\tcv2.namedWindow(titles[count], cv2.WINDOW_NORMAL)\\n\\t\\t\\tcv2.imshow(titles[count], i)\\n\\t\\t\\tcount += 1\\n\\tcv2.waitKey(wait) & 0xFF\\n\\tcv2.destroyAllWindows()\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: List[SegmObject]) -> np.ndarray:\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n mix_factor = .3\\n\\n self.layer = dpg.add_draw_layer(\\n parent=f'main_window_{self.id}',\\n tag=draw_layer_tag,\\n show=False\\n )\\n\\n for out in output_data:\\n if out.score < self.score_threshold:\\n continue\\n\\n mask = cv2.resize(\\n out.mask,\\n (self.width, self.height),\\n cv2.INTER_NEAREST\\n ).astype(np.uint8)\\n color_mask = np.tile(mask[..., None]/255., [1, 1, 4])\\n color_image = np.tile(\\n self.class_colors[out.clsname],\\n [self.height, self.width, 1]\\n )\\n img += color_image * color_mask * mix_factor\\n contour, _ = cv2.findContours(\\n mask.astype(np.uint8),\\n cv2.RETR_CCOMP,\\n cv2.CHAIN_APPROX_NONE\\n )\\n color = np.array(self.class_colors[out.clsname])\\n color = tuple((255*color).astype(np.uint8))\\n for c in contour:\\n dpg.draw_polyline(\\n parent=draw_layer_tag,\\n points=list(c[:, 0, :]),\\n color=color,\\n thickness=2\\n )\\n description = f'{out.clsname} [{out.score * 100:.2f}%]'\\n dpg.draw_text(\\n parent=draw_layer_tag,\\n text=description,\\n pos=(c[:, 0, 0].min() + _PADDING,\\n c[:, 0, 1].min() + _PADDING),\\n color=color,\\n size=_FONT_SIZE\\n )\\n\\n return img\",\n \"def show_visuals(self, objects_in_scene, image, axe_pred):\\n image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)\\n\\n # draw grid (slow)\\n #image = self.draw_grid(image)\\n\\n # add axe bounding box\\n #image = self.return_bbox_image(image, objects_in_scene.axes, \\\"Axe\\\", AXE_COLOR)\\n\\n # add mundo bounding box\\n #image = self.return_bbox_image(image, objects_in_scene.mundos, \\\"Mundo\\\", MUNDO_COLOR)\\n\\n # add a circle/dot at the centre of the axe bbox\\n image = self.show_centre_of_bbox(image, objects_in_scene.axes)\\n\\n # if there is a prediction made in the current frame, draw an arrow graphic to highlight\\n # where the program predicts the axe will go\\n if axe_pred:\\n image = self.draw_pred_arrows(image, axe_pred, 1)\\n\\n\\n\\n\\n # open live capture window with new shapes\\n try:\\n image = cv2.resize(image, (960, 540)) \\n cv2.imshow(\\\"visualisation\\\", image)\\n\\n if cv2.waitKey(25) & 0xFF == ord('q'):\\n cv2.destroyAllWindows()\\n exit()\\n\\n except:\\n pass\",\n \"def yolo_show(image_path_list, batch_list):\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n for img_path, batch in zip(image_path_list, batch_list):\\n result_list = batch.tolist()\\n img = cv2.imread(img_path)\\n for result in result_list:\\n cls = int(result[0])\\n bbox = result[1:-1]\\n score = result[-1]\\n print('img_file:', img_path)\\n print('cls:', cls)\\n print('bbox:', bbox)\\n c = ((int(bbox[0]) + int(bbox[2])) / 2, (int(bbox[1] + int(bbox[3])) / 2))\\n cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 255), 1)\\n cv2.putText(img, str(cls), (int(c[0]), int(c[1])), font, 1, (0, 0, 255), 1)\\n result_name = img_path.split('/')[-1]\\n cv2.imwrite(\\\"constant/results/\\\" + result_name, img)\",\n \"def show(self):\\n if self.video:\\n self.video.write(self.img)\\n cv2.imshow('Simpy', self.img)\\n cv2.waitKey(1000 // self.fps)\",\n \"def Show(orignal_img, sobel_image):\\n # use imshow() function to show the images\\n # syntax : cv2.imshow(winname, mat)\\n cv2.imshow(\\\"Original_Image\\\", orignal_img)\\n cv2.imshow(\\\"Sobel_Image\\\", sobel_image)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def draw_ui(img, vehicle_count, capacity, exit_masks=[]):\\r\\n # EXIT MASKS\\r\\n cv2.line(img, (0,400),(645,400),(0,255,0),2)\\r\\n cv2.line(img, (732,590),(1280,500),(0,255,0),2)\\r\\n \\r\\n # STATS\\r\\n cv2.rectangle(img, (0, 0), (img.shape[1], 50), (0, 0, 0), cv2.FILLED)\\r\\n cv2.putText(img, (\\\"Density: {cur_left}% Vehicles passed: {left} \\\\\\r\\n Density: {cur_right}% Vehicles passed: {right}\\\".format(\\\\\\r\\n left=vehicle_count[0], right=vehicle_count[1], \\\\\\r\\n cur_right=round(capacity[1]*100,3),\\\\\\r\\n cur_left=round(capacity[0]*100,3))), (30, 30),\\\\\\r\\n cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1)\\r\\n \\r\\n return img\",\n \"def popup(self):\\n opencv.imshow('dbg', self.img)\\n opencv.waitKey(0)\",\n \"def visualize(self):\\n colors = {'outline': (220, 220, 220),\\n 'inlier': (0, 255, 0),\\n 'outlier': (0, 0, 255),\\n 'lines': (128, 220, 128)}\\n # Create output image for visualization\\n gap = 5\\n h1, w1 = self.target.image.shape[:2]\\n h2, w2 = self.image.shape[:2]\\n vis = np.zeros((max(h1, h2), w1 + w2 + gap, 3), np.uint8)\\n vis[:h1, :w1, :] = self.target.image\\n w1 += gap\\n vis[:h2, w1:w1+w2, :] = self.image\\n \\n # Draw the located object \\n quad = np.float32(self.quad) + np.float32([w1, 0])\\n self.draw(vis, colors['outline'], 2, quad)\\n \\n # draw point details\\n inliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.inliers]\\n outliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.outliers]\\n if colors['outlier'] is not None: # draw x on each point\\n r = 2 # radius\\n thickness = 2\\n for x0, y0, x1, y1 in outliers:\\n cv2.line(vis, (x0 - r, y0 - r), (x0 + r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x0 + r, y0 - r), (x0 - r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 + r, y1 - r), (x1 - r, y1 + r), colors['outlier'], thickness)\\n if colors['lines'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.line(vis, (x0, y0), (x1, y1), colors['lines'], 1)\\n if colors['inlier'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.circle(vis, (x0, y0), 2, colors['inlier'], -1)\\n cv2.circle(vis, (x1, y1), 2, colors['inlier'], -1)\\n return vis\",\n \"def demo(sess, net, image_name):\\n # Load the demo image\\n global CLASS_NAME\\n global CHECK\\n CHECK = 0\\n # 读取的截图所在的位置\\n # im_file = Cnn_path + \\\"data/VOCdevkit2007/VOC2007/JPEGImages/\\\" + image_name\\n curpath = os.path.dirname(os.path.realpath(__file__))\\n im_file = curpath + \\\"\\\\\\\\data\\\\\\\\VOCdevkit2007\\\\\\\\VOC2007\\\\\\\\JPEGImages\\\\\\\\\\\" + image_name\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(sess, net, im)\\n timer.toc()\\n print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))\\n\\n # Visualize detections for each class\\n # score 阈值，最后画出候选框时需要，>thresh才会被画出\\n CONF_THRESH = 0.5\\n # 非极大值抑制的阈值，剔除重复候选框\\n NMS_THRESH = 0.3\\n # 利用enumerate函数，获得CLASSES中 类别的下标cls_ind和类别名cls\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 # because we skipped background\\n # 取出bbox ,score\\n cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n # 将bbox,score 一起存入dets\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n # 进行非极大值抑制，得到抑制后的 dets\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n # 画框\\n vis_detections(im, cls, dets, thresh=CONF_THRESH)\\n if CHECK == 0:\\n CLASS_NAME = \\\"None\\\"\\n # im = im[:, :, (2, 1, 0)]\\n # fig, ax = plt.subplots()\\n # ax.imshow(im, aspect='equal')\\n # ax.set_title(\\\"None\\\",fontsize=10)\\n # plt.axis('off')\\n # plt.tight_layout()\\n # plt.draw()\\n # RES[INDS.__getitem__(image_name.split(\\\"_\\\")[0])][INDS.__getitem__(CLASS_NAME)]+=1\\n # plt.savefig(\\\"./output/\\\"+CLASS_NAME+\\\"_\\\" + image_name)\\n # plt.savefig(\\\"./output/\\\" + image_name)\\n MAX_SCORE[0] = 0.0\",\n \"def run(self):\\n r = rospy.Rate(10)\\n while not rospy.is_shutdown():\\n\\n if not self.cv_image is None:\\n #cv2.imshow('video_window', self.cv_image)\\n cv2.imshow('video_window2', self.contour_image)\\n cv2.waitKey(10)\\n r.sleep()\",\n \"def _visualize_cam_w_s(self, imgs, names=\\\"2DPositions\\\"):\\n feed_dict = {}\\n feed_dict[self.images_tf] = imgs\\n conv6_val, output_val = self.sess.run([self.conv6, self.output],feed_dict=feed_dict)\\n preds = output_val\\n preds_order = preds.argsort( axis=1 )[:,::-1]\\n best_preds = preds.argmax( axis=1 )\\n\\n\\n if names == \\\"Predictions\\\":\\n self.classmap = self.detector.get_classmap( self.labels_tf, self.conv6, list(imgs.shape[1:3]), eval_all=False )\\n classmap_vals = self.sess.run(\\n self.classmap,\\n feed_dict={\\n self.labels_tf: best_preds,\\n self.conv6: conv6_val\\n })\\n \\n classmap_vis = map(lambda x: ((x-x.min())/(x.max()-x.min())), classmap_vals)\\n self.classmap_vis = classmap_vis # for Debug\\n named_preds = map(self.to_named_pred, preds)\\n\\n if names == \\\"BoundingBoxes\\\":\\n softmaxs = f_sotfmax(preds)\\n self.classmap = self.detector.get_classmap( self.labels_tf, self.conv6, list(imgs.shape[1:3]), eval_all=True )\\n classmap_vals = self.sess.run(\\n self.classmap,\\n feed_dict={\\n self.labels_tf: best_preds*0-1,\\n self.conv6: conv6_val\\n })\\n classmap_vis = classmap_vals\\n ls,ts,rs,bs = self._get_bounding_boxes(imgs, classmap_vals, threshold_value=.8)\\n named_preds = map(self.to_named_pred, softmaxs, ls, ts, rs, bs)\\n\\n\\n return named_preds, np.array(classmap_vis)[0]\",\n \"def update(self):\\n cv2.imshow(self.window_name, self.map.get_crop())\",\n \"def main(image_path):\\n temp_dir = tempfile.mkdtemp()\\n print('Saving output to {}'.format(temp_dir))\\n estimator = run_image(image_path)\\n visualize(estimator, image_path, temp_dir)\",\n \"def show(title, img, write = False, wait = False):\\n cv2.namedWindow(title, flags = cv2.WINDOW_NORMAL)\\n cv2.imshow(title, img)\\n cv2.resizeWindow(title, 1200, 900)\\n if write:\\n cv2.imwrite(title + \\\".png\\\", img)\\n if wait:\\n cv2.waitKey(1)\",\n \"def demo(net, data_dir, imgfile, out_dir):\\n\\n # Load the demo image\\n im_file = os.path.join(data_dir, imgfile)\\n im = cv2.imread(im_file)\\n\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im)\\n scores = np.squeeze(scores)\\n timer.toc()\\n print ('Detection took {:.3f}s for '\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0.12\\n NMS_THRESH = 0.3\\n color_white = (0, 0, 0)\\n for cls_ind, cls in enumerate(CLASSES[1:]):\\n cls_ind += 1 \\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n color = (random.randint(0, 256), random.randint(0, 256), random.randint(0, 256))\\n inds = np.where(dets[:, -1] >= CONF_THRESH)[0]\\n for i in inds:\\n bbox = dets[i, :4]\\n score = dets[i, -1]\\n bbox = map(int, bbox)\\n cv2.rectangle(im, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color=color, thickness=4)\\n cv2.putText(im, '%s %.3f' % (cls, score), (bbox[0], bbox[1] + 15),\\n color=color_white, fontFace=cv2.FONT_HERSHEY_COMPLEX, fontScale=0.5)\\n return im\",\n \"def yolo_show_img(image, class_ids, boxes, labels, confidences, colors):\\n for i, box in enumerate(boxes):\\n # extract the bounding box coordinates\\n (x, y) = (box[0], box[1])\\n (w, h) = (box[2], box[3])\\n\\n # draw a bounding box rectangle and label on the image\\n color = [int(c) for c in colors[class_ids[i]]]\\n cv2.rectangle(image, (x, y), (x + w, y + h), color, 3)\\n text = '{}: {:.4f}'.format(labels[i], confidences[i])\\n print(text)\\n\\n font_scale = 1.3\\n # set the rectangle background to white\\n rectangle_bgr = color\\n # set some text\\n # get the width and height of the text box\\n (text_width, text_height) = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=font_scale, thickness=1)[0]\\n # set the text start position\\n text_offset_x = x\\n text_offset_y = y - 3 \\n # make the coords of the box with a small padding of two pixels\\n box_coords = ((text_offset_x, text_offset_y), (text_offset_x + text_width + 10, text_offset_y - text_height - 10 ))\\n cv2.rectangle(image, box_coords[0], box_coords[1], rectangle_bgr, cv2.FILLED)\\n cv2.putText(image, text, (text_offset_x, text_offset_y), cv2.FONT_HERSHEY_SIMPLEX, \\n fontScale=font_scale, color=(255, 255, 255), thickness=2)\\n\\n cv2.imshow('yolo prediction', image)\\n cv2.waitKey(0)\",\n \"def figshow(img,hsize=400,title='hoge'):\\n shape = img.shape\\n ratio=shape[0]/shape[1]\\n img2= cv2.resize(img,(hsize,int(hsize*ratio)))\\n cv2.imshow(title,img2)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def showWait(img, title):\\r\\n cv2.imshow(title, img)\\r\\n cv2.waitKey(0)\\r\\n cv2.destroyAllWindows()\",\n \"def display(self):\\n nrow = 2\\n ncol = len(self.views) + 1\\n rows = [(self.views[0].original, len(self.views)),\\n (self.views[0].image, len(self.views) + 1)]\\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\\n figsize=self._figsize(rows),\\n squeeze=True)\\n originals = [(v.position.id, v.original) for v in self.views] + [\\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\\n warped = [(v.position.id, v.image) for v in self.views] + [\\n ('combined', self.image)]\\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\\n ax.imshow(img)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=title)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def show_img(self):\\n if self.image is not None:\\n cv2.imshow(self.image_window, self.image)\\n cv2.waitKey(1)\\n else:\\n rospy.loginfo(\\\"No image to show yet\\\")\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: np.ndarray) -> np.ndarray:\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n self.layer = dpg.add_draw_layer(\\n parent=f'main_window_{self.id}',\\n tag=draw_layer_tag,\\n show=False\\n )\\n\\n best_k = np.argsort(output_data)[-self.top_n:][::-1]\\n class_names = np.array(self.class_names)[best_k]\\n percentages = softmax(output_data[best_k])\\n\\n for i, (name, perc) in enumerate(zip(class_names, percentages)):\\n label_pos = dpg.get_item_pos(f'cell_bar_{i}_{self.id}')\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=label_pos,\\n pmax=(\\n label_pos[0] + _SCORE_COLUMN_WIDTH*perc,\\n label_pos[1] + _FONT_SIZE),\\n color=(0, 255, 0),\\n fill=(0, 255, 0)\\n )\\n dpg.set_value(f'cell_perc_{i}_{self.id}', f'{perc*100:.2f}%')\\n dpg.set_value(f'cell_name_{i}_{self.id}', name)\\n\\n return img\",\n \"def im_show(img_list,title=['']):\\n Error = False\\n if title == ['']:\\n title=[f'Image {i+1}' for i in range(len(img_list))]\\n if len(title) != len(img_list):\\n print('ERROR 1 (im_show)')\\n Error = True\\n if not Error:\\n for i,img in enumerate(img_list):\\n cv2.imshow(title[i],img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def display(image, fx=1, fy=1):\\n image = cv2.resize(image, (0, 0), fx=fx, fy=fy)\\n cv2.imshow('Image', image)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def displayImages(self):\\n\\n plt.figure(figsize=(8,6))\\n plt.subplot(1,2,1)\\n plt.imshow( self.original_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Original Image\\\")\\n plt.subplot(1,2,2)\\n plt.imshow( self.blurred_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Blurred Image\\\")\",\n \"def display_sample(display_list):\\n fig, axs = plt.subplots(1, len(display_list), figsize=(18, 18))\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n for i in range(len(display_list)):\\n axs[i].set_title(title[i])\\n axs[i].imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\\n axs[i].axis('off')\",\n \"def display_img_opencv_full_size(img_name, img):\\n cv2.imshow(img_name, img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def demo(net, image_name, conf_thres, nms_thres, resDir, bShow=False):\\n global CLASSES\\n\\n # Load the demo image\\n im_file = image_name\\n im = cv2.imread(im_file)\\n fname = os.path.basename(image_name)\\n\\n # Detect all object classes and regress object bounds\\n # timers\\n _t = {'im_detect' : Timer(), 'misc' : Timer(), 'save' : Timer()}\\n\\n _t['im_detect'].tic()\\n scores, boxes = im_detect(net, im)\\n _t['im_detect'].toc()\\n \\n \\n _t['misc'].tic() \\n results = np.zeros((0, 6), dtype=np.float32)\\n # Visualize detections for each class\\n # for cls_ind, cls in enumerate(CLASSES[1:5]):\\n for cls_ind, cls in enumerate(CLASSES[1:]): \\n cls_ind += 1 # because we skipped background\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n \\n # CPU NMS is much faster than GPU NMS when the number of boxes\\n # is relative small (e.g., < 10k)\\n # TODO(rbg): autotune NMS dispatch\\n keep = nms(dets, nms_thres, force_cpu=True)\\n dets = dets[keep, :]\\n results = np.vstack( (results, np.insert(dets, 0, cls_ind, axis=1)) ) \\n _t['misc'].toc() \\n \\n if bShow:\\n plt.figure(1, figsize=(15,10))\\n plt.clf()\\n axe = plt.gca()\\n axe.imshow(im[:,:,(2,1,0)])\\n\\n clrs = sns.color_palette(\\\"Set2\\\", len(CLASSES))\\n for det in results:\\n cls_ind, box, score = det[0], det[1:5], det[5]\\n if score < 0.8: continue\\n clr = clrs[int(cls_ind)]\\n rect = plt.Rectangle( (box[0], box[1]), box[2]-box[0], box[3]-box[1], fill=False, edgecolor=clr, linewidth=2.5)\\n axe.add_patch(rect)\\n axe.text(box[0], box[1]-2, '{:.3f}'.format(score), bbox=dict(facecolor=clr, alpha=0.5), fontsize=14, color='white')\\n\\n axe.axis('off')\\n save_name = os.path.basename(im_file)\\n plt.savefig('[DEMO]'+save_name, dpi=200) \\n\\n else:\\n _t['save'].tic()\\n with open( os.path.join(resDir, fname.split('.')[0] + '.txt'), 'w') as fp: \\n for det in results:\\n if len(det) == 0: continue \\n if det[5] < 0.01: continue\\n\\n resStr = '{:s} -1 -1 -10 '.format(CLASSES[int(det[0])]) \\n resStr += '{:.2f} {:.2f} {:.2f} {:.2f} '.format(det[1],det[2],det[3],det[4]) # x1 y1 x2 y2\\n resStr += '-1 -1 -1 -1000 -1000 -1000 -10 {:.4f}\\\\n'.format(det[5])\\n fp.write( resStr ) \\n _t['save'].toc()\\n\\n return _t\",\n \"def printMat(image):\\n for row in range(image.rows):\\n print \\\"[\\\",\\n for col in range(image.cols):\\n print cv.mGet(image, row, col),\\n print \\\"]\\\"\\n print \\\"\\\"\",\n \"def display_gui_window(self, window_title):\\r\\n cv2.imshow(window_title, self.image)\",\n \"def show_result(inputs, labels, outputs):\\n num_classes = outputs.size(1)\\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\\n if num_classes == 2:\\n outputs *= 255\\n mask = outputs[0].reshape((360, 640))\\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\\n ax[0].set_title('Image')\\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\\n ax[1].set_title('gt')\\n plt.show()\\n plt.figure()\\n plt.imshow(mask, cmap='gray')\\n plt.title('Pred')\\n plt.show()\",\n \"def show_four_images(img1, img2, img3, img4, title):\\n shape = (460, 250)\\n # Get all images in same size for better display\\n img1 = cv2.resize(img1, shape)\\n img2 = cv2.resize(img2, shape)\\n img3 = cv2.resize(img3, shape)\\n img4 = cv2.resize(img4, shape)\\n # combined 2 images horizontally\\n numpy_horizontal1 = np.hstack((img1, img2))\\n # combined the rest 2 images horizontally\\n numpy_horizontal2 = np.hstack((img3, img4))\\n # now combined all vertically to 1 image and display\\n numpy_vertical = np.vstack((numpy_horizontal1, numpy_horizontal2))\\n # final thing - show the output:\\n show_image(numpy_vertical, title)\",\n \"def show(image):\\n cv2.imshow('press ENTER to close', image)\\n cv2.waitKey(0)\",\n \"def showImages(images):\\n idx = 0\\n\\n while True:\\n\\n cv2.imshow(\\\"Image\\\", images[idx])\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"d\\\"):\\n if idx+1 >= len(images):\\n print(\\\"This is the last image in the set.\\\")\\n else:\\n idx += 1\\n print(\\\"Viewing image no. {0} / {1}\\\".format(idx+1, len(images)))\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"a\\\"):\\n if idx-1 < 0:\\n print(\\\"This is the first image in the set.\\\")\\n else:\\n idx -= 1\\n print(\\\"Viewing image no. {0} / {1}\\\".format(idx+1, len(images)))\\n\\n if cv2.waitKey(15) & 0xFF == ord(\\\"q\\\"):\\n break\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: Any):\\n raise NotImplementedError\",\n \"def display(self, image):\\n raise NotImplementedError()\",\n \"def display(self):\\n\\t\\t# print len(self.visibleFaceList)\\n\\t\\t# print \\\"not visible: \\\"\\n\\t\\t# for face in self.notVisibleFaceList:\\n\\t\\t# \\tprint face.id\\n\\t\\t# print \\\"visibel: \\\"\\n\\t\\tfor i in range(len(self.visibleFaceList)):\\n\\t\\t\\t# print self.visibleFaceList[i].id\\n\\t\\t\\tself.showRectangle(self.visibleFaceList[i].getPosition(),self.visibleFaceList[i].id)\\n\\t\\tcv2.imshow(\\\"show\\\", self.frameImage)\",\n \"def imshow(img):\\n imadd(img)\\n plt.ion()\\n plt.show()\",\n \"def showBPImg(pV,nV):\\n # object arrays of the positive and negative images\\n inv_crop = np.empty(8, dtype=object)\\n inv_crop2 = np.empty(8, dtype=object)\\n for t in range(8):\\n # backprojection functions\\n inverse = retina.inverse(pV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\\n inv_crop[t] = retina.crop(inverse,x,y,dloc[i])\\n inverse2 = retina.inverse(nV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)\\n inv_crop2[t] = retina.crop(inverse2,x,y,dloc[i])\\n # place descriptions\\n cv2.putText(inv_crop[t],types[t] + \\\" + \\\",(xx,yy), font, 1,(0,255,255),2)\\n cv2.putText(inv_crop2[t],types[t] + \\\" - \\\",(xx,yy), font, 1,(0,255,255),2)\\n # stack all images into a grid\\n posRG = np.vstack((inv_crop[:4]))\\n negRG = np.vstack((inv_crop2[:4]))\\n posYB = np.vstack((inv_crop[4:]))\\n negYB = np.vstack((inv_crop2[4:]))\\n merge = np.concatenate((posRG,negRG,posYB,negYB),axis=1)\\n return merge\",\n \"def vis_all_detection(im_array, detections, class_names, scale):\\n import matplotlib \\n matplotlib.use('Agg') \\n import matplotlib.pyplot as plt\\n from matplotlib.pyplot import savefig \\n import random\\n a = [103.06 ,115.9 ,123.15]\\n a = np.array(a)\\n im = image.transform_inverse(im_array,a)\\n plt.imshow(im)\\n for j in range(len(class_names)):\\n if class_names[j] == 0:\\n continue\\n color = (random.random(), random.random(), random.random()) # generate a random color\\n dets = detections[j]\\n det =dets\\n bbox = det[0:] \\n score = det[0]\\n rect = plt.Rectangle((bbox[0], bbox[1]),\\n bbox[2] - bbox[0],\\n bbox[3] - bbox[1], fill=False,\\n edgecolor=color, linewidth=3.5)\\n plt.gca().add_patch(rect)\\n plt.gca().text(bbox[0], bbox[1] - 2,\\n '{:s} {:.3f}'.format(str(class_names[j]), score),\\n bbox=dict(facecolor=color, alpha=0.5), fontsize=12, color='white')\\n plt.show()\\n name = np.mean(im)\\n savefig ('vis/'+str(name)+'.png')\\n plt.clf()\\n plt.cla()\\n\\n plt. close(0)\",\n \"def show_result(self,\\n img,\\n result,\\n palette=None,\\n win_name='',\\n show=False,\\n wait_time=0,\\n out_file=None,\\n opacity=0.5):\\n img = mmcv.imread(img)\\n img = img.copy()\\n seg = result[0]\\n if palette is None:\\n if self.PALETTE is None:\\n # Get random state before set seed,\\n # and restore random state later.\\n # It will prevent loss of randomness, as the palette\\n # may be different in each iteration if not specified.\\n # See: https://github.com/open-mmlab/mmdetection/issues/5844\\n state = np.random.get_state()\\n np.random.seed(42)\\n # random palette\\n palette = np.random.randint(\\n 0, 255, size=(len(self.CLASSES), 3))\\n np.random.set_state(state)\\n else:\\n palette = self.PALETTE\\n palette = np.array(palette)\\n assert palette.shape[0] == len(self.CLASSES)\\n assert palette.shape[1] == 3\\n assert len(palette.shape) == 2\\n assert 0 < opacity <= 1.0\\n color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)\\n for label, color in enumerate(palette):\\n color_seg[seg == label, :] = color\\n # convert to BGR\\n color_seg = color_seg[..., ::-1]\\n\\n img = img * (1 - opacity) + color_seg * opacity\\n img = img.astype(np.uint8)\\n # if out_file specified, do not show image in window\\n if out_file is not None:\\n show = False\\n\\n if show:\\n mmcv.imshow(img, win_name, wait_time)\\n if out_file is not None:\\n mmcv.imwrite(img, out_file)\\n\\n if not (show or out_file):\\n warnings.warn('show==False and out_file is not specified, only '\\n 'result image will be returned')\\n return img\",\n \"def display_sample_images(self):\\n if self.train_dataset is None:\\n self.init_datasets()\\n\\n images, labels = next(self.train_dataset)\\n plt.figure(figsize=(5,5))\\n for n in range(min(25, images.shape[0])):\\n ax = plt.subplot(5,5,n+1)\\n plt.imshow(images[n])\\n if len(labels.shape) == 1:\\n plt.title(self.class_names[int(labels[n])].title())\\n else:\\n m = np.argmax(labels[n])\\n plt.title(self.class_names[int(labels[n, m])].title())\\n plt.axis('off')\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def print_stats(cars, notcars):\\n print(\\\"Number of car samples: {0}\\\".format(len(cars)))\\n print(\\\"Number of non car samples: {0}\\\".format(len(notcars)))\\n img = cv2.imread(cars[0])\\n print(\\\"Image shape: {0}x{1}\\\".format(img.shape[0], img.shape[1]))\\n print(\\\"Image datatype: {}\\\".format(img.dtype))\",\n \"def demo(net, image_name, classes):\\n\\n # Load pre-computed Selected Search object proposals\\n # box_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo',image_name + '_boxes.mat')\\n test_mats_path = '/home/tanshen/fast-rcnn/data/kaggle/test_bbox'\\n box_file = os.path.join(test_mats_path ,image_name + '_boxes.mat')\\n obj_proposals = sio.loadmat(box_file)['boxes']\\n\\n # Load the demo image\\n test_images_path = '/home/tanshen/fast-rcnn/data/kaggle/ImagesTest'\\n # im_file = os.path.join(cfg.ROOT_DIR, 'data', 'demo', image_name + '.jpg')\\n im_file = os.path.join(test_images_path, image_name + '.jpg')\\n im = cv2.imread(im_file)\\n\\n # Detect all object classes and regress object bounds\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im, obj_proposals)\\n timer.toc()\\n # print ('Detection took {:.3f}s for '\\n # '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n CONF_THRESH = 0\\n NMS_THRESH = 0.3\\n max_inds = 0\\n max_score = 0.0\\n for cls in classes:\\n cls_ind = CLASSES.index(cls)\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n keep = np.where(cls_scores >= CONF_THRESH)[0]\\n cls_boxes = cls_boxes[keep, :]\\n cls_scores = cls_scores[keep]\\n dets = np.hstack((cls_boxes,\\n cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n # print 'All {} detections with p({} | box) >= {:.1f} in {}'.format(cls, cls,\\n # CONF_THRESH, image_name)\\n #if get_max!=[]: \\n\\n [ind,tmp]=get_max(im, cls, dets, thresh=CONF_THRESH)\\n #print image_name,cls,tmp\\n\\n #vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)\\n #print dets[:,-1]\\n #print image_name,max_score\\n file.writelines([image_name,'\\\\t',cls,'\\\\t',str(tmp),'\\\\n'])\\n if(max_score<tmp):\\n max_score=tmp\\n cls_max=cls\\n print image_name,cls_max,max_score\",\n \"def show_images_opencv(images, titles):\\n assert len(images) == len(titles), 'Every image should have unique title!'\\n for img, title in zip(images, titles):\\n cv2.imshow(title, img)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\",\n \"def update_image(self, cv_img):\\n qt_img = self.convert_cv_qt(cv_img)\\n if(self.iscapture):\\n print(\\\"update\\\")\\n direct = self.label1.text()\\n if direct == \\\"~default\\\":\\n direct = \\\"face_dataframes\\\"\\n else:\\n direct = direct + \\\"/face_dataframes\\\"\\n \\n if (not os.path.exists(direct)):\\n os.mkdir(direct)\\n cv2.imwrite(\\\"{1}/{2}{0}.jpeg\\\".format(self.count, direct,self.textbox.text()), cv_img)\\n self.iscapture = False\\n self.label2.setText(\\\"Image # 0{0} Saved\\\".format(self.count))\\n self.pushButton0.setEnabled(False)\\n self.count += 1\\n \\n \\n if(self.count == 6):\\n #print(\\\"greater\\\")\\n self.pushButton.setEnabled(False)\\n self.pushButton2.setDisabled(False)\\n\\n\\n self.image_label.setPixmap(qt_img)\",\n \"def im_show(image_path):\\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\\n cv.namedWindow('image', cv.WINDOW_NORMAL)\\n ret, threshed = cv.threshold(img, 0, 2 ** 16, cv.THRESH_BINARY)\\n print(ret)\\n print(threshed.shape, threshed.dtype)\\n cv.imshow('image', threshed)\\n cv.waitKey(0)\\n cv.destroyAllWindows()\",\n \"def display_image(mat):\\n\\timg = Image.fromarray(mat)\\n\\timg.show()\",\n \"def visualize(self,\\n model: torch.nn.Module,\\n image: Union[str, np.ndarray],\\n result: list,\\n output_file: str,\\n window_name: str = '',\\n show_result: bool = False):\\n show_img = mmcv.imread(image) if isinstance(image, str) else image\\n output_file = None if show_result else output_file\\n pred_score = np.max(result)\\n pred_label = np.argmax(result)\\n result = {'pred_label': pred_label, 'pred_score': float(pred_score)}\\n result['pred_class'] = model.CLASSES[result['pred_label']]\\n return model.show_result(\\n show_img,\\n result,\\n show=show_result,\\n win_name=window_name,\\n out_file=output_file)\",\n \"def show_plot(img, title):\\n plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\\n plt.title(\\\"Hand Number: \\\" + title)\\n plt.show()\",\n \"def visualizer(FRAME_STATS, save_image=True, image_dir='images'):\\r\\n frame = FRAME_STATS['frame'].copy()\\r\\n frame_number = FRAME_STATS['frame_number']\\r\\n paths = FRAME_STATS['paths']\\r\\n exit_masks = FRAME_STATS['exit_masks']\\r\\n vehicle_count = FRAME_STATS['vehicle_count']\\r\\n capacity = FRAME_STATS['capacity']\\r\\n\\r\\n frame = draw_ui(frame, vehicle_count, capacity, exit_masks)\\r\\n frame = draw_boxes(frame, paths, exit_masks)\\r\\n \\r\\n if save_image: cv2.imwrite(image_dir + \\\"/processed_%04d.png\\\" % frame_number, np.flip(frame,2))\",\n \"def fileCmd(self):\\n filename = askopenfilename() \\n self.cnvImgOrig.displayImage(filename)\\n self.cnvImgTest.displayImage(filename)\",\n \"def show_rgbd(self):\\n while self.depth_data is None:\\n pass\\n\\n while not rospy.is_shutdown():\\n rospy.Rate(10).sleep()\\n d = self.depth_data * self.cam.DEPTH_UNIT\\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\\n dc = np.concatenate((d, self.rgb_data), axis=1)\\n cv2.imshow('RGB & Depth Image', dc)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n cv2.destroyAllWindows()\",\n \"def draw_on_image(D):\\n \\n #Set up rectangle's position within window\\n lower_left_x = 20 \\n lower_left_y = 42\\n dx = 5\\n dy = 5\\n\\n #Display border for rectangle\\n #Border is a black rectangle under white text rectangle\\n bord_upper_left = (lower_left_x-dx-3, lower_left_y-dy-20-3)\\n bord_lower_right = (lower_left_x+dx+160+3, lower_left_y+dy+50+3)\\n cv.Rectangle(D.image, bord_upper_left, bord_lower_right, D.black, cv.CV_FILLED)\\n \\n #Display white rectangle under text\\n rect_upper_left = (lower_left_x-dx, lower_left_y-dy-20)\\n rect_lower_right = (lower_left_x+dx+160, lower_left_y+dy+50)\\n cv.Rectangle(D.image, rect_upper_left, rect_lower_right, D.white, cv.CV_FILLED)\\n \\n ####\\n hive = \\\"hi!\\\"\\n hiveStat = \\\"hive\\\"\\n \\n #Build Strings\\n robotAssignment = (\\\"Assignment #: %.lf\\\"%R.assignment)\\n robotConverged = (\\\"Converged: %s\\\"%R.converged)\\n robotStatus = (\\\"Robot Status: \\\" + R.status)\\n hiveCommand = (\\\"Hive Command: \\\" + hive)\\n hiveStatus = (\\\"Hive Status: \\\" + hiveStat)\\n \\n # Position strings in a box so they won't overlap\\n firstLineString = (lower_left_x,lower_left_y) \\n secondLineString = (lower_left_x, lower_left_y + 20) \\n thirdLineString = (lower_left_x, lower_left_y + 40)\\n fourthLineString = (lower_left_x, lower_left_y + 60)\\n fifthLineString = (lower_left_x, lower_left_y + 80)\\n\\n #Display strings in window\\n cv.PutText(D.image, robotAssignment, firstLineString, D.font, cv.RGB(0,0,255)) \\n cv.PutText(D.image, robotConverged, secondLineString, D.font, cv.RGB(0,0,255))\\n cv.PutText(D.image, robotStatus, thirdLineString, D.font, cv.RGB(0,0,255))\\n cv.PutText(D.image, hiveCommand, fourthLineString, D.font, cv.RGB(0,0,255))\\n cv.PutText(D.image, hiveStatus, fifthLineString, D.font, cv.RGB(0,0,255))\",\n \"def viz_pipeline(self, img):\\n y_fit, x_fit_left, x_fit_right = self.find_lines(img, ['all'])\\n dynamic_subplot = DynamicSubplot(3, 4)\\n dynamic_subplot.imshow(self.visuals['dash_undistorted'], \\\"Undistorted Road\\\")\\n dynamic_subplot.imshow(self.visuals['overhead'], \\\"Overhead\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['lightness'], \\\"Lightness\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['lightness_binary'], \\\"Binary Lightness\\\", cmap='gray')\\n dynamic_subplot.skip_plot()\\n dynamic_subplot.skip_plot()\\n dynamic_subplot.imshow(self.visuals['value'], \\\"Value\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['value_binary'], \\\"Binary Value\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['pixel_scores'], \\\"Scores\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['windows_raw'], \\\"Selected Windows\\\")\\n dynamic_subplot.imshow(self.visuals['windows_raw'], \\\"Fitted Lines\\\", cmap='gray')\\n dynamic_subplot.modify_plot('plot', x_fit_left, y_fit)\\n dynamic_subplot.modify_plot('plot', x_fit_right, y_fit)\\n dynamic_subplot.modify_plot('set_xlim', 0, camera.img_width)\\n dynamic_subplot.modify_plot('set_ylim', camera.img_height, 0)\\n dynamic_subplot.imshow(self.visuals['highlighted_lane'], \\\"Highlighted Lane\\\")\",\n \"def demo(net, image_name,num_class,save_ff):\\r\\n\\r\\n # Load the demo image\\r\\n #im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)\\r\\n im_file=image_name\\r\\n im = cv2.imread(im_file)\\r\\n\\r\\n # Detect all object classes and regress object bounds\\r\\n timer = Timer()\\r\\n timer.tic()\\r\\n #for zzz in range(100):\\r\\n scores, boxes = im_detect(net, im)\\r\\n timer.toc()\\r\\n print ('Detection took {:.3f}s for '\\r\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\r\\n\\r\\n # Visualize detections for each class\\r\\n CONF_THRESH = 0.35\\r\\n NMS_THRESH = 0.3\\r\\n thresh=CONF_THRESH\\r\\n for cls_ind, cls in enumerate(range(num_class)):#CLASSES[1:]\\r\\n cls_ind += 1 # because we skipped background\\r\\n # cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\r\\n # cls_scores = scores[:, cls_ind]\\r\\n # dets = np.hstack((cls_boxes,\\r\\n # cls_scores[:, np.newaxis])).astype(np.float32)\\r\\n inds = np.where(scores[:, cls_ind] > thresh)[0]\\r\\n cls_scores = scores[inds, cls_ind]\\r\\n if cfg.TEST.AGNOSTIC:\\r\\n cls_boxes = boxes[inds, 4:8]\\r\\n else:\\r\\n cls_boxes = boxes[inds, cls_ind*4:(cls_ind+1)*4]\\r\\n dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \\\\\\r\\n .astype(np.float32, copy=False)\\r\\n keep = nms(dets, NMS_THRESH)\\r\\n dets = dets[keep, :]\\r\\n #vis_detections(im, cls, dets, thresh=CONF_THRESH)\\r\\n inds = np.where(dets[:, -1] >= thresh)[0]\\r\\n if len(inds) == 0:\\r\\n continue\\r\\n\\r\\n im_tmp = im#im[:, :, (2, 1, 0)]\\r\\n for i in inds:\\r\\n bbox = dets[i, :4]\\r\\n score = dets[i, -1]\\r\\n print bbox,score,cls\\r\\n cv2.rectangle(im_tmp, (bbox[0],bbox[1]), (bbox[2],bbox[3]), (0,0,255),2)\\r\\n #save_ff=\\\"/storage2/liushuai/faster_rcnn/FasterRCNN-Encapsulation-Cplusplus/faster_cxx_lib_ev2641/test_result.jpg\\\"\\r\\n im_tmp = im#im[:, :, (2, 1, 0)]\\r\\n cv2.imwrite(save_ff,im_tmp)\\r\\n #save_pic(im, cls, dets, thresh=CONF_THRESH,save_ff)\\r\",\n \"def _visualize_cam_s(self, imgs, summed_filters=True, names=\\\"2DPositions\\\"):\\n feed_dict = {}\\n feed_dict[self.images_tf] = imgs\\n conv6_val, output_val = self.sess.run([self.conv6, self.output],feed_dict=feed_dict)\\n preds = output_val\\n\\n # <preds> to confidence (to softmax)\\n softmaxs = f_sotfmax(preds)\\n \\n # Computes the position of the max per axis [-1;1]\\n summed_viz = self.summed_vis(conv6_val)\\n if names == \\\"2DPositions\\\":\\n max_pos = lambda arr: (arr.argmax(axis=1) / float(arr.shape[-2]) *2)-1\\n xxs = max_pos( summed_viz.sum(axis=1) )\\n yys = max_pos( summed_viz.sum(axis=2) )\\n named_preds = map(self.to_named_pred, preds, xxs, yys)\\n \\n # Computes the bounding boxes coordinates of classes\\n if names == \\\"BoundingBoxes\\\":\\n ls,ts,rs,bs = self._get_bounding_boxes(imgs, summed_viz)\\n named_preds = map(self.to_named_pred, softmaxs, ls, ts, rs, bs)\\n \\n if summed_filters == True:\\n conv6_val = summed_viz \\n \\n return named_preds, conv6_val\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71970654","0.7002493","0.6995437","0.6975558","0.69294494","0.69176483","0.69103956","0.68500286","0.6783941","0.6769802","0.67669165","0.6740594","0.6729734","0.6711798","0.66964775","0.6684703","0.66664636","0.66619647","0.66425073","0.6603232","0.66009367","0.6586214","0.6581335","0.6560992","0.6556393","0.65514326","0.65144897","0.6502474","0.648315","0.6466632","0.6460533","0.6460529","0.6449647","0.6442359","0.64310676","0.6416155","0.63994133","0.6399395","0.6390025","0.6389545","0.6384445","0.63835967","0.63796604","0.6378498","0.63778484","0.6377752","0.63758206","0.6370542","0.63606507","0.6355621","0.6354659","0.63175255","0.6308942","0.63081485","0.63005304","0.62903535","0.6282515","0.62710875","0.6269209","0.62666416","0.62626535","0.6262436","0.62619615","0.6261159","0.62550646","0.62441754","0.6244076","0.62396127","0.62369555","0.6234387","0.6213634","0.6210551","0.6195687","0.61907136","0.61878556","0.6186359","0.61699784","0.61669475","0.61660117","0.61610544","0.61606306","0.6141127","0.6139957","0.61236495","0.6118684","0.61145973","0.61131936","0.6109085","0.6100513","0.6096134","0.6090507","0.608269","0.6078081","0.6071681","0.6066215","0.6065015","0.6054562","0.6051344","0.6050694","0.6049811","0.6030663"],"string":"[\n \"0.71970654\",\n \"0.7002493\",\n \"0.6995437\",\n \"0.6975558\",\n \"0.69294494\",\n \"0.69176483\",\n \"0.69103956\",\n \"0.68500286\",\n \"0.6783941\",\n \"0.6769802\",\n \"0.67669165\",\n \"0.6740594\",\n \"0.6729734\",\n \"0.6711798\",\n \"0.66964775\",\n \"0.6684703\",\n \"0.66664636\",\n \"0.66619647\",\n \"0.66425073\",\n \"0.6603232\",\n \"0.66009367\",\n \"0.6586214\",\n \"0.6581335\",\n \"0.6560992\",\n \"0.6556393\",\n \"0.65514326\",\n \"0.65144897\",\n \"0.6502474\",\n \"0.648315\",\n \"0.6466632\",\n \"0.6460533\",\n \"0.6460529\",\n \"0.6449647\",\n \"0.6442359\",\n \"0.64310676\",\n \"0.6416155\",\n \"0.63994133\",\n \"0.6399395\",\n \"0.6390025\",\n \"0.6389545\",\n \"0.6384445\",\n \"0.63835967\",\n \"0.63796604\",\n \"0.6378498\",\n \"0.63778484\",\n \"0.6377752\",\n \"0.63758206\",\n \"0.6370542\",\n \"0.63606507\",\n \"0.6355621\",\n \"0.6354659\",\n \"0.63175255\",\n \"0.6308942\",\n \"0.63081485\",\n \"0.63005304\",\n \"0.62903535\",\n \"0.6282515\",\n \"0.62710875\",\n \"0.6269209\",\n \"0.62666416\",\n \"0.62626535\",\n \"0.6262436\",\n \"0.62619615\",\n \"0.6261159\",\n \"0.62550646\",\n \"0.62441754\",\n \"0.6244076\",\n \"0.62396127\",\n \"0.62369555\",\n \"0.6234387\",\n \"0.6213634\",\n \"0.6210551\",\n \"0.6195687\",\n \"0.61907136\",\n \"0.61878556\",\n \"0.6186359\",\n \"0.61699784\",\n \"0.61669475\",\n \"0.61660117\",\n \"0.61610544\",\n \"0.61606306\",\n \"0.6141127\",\n \"0.6139957\",\n \"0.61236495\",\n \"0.6118684\",\n \"0.61145973\",\n \"0.61131936\",\n \"0.6109085\",\n \"0.6100513\",\n \"0.6096134\",\n \"0.6090507\",\n \"0.608269\",\n \"0.6078081\",\n \"0.6071681\",\n \"0.6066215\",\n \"0.6065015\",\n \"0.6054562\",\n \"0.6051344\",\n \"0.6050694\",\n \"0.6049811\",\n \"0.6030663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9299,"cells":{"query":{"kind":"string","value":"Summary Display function that generates the final output images using MatplotLib windows"},"document":{"kind":"string","value":"def imagetestplt(thetainput,doubleopponencyinput):\n theta = thetainput\n rgcMode = doubleopponencyinput\n\n\n C = retina.sample(img,x,y,coeff[i],loc[i],rgb=True) # CENTRE(sharp retina)\n S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True) # SURROUND(blurred retina)\n \n if rgcMode == 0:\n pV,nV = rgc.opponency(C,S,theta)\n else:\n pV,nV = rgc.doubleopponency(C,S,theta)\n\n rIntensity,cIntensity = showNonOpponency(C,theta)\n # Construct window plots\n plt.subplot(3,1,1), plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)), plt.title('Original test image')\n plt.xticks([]), plt.yticks([])\n plt.subplot(3,1,2), plt.imshow(cv2.cvtColor(rIntensity, cv2.COLOR_BGR2RGB)), plt.title('Backprojected R+G Intensity Response')\n plt.xticks([]), plt.yticks([])\n plt.subplot(3,1,3), plt.imshow(cv2.cvtColor(cIntensity, cv2.COLOR_BGR2RGB)), plt.title('Cortical R+G Intensity Response')\n plt.xticks([]), plt.yticks([])\n # format float to string\n thetastring = \"%.2f\" % theta\n plt.suptitle('Rectified DoG Intensity Images. Threshold:' + thetastring, fontsize=16)\n plt.show()\n\n #Generate backprojected images\n if showInverse:\n rOpponent = showBPImg(pV,nV)\n plt.imshow(cv2.cvtColor(rOpponent, cv2.COLOR_BGR2RGB)), plt.title('Backprojected Opponent Cells Output')\n plt.xticks([]), plt.yticks([])\n plt.show()\n # Cortex\n if showCortex:\n cOpponent = showCortexImg(pV,nV)\n plt.imshow(cv2.cvtColor(cOpponent, cv2.COLOR_BGR2RGB)), plt.title('Cortex Opponent Cells Output')\n plt.xticks([]), plt.yticks([])\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def display(self, workspace, figure):\n if self.show_window:\n figure.set_subplots((2, 2))\n \n orig_axes = figure.subplot(0,0)\n label_axes = figure.subplot(1,0, sharexy = orig_axes)\n outlined_axes = figure.subplot(0,1, sharexy = orig_axes)\n \n title = \"Input image, cycle #%d\"%(workspace.measurements.image_number,)\n image = workspace.display_data.image\n labeled_image = workspace.display_data.labeled_image\n border_excluded_labeled_image = workspace.display_data.border_excluded_labels\n\n ax = figure.subplot_imshow_grayscale(0, 0, image, title)\n figure.subplot_imshow_labels(1, 0, labeled_image, \n self.object_name.value,\n sharexy = ax)\n \n cplabels = [\n dict(name = self.object_name.value,\n labels = [labeled_image]),\n dict(name = \"Objects touching border\",\n labels = [border_excluded_labeled_image])]\n title = \"%s outlines\"%(self.object_name.value) \n figure.subplot_imshow_grayscale(\n 0, 1, image, title, cplabels = cplabels, sharexy = ax)\n \n figure.subplot_table(\n 1, 1, \n [[x[1]] for x in workspace.display_data.statistics],\n row_labels = [x[0] for x in workspace.display_data.statistics])","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def imshow(img):\n imadd(img)\n plt.ion()\n plt.show()","def display_sample(display_list):\n plt.figure(figsize=(18, 18))\n\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n\n for i in range(len(display_list)):\n plt.subplot(1, len(display_list), i+1)\n plt.title(title[i])\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n plt.axis('off')\n plt.show()","def display(self):\n nrow = 2\n ncol = len(self.views) + 1\n rows = [(self.views[0].original, len(self.views)),\n (self.views[0].image, len(self.views) + 1)]\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\n figsize=self._figsize(rows),\n squeeze=True)\n originals = [(v.position.id, v.original) for v in self.views] + [\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\n warped = [(v.position.id, v.image) for v in self.views] + [\n ('combined', self.image)]\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\n ax.imshow(img)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=title)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def visualize(**images):\r\n n_images = len(images)\r\n plt.figure(figsize=(20, 8))\r\n for idx, (name, image) in enumerate(images.items()):\r\n plt.subplot(1, n_images, idx + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n # get title from the parameter names\r\n plt.title(name.replace('_', ' ').title(), fontsize=20)\r\n plt.imshow(image)\r\n plt.show()","def show():\n setup()\n plt.show()","def show(self):\n \n \n \n \n \n \n r = 4\n f, axarr = plt.subplots(r, r, figsize=(8,8))\n counter = 0\n for i in range(r):\n for j in range(r):\n temp = self.x[counter,:]\n counter += 1\n img = self.x[counter,:]\n axarr[i][j].imshow(img)\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def display_sample(display_list):\n fig, axs = plt.subplots(1, len(display_list), figsize=(18, 18))\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n for i in range(len(display_list)):\n axs[i].set_title(title[i])\n axs[i].imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n axs[i].axis('off')","def main():\n font = {'family' : 'normal',\n 'weight' : 'normal',\n 'size' : 18}\n\n matplotlib.rc('font', **font)\n\n ###Plot overviews\n\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full.png\",\n# show_shells=False,title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n \n plot_overview(plotname=\"../paper/figs/12co_nroonly_peak_full_shells.png\", show_shells=True,\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\n title=r\"\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\n )\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_mom0_cometary.png\",\n # show_shells=False, title=r\"Combined Integrated $^{12}$CO\",\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000,\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(plotname=\"12co_nroonly_mom0_cometary.png\", show_shells=False,\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000, title=r\"NRO Integrated $^{12}$CO\",\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full_shells.png\",\n # show_shells=True, shells_highlight=shells_score3, title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # return\n\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\n\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\n\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\n\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\n\n planck_herschel_file = '../catalogs/planck_herschel.fits'\n\n region_file = '../shell_candidates/AllShells.reg'\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\n\n obaf_file = 'stars_obaf.txt'\n yso_file = \"../catalogs/spitzer_orion.fit\"\n\n obaf = ascii.read(obaf_file)\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\"b'\") for sp in obaf['SP_TYPE']])\n yso = fits.open(yso_file)[1].data\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\n\n # for nshell in range(19,43):\n # shell = shell_list[nshell-1]\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n # #Check whether shell is in each mips image coverage.\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\n \n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\n # hdu = mips_l1641_hdu\n # else:\n # hdu = mips_onc_hdu\n\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\n\n\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\n\n spec_cube = SpectralCube.read(cube_file)\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\n vel_grid = spec_cube.spectral_axis\n pad_factor = 1.5\n\n #plot_overview(show_shells=True)\n #plot_overview(plotname=\"12co_nro_peak.png\", show_shells=False)\n #plot_overview(cube=\"/Volumes/Untitled/13co_pix_2.cm.fits\", plotname=\"13co_combined_peak.png\", show_shells=False)\n #return\n #channel_vmax = [12.9, 14]\n for nshell in range(17,18):\n shell = shell_list[nshell-1]\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\n #print(l1641_xy)\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\n ir_hdu = ir_l1641_hdu\n else:\n ir_hdu = ir_onc_hdu\n\n #Extract sub_cube around shell.\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\n (abs(dec_grid - dec) < radius * pad_factor)\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n\n #Integrate between vmin and vmax.\n mom0_hdu = sub_cube.moment0().hdu\n\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\n # (abs(dec_grid - dec) < radius)\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\n\n #Calculate contour levels.\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\n #print(\"sigma: {}\".format(sigma))\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\n #print(\"delta_vel: {}\".format(delta_vel))\n mom0_sigma = sigma * delta_vel\n #print(mom0_sigma) \n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\n\n #Get source coordinates.\n\n\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \"12CO\", shell.vmin.value, shell.vmax.value),\n # return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\n # cbar_label=\"Counts\", cmap='inferno',\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\n # source_labels=[obaf_label, yso_label], dpi=300\n # )\n\n #cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n \n \n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\n # vmin=None, vmax=None, max_chans=12,\n # #cbar_label=\"Counts\",\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\n\n # angle = 90*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\n # width=7.5*u.arcsec, angle=angle,\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\n # stretch='linear', auto_scale=True, dpi=900.)\n \n\n\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\n\n\n #movie(test=False, labels=False) \n\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n # region_file = '../nro_maps/SouthShells.reg'\n # N = 2 # Number of shell candidates to plot\n # shell_list = get_shells(region_file=region_file)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # #cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n\n # for n in range(1,2):\n # shell = shell_list[n]\n # for deg in np.linspace(0, 180, 13):\n # angle = deg*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\n # width=7.5*u.arcsec, angle=105*u.deg,\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\n # stretch='linear', auto_scale=True)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\n\n # cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')","def matplotlibDisplay(img, title=\"Image\", colorFlag = 'gray'):\n plt.imshow(img, colorFlag)\n plt.title(title)\n plt.xticks([])\n plt.yticks([])\n plt.show()","def show():\n\tplt.show()","def visualize(self):\r\n self.aggregator.plot_loss()\r\n self.save_figure()","def _display_window(self, axes, filename, extra=None):\n\n fn = os.path.join(self._data_directory, filename)\n data = self._rgb2plot(fits.open(fn)[1].data)\n\n # Plot the hubble data in a subplot\n axes.clear()\n axes.imshow(data, cmap=plt.gray(), origin='upper')\n axes.set_xticks([]) \n axes.set_yticks([])\n clow, chigh = np.percentile(data[np.isfinite(data)], (1, 99))\n axes.get_images()[0].set_clim((clow, chigh))\n\n # Display the filename as the title of the axes\n tt = filename.split('/')[-1]\n if extra:\n tt += ' ' + str(extra)\n axes.set_title(tt)\n plt.figure(1).canvas.draw()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def display_images():\n vc = cv2.VideoCapture(0) # Open webcam\n figure, ax = plt.subplots(1, 2, figsize=(10, 5)) # Intiialise plot\n\n count = 0 # Counter for number of aquired frames\n intensity = [] # Append intensity across time\n\n # For loop over generator here\n intensity.append(imageintensity)\n plot_image_and_brightness() # Call plot function\n count += 1\n\n # This triggers exit sequences when user presses q\n if cv2.waitKey(1) & 0xFF == ord('q'):\n # Clean up here\n plt.close('all') # close plots\n generator.close() # Use generator exit for clean up,\n break # break loop","def show(images, concat=True, return_plots=False):\r\n if concat:\r\n images = np.concatenate([img_to_rgb(img) for img in images], axis=1)\r\n return show([images], concat=False, return_plots=return_plots)\r\n else:\r\n plots = []\r\n for img in images:\r\n fig = plt.figure(figsize=(15, 7))\r\n plots.append(fig)\r\n plt.imshow((img * 255).astype(np.uint8))\r\n plt.show()\r\n if return_plots:\r\n return plots","def show(image, label, weights, prediction, ax):\n global img_objects\n if len(img_objects)==0:\n for i in range(10):\n _img = ax[0, i].imshow(weights[i].reshape(28,28), cmap='gray')\n img_objects.append(_img)\n _img = ax[1, 5].imshow(image.reshape(28,28), cmap='gray')\n img_objects.append(_img)\n else:\n for i in range(10):\n img_objects[i].set_data(weights[i].reshape(28,28))\n img_objects[i].set_clim(vmin=0, vmax=np.max(weights[i]))\n img_objects[10].set_data(image.reshape(28,28))\n ax[0,5].set_title('truth: %d, predict: %d'%(np.argmax(label), prediction))","def show():\n plt.show()","def show():\n plt.show()","def show():\n plt.show()","def matplotlibDisplayMulti(imgs, titles=None, colorFlag='gray'):\n if titles is None:\n titles = []\n for i in range(len(imgs)):\n titles.append(\"IMAGE \" + str(i))\n for i in range(len(imgs)):\n plt.subplot(1, len(imgs), 1+i)\n plt.imshow(imgs[i], colorFlag)\n plt.title(titles[i])\n plt.xticks([])\n plt.yticks([])\n plt.show()","def display(self):\n nrow = 1\n ncol = len(self.views) + 1\n rows = [(self.views[0].image, len(self.views) + 1)]\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\n figsize=self._figsize(rows),\n squeeze=True)\n for ax, (title, img) in zip(axes.ravel(),\n [(v.position.id, v.image) for v in self.views] + [\n ('combined', self.image)]):\n ax.imshow(img)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=title)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def show_image(self, image_set='train', index=None, interactive_mode=True):\n if interactive_mode:\n plt.ion()\n else:\n plt.ioff()\n\n if image_set == 'train':\n target = self.train_dataset\n else:\n target = self.test_dataset\n\n if index is None:\n index = randint(0, len(target['data']))\n\n plt.figure(num=self.LABELS[target['labels'][index]])\n plt.imshow(target['data'][index])\n plt.show()","def run_ML_onImg_and_display(self):\r\n self.Matdisplay_Figure.clear()\r\n ax1 = self.Matdisplay_Figure.add_subplot(111)\r\n \r\n # Depends on show_mask or not, the returned figure will be input raw image with mask or not.\r\n self.MLresults, self.Matdisplay_Figure_axis, self.unmasked_fig = self.ProcessML.DetectionOnImage(self.MLtargetedImg, axis = ax1, show_mask=False, show_bbox=False) \r\n self.Mask = self.MLresults['masks']\r\n self.Label = self.MLresults['class_ids']\r\n self.Score = self.MLresults['scores']\r\n self.Bbox = self.MLresults['rois']\r\n\r\n self.SelectedCellIndex = 0\r\n self.NumCells = int(len(self.Label))\r\n self.selected_ML_Index = []\r\n self.selected_cells_infor_dict = {}\r\n \r\n self.Matdisplay_Figure_axis.imshow(self.unmasked_fig.astype(np.uint8))\r\n \r\n self.Matdisplay_Figure.tight_layout()\r\n self.Matdisplay_Canvas.draw()","def show_plots():\n plt.show()","def plot(self, windowSize='800x600'):\n if not hasattr(self, 'compiled'):\n raise RuntimeError('The object has not compiled yet')\n # create a scrollable window\n _, fm, run = simple_scrollable_window(windowSize)\n count = 0\n img_ref = []\n for key, val in {**self.qubitDict, **self.readoutDict}.items():\n Label(\n fm, text=key + f':{val}', font='Consolas',\n relief='solid', borderwidth=1\n ).grid(row=count, column=0, ipadx=5, ipady=5, sticky='news')\n img_data = self.compiled[val].plot(\n allInOne=False, toByteStream=True, showSizeInfo=False,\n size=[20, 4]\n )\n render = ImageTk.PhotoImage(Image.open(img_data))\n img_ref += [render]\n img = Label(fm, image=render, borderwidth=1, relief='solid')\n img.grid(row=count, column=1, ipadx=5, ipady=5, sticky='news')\n img.image = render\n count += 1\n run()","def visualize_MTL(**images):\r\n n = len(images)\r\n plt.figure(figsize=(16, 5))\r\n for i, (name, image) in enumerate(images.items()):\r\n if image==None:\r\n continue\r\n else:\r\n plt.subplot(1, n, i + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n plt.title(' '.join(name.split('_')).title())\r\n plt.imshow(image)\r\n plt.show()","def visualize(self, paths, instance, during_analysis):\r\n xvalues = np.arange(self.data.shape[0])\r\n\r\n model_data = self.model_data_from_instance(instance=instance)\r\n\r\n residual_map = self.data - model_data\r\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\r\n\r\n \"\"\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\"\"\"\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=self.data,\r\n title=\"Data\",\r\n ylabel=\"Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=model_data,\r\n title=\"Model Data\",\r\n ylabel=\"Model Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"model_data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=residual_map,\r\n title=\"Residual Map\",\r\n ylabel=\"Residuals\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"residual_map\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=chi_squared_map,\r\n title=\"Chi-Squared Map\",\r\n ylabel=\"Chi-Squareds\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"chi_squared_map\",\r\n )","def display(array):\n plt.figure()\n plt.imshow(array)\n plt.show()","def displayImages(self):\n\n plt.figure(figsize=(8,6))\n plt.subplot(1,2,1)\n plt.imshow( self.original_image, cmap=\"gray\")\n plt.title(\"Original Image\")\n plt.subplot(1,2,2)\n plt.imshow( self.blurred_image, cmap=\"gray\")\n plt.title(\"Blurred Image\")","def visualization(tv_summary, speech_summary, start, stop, mode='interactive'):\n\n # There was a problem with unicode to ascii errors cropping up again in matplotlib\n # TODO fix encoding errors for the following years\n skip_years = [1941, 1942, 1945, 1995, 2005, 2006, 2010, 2011]\n for start_year in [year for year in range(start, stop) if year not in skip_years]:\n print \"Creating figure for \" + str(start_year)\n heat_map, keywords = create_heat_map(source=tv_summary,\n response=speech_summary,\n max_keywords=45,\n start_year=start_year,\n interval=50)\n\n fig = plot_heat_map(heat_map, keywords, start_year)\n\n if mode == 'save':\n # Save fig to file\n fig.set_size_inches(11, 7.5)\n fig.savefig('output/output' + str(start_year) + '.png', dpi=100)\n else:\n plt.draw()\n if mode != 'save':\n plt.show()","def visualize_output(\n self,\n img: np.ndarray,\n output_data: Any):\n raise NotImplementedError","def visualizeW1(images, vis_patch_side, hid_patch_side, iter, file_name=\"trained_\"):\n\n figure, axes = matplotlib.pyplot.subplots(nrows=hid_patch_side, ncols=hid_patch_side)\n index = 0\n\n for axis in axes.flat:\n \"\"\" Add row of weights as an image to the plot \"\"\"\n\n image = axis.imshow(images[index, :].reshape(vis_patch_side, vis_patch_side),\n cmap=matplotlib.pyplot.cm.gray, interpolation='nearest')\n axis.set_frame_on(False)\n axis.set_axis_off()\n index += 1\n\n \"\"\" Show the obtained plot \"\"\"\n file=file_name+str(iter)+\".png\"\n matplotlib.pyplot.savefig(file)\n print(\"Written into \"+ file)\n matplotlib.pyplot.close()","def show_plot() :\n logger.info(\"Show plot\")\n pylab.axis('equal')\n pylab.xlabel(\"Longitud\")\n pylab.ylabel(\"Latitud\")\n pylab.grid(True)\n pylab.title(\"Product tiles and product source\")\n pylab.show()","def show(image,label,pred):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n s=\"True Label : \"+str(label)+\" Predicted label : \"+str(pred)\n pyplot.xlabel(s,fontname=\"Arial\", fontsize=20 )\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()","def show(self):\n plt.show()","def show_image(dataset, domain, image_class, image_name):\n\timage_file = io.imread(os.path.join(\"data\", dataset, domain, \"images\", image_class, image_name))\n\tplt.imshow(image_file)\n\tplt.pause(0.001)\n\tplt.figure()","def show_to_window(self):\n if self.normal_mode:\n self.show_image.show_original_image(\n self.image, self.width_original_image)\n self.show_image.show_result_image(\n self.image, self.width_result_image, self.angle)\n\n else:\n if self.panorama_mode:\n image = draw_polygon(\n self.image.copy(),\n self.mapX_pano,\n self.mapY_pano)\n mapX = np.load(\n './plugins/Thread_inspection/view_image/maps_pano/mapX.npy')\n mapY = np.load(\n './plugins/Thread_inspection/view_image/maps_pano/mapY.npy')\n rho = self.panorama.rho\n\n self.result_image = cv2.remap(\n self.image,\n mapX,\n mapY,\n cv2.INTER_CUBIC)\n self.result_image = self.result_image[round(\n rho + round(self.moildev.getRhoFromAlpha(30))):self.h, 0:self.w]\n # print(self.width_result_image)\n else:\n image = draw_polygon(self.image.copy(), self.mapX, self.mapY)\n self.result_image = cv2.remap(\n self.image,\n self.mapX,\n self.mapY,\n cv2.INTER_CUBIC)\n self.show_image.show_original_image(\n image, self.width_original_image)\n self.show_image.show_result_image(\n self.result_image, self.width_result_image, self.angle)","def show_env(self, img):\n plt.figure(1)\n plt.subplot(111)\n plt.imshow(img, interpolation=\"nearest\")\n plt.show()","def simplePlots() -> None:\r\n \r\n # Univariate data -------------------------\r\n \r\n # Make sure that always the same random numbers are generated\r\n np.random.seed(1234)\r\n \r\n # Generate data that are normally distributed\r\n x = np.random.randn(500)\r\n \r\n # Other graphics settings\r\n # Set \" context='poster' \" for printouts, and \"set_fonts(32)\"\r\n sns.set(context='notebook', style='ticks', palette='muted')\r\n \r\n # Set the fonts the way I like them\r\n set_fonts(16)\r\n \r\n # Scatter plot\r\n plt.plot(x, '.', markersize=7)\r\n plt.xlim([0, len(x)])\r\n \r\n # Save and show the data, in a systematic format\r\n printout('scatterPlot.jpg', xlabel='Datapoints', ylabel='Values', title='Scatter')\r\n \r\n # Histogram\r\n plt.hist(x)\r\n printout('histogram_plain.jpg', xlabel='Data Values',\r\n ylabel='Frequency', title='Histogram, default settings')\r\n \r\n plt.hist(x, 25, density=True)\r\n printout('density_histogram.jpg', xlabel='Data Values', ylabel='Probability',\r\n title='Density Histogram, 25 bins')\r\n \r\n # Boxplot\r\n # The ox consists of the first, second (middle) and third quartile\r\n set_fonts(18)\r\n plt.boxplot(x, sym='*')\r\n printout('boxplot.jpg', xlabel='Values', title='Boxplot')\r\n \r\n plt.boxplot(x, sym='*', vert=False)\r\n plt.title('Boxplot, horizontal')\r\n plt.xlabel('Values')\r\n plt.show()\r\n \r\n # Errorbars\r\n x = np.arange(5)\r\n y = x**2\r\n errorBar = x/2\r\n plt.errorbar(x,y, yerr=errorBar, fmt='o', capsize=5, capthick=3)\r\n plt.xlim([-0.2, 4.2])\r\n plt.ylim([-0.2, 19])\r\n printout('Errorbars.jpg', xlabel='Data Values', ylabel='Measurements', title='Errorbars')\r\n\r\n # SD for two groups\r\n weight = {'USA':89, 'Austria':74}\r\n weight_SD_male = 12\r\n plt.errorbar([1,2], weight.values(), yerr=weight_SD_male * np.r_[1,1],\r\n capsize=5, LineStyle='', marker='o')\r\n plt.xlim([0.5, 2.5])\r\n plt.xticks([1,2], weight.keys())\r\n plt.ylabel('Weight [kg]')\r\n plt.title('Adult male, mean +/- SD')\r\n\r\n show_data('SD_groups.jpg', out_dir='.')\r\n \r\n # Barplot\r\n # The font-size is set such that the legend does not overlap with the data\r\n np.random.seed(1234)\r\n set_fonts(16)\r\n \r\n df = pd.DataFrame(np.random.rand(7, 3), columns=['one', 'two', 'three'])\r\n df.plot(kind='bar', grid=False, color=sns.color_palette('muted'))\r\n \r\n show_data('barplot.jpg')\r\n\r\n # Bivariate Plots\r\n df2 = pd.DataFrame(np.random.rand(50, 3), columns=['a', 'b', 'c'])\r\n df2.plot(kind='scatter', x='a', y='b', s=df2['c']*500);\r\n plt.axhline(0, ls='--', color='#999999')\r\n plt.axvline(0, ls='--', color='#999999')\r\n printout('bivariate.jpg')\r\n \r\n sns.set_style('ticks')\r\n\r\n # Pieplot\r\n txtLabels = 'Cats', 'Dogs', 'Frogs', 'Others'\r\n fractions = [45, 30, 15, 10]\r\n offsets =(0, 0.05, 0, 0)\r\n \r\n plt.pie(fractions, explode=offsets, labels=txtLabels,\r\n autopct='%1.1f%%', shadow=True, startangle=90,\r\n colors=sns.color_palette('muted') )\r\n plt.axis('equal')\r\n printout('piePlot.jpg', title=' ')","def visualize(original, s, m, l, s_pred, m_pred, l_pred):\n\tfig = plt.figure(figsize=(20, 10))\n\tplt.subplot(1,7,1)\n\tplt.title('Original image')\n\tplt.imshow(original)\n\n\tplt.subplot(1,7,2)\n\tplt.title('S image')\n\tplt.imshow(s)\n\tplt.subplot(1,7,3)\n\tplt.title('S Pred image')\n\tplt.imshow(s_pred)\n\n\tplt.subplot(1,7,4)\n\tplt.title('M image')\n\tplt.imshow(m)\n\tplt.subplot(1,7,5)\n\tplt.title('M Pred image')\n\tplt.imshow(m_pred)\n\n\tplt.subplot(1,7,6)\n\tplt.title('L image')\n\tplt.imshow(l)\n\tplt.subplot(1,7,7)\n\tplt.title('L Pred image')\n\tplt.imshow(l_pred)","def plots():\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\n return display(widgrid, out)","def show_input_to_output(img_ns):\n figure()\n \n sp = subplot(1, 2, 1).imshow(img_ns.img)\n sp.axes.grid(False)\n sp.axes.tick_params(bottom=False, left=False, which='both',labelleft=False,labelbottom=False,length=0)\n title(\"Input Image\", fontsize=10);\n outimg = tiles_to_images(img_ns, img_ns.tile_grid, img_ns.tile_catalog, img_ns.tile_size)\n sp = subplot(1, 2, 2).imshow(outimg.astype(np.uint8));\n sp.axes.tick_params(bottom=False, left=False, which='both',labelleft=False,labelbottom=False,length=0)\n title(\"Output Image From Tiles\", fontsize=10);\n sp.axes.grid(False)\n #print(outimg.astype(np.uint8))\n #print(img_ns)\n plt.savefig(img_ns.output_filename + \"_input_to_output.pdf\", bbox_inches=\"tight\")\n plt.close()","def display_dataset(path, save, dset='sum'):\n # List datasets\n files_surf = os.listdir(path[0])\n files_surf.sort()\n files_deep = os.listdir(path[1])\n files_deep.sort()\n files_calc = os.listdir(path[2])\n files_calc.sort()\n\n # Corrected names\n files = os.listdir(r'Y:\\3DHistoData\\Subvolumes_2mm')\n files.sort()\n\n k = 0\n # Loop for displaying images\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\n # Load images\n im_surf = loadh5(path[0], fsurf, dset)\n im_deep = loadh5(path[1], fdeep, dset)\n im_calc = loadh5(path[2], fcalc, dset)\n # Create figure\n fig = plt.figure(dpi=300)\n ax1 = fig.add_subplot(131)\n ax1.imshow(im_surf, cmap='gray')\n plt.title(fsurf + ', Surface')\n ax2 = fig.add_subplot(132)\n ax2.imshow(im_deep, cmap='gray')\n plt.title('Deep')\n ax3 = fig.add_subplot(133)\n ax3.imshow(im_calc, cmap='gray')\n plt.title('Calcified')\n if save is not None:\n while files[k] == 'Images' or files[k] == 'MeanStd':\n k += 1\n\n # Save figure\n if not os.path.exists(save):\n os.makedirs(save, exist_ok=True)\n plt.tight_layout()\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\"tight\", transparent=True)\n plt.close()\n\n # Save h5\n if not os.path.exists(save + '\\\\MeanStd\\\\'):\n os.makedirs(save + '\\\\MeanStd\\\\', exist_ok=True)\n\n h5 = h5py.File(save + \"\\\\MeanStd\\\\\" + files[k] + '.h5', 'w')\n h5.create_dataset('surf', data=im_surf)\n h5.create_dataset('deep', data=im_deep)\n h5.create_dataset('calc', data=im_calc)\n h5.close()\n else:\n plt.show()\n k += 1","def display_image(X):\n\n\tim = X.reshape(28, 28)\n\ttemp = plt.imshow(im)\n\tplt.show()","def display_sample_images(self):\n if self.train_dataset is None:\n self.init_datasets()\n\n images, labels = next(self.train_dataset)\n plt.figure(figsize=(5,5))\n for n in range(min(25, images.shape[0])):\n ax = plt.subplot(5,5,n+1)\n plt.imshow(images[n])\n if len(labels.shape) == 1:\n plt.title(self.class_names[int(labels[n])].title())\n else:\n m = np.argmax(labels[n])\n plt.title(self.class_names[int(labels[n, m])].title())\n plt.axis('off')\n\n plt.tight_layout()\n plt.show()","def display_metrics3(self):\n messagebox.showinfo(\"Processed Image Metrics\", self.pro_metrics)","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def show_figure(self):\n pylab.show()","def visualize_output(\n self,\n img: np.ndarray,\n output_data: np.ndarray) -> np.ndarray:\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n self.layer = dpg.add_draw_layer(\n parent=f'main_window_{self.id}',\n tag=draw_layer_tag,\n show=False\n )\n\n best_k = np.argsort(output_data)[-self.top_n:][::-1]\n class_names = np.array(self.class_names)[best_k]\n percentages = softmax(output_data[best_k])\n\n for i, (name, perc) in enumerate(zip(class_names, percentages)):\n label_pos = dpg.get_item_pos(f'cell_bar_{i}_{self.id}')\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=label_pos,\n pmax=(\n label_pos[0] + _SCORE_COLUMN_WIDTH*perc,\n label_pos[1] + _FONT_SIZE),\n color=(0, 255, 0),\n fill=(0, 255, 0)\n )\n dpg.set_value(f'cell_perc_{i}_{self.id}', f'{perc*100:.2f}%')\n dpg.set_value(f'cell_name_{i}_{self.id}', name)\n\n return img","def display_data():\n data = read_data_from_file()\n data_size = len(data)\n print('Data size - ' + str(data_size))\n\n\n for i in range(data_size-1, 0, -1):\n image = data[i]\n cv2.imshow('window', image[0])\n print(str(image[1]))\n cv2.waitKey(50)","def show_result(inputs, labels, outputs):\n num_classes = outputs.size(1)\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\n if num_classes == 2:\n outputs *= 255\n mask = outputs[0].reshape((360, 640))\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\n ax[0].set_title('Image')\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\n ax[1].set_title('gt')\n plt.show()\n plt.figure()\n plt.imshow(mask, cmap='gray')\n plt.title('Pred')\n plt.show()","def display(self):\n nrow = len(self.labels) + 1\n ncol = len(self.views)\n rows = [(self.views[0].image, len(self.views))]\n viewfig, viewaxes = plt.subplots(ncols=ncol, figsize=self._figsize(rows))\n for ax, view in zip(viewaxes, self.views):\n ax.imshow(view.image if len(self.labels) == 0 else view.original)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=view.position.id)\n viewfig.tight_layout()\n viewfig.canvas.draw()\n views = np.array(viewfig.canvas.renderer._renderer)\n\n rows = [(views, 1),\n *[(l.display, 1) for l in self.labels]]\n fig, axes = plt.subplots(nrows=nrow,\n figsize=self._figsize(rows))\n if nrow == 1:\n axes = [axes]\n for ax, img in zip(axes, [views] + [l.display for l in self.labels]):\n ax.imshow(img)\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def _init_plot(self) -> None:\n\n # create a grayscale plot\n out = sys.stdout\n sys.stdout = open(\"/dev/null\", \"w\")\n hdu = self.image_generator.image(self.ra, self.dec)\n self.plot = aplpy.FITSFigure(hdu)\n self.plot.show_grayscale()\n self.plot.set_theme(\"publication\")\n sys.stdout = out\n\n # label for the position angle\n pa_string = \"PA = %.1f\" % self.mode_details.position_angle().to_value(u.deg)\n if self.mode_details.automated_position_angle():\n pa_string += \" (auto)\"\n self.draw_label(0.95, -0.05, pa_string, style=\"italic\", weight=\"bold\")\n\n # label for the title\n if self.title:\n self.draw_label(\n 0.5, 1.03, self.title, style=\"italic\", weight=\"bold\", size=\"large\"\n )\n\n # label for the image source\n self.draw_label(\n -0.05,\n -0.05,\n \"%s\" % self.image_generator.source(),\n style=\"italic\",\n weight=\"bold\",\n )\n\n # grid overlay\n self.plot.add_grid()\n self.plot.grid.set_alpha(0.2)\n self.plot.grid.set_color(\"b\")\n\n # indicate the RSS field of view\n self.draw_circle(self.ra, self.dec, 4.0 * u.arcmin, \"g\")\n self.draw_label(\n 0.79,\n 0.79,\n \"RSS\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"left\",\n color=(0, 0, 1),\n )\n\n # indicate the Salticam field of view\n self.draw_circle(self.ra, self.dec, 5.0 * u.arcmin, \"g\")\n self.draw_label(\n 0.86,\n 0.86,\n \"SCAM\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"left\",\n color=(0, 0, 1),\n )\n\n # labels for north and east direction\n self.draw_label(\n self.ra,\n self.dec + 4.8 * u.arcmin,\n \"N\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n color=(0, 0.5, 1),\n )\n self.draw_label(\n self.ra + 4.8 * u.arcmin / np.abs(np.cos(self.dec)),\n self.dec,\n \"E\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"right\",\n color=(0, 0.5, 1),\n )\n\n # add cross hairs\n self.draw_centered_line(\n 0 * u.deg,\n 8 * u.arcmin,\n self.ra,\n self.dec,\n color=\"g\",\n linewidth=0.5,\n alpha=1.0,\n )\n self.draw_centered_line(\n 90 * u.deg,\n 8 * u.arcmin,\n self.ra,\n self.dec,\n color=\"g\",\n linewidth=0.5,\n alpha=1.0,\n )\n\n # label for the magnitude range and bandpass\n if self.magnitude_range:\n self._show_magnitudes()\n\n # add mode specific content\n if not self.basic_annotations:\n self.mode_details.annotate_finder_chart(self)","def montage(W):\n import matplotlib.pyplot as plt\n fig, ax = plt.subplots(2, 5)\n for i in range(2):\n for j in range(5):\n im = W[i * 5 + j, :].reshape(32, 32, 3, order='F')\n sim = (im - np.min(im[:])) / (np.max(im[:]) - np.min(im[:]))\n sim = sim.transpose(1, 0, 2)\n ax[i][j].imshow(sim, interpolation='nearest')\n ax[i][j].set_title(\"y=\" + str(5 * i + j))\n ax[i][j].axis('off')\n #plt.savefig(\"plots/ \"+fname +\".png\")\n plt.show()","def display(self):\n display(self.image)","def combine_plot(qa_out_path,brain_path):\n \n #Get the scan volume of the brain.\n brain_ref = nib.load(brain_path)\n brain_ref_shape = brain_ref.shape[0:3]\n \n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\n y_labels = [\"Rotate with Z axis\",\"Rotate with Y axis\",\"Rotate with X axis\"]\n x_labels = [\"angle=0\",\"angle=120\",\"angle=240\"]\n \n #Temporary list to store the image nparray:\n im_arr=[] \n \n fig= plt.figure()\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\n\\n', fontsize=60,fontweight='bold')\n plt.xticks([])\n plt.yticks([])\n plt.axis(\"off\")\n\n j = 0\n for i in range(9):\n #Load in the nine images into a nparray one by one.\n im_arr = np.array(Image.open(qa_out_path + \"/\" + plots_list[i]))\n #Change the background of the image into black:\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \n ax = fig.add_subplot(3,3,i+1)\n ax.imshow(im_arr,interpolation=\"none\",alpha=0.9)\n \n #Set the X labels and Y labels\n if i<3:\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\n if i % 3 == 0:\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\n j = j + 1\n plt.xticks([])\n plt.yticks([])\n \n fig.set_size_inches(40, 40, forward = True)\n fig.savefig(qa_out_path + \"/\" + 'qa_tractography.png', format='png')\n\n #Delete the Nine images which used to generate the qa_tractography.png \n for plot in plots_list:\n if os.path.exists(qa_out_path + \"/\" + plot):\n os.remove(qa_out_path + \"/\" + plot)\n else:\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')","def imdisplay(filename, representation):\n im = read_image(filename, representation)\n if representation == 1:\n plt.imshow(im, cmap='gray')\n plt.show()\n if representation == 2:\n plt.imshow(im)\n plt.show()","def showSnapshots(self):\n from .utils import sp\n s = self.getSnapshots()\n ax = sp(len(s))\n for i, S in enumerate(s):\n ax[i].imshow(S)","def imdisplay(filename, representation):\n\n image = read_image(filename, representation)\n plt.imshow(image, cmap=\"gray\")\n plt.show()","def showimage(image):\n mplt.figure()\n mplt.imshow(image)\n mplt.show()","def showPlot1():\n\n interested_in = list(range(5,30,5))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on room size')\n xlabel('area of the room (tiles)')\n ylabel('mean time (clocks)')\n show()","def main():\n save = False\n show = True\n\n #hd_parameter_plots = HDparameterPlots(save=save)\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\n #ice5g_comparison_plots.plotLine()\n #ice5g_comparison_plots.plotFilled()\n #ice5g_comparison_plots.plotCombined()\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\n #flowmapplot = FlowMapPlots(save)\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\n #flowmapplot.Etopo1FlowMap()\n #flowmapplot.ICE5G_data_all_points_0k()\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\n #flowmapplot.Etopo1FlowMap_two_color()\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\n outflowplots = OutflowPlots(save)\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\n #hd_output_plots = HDOutputPlots()\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\n #lake_plots = LakePlots()\n #lake_plots.plotLakeDepths()\n #lake_plots.LakeAndRiverMap()\n #lake_plots.LakeAndRiverMaps()\n if show:\n plt.show()","def plot_oneshot_task(pairs):\n fig,(ax1,ax2) = plt.subplots(2)\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\n img = concat_images(pairs[1])\n ax1.get_yaxis().set_visible(False)\n ax1.get_xaxis().set_visible(False)\n ax2.matshow(img,cmap='gray')\n plt.xticks([])\n plt.yticks([])\n plt.show()","def plot_image_sequence(self):\r\n\r\n imv = pg.ImageView()\r\n\r\n imv.show()\r\n\r\n imv.setImage(self.imageData)\r\n\r\n self.layout.addWidget(imv, 0, 0)\r\n\r\n\r\n\r\n avgImage = np.mean(self.imageData, axis=0)\r\n\r\n ima = pg.ImageView()\r\n\r\n ima.setImage(avgImage)\r\n\r\n self.layout.addWidget(ima, 1, 0)","def imdisplay(filename, representation):\n image = read_image(filename, representation)\n\n if representation == GRAY_OUT:\n plt.imshow(image, cmap='gray')\n else:\n plt.imshow(image)\n\n plt.show()","def makeFigure(imgList):\n for i, img in enumerate(imgList):\n i += 1\n ax = plt.subplot(len(imgList), 1, i)\n ax.imshow(img[0], cmap=COLOR_MAP)\n ax.get_yaxis().set_ticks([])\n if i == len(imgList):\n ax.set_xlabel('Time of day')\n ax.set_ylabel('Day of week')\n # add name of the repo as title\n plt.title(img[1])\n\n plt.tight_layout(pad=0)\n plt.show()","def print_image(img):\r\n # On affiche l'image\r\n plt.figure(figsize=(20, 5))\r\n plt.subplot(1, 2, 1)\r\n plt.imshow(img)\r\n # On affiche l'histogramme\r\n plt.subplot(1, 2, 2)\r\n plt.hist(img.flatten(), bins=range(256))\r\n plt.show()","def show_img(graphs = False):\n while True:\n screen = (yield)\n window_title = \"logs\" if graphs else \"game_play\"\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL) \n imS = cv2.resize(screen, (800, 400)) \n cv2.imshow(window_title, screen)\n if (cv2.waitKey(1) & 0xFF == ord('q')):\n cv2.destroyAllWindows()\n break","def main(image_path):\n temp_dir = tempfile.mkdtemp()\n print('Saving output to {}'.format(temp_dir))\n estimator = run_image(image_path)\n visualize(estimator, image_path, temp_dir)","def show(self) -> None:\n cv.imshow(str(self.__class__), self.output_image)","def display(self):\n fig, axes = plt.subplots(1, len(self.views),\n figsize=self._figsize(\n [(self.views[0].image, len(self.views))]),\n squeeze=True)\n for ax, view in zip(axes.ravel(), self.views):\n ax.imshow(view.grey)\n points = self._common_keypoints(view).reshape(-1, 2)[::-1]\n ax.plot(points[..., 0], points[..., 1], 'r+')\n ax.axis('off')\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n ax.set(title=view.position.id)\n fig.tight_layout()\n fig.canvas.draw()\n img_array = np.array(fig.canvas.renderer._renderer)\n plt.close('all')\n return img_array","def display(self, image):\n raise NotImplementedError()","def plot_overview(cube=nro_12co,\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\n scalebar_color=\"white\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\n pmax=99.75, cbar_label=r\"Peak T$_{\\rm MB}$ [K]\",\n circle_color='white', circle_linewidth=1, circle_style=\"solid\", return_fig=False, show=True,\n title=r\"$^{12}$CO Peak T$_{MB}$\", recenter=False, ra=None, dec=None, radius=None):\n try:\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if mode == \"peak\":\n image = (cube.max(axis=0) * scale_factor).hdu\n \n\n if mode == \"mom0\":\n image = (cube.moment0() * scale_factor).hdu\n\n\n\n fig = FITSFigure(image)\n if show:\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\n pmax=pmax, interpolation='none')\n fig.tick_labels.set_yformat(\"dd:mm\")\n fig.tick_labels.set_xformat(\"hh:mm\")\n #fig.hide_yaxis_label()\n #fig.hide_ytick_labels()\n plt.title(title)\n plt.xlabel(\"RA (J2000)\")\n plt.ylabel(\"DEC (J2000)\")\n\n if show_shells:\n shell_list = get_shells(region_file=region_file)\n for i, shell in enumerate(shell_list):\n if shells_highlight:\n if i+1 in shells_highlight:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\n facecolor='none', linewidth=3)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n\n #RECENTER\n if recenter:\n fig.recenter(ra, dec, radius)\n\n\n #SCALEBAR\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\n fig.scalebar.set_label(\"{} pc\".format(scalebar_pc))\n\n fig.add_colorbar()\n cb = fig.colorbar\n cb.set_axis_label_text(cbar_label)\n\n if return_fig:\n return fig\n else:\n fig.save(plotname, dpi=600)","def showPlot5():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n len_sim_data2 = []\n raw_sim_data2 = runSimulation(item, 1.0, 25, 25, 0.75, 100, RandomWalkRobot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n for mes in raw_sim_data2:\n len_sim_data2.append(len(mes))\n overa = [sum(len_sim_data)/len(len_sim_data), sum(len_sim_data2)/len(len_sim_data2)]\n proc_sim_data.append(overa)\n plot(interested_in, proc_sim_data)\n title('performance comparision of the two types of bots')\n xlabel('number of robots')\n ylabel('mean time (clocks)')\n show()","def plot_img():\n plt.subplot(121)\n plt.imshow(data.data.numpy()[0,].squeeze())\n plt.subplot(122)\n plt.imshow(dec_mean.view(-1,28,28).data.numpy()[0,].squeeze())\n\n plt.show()\n plt.pause(1e-6)\n plt.gcf().clear()\n sample = model.sample_z(data) \n plt.imshow(sample)","def imdisplay(filename, representation):\n img = read_image(filename, representation)\n if representation == GS_REP:\n plt.imshow(img, cmap=plt.cm.gray)\n else:\n plt.imshow(img)","def print_images_out_statistics(self):\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)","def visualize_output(\n self,\n img: np.ndarray,\n output_data: List[DetectObject]) -> np.ndarray:\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n self.layer = dpg.add_draw_layer(\n parent=f'main_window_{self.id}',\n tag=draw_layer_tag,\n show=False\n )\n for out in output_data:\n description = f'{out.clsname} [{out.score*100:.2f}%]'\n # add alpha and convert to RGB\n color = np.array(self.class_colors[out.clsname])\n color = tuple((255*color).astype(np.uint8))\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=(out.xmin*self.width,\n out.ymin*self.height),\n pmax=(out.xmax*self.width,\n out.ymax*self.height),\n color=color,\n thickness=2\n )\n dpg.draw_text(\n parent=draw_layer_tag,\n text=description,\n pos=(out.xmin*self.width + _PADDING,\n out.ymin*self.height + _PADDING),\n color=color,\n size=_FONT_SIZE\n )\n\n return img","def summary_plot(self, cm_plot_style):\n plt.figure(figsize=(10, 3), dpi=300)\n plt.subplot(1, 2, 1)\n self.conditional_activation_plot(cm_plot_style, False)\n plt.subplot(1, 2, 2)\n self.cumulative_days_plot(cm_plot_style, False)\n plt.tight_layout()\n plt.savefig(\"FigureCA.pdf\", bbox_inches='tight')\n # sns.despine()","def visualize(self):\n\n check_is_fitted(self, \"sm_\")\n\n fig = plt.figure(figsize=(6, 4))\n inner = gridspec.GridSpec(2, 1, hspace=0.1, height_ratios=[6, 1])\n ax1_main = plt.Subplot(fig, inner[0]) \n xgrid = np.linspace(self.xmin, self.xmax, 100).reshape([-1, 1])\n ygrid = self.decision_function(xgrid)\n ax1_main.plot(xgrid, ygrid)\n ax1_main.set_xticklabels([])\n ax1_main.set_title(\"Shape Function\", fontsize=12)\n fig.add_subplot(ax1_main)\n \n ax1_density = plt.Subplot(fig, inner[1]) \n xint = ((np.array(self.bins_[1:]) + np.array(self.bins_[:-1])) / 2).reshape([-1, 1]).reshape([-1])\n ax1_density.bar(xint, self.density_, width=xint[1] - xint[0])\n ax1_main.get_shared_x_axes().join(ax1_main, ax1_density)\n ax1_density.set_yticklabels([])\n ax1_density.autoscale()\n fig.add_subplot(ax1_density)\n plt.show()","def display_results(experiment, norms, nus, filename):\n # plot the results of the experiment\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\n\n # plot large scale overview\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\n\n # plot more detailed errors exluding OLS estimate\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\n\n # add title and save\n plt.savefig(filename, dpi=300)","def image_show(inp, title=None):\n inp = inp.numpy().transpose((1, 2, 0))\n mean = np.array([0.485, 0.456, 0.406])\n std = np.array([0.229, 0.224, 0.225])\n inp = std * inp + mean\n inp = np.clip(inp, 0, 1)\n plt.imshow(inp)\n\n if title is not None:\n plt.title(title)\n plt.pause(0.001)","def btn_display_hist_callback(self):\n self.show_as_waiting(True)\n ids = self.tbl_images.get_selected_ids()\n names = self.tbl_images.get_selected_names()\n\n for id, name in zip(ids, names):\n ret = api.get_single_image(id, self.user_hash)\n if ret.get('success') is False:\n self.show_error(ret['error_msg'])\n else:\n image_fio = b64s_to_fio(ret['data'])\n img_hist_fio = img_proc.fio_hist_fio(image_fio)\n self.img_displayer.new_display(\n img_hist_fio, name + ' Histogram')\n del image_fio\n del img_hist_fio\n self.show_as_waiting(False)","def display(self, index):\n img = self.img(index)\n transcription = self.transcript(index)\n plt.imshow(self.norm_img(img), cmap='bone')\n plt.title(transcription, fontdict={'fontsize': 64})\n plt.show()","def show_plot(self):\n runs = self.GetParent().runs\n if len(runs) <= 0: return\n\n t1 = time.time()\n total_width = self.GetParent().total_width\n\n newwidth = total_width * (self.GetParent().zoom / 100)\n newmid = total_width * (self.GetParent().pan/100)\n newxmin = newmid - (newwidth/2)\n newxmax = newxmin + newwidth\n\n if newxmin < 0:\n newxmin = 0\n newxmax = newwidth\n elif newxmax > total_width:\n newxmax = total_width\n newxmin = newxmax - newwidth\n\n assert newxmin >= 0 and newxmin <= total_width\n\n #print \"**** Zoom: %s, pan: %s, total_width: %s, newwidth: %s, newmid: %s, newxmin: %s, newxmax: %s\" \\\n # %(self.GetParent().zoom,self.GetParent().pan,total_width,newwidth,newmid,newxmin,newxmax)\n\n left = 0\n width_so_far = 0\n self.figure.clear()\n braggsmax = max(flex.max(r.culled_braggs) for r in runs)\n braggsmin = min(flex.min(r.culled_braggs) for r in runs)\n distsmax = max(flex.max(r.culled_distances) for r in runs)\n distsmin = min(flex.min(r.culled_distances) for r in runs)\n sifomax = max(flex.max(r.culled_sifoils) for r in runs)\n sifomin = min(flex.min(r.culled_sifoils) for r in runs)\n wavemax = max(flex.max(r.culled_wavelengths) for r in runs)\n wavemin = min(flex.min(r.culled_wavelengths) for r in runs)\n\n #above tricks don't work for hit rates as they can be empty if the run is new\n goodruns = []\n for run in runs:\n if len(run.hit_rates) > 0: goodruns.append(run)\n if len(goodruns) > 0:\n hitsmax = max(flex.max(r.hit_rates) for r in goodruns)\n hitsmin = min(flex.min(r.hit_rates) for r in goodruns)\n else:\n hitsmax = hitsmin = 0\n\n first_run = True\n for run in runs:\n right = left + run.width()\n\n if right < newxmin or left > newxmax:\n left += run.width()\n #print \"Not showing run %s\"%run.runId\n continue\n\n if left < newxmin:\n xmin = run.min() + (newxmin - left)\n else:\n xmin = run.min()\n\n if right > newxmax:\n xmax = run.min() + (newxmax - left)\n else:\n xmax = run.max()\n\n #print \"Run: %s, run.width(): %s, left: %s, right: %s, run.min(): %s, run.max(): %s, xmin: %s, xmax: %s, width_so_far: %s, xmax-xmin: %s\" \\\n #%(run.runId,run.width(),left,right,run.min(),run.max(),xmin,xmax,width_so_far,xmax-xmin)\n\n ax1 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.05, 0.9*(xmax-xmin)/newwidth, 0.4])\n ax2 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.45, 0.9*(xmax-xmin)/newwidth, 0.2], sharex=ax1)\n ax3 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.65, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n ax4 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.75, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n ax5 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.85, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n left += run.width()\n width_so_far += (xmax-xmin)\n\n ax1.grid(True, color=\"0.75\")\n ax2.grid(True, color=\"0.75\")\n ax3.grid(True, color=\"0.75\")\n ax4.grid(True, color=\"0.75\")\n ax5.grid(True, color=\"0.75\")\n ax1.plot(run.culled_bragg_times.select(run.culled_indexed),\n run.culled_braggs.select(run.culled_indexed), 'd', color=[0.0,1.0,0.0])\n ax1.plot(run.culled_bragg_times.select(~run.culled_indexed),\n run.culled_braggs.select(~run.culled_indexed), 'd', color=[0.0,0.5,1.0])\n ax2.plot(run.hit_rates_times, run.hit_rates, 'o-', color=[0.0,1.0,0.0])\n ax3.plot(run.culled_bragg_times, run.culled_wavelengths, '^', color=[0.8,0.0,0.2])\n ax4.plot(run.culled_bragg_times, run.culled_sifoils, '<', color=[0.8,0.0,0.2])\n ax5.plot(run.culled_bragg_times, run.culled_distances, '>', color=[0.8,0.0,0.2])\n ax1.set_ylabel(\"# of Bragg spots\")\n ax2.set_ylabel(\"Hit rate (%)\")\n ax3.set_ylabel(\"WaveL\")\n ax4.set_ylabel(\"SiFoils(mm)\")\n ax5.set_ylabel(\"Dist (mm)\")\n ax1.set_xlim(xmin, xmax)\n ax1.set_ylim(braggsmin, braggsmax)\n ax2.set_ylim(hitsmin, hitsmax)\n ax3.set_ylim(wavemin, wavemax)\n ax4.set_ylim(sifomin-10, sifomax+10)\n ax5.set_ylim(distsmin-3, distsmax+3)\n ax1.set_xlabel(\"Time\")\n for ax in ax1, ax2, ax3, ax4, ax5:\n if (ax is not ax1) :\n for label in ax.get_xticklabels():\n label.set_visible(False)\n ax.get_yticklabels()[0].set_visible(False)\n if not first_run:\n ax.get_yaxis().set_visible(False)\n\n ax1.xaxis.set_major_formatter(ticker.FuncFormatter(status_plot.format_time))\n ax3.yaxis.set_major_formatter(ticker.FormatStrFormatter(\"%.3f\"))\n ax5.yaxis.set_major_formatter(ticker.FormatStrFormatter(\"%.0f\"))\n ax5.set_title(\"%d:%d/%d:%.1f%% I:%d\"%(run.runId, run.hits_count, len(run.braggs), 100*run.hits_count/len(run.braggs),run.indexed.count(True)))\n\n labels = ax1.get_xticklabels()\n for label in labels:\n label.set_rotation(30)\n\n first_run = False\n\n self.figure.autofmt_xdate()\n self.canvas.draw()\n self.parent.Refresh()\n\n t2 = time.time()\n print(\"Plotted in %.2fs\" % (t2 - t1))","def _generate_plot(ax, power_data, title, min_db, max_db):\n # only generate plots for the transducers that have data\n if power_data.size <= 0:\n return\n\n ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)\n return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)","def print_image(indiv,name):\n routine = gp.compile(indiv,pset)\n output = gen_beat_output(routine)\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\n plt.style.use('classic')\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\n plt.savefig(name+\".png\",dpi=150)","def display_image(mat):\n\timg = Image.fromarray(mat)\n\timg.show()","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def plotRandImages(train_data, output):\n rint_array = np.random.randint(0,train_data.shape[0],size=4)\n\n fig = plt.figure(figsize=(8,8))\n plt.subplot(2,2,1)\n for ii,rint in enumerate(rint_array):\n plt.subplot(2,2,ii+1)\n img = train_data[rint].reshape((20,20)).T\n #print \" output: \",output[rint]\n plt.imshow(img,aspect='auto',interpolation='nearest',\n origin='lower')\n plt.title('Image of %d'%output.T[rint])\n plt.show()\n\n return","def walkplot(cons):\n # Call always after cons.runn()!\n if not hasattr(cons, \"outplot\"):\n print(\"Consortium must run before analyzing the output of the run!\")\n return\n global plt\n if not plt:\n import matplotlib.pyplot as plt\n\n # keep original inputs\n original_metplots = dcp(cons.mets_to_plot)\n original_outplot = dcp(cons.outplot)\n cons.outplot = \"tmp.png\"\n mets = [k for k in cons.media]\n # loop over metabolites, plot them and let the user close the window\n for m in range(0, len(mets), 4):\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\n plot_comm(cons)\n plt.show()\n print(\"Image number\", m / 4)\n\n # clean temporary files, return to orginal parameters\n plt.close(\"all\")\n os.remove(cons.outplot)\n cons.mets_to_plot = original_metplots\n cons.outplot = original_outplot\n return","def exp_summary(habitat,temperature,species):\n plt.subplot(2,2,1)\n niches(species)\n plt.subplot(2,2,2)\n environment(habitat,temperature)\n plt.subplot(2,2,3)\n show_matrix(habitat,\"habitat\")\n plt.subplot(2,2,4)\n show_matrix(temperature,\"temperature\")","def visualize_image(images, save_name):\n dim = images.shape[0]\n n_image_rows = int(np.ceil(np.sqrt(dim)))\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\n right=1., left=0., hspace=0., wspace=0.)\n\n for g, count in zip(gs, range(int(dim))):\n ax = plt.subplot(g)\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\n ax.set_xticks([])\n ax.set_yticks([])\n plt.savefig(save_name + '_vis.png')","def display_multispectral_image(data, mask, sl, scale = 300):\n fig, axes = plt.subplots(2,2, figsize=(10,10))\n ax = axes.ravel()\n for k, ch in enumerate(chn_names):\n ax[k].imshow(data[:, :, sl, k].T + 300*mask[:,:,sl].T, cmap='gray', origin='lower')\n ax[k].set_title(ch)\n ax[k].set(xlabel=\"\")\n ax[k].axis('off')\n plt.suptitle('The multispectral MRI slice %d with the ROI mask' % sl) \n plt.tight_layout\n plt.show()","def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\n \n coord,connectivity = [],[] # List of prediction and ground truth images\n for k in range(n_images):\n \n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\n \n # Get the coordinate and connectivity data\n coord += [dataset[or_case].coord.numpy()] \n connectivity += [dataset[or_case].connectivity.numpy()]\n\n # Save npz array with the results of this iteration\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\n\n # Call mesh_plotter to create the figures\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\n \n # Send image for visualization in W&B\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \"Epoch \"+str(epoch))\n wandb.log({\"Prediction\": images})","def print_images_in_statistics(self):\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)"],"string":"[\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def display(self, workspace, figure):\\n if self.show_window:\\n figure.set_subplots((2, 2))\\n \\n orig_axes = figure.subplot(0,0)\\n label_axes = figure.subplot(1,0, sharexy = orig_axes)\\n outlined_axes = figure.subplot(0,1, sharexy = orig_axes)\\n \\n title = \\\"Input image, cycle #%d\\\"%(workspace.measurements.image_number,)\\n image = workspace.display_data.image\\n labeled_image = workspace.display_data.labeled_image\\n border_excluded_labeled_image = workspace.display_data.border_excluded_labels\\n\\n ax = figure.subplot_imshow_grayscale(0, 0, image, title)\\n figure.subplot_imshow_labels(1, 0, labeled_image, \\n self.object_name.value,\\n sharexy = ax)\\n \\n cplabels = [\\n dict(name = self.object_name.value,\\n labels = [labeled_image]),\\n dict(name = \\\"Objects touching border\\\",\\n labels = [border_excluded_labeled_image])]\\n title = \\\"%s outlines\\\"%(self.object_name.value) \\n figure.subplot_imshow_grayscale(\\n 0, 1, image, title, cplabels = cplabels, sharexy = ax)\\n \\n figure.subplot_table(\\n 1, 1, \\n [[x[1]] for x in workspace.display_data.statistics],\\n row_labels = [x[0] for x in workspace.display_data.statistics])\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def imshow(img):\\n imadd(img)\\n plt.ion()\\n plt.show()\",\n \"def display_sample(display_list):\\n plt.figure(figsize=(18, 18))\\n\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n\\n for i in range(len(display_list)):\\n plt.subplot(1, len(display_list), i+1)\\n plt.title(title[i])\\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\\n plt.axis('off')\\n plt.show()\",\n \"def display(self):\\n nrow = 2\\n ncol = len(self.views) + 1\\n rows = [(self.views[0].original, len(self.views)),\\n (self.views[0].image, len(self.views) + 1)]\\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\\n figsize=self._figsize(rows),\\n squeeze=True)\\n originals = [(v.position.id, v.original) for v in self.views] + [\\n ('combined', np.median(np.stack([v.original for v in self.views]), axis=0))]\\n warped = [(v.position.id, v.image) for v in self.views] + [\\n ('combined', self.image)]\\n for ax, (title, img) in zip(axes.ravel(), originals + warped):\\n ax.imshow(img)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=title)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def visualize(**images):\\r\\n n_images = len(images)\\r\\n plt.figure(figsize=(20, 8))\\r\\n for idx, (name, image) in enumerate(images.items()):\\r\\n plt.subplot(1, n_images, idx + 1)\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n # get title from the parameter names\\r\\n plt.title(name.replace('_', ' ').title(), fontsize=20)\\r\\n plt.imshow(image)\\r\\n plt.show()\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def show(self):\\n \\n \\n \\n \\n \\n \\n r = 4\\n f, axarr = plt.subplots(r, r, figsize=(8,8))\\n counter = 0\\n for i in range(r):\\n for j in range(r):\\n temp = self.x[counter,:]\\n counter += 1\\n img = self.x[counter,:]\\n axarr[i][j].imshow(img)\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def display_sample(display_list):\\n fig, axs = plt.subplots(1, len(display_list), figsize=(18, 18))\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n for i in range(len(display_list)):\\n axs[i].set_title(title[i])\\n axs[i].imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\\n axs[i].axis('off')\",\n \"def main():\\n font = {'family' : 'normal',\\n 'weight' : 'normal',\\n 'size' : 18}\\n\\n matplotlib.rc('font', **font)\\n\\n ###Plot overviews\\n\\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full.png\\\",\\n# show_shells=False,title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n \\n plot_overview(plotname=\\\"../paper/figs/12co_nroonly_peak_full_shells.png\\\", show_shells=True,\\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\\n title=r\\\"\\\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\\n )\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_mom0_cometary.png\\\",\\n # show_shells=False, title=r\\\"Combined Integrated $^{12}$CO\\\",\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000,\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(plotname=\\\"12co_nroonly_mom0_cometary.png\\\", show_shells=False,\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000, title=r\\\"NRO Integrated $^{12}$CO\\\",\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full_shells.png\\\",\\n # show_shells=True, shells_highlight=shells_score3, title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # return\\n\\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\\n\\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\\n\\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\\n\\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\\n\\n planck_herschel_file = '../catalogs/planck_herschel.fits'\\n\\n region_file = '../shell_candidates/AllShells.reg'\\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\\n\\n obaf_file = 'stars_obaf.txt'\\n yso_file = \\\"../catalogs/spitzer_orion.fit\\\"\\n\\n obaf = ascii.read(obaf_file)\\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\\\"b'\\\") for sp in obaf['SP_TYPE']])\\n yso = fits.open(yso_file)[1].data\\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\\n\\n # for nshell in range(19,43):\\n # shell = shell_list[nshell-1]\\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n # #Check whether shell is in each mips image coverage.\\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\\n \\n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\\\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\\n # hdu = mips_l1641_hdu\\n # else:\\n # hdu = mips_onc_hdu\\n\\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \\n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\\n\\n\\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\\n\\n spec_cube = SpectralCube.read(cube_file)\\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\\n vel_grid = spec_cube.spectral_axis\\n pad_factor = 1.5\\n\\n #plot_overview(show_shells=True)\\n #plot_overview(plotname=\\\"12co_nro_peak.png\\\", show_shells=False)\\n #plot_overview(cube=\\\"/Volumes/Untitled/13co_pix_2.cm.fits\\\", plotname=\\\"13co_combined_peak.png\\\", show_shells=False)\\n #return\\n #channel_vmax = [12.9, 14]\\n for nshell in range(17,18):\\n shell = shell_list[nshell-1]\\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\\n #print(l1641_xy)\\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\\\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\\n ir_hdu = ir_l1641_hdu\\n else:\\n ir_hdu = ir_onc_hdu\\n\\n #Extract sub_cube around shell.\\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\\\\n (abs(dec_grid - dec) < radius * pad_factor)\\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n\\n #Integrate between vmin and vmax.\\n mom0_hdu = sub_cube.moment0().hdu\\n\\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\\\\n # (abs(dec_grid - dec) < radius)\\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\\n\\n #Calculate contour levels.\\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\\n #print(\\\"sigma: {}\\\".format(sigma))\\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\\n #print(\\\"delta_vel: {}\\\".format(delta_vel))\\n mom0_sigma = sigma * delta_vel\\n #print(mom0_sigma) \\n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\\n\\n #Get source coordinates.\\n\\n\\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \\\"12CO\\\", shell.vmin.value, shell.vmax.value),\\n # return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\\n # cbar_label=\\\"Counts\\\", cmap='inferno',\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\\n # source_labels=[obaf_label, yso_label], dpi=300\\n # )\\n\\n #cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n \\n \\n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\\n # vmin=None, vmax=None, max_chans=12,\\n # #cbar_label=\\\"Counts\\\",\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\\n\\n # angle = 90*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\\n # width=7.5*u.arcsec, angle=angle,\\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\\n # stretch='linear', auto_scale=True, dpi=900.)\\n \\n\\n\\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\\n\\n\\n #movie(test=False, labels=False) \\n\\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n # region_file = '../nro_maps/SouthShells.reg'\\n # N = 2 # Number of shell candidates to plot\\n # shell_list = get_shells(region_file=region_file)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # #cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n\\n # for n in range(1,2):\\n # shell = shell_list[n]\\n # for deg in np.linspace(0, 180, 13):\\n # angle = deg*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\\n # width=7.5*u.arcsec, angle=105*u.deg,\\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\\n # stretch='linear', auto_scale=True)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\\n\\n # cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\",\n \"def matplotlibDisplay(img, title=\\\"Image\\\", colorFlag = 'gray'):\\n plt.imshow(img, colorFlag)\\n plt.title(title)\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def show():\\n\\tplt.show()\",\n \"def visualize(self):\\r\\n self.aggregator.plot_loss()\\r\\n self.save_figure()\",\n \"def _display_window(self, axes, filename, extra=None):\\n\\n fn = os.path.join(self._data_directory, filename)\\n data = self._rgb2plot(fits.open(fn)[1].data)\\n\\n # Plot the hubble data in a subplot\\n axes.clear()\\n axes.imshow(data, cmap=plt.gray(), origin='upper')\\n axes.set_xticks([]) \\n axes.set_yticks([])\\n clow, chigh = np.percentile(data[np.isfinite(data)], (1, 99))\\n axes.get_images()[0].set_clim((clow, chigh))\\n\\n # Display the filename as the title of the axes\\n tt = filename.split('/')[-1]\\n if extra:\\n tt += ' ' + str(extra)\\n axes.set_title(tt)\\n plt.figure(1).canvas.draw()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def display_images():\\n vc = cv2.VideoCapture(0) # Open webcam\\n figure, ax = plt.subplots(1, 2, figsize=(10, 5)) # Intiialise plot\\n\\n count = 0 # Counter for number of aquired frames\\n intensity = [] # Append intensity across time\\n\\n # For loop over generator here\\n intensity.append(imageintensity)\\n plot_image_and_brightness() # Call plot function\\n count += 1\\n\\n # This triggers exit sequences when user presses q\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n # Clean up here\\n plt.close('all') # close plots\\n generator.close() # Use generator exit for clean up,\\n break # break loop\",\n \"def show(images, concat=True, return_plots=False):\\r\\n if concat:\\r\\n images = np.concatenate([img_to_rgb(img) for img in images], axis=1)\\r\\n return show([images], concat=False, return_plots=return_plots)\\r\\n else:\\r\\n plots = []\\r\\n for img in images:\\r\\n fig = plt.figure(figsize=(15, 7))\\r\\n plots.append(fig)\\r\\n plt.imshow((img * 255).astype(np.uint8))\\r\\n plt.show()\\r\\n if return_plots:\\r\\n return plots\",\n \"def show(image, label, weights, prediction, ax):\\n global img_objects\\n if len(img_objects)==0:\\n for i in range(10):\\n _img = ax[0, i].imshow(weights[i].reshape(28,28), cmap='gray')\\n img_objects.append(_img)\\n _img = ax[1, 5].imshow(image.reshape(28,28), cmap='gray')\\n img_objects.append(_img)\\n else:\\n for i in range(10):\\n img_objects[i].set_data(weights[i].reshape(28,28))\\n img_objects[i].set_clim(vmin=0, vmax=np.max(weights[i]))\\n img_objects[10].set_data(image.reshape(28,28))\\n ax[0,5].set_title('truth: %d, predict: %d'%(np.argmax(label), prediction))\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def matplotlibDisplayMulti(imgs, titles=None, colorFlag='gray'):\\n if titles is None:\\n titles = []\\n for i in range(len(imgs)):\\n titles.append(\\\"IMAGE \\\" + str(i))\\n for i in range(len(imgs)):\\n plt.subplot(1, len(imgs), 1+i)\\n plt.imshow(imgs[i], colorFlag)\\n plt.title(titles[i])\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def display(self):\\n nrow = 1\\n ncol = len(self.views) + 1\\n rows = [(self.views[0].image, len(self.views) + 1)]\\n fig, axes = plt.subplots(nrows=nrow, ncols=ncol,\\n figsize=self._figsize(rows),\\n squeeze=True)\\n for ax, (title, img) in zip(axes.ravel(),\\n [(v.position.id, v.image) for v in self.views] + [\\n ('combined', self.image)]):\\n ax.imshow(img)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=title)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def show_image(self, image_set='train', index=None, interactive_mode=True):\\n if interactive_mode:\\n plt.ion()\\n else:\\n plt.ioff()\\n\\n if image_set == 'train':\\n target = self.train_dataset\\n else:\\n target = self.test_dataset\\n\\n if index is None:\\n index = randint(0, len(target['data']))\\n\\n plt.figure(num=self.LABELS[target['labels'][index]])\\n plt.imshow(target['data'][index])\\n plt.show()\",\n \"def run_ML_onImg_and_display(self):\\r\\n self.Matdisplay_Figure.clear()\\r\\n ax1 = self.Matdisplay_Figure.add_subplot(111)\\r\\n \\r\\n # Depends on show_mask or not, the returned figure will be input raw image with mask or not.\\r\\n self.MLresults, self.Matdisplay_Figure_axis, self.unmasked_fig = self.ProcessML.DetectionOnImage(self.MLtargetedImg, axis = ax1, show_mask=False, show_bbox=False) \\r\\n self.Mask = self.MLresults['masks']\\r\\n self.Label = self.MLresults['class_ids']\\r\\n self.Score = self.MLresults['scores']\\r\\n self.Bbox = self.MLresults['rois']\\r\\n\\r\\n self.SelectedCellIndex = 0\\r\\n self.NumCells = int(len(self.Label))\\r\\n self.selected_ML_Index = []\\r\\n self.selected_cells_infor_dict = {}\\r\\n \\r\\n self.Matdisplay_Figure_axis.imshow(self.unmasked_fig.astype(np.uint8))\\r\\n \\r\\n self.Matdisplay_Figure.tight_layout()\\r\\n self.Matdisplay_Canvas.draw()\",\n \"def show_plots():\\n plt.show()\",\n \"def plot(self, windowSize='800x600'):\\n if not hasattr(self, 'compiled'):\\n raise RuntimeError('The object has not compiled yet')\\n # create a scrollable window\\n _, fm, run = simple_scrollable_window(windowSize)\\n count = 0\\n img_ref = []\\n for key, val in {**self.qubitDict, **self.readoutDict}.items():\\n Label(\\n fm, text=key + f':{val}', font='Consolas',\\n relief='solid', borderwidth=1\\n ).grid(row=count, column=0, ipadx=5, ipady=5, sticky='news')\\n img_data = self.compiled[val].plot(\\n allInOne=False, toByteStream=True, showSizeInfo=False,\\n size=[20, 4]\\n )\\n render = ImageTk.PhotoImage(Image.open(img_data))\\n img_ref += [render]\\n img = Label(fm, image=render, borderwidth=1, relief='solid')\\n img.grid(row=count, column=1, ipadx=5, ipady=5, sticky='news')\\n img.image = render\\n count += 1\\n run()\",\n \"def visualize_MTL(**images):\\r\\n n = len(images)\\r\\n plt.figure(figsize=(16, 5))\\r\\n for i, (name, image) in enumerate(images.items()):\\r\\n if image==None:\\r\\n continue\\r\\n else:\\r\\n plt.subplot(1, n, i + 1)\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n plt.title(' '.join(name.split('_')).title())\\r\\n plt.imshow(image)\\r\\n plt.show()\",\n \"def visualize(self, paths, instance, during_analysis):\\r\\n xvalues = np.arange(self.data.shape[0])\\r\\n\\r\\n model_data = self.model_data_from_instance(instance=instance)\\r\\n\\r\\n residual_map = self.data - model_data\\r\\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\\r\\n\\r\\n \\\"\\\"\\\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\\\"\\\"\\\"\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=self.data,\\r\\n title=\\\"Data\\\",\\r\\n ylabel=\\\"Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=model_data,\\r\\n title=\\\"Model Data\\\",\\r\\n ylabel=\\\"Model Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"model_data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=residual_map,\\r\\n title=\\\"Residual Map\\\",\\r\\n ylabel=\\\"Residuals\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"residual_map\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=chi_squared_map,\\r\\n title=\\\"Chi-Squared Map\\\",\\r\\n ylabel=\\\"Chi-Squareds\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"chi_squared_map\\\",\\r\\n )\",\n \"def display(array):\\n plt.figure()\\n plt.imshow(array)\\n plt.show()\",\n \"def displayImages(self):\\n\\n plt.figure(figsize=(8,6))\\n plt.subplot(1,2,1)\\n plt.imshow( self.original_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Original Image\\\")\\n plt.subplot(1,2,2)\\n plt.imshow( self.blurred_image, cmap=\\\"gray\\\")\\n plt.title(\\\"Blurred Image\\\")\",\n \"def visualization(tv_summary, speech_summary, start, stop, mode='interactive'):\\n\\n # There was a problem with unicode to ascii errors cropping up again in matplotlib\\n # TODO fix encoding errors for the following years\\n skip_years = [1941, 1942, 1945, 1995, 2005, 2006, 2010, 2011]\\n for start_year in [year for year in range(start, stop) if year not in skip_years]:\\n print \\\"Creating figure for \\\" + str(start_year)\\n heat_map, keywords = create_heat_map(source=tv_summary,\\n response=speech_summary,\\n max_keywords=45,\\n start_year=start_year,\\n interval=50)\\n\\n fig = plot_heat_map(heat_map, keywords, start_year)\\n\\n if mode == 'save':\\n # Save fig to file\\n fig.set_size_inches(11, 7.5)\\n fig.savefig('output/output' + str(start_year) + '.png', dpi=100)\\n else:\\n plt.draw()\\n if mode != 'save':\\n plt.show()\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: Any):\\n raise NotImplementedError\",\n \"def visualizeW1(images, vis_patch_side, hid_patch_side, iter, file_name=\\\"trained_\\\"):\\n\\n figure, axes = matplotlib.pyplot.subplots(nrows=hid_patch_side, ncols=hid_patch_side)\\n index = 0\\n\\n for axis in axes.flat:\\n \\\"\\\"\\\" Add row of weights as an image to the plot \\\"\\\"\\\"\\n\\n image = axis.imshow(images[index, :].reshape(vis_patch_side, vis_patch_side),\\n cmap=matplotlib.pyplot.cm.gray, interpolation='nearest')\\n axis.set_frame_on(False)\\n axis.set_axis_off()\\n index += 1\\n\\n \\\"\\\"\\\" Show the obtained plot \\\"\\\"\\\"\\n file=file_name+str(iter)+\\\".png\\\"\\n matplotlib.pyplot.savefig(file)\\n print(\\\"Written into \\\"+ file)\\n matplotlib.pyplot.close()\",\n \"def show_plot() :\\n logger.info(\\\"Show plot\\\")\\n pylab.axis('equal')\\n pylab.xlabel(\\\"Longitud\\\")\\n pylab.ylabel(\\\"Latitud\\\")\\n pylab.grid(True)\\n pylab.title(\\\"Product tiles and product source\\\")\\n pylab.show()\",\n \"def show(image,label,pred):\\n from matplotlib import pyplot\\n import matplotlib as mpl\\n fig = pyplot.figure()\\n ax = fig.add_subplot(1,1,1)\\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\\n imgplot.set_interpolation('nearest')\\n s=\\\"True Label : \\\"+str(label)+\\\" Predicted label : \\\"+str(pred)\\n pyplot.xlabel(s,fontname=\\\"Arial\\\", fontsize=20 )\\n ax.xaxis.set_ticks_position('top')\\n ax.yaxis.set_ticks_position('left')\\n pyplot.show()\",\n \"def show(self):\\n plt.show()\",\n \"def show_image(dataset, domain, image_class, image_name):\\n\\timage_file = io.imread(os.path.join(\\\"data\\\", dataset, domain, \\\"images\\\", image_class, image_name))\\n\\tplt.imshow(image_file)\\n\\tplt.pause(0.001)\\n\\tplt.figure()\",\n \"def show_to_window(self):\\n if self.normal_mode:\\n self.show_image.show_original_image(\\n self.image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.image, self.width_result_image, self.angle)\\n\\n else:\\n if self.panorama_mode:\\n image = draw_polygon(\\n self.image.copy(),\\n self.mapX_pano,\\n self.mapY_pano)\\n mapX = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapX.npy')\\n mapY = np.load(\\n './plugins/Thread_inspection/view_image/maps_pano/mapY.npy')\\n rho = self.panorama.rho\\n\\n self.result_image = cv2.remap(\\n self.image,\\n mapX,\\n mapY,\\n cv2.INTER_CUBIC)\\n self.result_image = self.result_image[round(\\n rho + round(self.moildev.getRhoFromAlpha(30))):self.h, 0:self.w]\\n # print(self.width_result_image)\\n else:\\n image = draw_polygon(self.image.copy(), self.mapX, self.mapY)\\n self.result_image = cv2.remap(\\n self.image,\\n self.mapX,\\n self.mapY,\\n cv2.INTER_CUBIC)\\n self.show_image.show_original_image(\\n image, self.width_original_image)\\n self.show_image.show_result_image(\\n self.result_image, self.width_result_image, self.angle)\",\n \"def show_env(self, img):\\n plt.figure(1)\\n plt.subplot(111)\\n plt.imshow(img, interpolation=\\\"nearest\\\")\\n plt.show()\",\n \"def simplePlots() -> None:\\r\\n \\r\\n # Univariate data -------------------------\\r\\n \\r\\n # Make sure that always the same random numbers are generated\\r\\n np.random.seed(1234)\\r\\n \\r\\n # Generate data that are normally distributed\\r\\n x = np.random.randn(500)\\r\\n \\r\\n # Other graphics settings\\r\\n # Set \\\" context='poster' \\\" for printouts, and \\\"set_fonts(32)\\\"\\r\\n sns.set(context='notebook', style='ticks', palette='muted')\\r\\n \\r\\n # Set the fonts the way I like them\\r\\n set_fonts(16)\\r\\n \\r\\n # Scatter plot\\r\\n plt.plot(x, '.', markersize=7)\\r\\n plt.xlim([0, len(x)])\\r\\n \\r\\n # Save and show the data, in a systematic format\\r\\n printout('scatterPlot.jpg', xlabel='Datapoints', ylabel='Values', title='Scatter')\\r\\n \\r\\n # Histogram\\r\\n plt.hist(x)\\r\\n printout('histogram_plain.jpg', xlabel='Data Values',\\r\\n ylabel='Frequency', title='Histogram, default settings')\\r\\n \\r\\n plt.hist(x, 25, density=True)\\r\\n printout('density_histogram.jpg', xlabel='Data Values', ylabel='Probability',\\r\\n title='Density Histogram, 25 bins')\\r\\n \\r\\n # Boxplot\\r\\n # The ox consists of the first, second (middle) and third quartile\\r\\n set_fonts(18)\\r\\n plt.boxplot(x, sym='*')\\r\\n printout('boxplot.jpg', xlabel='Values', title='Boxplot')\\r\\n \\r\\n plt.boxplot(x, sym='*', vert=False)\\r\\n plt.title('Boxplot, horizontal')\\r\\n plt.xlabel('Values')\\r\\n plt.show()\\r\\n \\r\\n # Errorbars\\r\\n x = np.arange(5)\\r\\n y = x**2\\r\\n errorBar = x/2\\r\\n plt.errorbar(x,y, yerr=errorBar, fmt='o', capsize=5, capthick=3)\\r\\n plt.xlim([-0.2, 4.2])\\r\\n plt.ylim([-0.2, 19])\\r\\n printout('Errorbars.jpg', xlabel='Data Values', ylabel='Measurements', title='Errorbars')\\r\\n\\r\\n # SD for two groups\\r\\n weight = {'USA':89, 'Austria':74}\\r\\n weight_SD_male = 12\\r\\n plt.errorbar([1,2], weight.values(), yerr=weight_SD_male * np.r_[1,1],\\r\\n capsize=5, LineStyle='', marker='o')\\r\\n plt.xlim([0.5, 2.5])\\r\\n plt.xticks([1,2], weight.keys())\\r\\n plt.ylabel('Weight [kg]')\\r\\n plt.title('Adult male, mean +/- SD')\\r\\n\\r\\n show_data('SD_groups.jpg', out_dir='.')\\r\\n \\r\\n # Barplot\\r\\n # The font-size is set such that the legend does not overlap with the data\\r\\n np.random.seed(1234)\\r\\n set_fonts(16)\\r\\n \\r\\n df = pd.DataFrame(np.random.rand(7, 3), columns=['one', 'two', 'three'])\\r\\n df.plot(kind='bar', grid=False, color=sns.color_palette('muted'))\\r\\n \\r\\n show_data('barplot.jpg')\\r\\n\\r\\n # Bivariate Plots\\r\\n df2 = pd.DataFrame(np.random.rand(50, 3), columns=['a', 'b', 'c'])\\r\\n df2.plot(kind='scatter', x='a', y='b', s=df2['c']*500);\\r\\n plt.axhline(0, ls='--', color='#999999')\\r\\n plt.axvline(0, ls='--', color='#999999')\\r\\n printout('bivariate.jpg')\\r\\n \\r\\n sns.set_style('ticks')\\r\\n\\r\\n # Pieplot\\r\\n txtLabels = 'Cats', 'Dogs', 'Frogs', 'Others'\\r\\n fractions = [45, 30, 15, 10]\\r\\n offsets =(0, 0.05, 0, 0)\\r\\n \\r\\n plt.pie(fractions, explode=offsets, labels=txtLabels,\\r\\n autopct='%1.1f%%', shadow=True, startangle=90,\\r\\n colors=sns.color_palette('muted') )\\r\\n plt.axis('equal')\\r\\n printout('piePlot.jpg', title=' ')\",\n \"def visualize(original, s, m, l, s_pred, m_pred, l_pred):\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tplt.subplot(1,7,1)\\n\\tplt.title('Original image')\\n\\tplt.imshow(original)\\n\\n\\tplt.subplot(1,7,2)\\n\\tplt.title('S image')\\n\\tplt.imshow(s)\\n\\tplt.subplot(1,7,3)\\n\\tplt.title('S Pred image')\\n\\tplt.imshow(s_pred)\\n\\n\\tplt.subplot(1,7,4)\\n\\tplt.title('M image')\\n\\tplt.imshow(m)\\n\\tplt.subplot(1,7,5)\\n\\tplt.title('M Pred image')\\n\\tplt.imshow(m_pred)\\n\\n\\tplt.subplot(1,7,6)\\n\\tplt.title('L image')\\n\\tplt.imshow(l)\\n\\tplt.subplot(1,7,7)\\n\\tplt.title('L Pred image')\\n\\tplt.imshow(l_pred)\",\n \"def plots():\\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\\n return display(widgrid, out)\",\n \"def show_input_to_output(img_ns):\\n figure()\\n \\n sp = subplot(1, 2, 1).imshow(img_ns.img)\\n sp.axes.grid(False)\\n sp.axes.tick_params(bottom=False, left=False, which='both',labelleft=False,labelbottom=False,length=0)\\n title(\\\"Input Image\\\", fontsize=10);\\n outimg = tiles_to_images(img_ns, img_ns.tile_grid, img_ns.tile_catalog, img_ns.tile_size)\\n sp = subplot(1, 2, 2).imshow(outimg.astype(np.uint8));\\n sp.axes.tick_params(bottom=False, left=False, which='both',labelleft=False,labelbottom=False,length=0)\\n title(\\\"Output Image From Tiles\\\", fontsize=10);\\n sp.axes.grid(False)\\n #print(outimg.astype(np.uint8))\\n #print(img_ns)\\n plt.savefig(img_ns.output_filename + \\\"_input_to_output.pdf\\\", bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def display_dataset(path, save, dset='sum'):\\n # List datasets\\n files_surf = os.listdir(path[0])\\n files_surf.sort()\\n files_deep = os.listdir(path[1])\\n files_deep.sort()\\n files_calc = os.listdir(path[2])\\n files_calc.sort()\\n\\n # Corrected names\\n files = os.listdir(r'Y:\\\\3DHistoData\\\\Subvolumes_2mm')\\n files.sort()\\n\\n k = 0\\n # Loop for displaying images\\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\\n # Load images\\n im_surf = loadh5(path[0], fsurf, dset)\\n im_deep = loadh5(path[1], fdeep, dset)\\n im_calc = loadh5(path[2], fcalc, dset)\\n # Create figure\\n fig = plt.figure(dpi=300)\\n ax1 = fig.add_subplot(131)\\n ax1.imshow(im_surf, cmap='gray')\\n plt.title(fsurf + ', Surface')\\n ax2 = fig.add_subplot(132)\\n ax2.imshow(im_deep, cmap='gray')\\n plt.title('Deep')\\n ax3 = fig.add_subplot(133)\\n ax3.imshow(im_calc, cmap='gray')\\n plt.title('Calcified')\\n if save is not None:\\n while files[k] == 'Images' or files[k] == 'MeanStd':\\n k += 1\\n\\n # Save figure\\n if not os.path.exists(save):\\n os.makedirs(save, exist_ok=True)\\n plt.tight_layout()\\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\\\"tight\\\", transparent=True)\\n plt.close()\\n\\n # Save h5\\n if not os.path.exists(save + '\\\\\\\\MeanStd\\\\\\\\'):\\n os.makedirs(save + '\\\\\\\\MeanStd\\\\\\\\', exist_ok=True)\\n\\n h5 = h5py.File(save + \\\"\\\\\\\\MeanStd\\\\\\\\\\\" + files[k] + '.h5', 'w')\\n h5.create_dataset('surf', data=im_surf)\\n h5.create_dataset('deep', data=im_deep)\\n h5.create_dataset('calc', data=im_calc)\\n h5.close()\\n else:\\n plt.show()\\n k += 1\",\n \"def display_image(X):\\n\\n\\tim = X.reshape(28, 28)\\n\\ttemp = plt.imshow(im)\\n\\tplt.show()\",\n \"def display_sample_images(self):\\n if self.train_dataset is None:\\n self.init_datasets()\\n\\n images, labels = next(self.train_dataset)\\n plt.figure(figsize=(5,5))\\n for n in range(min(25, images.shape[0])):\\n ax = plt.subplot(5,5,n+1)\\n plt.imshow(images[n])\\n if len(labels.shape) == 1:\\n plt.title(self.class_names[int(labels[n])].title())\\n else:\\n m = np.argmax(labels[n])\\n plt.title(self.class_names[int(labels[n, m])].title())\\n plt.axis('off')\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def display_metrics3(self):\\n messagebox.showinfo(\\\"Processed Image Metrics\\\", self.pro_metrics)\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def show_figure(self):\\n pylab.show()\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: np.ndarray) -> np.ndarray:\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n self.layer = dpg.add_draw_layer(\\n parent=f'main_window_{self.id}',\\n tag=draw_layer_tag,\\n show=False\\n )\\n\\n best_k = np.argsort(output_data)[-self.top_n:][::-1]\\n class_names = np.array(self.class_names)[best_k]\\n percentages = softmax(output_data[best_k])\\n\\n for i, (name, perc) in enumerate(zip(class_names, percentages)):\\n label_pos = dpg.get_item_pos(f'cell_bar_{i}_{self.id}')\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=label_pos,\\n pmax=(\\n label_pos[0] + _SCORE_COLUMN_WIDTH*perc,\\n label_pos[1] + _FONT_SIZE),\\n color=(0, 255, 0),\\n fill=(0, 255, 0)\\n )\\n dpg.set_value(f'cell_perc_{i}_{self.id}', f'{perc*100:.2f}%')\\n dpg.set_value(f'cell_name_{i}_{self.id}', name)\\n\\n return img\",\n \"def display_data():\\n data = read_data_from_file()\\n data_size = len(data)\\n print('Data size - ' + str(data_size))\\n\\n\\n for i in range(data_size-1, 0, -1):\\n image = data[i]\\n cv2.imshow('window', image[0])\\n print(str(image[1]))\\n cv2.waitKey(50)\",\n \"def show_result(inputs, labels, outputs):\\n num_classes = outputs.size(1)\\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\\n if num_classes == 2:\\n outputs *= 255\\n mask = outputs[0].reshape((360, 640))\\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\\n ax[0].set_title('Image')\\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\\n ax[1].set_title('gt')\\n plt.show()\\n plt.figure()\\n plt.imshow(mask, cmap='gray')\\n plt.title('Pred')\\n plt.show()\",\n \"def display(self):\\n nrow = len(self.labels) + 1\\n ncol = len(self.views)\\n rows = [(self.views[0].image, len(self.views))]\\n viewfig, viewaxes = plt.subplots(ncols=ncol, figsize=self._figsize(rows))\\n for ax, view in zip(viewaxes, self.views):\\n ax.imshow(view.image if len(self.labels) == 0 else view.original)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=view.position.id)\\n viewfig.tight_layout()\\n viewfig.canvas.draw()\\n views = np.array(viewfig.canvas.renderer._renderer)\\n\\n rows = [(views, 1),\\n *[(l.display, 1) for l in self.labels]]\\n fig, axes = plt.subplots(nrows=nrow,\\n figsize=self._figsize(rows))\\n if nrow == 1:\\n axes = [axes]\\n for ax, img in zip(axes, [views] + [l.display for l in self.labels]):\\n ax.imshow(img)\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def _init_plot(self) -> None:\\n\\n # create a grayscale plot\\n out = sys.stdout\\n sys.stdout = open(\\\"/dev/null\\\", \\\"w\\\")\\n hdu = self.image_generator.image(self.ra, self.dec)\\n self.plot = aplpy.FITSFigure(hdu)\\n self.plot.show_grayscale()\\n self.plot.set_theme(\\\"publication\\\")\\n sys.stdout = out\\n\\n # label for the position angle\\n pa_string = \\\"PA = %.1f\\\" % self.mode_details.position_angle().to_value(u.deg)\\n if self.mode_details.automated_position_angle():\\n pa_string += \\\" (auto)\\\"\\n self.draw_label(0.95, -0.05, pa_string, style=\\\"italic\\\", weight=\\\"bold\\\")\\n\\n # label for the title\\n if self.title:\\n self.draw_label(\\n 0.5, 1.03, self.title, style=\\\"italic\\\", weight=\\\"bold\\\", size=\\\"large\\\"\\n )\\n\\n # label for the image source\\n self.draw_label(\\n -0.05,\\n -0.05,\\n \\\"%s\\\" % self.image_generator.source(),\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n )\\n\\n # grid overlay\\n self.plot.add_grid()\\n self.plot.grid.set_alpha(0.2)\\n self.plot.grid.set_color(\\\"b\\\")\\n\\n # indicate the RSS field of view\\n self.draw_circle(self.ra, self.dec, 4.0 * u.arcmin, \\\"g\\\")\\n self.draw_label(\\n 0.79,\\n 0.79,\\n \\\"RSS\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"left\\\",\\n color=(0, 0, 1),\\n )\\n\\n # indicate the Salticam field of view\\n self.draw_circle(self.ra, self.dec, 5.0 * u.arcmin, \\\"g\\\")\\n self.draw_label(\\n 0.86,\\n 0.86,\\n \\\"SCAM\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"left\\\",\\n color=(0, 0, 1),\\n )\\n\\n # labels for north and east direction\\n self.draw_label(\\n self.ra,\\n self.dec + 4.8 * u.arcmin,\\n \\\"N\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n color=(0, 0.5, 1),\\n )\\n self.draw_label(\\n self.ra + 4.8 * u.arcmin / np.abs(np.cos(self.dec)),\\n self.dec,\\n \\\"E\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"right\\\",\\n color=(0, 0.5, 1),\\n )\\n\\n # add cross hairs\\n self.draw_centered_line(\\n 0 * u.deg,\\n 8 * u.arcmin,\\n self.ra,\\n self.dec,\\n color=\\\"g\\\",\\n linewidth=0.5,\\n alpha=1.0,\\n )\\n self.draw_centered_line(\\n 90 * u.deg,\\n 8 * u.arcmin,\\n self.ra,\\n self.dec,\\n color=\\\"g\\\",\\n linewidth=0.5,\\n alpha=1.0,\\n )\\n\\n # label for the magnitude range and bandpass\\n if self.magnitude_range:\\n self._show_magnitudes()\\n\\n # add mode specific content\\n if not self.basic_annotations:\\n self.mode_details.annotate_finder_chart(self)\",\n \"def montage(W):\\n import matplotlib.pyplot as plt\\n fig, ax = plt.subplots(2, 5)\\n for i in range(2):\\n for j in range(5):\\n im = W[i * 5 + j, :].reshape(32, 32, 3, order='F')\\n sim = (im - np.min(im[:])) / (np.max(im[:]) - np.min(im[:]))\\n sim = sim.transpose(1, 0, 2)\\n ax[i][j].imshow(sim, interpolation='nearest')\\n ax[i][j].set_title(\\\"y=\\\" + str(5 * i + j))\\n ax[i][j].axis('off')\\n #plt.savefig(\\\"plots/ \\\"+fname +\\\".png\\\")\\n plt.show()\",\n \"def display(self):\\n display(self.image)\",\n \"def combine_plot(qa_out_path,brain_path):\\n \\n #Get the scan volume of the brain.\\n brain_ref = nib.load(brain_path)\\n brain_ref_shape = brain_ref.shape[0:3]\\n \\n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\\n y_labels = [\\\"Rotate with Z axis\\\",\\\"Rotate with Y axis\\\",\\\"Rotate with X axis\\\"]\\n x_labels = [\\\"angle=0\\\",\\\"angle=120\\\",\\\"angle=240\\\"]\\n \\n #Temporary list to store the image nparray:\\n im_arr=[] \\n \\n fig= plt.figure()\\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\\\n\\\\n', fontsize=60,fontweight='bold')\\n plt.xticks([])\\n plt.yticks([])\\n plt.axis(\\\"off\\\")\\n\\n j = 0\\n for i in range(9):\\n #Load in the nine images into a nparray one by one.\\n im_arr = np.array(Image.open(qa_out_path + \\\"/\\\" + plots_list[i]))\\n #Change the background of the image into black:\\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \\n ax = fig.add_subplot(3,3,i+1)\\n ax.imshow(im_arr,interpolation=\\\"none\\\",alpha=0.9)\\n \\n #Set the X labels and Y labels\\n if i<3:\\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\\n if i % 3 == 0:\\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\\n j = j + 1\\n plt.xticks([])\\n plt.yticks([])\\n \\n fig.set_size_inches(40, 40, forward = True)\\n fig.savefig(qa_out_path + \\\"/\\\" + 'qa_tractography.png', format='png')\\n\\n #Delete the Nine images which used to generate the qa_tractography.png \\n for plot in plots_list:\\n if os.path.exists(qa_out_path + \\\"/\\\" + plot):\\n os.remove(qa_out_path + \\\"/\\\" + plot)\\n else:\\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')\",\n \"def imdisplay(filename, representation):\\n im = read_image(filename, representation)\\n if representation == 1:\\n plt.imshow(im, cmap='gray')\\n plt.show()\\n if representation == 2:\\n plt.imshow(im)\\n plt.show()\",\n \"def showSnapshots(self):\\n from .utils import sp\\n s = self.getSnapshots()\\n ax = sp(len(s))\\n for i, S in enumerate(s):\\n ax[i].imshow(S)\",\n \"def imdisplay(filename, representation):\\n\\n image = read_image(filename, representation)\\n plt.imshow(image, cmap=\\\"gray\\\")\\n plt.show()\",\n \"def showimage(image):\\n mplt.figure()\\n mplt.imshow(image)\\n mplt.show()\",\n \"def showPlot1():\\n\\n interested_in = list(range(5,30,5))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on room size')\\n xlabel('area of the room (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def main():\\n save = False\\n show = True\\n\\n #hd_parameter_plots = HDparameterPlots(save=save)\\n #hd_parameter_plots.flow_parameter_distribution_for_non_lake_cells_for_current_HD_model()\\n #hd_parameter_plots.flow_parameter_distribution_current_HD_model_for_current_HD_model_reprocessed_without_lakes_and_wetlands()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs()\\n #hd_parameter_plots.flow_parameter_distribution_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_no_tuning()\\n #ice5g_comparison_plots = Ice5GComparisonPlots(save=save)\\n #ice5g_comparison_plots.plotLine()\\n #ice5g_comparison_plots.plotFilled()\\n #ice5g_comparison_plots.plotCombined()\\n #ice5g_comparison_plots.plotCombinedIncludingOceanFloors()\\n #flowmapplot = FlowMapPlots(save)\\n #flowmapplot.FourFlowMapSectionsFromDeglaciation()\\n #flowmapplot.Etopo1FlowMap()\\n #flowmapplot.ICE5G_data_all_points_0k()\\n #flowmapplot.ICE5G_data_all_points_0k_no_sink_filling()\\n #flowmapplot.ICE5G_data_all_points_0k_alg4_two_color()\\n #flowmapplot.ICE5G_data_all_points_21k_alg4_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color()\\n #flowmapplot.Etopo1FlowMap_two_color_directly_upscaled_fields()\\n #flowmapplot.Corrected_HD_Rdirs_FlowMap_two_color()\\n #flowmapplot.ICE5G_data_ALG4_true_sinks_21k_And_ICE5G_data_ALG4_true_sinks_0k_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_sinkless_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_data_ALG4_no_true_sinks_corr_orog_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Corrected_HD_Rdirs_And_ICE5G_HD_as_data_ALG4_true_sinks_0k_directly_upscaled_fields_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplot.Ten_Minute_Data_from_Virna_data_ALG4_corr_orog_downscaled_lsmask_no_sinks_21k_vs_0k_FlowMap_comparison()\\n #flowmapplot.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n flowmapplotwithcatchment = FlowMapPlotsWithCatchments(save)\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs()\\n #flowmapplotwithcatchment.Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.upscaled_rdirs_with_and_without_tarasov_upscaled_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.\\\\\\n #Upscaled_Rdirs_vs_Corrected_HD_Rdirs_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_glcc_olson_lsmask_0k_FlowMap_comparison()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs()\\n #flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts()\\n flowmapplotwithcatchment.compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min()\\n outflowplots = OutflowPlots(save)\\n #outflowplots.Compare_Upscaled_Rdirs_vs_Directly_Upscaled_fields_ICE5G_data_ALG4_corr_orog_downscaled_ls_mask_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_sinkless_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_as_HD_data_ALG4_true_sinks_all_points_0k()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_sinkless_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_true_sinks_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_ALG4_corr_orog_downscaled_ls_mask_all_points_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_sinkless_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_Etopo1_ALG4_true_sinks_directly_upscaled_fields()\\n #outflowplots.Compare_Corrected_HD_Rdirs_And_ICE5G_plus_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k()\\n outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks()\\n #outflowplots.Compare_Original_Corrections_vs_Upscaled_MERIT_DEM_0k_new_truesinks_individual_rivers()\\n #outflowplots.Compare_ICE5G_with_and_without_tarasov_upscaled_srtm30_ALG4_corr_orog_0k_directly_upscaled_fields()\\n #hd_output_plots = HDOutputPlots()\\n #hd_output_plots.check_water_balance_of_1978_for_constant_forcing_of_0_01()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data()\\n #hd_output_plots.plot_comparison_using_1990_rainfall_data_adding_back_to_discharge()\\n #coupledrunoutputplots = CoupledRunOutputPlots(save=save)\\n #coupledrunoutputplots.ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.ocean_grid_extended_present_day_rdirs_vs_ice6g_rdirs_lgm_run_discharge_plot()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_echam()\\n #coupledrunoutputplots.extended_present_day_rdirs_vs_ice6g_rdirs_lgm_mpiom_pem()\\n #lake_plots = LakePlots()\\n #lake_plots.plotLakeDepths()\\n #lake_plots.LakeAndRiverMap()\\n #lake_plots.LakeAndRiverMaps()\\n if show:\\n plt.show()\",\n \"def plot_oneshot_task(pairs):\\n fig,(ax1,ax2) = plt.subplots(2)\\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\\n img = concat_images(pairs[1])\\n ax1.get_yaxis().set_visible(False)\\n ax1.get_xaxis().set_visible(False)\\n ax2.matshow(img,cmap='gray')\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def plot_image_sequence(self):\\r\\n\\r\\n imv = pg.ImageView()\\r\\n\\r\\n imv.show()\\r\\n\\r\\n imv.setImage(self.imageData)\\r\\n\\r\\n self.layout.addWidget(imv, 0, 0)\\r\\n\\r\\n\\r\\n\\r\\n avgImage = np.mean(self.imageData, axis=0)\\r\\n\\r\\n ima = pg.ImageView()\\r\\n\\r\\n ima.setImage(avgImage)\\r\\n\\r\\n self.layout.addWidget(ima, 1, 0)\",\n \"def imdisplay(filename, representation):\\n image = read_image(filename, representation)\\n\\n if representation == GRAY_OUT:\\n plt.imshow(image, cmap='gray')\\n else:\\n plt.imshow(image)\\n\\n plt.show()\",\n \"def makeFigure(imgList):\\n for i, img in enumerate(imgList):\\n i += 1\\n ax = plt.subplot(len(imgList), 1, i)\\n ax.imshow(img[0], cmap=COLOR_MAP)\\n ax.get_yaxis().set_ticks([])\\n if i == len(imgList):\\n ax.set_xlabel('Time of day')\\n ax.set_ylabel('Day of week')\\n # add name of the repo as title\\n plt.title(img[1])\\n\\n plt.tight_layout(pad=0)\\n plt.show()\",\n \"def print_image(img):\\r\\n # On affiche l'image\\r\\n plt.figure(figsize=(20, 5))\\r\\n plt.subplot(1, 2, 1)\\r\\n plt.imshow(img)\\r\\n # On affiche l'histogramme\\r\\n plt.subplot(1, 2, 2)\\r\\n plt.hist(img.flatten(), bins=range(256))\\r\\n plt.show()\",\n \"def show_img(graphs = False):\\n while True:\\n screen = (yield)\\n window_title = \\\"logs\\\" if graphs else \\\"game_play\\\"\\n cv2.namedWindow(window_title, cv2.WINDOW_NORMAL) \\n imS = cv2.resize(screen, (800, 400)) \\n cv2.imshow(window_title, screen)\\n if (cv2.waitKey(1) & 0xFF == ord('q')):\\n cv2.destroyAllWindows()\\n break\",\n \"def main(image_path):\\n temp_dir = tempfile.mkdtemp()\\n print('Saving output to {}'.format(temp_dir))\\n estimator = run_image(image_path)\\n visualize(estimator, image_path, temp_dir)\",\n \"def show(self) -> None:\\n cv.imshow(str(self.__class__), self.output_image)\",\n \"def display(self):\\n fig, axes = plt.subplots(1, len(self.views),\\n figsize=self._figsize(\\n [(self.views[0].image, len(self.views))]),\\n squeeze=True)\\n for ax, view in zip(axes.ravel(), self.views):\\n ax.imshow(view.grey)\\n points = self._common_keypoints(view).reshape(-1, 2)[::-1]\\n ax.plot(points[..., 0], points[..., 1], 'r+')\\n ax.axis('off')\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n ax.set(title=view.position.id)\\n fig.tight_layout()\\n fig.canvas.draw()\\n img_array = np.array(fig.canvas.renderer._renderer)\\n plt.close('all')\\n return img_array\",\n \"def display(self, image):\\n raise NotImplementedError()\",\n \"def plot_overview(cube=nro_12co,\\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\\n scalebar_color=\\\"white\\\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\\n pmax=99.75, cbar_label=r\\\"Peak T$_{\\\\rm MB}$ [K]\\\",\\n circle_color='white', circle_linewidth=1, circle_style=\\\"solid\\\", return_fig=False, show=True,\\n title=r\\\"$^{12}$CO Peak T$_{MB}$\\\", recenter=False, ra=None, dec=None, radius=None):\\n try:\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if mode == \\\"peak\\\":\\n image = (cube.max(axis=0) * scale_factor).hdu\\n \\n\\n if mode == \\\"mom0\\\":\\n image = (cube.moment0() * scale_factor).hdu\\n\\n\\n\\n fig = FITSFigure(image)\\n if show:\\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\\n pmax=pmax, interpolation='none')\\n fig.tick_labels.set_yformat(\\\"dd:mm\\\")\\n fig.tick_labels.set_xformat(\\\"hh:mm\\\")\\n #fig.hide_yaxis_label()\\n #fig.hide_ytick_labels()\\n plt.title(title)\\n plt.xlabel(\\\"RA (J2000)\\\")\\n plt.ylabel(\\\"DEC (J2000)\\\")\\n\\n if show_shells:\\n shell_list = get_shells(region_file=region_file)\\n for i, shell in enumerate(shell_list):\\n if shells_highlight:\\n if i+1 in shells_highlight:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\\n facecolor='none', linewidth=3)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n\\n #RECENTER\\n if recenter:\\n fig.recenter(ra, dec, radius)\\n\\n\\n #SCALEBAR\\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\\n fig.scalebar.set_label(\\\"{} pc\\\".format(scalebar_pc))\\n\\n fig.add_colorbar()\\n cb = fig.colorbar\\n cb.set_axis_label_text(cbar_label)\\n\\n if return_fig:\\n return fig\\n else:\\n fig.save(plotname, dpi=600)\",\n \"def showPlot5():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n len_sim_data2 = []\\n raw_sim_data2 = runSimulation(item, 1.0, 25, 25, 0.75, 100, RandomWalkRobot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n for mes in raw_sim_data2:\\n len_sim_data2.append(len(mes))\\n overa = [sum(len_sim_data)/len(len_sim_data), sum(len_sim_data2)/len(len_sim_data2)]\\n proc_sim_data.append(overa)\\n plot(interested_in, proc_sim_data)\\n title('performance comparision of the two types of bots')\\n xlabel('number of robots')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plot_img():\\n plt.subplot(121)\\n plt.imshow(data.data.numpy()[0,].squeeze())\\n plt.subplot(122)\\n plt.imshow(dec_mean.view(-1,28,28).data.numpy()[0,].squeeze())\\n\\n plt.show()\\n plt.pause(1e-6)\\n plt.gcf().clear()\\n sample = model.sample_z(data) \\n plt.imshow(sample)\",\n \"def imdisplay(filename, representation):\\n img = read_image(filename, representation)\\n if representation == GS_REP:\\n plt.imshow(img, cmap=plt.cm.gray)\\n else:\\n plt.imshow(img)\",\n \"def print_images_out_statistics(self):\\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)\",\n \"def visualize_output(\\n self,\\n img: np.ndarray,\\n output_data: List[DetectObject]) -> np.ndarray:\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n self.layer = dpg.add_draw_layer(\\n parent=f'main_window_{self.id}',\\n tag=draw_layer_tag,\\n show=False\\n )\\n for out in output_data:\\n description = f'{out.clsname} [{out.score*100:.2f}%]'\\n # add alpha and convert to RGB\\n color = np.array(self.class_colors[out.clsname])\\n color = tuple((255*color).astype(np.uint8))\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=(out.xmin*self.width,\\n out.ymin*self.height),\\n pmax=(out.xmax*self.width,\\n out.ymax*self.height),\\n color=color,\\n thickness=2\\n )\\n dpg.draw_text(\\n parent=draw_layer_tag,\\n text=description,\\n pos=(out.xmin*self.width + _PADDING,\\n out.ymin*self.height + _PADDING),\\n color=color,\\n size=_FONT_SIZE\\n )\\n\\n return img\",\n \"def summary_plot(self, cm_plot_style):\\n plt.figure(figsize=(10, 3), dpi=300)\\n plt.subplot(1, 2, 1)\\n self.conditional_activation_plot(cm_plot_style, False)\\n plt.subplot(1, 2, 2)\\n self.cumulative_days_plot(cm_plot_style, False)\\n plt.tight_layout()\\n plt.savefig(\\\"FigureCA.pdf\\\", bbox_inches='tight')\\n # sns.despine()\",\n \"def visualize(self):\\n\\n check_is_fitted(self, \\\"sm_\\\")\\n\\n fig = plt.figure(figsize=(6, 4))\\n inner = gridspec.GridSpec(2, 1, hspace=0.1, height_ratios=[6, 1])\\n ax1_main = plt.Subplot(fig, inner[0]) \\n xgrid = np.linspace(self.xmin, self.xmax, 100).reshape([-1, 1])\\n ygrid = self.decision_function(xgrid)\\n ax1_main.plot(xgrid, ygrid)\\n ax1_main.set_xticklabels([])\\n ax1_main.set_title(\\\"Shape Function\\\", fontsize=12)\\n fig.add_subplot(ax1_main)\\n \\n ax1_density = plt.Subplot(fig, inner[1]) \\n xint = ((np.array(self.bins_[1:]) + np.array(self.bins_[:-1])) / 2).reshape([-1, 1]).reshape([-1])\\n ax1_density.bar(xint, self.density_, width=xint[1] - xint[0])\\n ax1_main.get_shared_x_axes().join(ax1_main, ax1_density)\\n ax1_density.set_yticklabels([])\\n ax1_density.autoscale()\\n fig.add_subplot(ax1_density)\\n plt.show()\",\n \"def display_results(experiment, norms, nus, filename):\\n # plot the results of the experiment\\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\\n\\n # plot large scale overview\\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\\n\\n # plot more detailed errors exluding OLS estimate\\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\\n\\n # add title and save\\n plt.savefig(filename, dpi=300)\",\n \"def image_show(inp, title=None):\\n inp = inp.numpy().transpose((1, 2, 0))\\n mean = np.array([0.485, 0.456, 0.406])\\n std = np.array([0.229, 0.224, 0.225])\\n inp = std * inp + mean\\n inp = np.clip(inp, 0, 1)\\n plt.imshow(inp)\\n\\n if title is not None:\\n plt.title(title)\\n plt.pause(0.001)\",\n \"def btn_display_hist_callback(self):\\n self.show_as_waiting(True)\\n ids = self.tbl_images.get_selected_ids()\\n names = self.tbl_images.get_selected_names()\\n\\n for id, name in zip(ids, names):\\n ret = api.get_single_image(id, self.user_hash)\\n if ret.get('success') is False:\\n self.show_error(ret['error_msg'])\\n else:\\n image_fio = b64s_to_fio(ret['data'])\\n img_hist_fio = img_proc.fio_hist_fio(image_fio)\\n self.img_displayer.new_display(\\n img_hist_fio, name + ' Histogram')\\n del image_fio\\n del img_hist_fio\\n self.show_as_waiting(False)\",\n \"def display(self, index):\\n img = self.img(index)\\n transcription = self.transcript(index)\\n plt.imshow(self.norm_img(img), cmap='bone')\\n plt.title(transcription, fontdict={'fontsize': 64})\\n plt.show()\",\n \"def show_plot(self):\\n runs = self.GetParent().runs\\n if len(runs) <= 0: return\\n\\n t1 = time.time()\\n total_width = self.GetParent().total_width\\n\\n newwidth = total_width * (self.GetParent().zoom / 100)\\n newmid = total_width * (self.GetParent().pan/100)\\n newxmin = newmid - (newwidth/2)\\n newxmax = newxmin + newwidth\\n\\n if newxmin < 0:\\n newxmin = 0\\n newxmax = newwidth\\n elif newxmax > total_width:\\n newxmax = total_width\\n newxmin = newxmax - newwidth\\n\\n assert newxmin >= 0 and newxmin <= total_width\\n\\n #print \\\"**** Zoom: %s, pan: %s, total_width: %s, newwidth: %s, newmid: %s, newxmin: %s, newxmax: %s\\\" \\\\\\n # %(self.GetParent().zoom,self.GetParent().pan,total_width,newwidth,newmid,newxmin,newxmax)\\n\\n left = 0\\n width_so_far = 0\\n self.figure.clear()\\n braggsmax = max(flex.max(r.culled_braggs) for r in runs)\\n braggsmin = min(flex.min(r.culled_braggs) for r in runs)\\n distsmax = max(flex.max(r.culled_distances) for r in runs)\\n distsmin = min(flex.min(r.culled_distances) for r in runs)\\n sifomax = max(flex.max(r.culled_sifoils) for r in runs)\\n sifomin = min(flex.min(r.culled_sifoils) for r in runs)\\n wavemax = max(flex.max(r.culled_wavelengths) for r in runs)\\n wavemin = min(flex.min(r.culled_wavelengths) for r in runs)\\n\\n #above tricks don't work for hit rates as they can be empty if the run is new\\n goodruns = []\\n for run in runs:\\n if len(run.hit_rates) > 0: goodruns.append(run)\\n if len(goodruns) > 0:\\n hitsmax = max(flex.max(r.hit_rates) for r in goodruns)\\n hitsmin = min(flex.min(r.hit_rates) for r in goodruns)\\n else:\\n hitsmax = hitsmin = 0\\n\\n first_run = True\\n for run in runs:\\n right = left + run.width()\\n\\n if right < newxmin or left > newxmax:\\n left += run.width()\\n #print \\\"Not showing run %s\\\"%run.runId\\n continue\\n\\n if left < newxmin:\\n xmin = run.min() + (newxmin - left)\\n else:\\n xmin = run.min()\\n\\n if right > newxmax:\\n xmax = run.min() + (newxmax - left)\\n else:\\n xmax = run.max()\\n\\n #print \\\"Run: %s, run.width(): %s, left: %s, right: %s, run.min(): %s, run.max(): %s, xmin: %s, xmax: %s, width_so_far: %s, xmax-xmin: %s\\\" \\\\\\n #%(run.runId,run.width(),left,right,run.min(),run.max(),xmin,xmax,width_so_far,xmax-xmin)\\n\\n ax1 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.05, 0.9*(xmax-xmin)/newwidth, 0.4])\\n ax2 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.45, 0.9*(xmax-xmin)/newwidth, 0.2], sharex=ax1)\\n ax3 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.65, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n ax4 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.75, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n ax5 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.85, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n left += run.width()\\n width_so_far += (xmax-xmin)\\n\\n ax1.grid(True, color=\\\"0.75\\\")\\n ax2.grid(True, color=\\\"0.75\\\")\\n ax3.grid(True, color=\\\"0.75\\\")\\n ax4.grid(True, color=\\\"0.75\\\")\\n ax5.grid(True, color=\\\"0.75\\\")\\n ax1.plot(run.culled_bragg_times.select(run.culled_indexed),\\n run.culled_braggs.select(run.culled_indexed), 'd', color=[0.0,1.0,0.0])\\n ax1.plot(run.culled_bragg_times.select(~run.culled_indexed),\\n run.culled_braggs.select(~run.culled_indexed), 'd', color=[0.0,0.5,1.0])\\n ax2.plot(run.hit_rates_times, run.hit_rates, 'o-', color=[0.0,1.0,0.0])\\n ax3.plot(run.culled_bragg_times, run.culled_wavelengths, '^', color=[0.8,0.0,0.2])\\n ax4.plot(run.culled_bragg_times, run.culled_sifoils, '<', color=[0.8,0.0,0.2])\\n ax5.plot(run.culled_bragg_times, run.culled_distances, '>', color=[0.8,0.0,0.2])\\n ax1.set_ylabel(\\\"# of Bragg spots\\\")\\n ax2.set_ylabel(\\\"Hit rate (%)\\\")\\n ax3.set_ylabel(\\\"WaveL\\\")\\n ax4.set_ylabel(\\\"SiFoils(mm)\\\")\\n ax5.set_ylabel(\\\"Dist (mm)\\\")\\n ax1.set_xlim(xmin, xmax)\\n ax1.set_ylim(braggsmin, braggsmax)\\n ax2.set_ylim(hitsmin, hitsmax)\\n ax3.set_ylim(wavemin, wavemax)\\n ax4.set_ylim(sifomin-10, sifomax+10)\\n ax5.set_ylim(distsmin-3, distsmax+3)\\n ax1.set_xlabel(\\\"Time\\\")\\n for ax in ax1, ax2, ax3, ax4, ax5:\\n if (ax is not ax1) :\\n for label in ax.get_xticklabels():\\n label.set_visible(False)\\n ax.get_yticklabels()[0].set_visible(False)\\n if not first_run:\\n ax.get_yaxis().set_visible(False)\\n\\n ax1.xaxis.set_major_formatter(ticker.FuncFormatter(status_plot.format_time))\\n ax3.yaxis.set_major_formatter(ticker.FormatStrFormatter(\\\"%.3f\\\"))\\n ax5.yaxis.set_major_formatter(ticker.FormatStrFormatter(\\\"%.0f\\\"))\\n ax5.set_title(\\\"%d:%d/%d:%.1f%% I:%d\\\"%(run.runId, run.hits_count, len(run.braggs), 100*run.hits_count/len(run.braggs),run.indexed.count(True)))\\n\\n labels = ax1.get_xticklabels()\\n for label in labels:\\n label.set_rotation(30)\\n\\n first_run = False\\n\\n self.figure.autofmt_xdate()\\n self.canvas.draw()\\n self.parent.Refresh()\\n\\n t2 = time.time()\\n print(\\\"Plotted in %.2fs\\\" % (t2 - t1))\",\n \"def _generate_plot(ax, power_data, title, min_db, max_db):\\n # only generate plots for the transducers that have data\\n if power_data.size <= 0:\\n return\\n\\n ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)\\n return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)\",\n \"def print_image(indiv,name):\\n routine = gp.compile(indiv,pset)\\n output = gen_beat_output(routine)\\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\\n plt.style.use('classic')\\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\\n plt.savefig(name+\\\".png\\\",dpi=150)\",\n \"def display_image(mat):\\n\\timg = Image.fromarray(mat)\\n\\timg.show()\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plotRandImages(train_data, output):\\n rint_array = np.random.randint(0,train_data.shape[0],size=4)\\n\\n fig = plt.figure(figsize=(8,8))\\n plt.subplot(2,2,1)\\n for ii,rint in enumerate(rint_array):\\n plt.subplot(2,2,ii+1)\\n img = train_data[rint].reshape((20,20)).T\\n #print \\\" output: \\\",output[rint]\\n plt.imshow(img,aspect='auto',interpolation='nearest',\\n origin='lower')\\n plt.title('Image of %d'%output.T[rint])\\n plt.show()\\n\\n return\",\n \"def walkplot(cons):\\n # Call always after cons.runn()!\\n if not hasattr(cons, \\\"outplot\\\"):\\n print(\\\"Consortium must run before analyzing the output of the run!\\\")\\n return\\n global plt\\n if not plt:\\n import matplotlib.pyplot as plt\\n\\n # keep original inputs\\n original_metplots = dcp(cons.mets_to_plot)\\n original_outplot = dcp(cons.outplot)\\n cons.outplot = \\\"tmp.png\\\"\\n mets = [k for k in cons.media]\\n # loop over metabolites, plot them and let the user close the window\\n for m in range(0, len(mets), 4):\\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\\n plot_comm(cons)\\n plt.show()\\n print(\\\"Image number\\\", m / 4)\\n\\n # clean temporary files, return to orginal parameters\\n plt.close(\\\"all\\\")\\n os.remove(cons.outplot)\\n cons.mets_to_plot = original_metplots\\n cons.outplot = original_outplot\\n return\",\n \"def exp_summary(habitat,temperature,species):\\n plt.subplot(2,2,1)\\n niches(species)\\n plt.subplot(2,2,2)\\n environment(habitat,temperature)\\n plt.subplot(2,2,3)\\n show_matrix(habitat,\\\"habitat\\\")\\n plt.subplot(2,2,4)\\n show_matrix(temperature,\\\"temperature\\\")\",\n \"def visualize_image(images, save_name):\\n dim = images.shape[0]\\n n_image_rows = int(np.ceil(np.sqrt(dim)))\\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\\n right=1., left=0., hspace=0., wspace=0.)\\n\\n for g, count in zip(gs, range(int(dim))):\\n ax = plt.subplot(g)\\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n plt.savefig(save_name + '_vis.png')\",\n \"def display_multispectral_image(data, mask, sl, scale = 300):\\n fig, axes = plt.subplots(2,2, figsize=(10,10))\\n ax = axes.ravel()\\n for k, ch in enumerate(chn_names):\\n ax[k].imshow(data[:, :, sl, k].T + 300*mask[:,:,sl].T, cmap='gray', origin='lower')\\n ax[k].set_title(ch)\\n ax[k].set(xlabel=\\\"\\\")\\n ax[k].axis('off')\\n plt.suptitle('The multispectral MRI slice %d with the ROI mask' % sl) \\n plt.tight_layout\\n plt.show()\",\n \"def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\\n \\n coord,connectivity = [],[] # List of prediction and ground truth images\\n for k in range(n_images):\\n \\n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\\n \\n # Get the coordinate and connectivity data\\n coord += [dataset[or_case].coord.numpy()] \\n connectivity += [dataset[or_case].connectivity.numpy()]\\n\\n # Save npz array with the results of this iteration\\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\\n\\n # Call mesh_plotter to create the figures\\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\\n \\n # Send image for visualization in W&B\\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \\\"Epoch \\\"+str(epoch))\\n wandb.log({\\\"Prediction\\\": images})\",\n \"def print_images_in_statistics(self):\\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6950144","0.6822228","0.6799319","0.6795833","0.6745523","0.6712222","0.66112965","0.6607922","0.65862733","0.6581138","0.65078765","0.6487054","0.64790344","0.646684","0.64635116","0.64561826","0.64561826","0.64561826","0.6436497","0.64337176","0.6424609","0.64223903","0.64223903","0.64223903","0.64140666","0.6348933","0.6339352","0.63326484","0.6327082","0.6323834","0.63218194","0.63209265","0.6320263","0.63175005","0.6312985","0.6311541","0.6302971","0.63018084","0.6270365","0.62678117","0.62661713","0.6265614","0.6246057","0.62424415","0.6224011","0.6217169","0.62135977","0.6212648","0.6210694","0.6210686","0.6190168","0.6188331","0.6186246","0.6182705","0.61825705","0.618042","0.6180062","0.6166692","0.6165042","0.61641383","0.6163883","0.6160209","0.6158296","0.6156658","0.61534345","0.6149459","0.614865","0.6145494","0.6144248","0.61416745","0.61372745","0.6133433","0.6128921","0.6121655","0.61158997","0.61158645","0.6114205","0.61130464","0.6100436","0.60906315","0.60790306","0.6077845","0.60769814","0.60748595","0.6073173","0.6072115","0.60692126","0.60691017","0.60675704","0.6065843","0.6057319","0.6056832","0.60556334","0.60450244","0.60438347","0.6043658","0.6037898","0.60323536","0.6032067","0.6029602","0.60275143"],"string":"[\n \"0.6950144\",\n \"0.6822228\",\n \"0.6799319\",\n \"0.6795833\",\n \"0.6745523\",\n \"0.6712222\",\n \"0.66112965\",\n \"0.6607922\",\n \"0.65862733\",\n \"0.6581138\",\n \"0.65078765\",\n \"0.6487054\",\n \"0.64790344\",\n \"0.646684\",\n \"0.64635116\",\n \"0.64561826\",\n \"0.64561826\",\n \"0.64561826\",\n \"0.6436497\",\n \"0.64337176\",\n \"0.6424609\",\n \"0.64223903\",\n \"0.64223903\",\n \"0.64223903\",\n \"0.64140666\",\n \"0.6348933\",\n \"0.6339352\",\n \"0.63326484\",\n \"0.6327082\",\n \"0.6323834\",\n \"0.63218194\",\n \"0.63209265\",\n \"0.6320263\",\n \"0.63175005\",\n \"0.6312985\",\n \"0.6311541\",\n \"0.6302971\",\n \"0.63018084\",\n \"0.6270365\",\n \"0.62678117\",\n \"0.62661713\",\n \"0.6265614\",\n \"0.6246057\",\n \"0.62424415\",\n \"0.6224011\",\n \"0.6217169\",\n \"0.62135977\",\n \"0.6212648\",\n \"0.6210694\",\n \"0.6210686\",\n \"0.6190168\",\n \"0.6188331\",\n \"0.6186246\",\n \"0.6182705\",\n \"0.61825705\",\n \"0.618042\",\n \"0.6180062\",\n \"0.6166692\",\n \"0.6165042\",\n \"0.61641383\",\n \"0.6163883\",\n \"0.6160209\",\n \"0.6158296\",\n \"0.6156658\",\n \"0.61534345\",\n \"0.6149459\",\n \"0.614865\",\n \"0.6145494\",\n \"0.6144248\",\n \"0.61416745\",\n \"0.61372745\",\n \"0.6133433\",\n \"0.6128921\",\n \"0.6121655\",\n \"0.61158997\",\n \"0.61158645\",\n \"0.6114205\",\n \"0.61130464\",\n \"0.6100436\",\n \"0.60906315\",\n \"0.60790306\",\n \"0.6077845\",\n \"0.60769814\",\n \"0.60748595\",\n \"0.6073173\",\n \"0.6072115\",\n \"0.60692126\",\n \"0.60691017\",\n \"0.60675704\",\n \"0.6065843\",\n \"0.6057319\",\n \"0.6056832\",\n \"0.60556334\",\n \"0.60450244\",\n \"0.60438347\",\n \"0.6043658\",\n \"0.6037898\",\n \"0.60323536\",\n \"0.6032067\",\n \"0.6029602\",\n \"0.60275143\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":92,"numItemsPerPage":100,"numTotalItems":95772,"offset":9200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDM0OTcxNCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQzNTMzMTQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.NElp65NPp35ccduS74XyISXSIxypy2McvEkvgbKDDfGSJCXXi2qc4jAnXaJL_UbwCGiDR6PJcPXdyuMBbPprDQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Filled name (if applicable). | def nn_filled(self):
if self.parent in filled_variables:
return f"{self._nn_fill_root} {self.shift}M"
return self._nn_fill_root | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self, name):\n pass",
"def name():\n pass",
"def name():\n pass",
"def getName(self):\n return \"\"",
"def name_field(self):\r\n return 'name'",
"def test_name_empty_string(self):\r\n self.name = \"\"",
"def name(self) -> str: # pragma: no cover",... | [
"0.69951504",
"0.6751056",
"0.6751056",
"0.67024434",
"0.6659543",
"0.6640836",
"0.65940964",
"0.65553534",
"0.65237314",
"0.6510735",
"0.64991957",
"0.64991957",
"0.64991957",
"0.64991957",
"0.64991957",
"0.647957",
"0.647957",
"0.647957",
"0.647957",
"0.6468007",
"0.6453826... | 0.0 | -1 |
Sort variables based on their rank and shift. Note that this relies on all variables having a unique rank. | def sort_variables(variables):
return tuple(sorted(variables, key=lambda v: (v.rank, v.shift))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort(self, varnames):\n varnames = self._find_vars(varnames, unique=True, empty_ok=False)\n var_ind_list = list(map(self._varlist.index, varnames))\n new_srtlist = var_ind_list + [None]*(self._nvar - len(varnames))\n if self._srtlist == new_srtlist:\n return\n sort... | [
"0.6356814",
"0.59954023",
"0.5840146",
"0.57373804",
"0.5699405",
"0.56901157",
"0.5626263",
"0.5604119",
"0.55457306",
"0.55165404",
"0.55016434",
"0.5487663",
"0.5474271",
"0.5438897",
"0.5397592",
"0.5390707",
"0.53346616",
"0.5334493",
"0.53060263",
"0.5277838",
"0.51805... | 0.74932057 | 0 |
Given a set of criteria, find the matching variables(s). | def get_matching(variables, strict=True, single=True, **criteria):
matching = []
for var in variables:
for crit_name, crit_info in criteria.items():
if getattr(var, crit_name) == crit_info:
continue
else:
break
else:
matching.append(var)
if not matching and strict:
raise RuntimeError("No matching variables were found.")
if single:
if len(matching) > 1:
raise RuntimeError(
f"Expected to find 1 matching variable. Found '{matching}'."
)
if not matching:
return ()
return matching[0]
return tuple(matching) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_variables(md):\n\n # save as dictionaries with searchers as keys\n x_searchers = {}\n b_target = {}\n\n t_max = 0\n\n for var in md.getVars():\n my_var_name = var.varName\n my_var_value = var.x\n # print('%s %g' % (my_var_name, my_var_value))\n\n if 'x' in my_va... | [
"0.6416395",
"0.6279023",
"0.61213815",
"0.5955996",
"0.5882055",
"0.58465207",
"0.58342683",
"0.5712536",
"0.56871027",
"0.56653214",
"0.54515976",
"0.5413046",
"0.54008603",
"0.5400208",
"0.53811234",
"0.5380468",
"0.53650934",
"0.53530097",
"0.53530097",
"0.5344481",
"0.53... | 0.7268741 | 0 |
Match variable to VariableFactory using rank, name, and units. | def match_factory(variable, factories):
if not isinstance(factories, tuple):
factories = (factories,)
for factory in factories:
if (
variable.rank == factory.rank
and variable.name == factory.name
and variable.units == factory.units
):
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variable_factory(p, variable_name):\n if isinstance(variable_name, (Variable,)):\n return variable_name\n if not hasattr(p, \"variable_mapping\"):\n setattr(p, \"variable_mapping\", {})\n if variable_name not in p.variable_mapping:\n p.variable_mapping[variable_name] = Variable(va... | [
"0.6039259",
"0.5748577",
"0.5715186",
"0.56820124",
"0.56072986",
"0.5535535",
"0.55185264",
"0.53700167",
"0.5367385",
"0.536188",
"0.53586817",
"0.53523105",
"0.5274955",
"0.5252807",
"0.52485764",
"0.5248227",
"0.5243896",
"0.51856565",
"0.5179017",
"0.517816",
"0.5174382... | 0.6425409 | 0 |
Get the lags for a given VariableFactory. | def get_variable_lags(var_factory):
if var_factory in shifted_variables:
return lags
return (0,) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_shifted_variables(var_factory):\n shifted = []\n for lag in get_variable_lags(var_factory):\n shifted.append(var_factory[lag])\n return tuple(shifted)",
"def lag(self):\n self._assert_counted_at_lag()\n return self._lag",
"def create_predictors(y): # pragma: no cover\n ... | [
"0.67575127",
"0.5803747",
"0.5776367",
"0.54579306",
"0.54395133",
"0.5426974",
"0.53509307",
"0.53438425",
"0.5341233",
"0.52827334",
"0.5247959",
"0.5246997",
"0.5176305",
"0.50930464",
"0.5059406",
"0.50513554",
"0.5010745",
"0.4938749",
"0.4918975",
"0.49158582",
"0.4873... | 0.87622905 | 0 |
Get all possible shifted variables given a VariableFactory. | def get_shifted_variables(var_factory):
shifted = []
for lag in get_variable_lags(var_factory):
shifted.append(var_factory[lag])
return tuple(shifted) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_variable_lags(var_factory):\n if var_factory in shifted_variables:\n return lags\n return (0,)",
"def vars(self):\n return [Var(i,self.dims[i]) for i in range(self.nvar)] # TODO: use stored state info (=1 sometimes)",
"def get_all_variables(self):\n out = []\n for i in se... | [
"0.69359124",
"0.5861063",
"0.5553798",
"0.5553798",
"0.5553798",
"0.5403311",
"0.53172415",
"0.5283232",
"0.5274266",
"0.5179303",
"0.5173764",
"0.51522267",
"0.51142913",
"0.50858605",
"0.5057335",
"0.5056801",
"0.5049597",
"0.50440574",
"0.49971545",
"0.49796465",
"0.49775... | 0.8306546 | 0 |
Determina el vertice con mayor grado que no este coloreado ni pertenezca la lista de tabues. | def _max_vdegree_with_sdegree(self, semi_coloring, tabu_list=[]):
best_v = None
for v in self.vertices():
# comprobamos que el vertice no este coloreado y no pertenezca
# a tabu_list
if not semi_coloring[v] and not v in tabu_list:
if not best_v:
best_v = v
if self._vertex_degree[v] > self._vertex_degree[best_v]:
best_v = v
return best_v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vitoria_1(tab,jog):\r\n for i in range(1,4):\r\n win = [(0,jog,jog), (jog,0,jog), (jog,jog,0)]\r\n coluna = obter_coluna(tab, i)\r\n linha = obter_linha(tab, i) \r\n if coluna in win:\r\n return i+3*win.index(coluna)\r\... | [
"0.57876396",
"0.56284934",
"0.5594405",
"0.5568034",
"0.55080384",
"0.5484388",
"0.54362154",
"0.5413025",
"0.5407047",
"0.5402674",
"0.53891736",
"0.5375746",
"0.53344095",
"0.53134215",
"0.5284173",
"0.5273966",
"0.5259709",
"0.52496856",
"0.5219884",
"0.52110505",
"0.5200... | 0.5004707 | 42 |
Determina el minimo umbral kcromatico de TSC usando un metodo de coloracion secuencial que toma dos vertices en cada paso. | def ThresholdSpectrumColoring(self, k):
# inicializamos una coloracion y limpiamos la memoria
semi_coloring = self._new_coloring()
# reducimos el numero de colores del espectro a k
spectrum = self._spectrum[:k]
# vertices = self.vertices()
n_colored = 0
n_vertices = len(self.vertices())
while n_colored < n_vertices:
# tomamos el vertices con mayor grado entre los no visitados
vertex = self._max_vdegree_with_sdegree(semi_coloring)
self._vertex_order.append(vertex)
# tomamos el color con la menor potencial interferencia para el vertice
color = self._min_semi_interference(vertex, semi_coloring, spectrum)
# asignamos el color al vertice
semi_coloring[vertex] = color
n_colored+=1
# actualizamos los valores de las memorias
self._update_values(vertex, color, semi_coloring)
# tomamos el vertice de mayor grado no adyacente al que seleccionamos
# anteriormente, y en caso de que exista, repetimos el mismo proceso
fneighbour = self._max_vdegree_with_sdegree(semi_coloring, self._graph.neighbours(vertex))
if fneighbour is not None:
self._vertex_order.append(fneighbour)
color = self._min_semi_interference(fneighbour, semi_coloring, spectrum)
semi_coloring[fneighbour] = color
n_colored+=1
self._update_values(fneighbour, color, semi_coloring)
return self.threshold(semi_coloring), semi_coloring | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tabu_precoloring(*args):\r\n # get arguments\r\n G = args[0]\r\n n = G.nodes()\r\n m = G.arcs()\r\n \r\n # check if it a valid Graph\r\n if not G.is_correct_type('u'):\r\n print \"ERROR: the graph is not in one of the valid formats for tabu_coloring()\"\r\n return [], []\r\n ... | [
"0.5584136",
"0.55213815",
"0.551191",
"0.549267",
"0.546483",
"0.5403701",
"0.53459257",
"0.5344636",
"0.5285508",
"0.52787477",
"0.5213398",
"0.5209369",
"0.5208083",
"0.5198757",
"0.5198398",
"0.5157316",
"0.5147865",
"0.5131297",
"0.5127294",
"0.51265067",
"0.5125503",
... | 0.53559506 | 6 |
Returns the path to our major ldso symlink. (Which allows us to change which ldso we are actively using without patching a bunch of binaries) | def ld_linux_path(root):
return os.path.join(root, 'lib', 'ld-linux-xpkg.so') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_ld_version():\n if sys.platform == 'darwin':\n return _find_exe_version('ld -v', _MAC_OS_X_LD_VERSION)\n else:\n return _find_exe_version('ld -v')",
"def get_linked_libpython():\n if is_windows():\n return\n libdl = ctypes.CDLL(ctypes.util.find_library(\"dl\"))\n lib... | [
"0.66215503",
"0.6279569",
"0.5894043",
"0.5856724",
"0.5856588",
"0.5700655",
"0.56694955",
"0.55614096",
"0.5547654",
"0.55200994",
"0.5495592",
"0.54438263",
"0.5425426",
"0.5324425",
"0.5300233",
"0.5298378",
"0.52957606",
"0.5281993",
"0.52785194",
"0.5256666",
"0.525556... | 0.6632493 | 0 |
If the x,y equal, we assume that the both Nodes are same | def equal(self,other):
if(self.x == other.x) and (self.y == other.y):
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_same_as(self, other) -> bool:\n return self.x == other.x and self.y == other.y",
"def compareNodes(x, y):\n return x.pathValue - y.pathValue",
"def __eq__(self, other):\n return self.x == other.x and self.y == other.y",
"def __eq__(self, second):\r\n\t\treturn self.x == other.x and se... | [
"0.7050482",
"0.70344174",
"0.69647264",
"0.693082",
"0.69281536",
"0.68705666",
"0.68475515",
"0.68315655",
"0.67769325",
"0.67707807",
"0.67489284",
"0.67242",
"0.67242",
"0.6677688",
"0.6663041",
"0.6656221",
"0.6656221",
"0.6656221",
"0.6656221",
"0.6656221",
"0.66506815"... | 0.69610524 | 3 |
For each node, the cost of getting from the start node to that node. | def create_gScore(width,height):
gScore = [[np.inf for i in range(width)] for i in range(height)]
return gScore | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost(self):\n node, path_back = self, []\n cost = 0\n while node:\n path_back.append(node)\n if node.action is not None:\n cost = cost + node.action.cost\n node = node.parent\n # remove one due to root empty node \n #cost = c... | [
"0.7186682",
"0.70747066",
"0.676554",
"0.65974796",
"0.6534421",
"0.6378079",
"0.6378079",
"0.631064",
"0.6299445",
"0.6267691",
"0.6214393",
"0.6190077",
"0.6176873",
"0.61578125",
"0.61578125",
"0.61578125",
"0.6116098",
"0.60726243",
"0.6060423",
"0.60556203",
"0.6041697"... | 0.0 | -1 |
For each node, the cost of getting from the start node to that node. | def create_fScore(width,height):
fScore = [[np.inf for i in range(width)] for i in range(height)]
return fScore | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost(self):\n node, path_back = self, []\n cost = 0\n while node:\n path_back.append(node)\n if node.action is not None:\n cost = cost + node.action.cost\n node = node.parent\n # remove one due to root empty node \n #cost = c... | [
"0.7186859",
"0.70753443",
"0.6766204",
"0.6596982",
"0.65339065",
"0.63787216",
"0.63787216",
"0.63113326",
"0.63002783",
"0.6268371",
"0.6213697",
"0.6189538",
"0.6177489",
"0.6158397",
"0.6158397",
"0.6158397",
"0.611681",
"0.6072511",
"0.60598373",
"0.6056283",
"0.6042592... | 0.0 | -1 |
Diagonal distance h_diagonal(n) = min(abs(n.x goal.x), abs(n.y goal.y)) h_straight(n) = (abs(n.x goal.x) + abs(n.y goal.y)) h(n) = D_diagnoal h_diagonal(n) + D_straight (h_straight(n) 2h_diagonal(n))) | def heuristic_cost_estimate(start, goal,d_diagnoal,d_straight):
start_x = start.x
start_y = start.y
goal_x = goal.x
goal_y = goal.y
h_diagonal = min(np.abs(start_x - goal_x),np.abs(start_y - goal_y))
h_straight = np.abs(start_x - goal_x) + np.abs(start_y - goal_y)
h = d_diagnoal * h_diagonal + d_straight * (h_straight - 2 * h_diagonal)
return h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dist_between(current, neighbor,d_diagnoal,d_straight):\n start_x = current.x\n start_y = current.y\n goal_x = neighbor.x\n goal_y = neighbor.y\n\n h_diagonal = min(np.abs(start_x - goal_x),np.abs(start_y - goal_y))\n h_straight = np.abs(start_x - goal_x) + np.abs(start_y - goal_y)\n h = d_... | [
"0.8049952",
"0.6934964",
"0.69334024",
"0.6747959",
"0.644159",
"0.62714773",
"0.6160783",
"0.6144977",
"0.6144977",
"0.61420053",
"0.6101649",
"0.6096123",
"0.60647726",
"0.6007809",
"0.59770143",
"0.5892348",
"0.5882317",
"0.5860657",
"0.5833256",
"0.58259183",
"0.57475424... | 0.7815696 | 1 |
Diagonal distance h_diagonal(n) = min(abs(n.x goal.x), abs(n.y goal.y)) h_straight(n) = (abs(n.x goal.x) + abs(n.y goal.y)) h(n) = D_diagnoal h_diagonal(n) + D_straight (h_straight(n) 2h_diagonal(n))) | def dist_between(current, neighbor,d_diagnoal,d_straight):
start_x = current.x
start_y = current.y
goal_x = neighbor.x
goal_y = neighbor.y
h_diagonal = min(np.abs(start_x - goal_x),np.abs(start_y - goal_y))
h_straight = np.abs(start_x - goal_x) + np.abs(start_y - goal_y)
h = d_diagnoal * h_diagonal + d_straight * (h_straight - 2 * h_diagonal)
return h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heuristic_cost_estimate(start, goal,d_diagnoal,d_straight):\n start_x = start.x\n start_y = start.y\n goal_x = goal.x\n goal_y = goal.y\n\n h_diagonal = min(np.abs(start_x - goal_x),np.abs(start_y - goal_y))\n h_straight = np.abs(start_x - goal_x) + np.abs(start_y - goal_y)\n h = d_diagnoa... | [
"0.7815963",
"0.6935118",
"0.69333106",
"0.6748271",
"0.6441967",
"0.6272037",
"0.616098",
"0.614516",
"0.614516",
"0.6142244",
"0.61005026",
"0.6096975",
"0.60649806",
"0.60074985",
"0.59759593",
"0.58921903",
"0.5882251",
"0.58594304",
"0.58325016",
"0.5826039",
"0.57475173... | 0.80509466 | 0 |
Get neighbors of current node | def getNeighbors(current,width,height):
x = current.x
y = current.y
neighbors = np.array([[x],[y]])
if (x - 1) >= 0:
t = np.array([[x - 1], [y]])
neighbors = np.hstack((neighbors, t))
if (y - 1) >= 0:
t = np.array([[x - 1], [y - 1]])
neighbors = np.hstack((neighbors,t))
if (y + 1) < width:
t = np.array([[x - 1], [y + 1]])
neighbors = np.hstack((neighbors,t))
if (y - 1) >= 0:
t = np.array([[x], [y - 1]])
neighbors = np.hstack((neighbors, t))
if (y + 1) < width:
t = np.array([[x], [y + 1]])
neighbors = np.hstack((neighbors, t))
if (x + 1) < height:
t = np.array([[x + 1], [y]])
neighbors = np.hstack((neighbors, t))
if (y - 1) >= 0:
t = np.array([[x + 1], [y - 1]])
neighbors = np.hstack((neighbors,t))
if (y + 1) < width:
t = np.array([[x + 1], [y + 1]])
neighbors = np.hstack((neighbors,t))
neighbors = neighbors[:,1:]
return neighbors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def neighbors(self, node):\r\n return list(self.graph.neighbors(node))",
"def get_neighbors(self):\n return self.neighbors",
"def get_neighbors(self):\n return self.neighbors",
"def get_neighbors(self):\n return self.neighbors",
"def get_neighbors(self):\n return self.nei... | [
"0.82076806",
"0.81595117",
"0.81595117",
"0.81595117",
"0.81595117",
"0.81556916",
"0.81038094",
"0.8046027",
"0.80142957",
"0.79389143",
"0.7928019",
"0.7904153",
"0.78723794",
"0.7864975",
"0.78584856",
"0.7812342",
"0.78112066",
"0.77656096",
"0.77593744",
"0.772959",
"0.... | 0.66926175 | 100 |
Get path of A | def reconstruct_path(cameFrom, current):
total_path = np.array([[current.x],[current.y]])
while current_in_cameFrom(current,cameFrom):
current = current.father
node_x = current.x
node_y = current.y
node_pos = np.array([[node_x],[node_y]])
total_path = np.hstack((total_path,node_pos))
l1 = total_path[0,:]
l1 = l1[::-1]
l2 = total_path[1,:]
l2 = l2[::-1]
total_path = np.vstack((l1,l2))
return total_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPath(obj):",
"def get_path(self):\n return self.path",
"def _get_as_path(self):\n return self.__as_path",
"def __get_path(self):\n return self.path",
"def path(self) -> Path:\n return self[0]",
"def get_path(self):\n return self.path",
"def __path(self):\n if se... | [
"0.7251213",
"0.6919148",
"0.6838147",
"0.68078834",
"0.6688719",
"0.66773564",
"0.6611869",
"0.65055686",
"0.6474741",
"0.64676434",
"0.6441411",
"0.6440321",
"0.6404309",
"0.6396458",
"0.6394175",
"0.6383371",
"0.63829833",
"0.6375241",
"0.6375075",
"0.63631576",
"0.6362070... | 0.0 | -1 |
convert the path in real to grid, e.g. 21 > 2.15 sx= ix reso + reso/2 | def convertGridPathToReal(pathInGrid, sx, sy, gx, gy, grid_reso = 0.1):
pathInReal = (pathInGrid * grid_reso + grid_reso / 2)
stepNum = pathInReal.shape[1]
# Replace head and tail
pathInReal[:, 0] = [sx, sy]
pathInReal[:, 0] = [sx, sy]
pathInReal[:, stepNum - 1] = [gx, gy]
pathInReal[:, stepNum - 1] = [gx, gy]
return pathInReal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fifteen():\r\n\r\n currentcell = 1.0\r\n cellpaths = 2.0\r\n \r\n while currentcell < 20.0:\r\n currentcell += 1.0\r\n cellpaths = cellpaths * (4.0 - 2.0/currentcell)\r\n \r\n return cellpaths",
"def gen_grids(self):\n self.dx = self.grid_width / self.grid_resol\n ... | [
"0.5953606",
"0.5806127",
"0.57640606",
"0.5755406",
"0.57439196",
"0.5740067",
"0.5653222",
"0.5591101",
"0.55833936",
"0.5580926",
"0.5577852",
"0.5570575",
"0.5565106",
"0.55632424",
"0.5562481",
"0.5536194",
"0.55283296",
"0.5520637",
"0.5520081",
"0.5514781",
"0.55122167... | 0.7544195 | 0 |
A algorithm A square 6m x 3m region | def aStar(sx = 1.55, sy = 2.05, gx = 1.55, gy = 4.05, d_diagnoal = 14, d_straight = 10, grid_reso = 0.1, grid_width = 6, grid_height = 3):
width = int(grid_width/grid_reso)
height = int(grid_height/grid_reso)
#TODO
A_sx, A_sy = realPosTogridPos(sx, sy, grid_reso = grid_reso)
A_gx, A_gy = realPosTogridPos(gx, gy, grid_reso = grid_reso)
startNode = Node(A_sx,A_sy,None,0,0,0)
goalNode = Node(A_gx,A_gy,None,0,0,0)
# The set of nodes already evaluated
closedSet = set()
# The set of currently discovered nodes that are not evaluated yet.
openSet = set()
# Initially, only the start node is known.
openSet.add(startNode)
# For each node, which node it can most efficiently be reached from.If a node can be reached from many nodes, cameFrom will eventually contain the most efficient previous step.
cameFrom = []
# For each node, the cost of getting from the start node to that node.
gScore = create_gScore(width, height)
start_x = startNode.x
start_y = startNode.y
# The cost of going from start to start is zero.
startNode.g_value = 0
gScore[start_x][start_y] = 0
# For each node, the total cost of getting from the start node to the goal by passing by that node. That value is partly known, partly heuristic.
fScore = create_fScore(width, height)
# For the first node, that value is completely heuristic.
startNode.f_value = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)
fScore[start_x][start_y] = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)
while len(openSet) != 0:
# current := the node in openSet having the lowest fScore[] value
current = node_lowest_fScore(openSet)
# If it is the item we want, retrace the path and return it
if current.equal(goalNode):
path = reconstruct_path(cameFrom, current) # path in real
# print "path",path
pathInReal = convertGridPathToReal(path, sx, sy, gx, gy, grid_reso = grid_reso) # path in grid
return pathInReal
openSet.remove(current)
closedSet.add(current)
current_neighbors = getNeighbors(current, width, height)
current_neighbors_num = current_neighbors.shape[1]
# for neighbor in current_neighbors:
for index in range(current_neighbors_num):
[neighbor_x,neighbor_y] = current_neighbors[:,index]
neighbor = Node(neighbor_x,neighbor_y,None,np.inf,np.inf,np.inf)
if neighbor_in_closedSet(neighbor,closedSet):
continue
if neighbor_not_in_openSet(neighbor,openSet): # Discover a new node
openSet.add(neighbor)
# The distance from start to a neighbor the "dist_between" function may vary as per the solution requirements.
current_x = current.x
current_y = current.y
tentative_gScore = gScore[current_x][current_y] + dist_between(current, neighbor,d_diagnoal,d_straight)
neighbor_x = neighbor.x
neighbor_y = neighbor.y
if tentative_gScore >= gScore[neighbor_x][neighbor_y]:
continue # This is not a better path.
neighbor.father = current
cameFrom.append(neighbor)
gScore[neighbor_x][neighbor_y] = tentative_gScore
neighbor.g_value = tentative_gScore
neighbor_f_value = gScore[neighbor_x][neighbor_y] + heuristic_cost_estimate(neighbor, goalNode,d_diagnoal,d_straight)
fScore[neighbor_x][neighbor_y] = neighbor_f_value
neighbor.f_value = neighbor_f_value
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phantom_squares(n_points,S):\n \n #Rescaling according to image size \n S[:,0] = S[:,0]*n_points/2\n S[:,1] = S[:,1]*n_points/2\n S[:,2] = S[:,2]*n_points/2\n S[:,3] = S[:,3]*math.pi/180\n \n x,y = np.meshgrid(np.arange(0,n_points)-n_points//2 ,np.arange(0,n_points)-n_points//2 ) \n ... | [
"0.6708951",
"0.6398944",
"0.62836295",
"0.6229607",
"0.6192689",
"0.6141865",
"0.6077024",
"0.6006059",
"0.5976849",
"0.597339",
"0.59075284",
"0.58768487",
"0.5871641",
"0.5842441",
"0.58300805",
"0.5829569",
"0.5814981",
"0.5807813",
"0.5806518",
"0.5789432",
"0.5779059",
... | 0.0 | -1 |
One dimensional power law model function | def evaluate(x, amplitude, x_0, alpha):
xx = x / x_0
return amplitude * xx ** (-alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __pow__(self,power):\n return Factor().__build( VarSet(self.v) , np.power(self.t,power) )",
"def powerlaw(E,alpha,A):\n\n\treturn A*E**alpha",
"def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)",
"def f_mw(f):\n re... | [
"0.6872667",
"0.6868249",
"0.64523995",
"0.639687",
"0.62560534",
"0.62294555",
"0.6126374",
"0.6074723",
"0.6066187",
"0.6004509",
"0.5986175",
"0.5976839",
"0.5966759",
"0.59441537",
"0.5944057",
"0.5937536",
"0.5917039",
"0.5900731",
"0.58842295",
"0.5877201",
"0.5864981",... | 0.0 | -1 |
One dimensional power law derivative with respect to parameters | def fit_deriv(x, amplitude, x_0, alpha):
xx = x / x_0
d_amplitude = xx ** (-alpha)
d_x_0 = amplitude * alpha * d_amplitude / x_0
d_alpha = -amplitude * d_amplitude * np.log(xx)
return [d_amplitude, d_x_0, d_alpha] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dgdy(self, X):\n \n return 3*X[1]**2",
"def dV(X):\n return -4 * a * np.power(X, 3) + 2 * b * X",
"def derivatives(x_p, y_p):\r\n # set up the matrix equation\r\n n = x_p.shape[0]\r\n M = np.zeros( [n,n] )\r\n d = np.zeros( [n,1] )\r\n \r\n # fill in the constants where t... | [
"0.6734102",
"0.65710866",
"0.64798695",
"0.6456969",
"0.64338213",
"0.64268124",
"0.63887954",
"0.63887954",
"0.634643",
"0.63460815",
"0.6338571",
"0.63372827",
"0.6308936",
"0.63080084",
"0.6305035",
"0.6289483",
"0.62714446",
"0.62588847",
"0.62584984",
"0.6250596",
"0.62... | 0.6106129 | 44 |
One dimensional broken power law model function | def evaluate(x, amplitude, x_break, alpha_1, alpha_2):
alpha = np.where(x < x_break, alpha_1, alpha_2)
xx = x / x_break
return amplitude * xx ** (-alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def powerlaw(E,alpha,A):\n\n\treturn A*E**alpha",
"def __pow__(self,power):\n return Factor().__build( VarSet(self.v) , np.power(self.t,power) )",
"def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)",
"def ForceFitPowerlaw... | [
"0.6540572",
"0.64533246",
"0.62271285",
"0.6183615",
"0.6153722",
"0.6143716",
"0.6098002",
"0.6049835",
"0.6040145",
"0.6030009",
"0.6010443",
"0.59917516",
"0.5971195",
"0.5968484",
"0.59673804",
"0.59626305",
"0.5958735",
"0.59169805",
"0.5871685",
"0.5862314",
"0.5814751... | 0.0 | -1 |
One dimensional broken power law derivative with respect to parameters | def fit_deriv(x, amplitude, x_break, alpha_1, alpha_2):
alpha = np.where(x < x_break, alpha_1, alpha_2)
xx = x / x_break
d_amplitude = xx ** (-alpha)
d_x_break = amplitude * alpha * d_amplitude / x_break
d_alpha = -amplitude * d_amplitude * np.log(xx)
d_alpha_1 = np.where(x < x_break, d_alpha, 0)
d_alpha_2 = np.where(x >= x_break, d_alpha, 0)
return [d_amplitude, d_x_break, d_alpha_1, d_alpha_2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dgdy(self, X):\n \n return 3*X[1]**2",
"def derivativeW(self, *args):\n if self.n_dims >= 4:\n j = 0\n else:\n assert (\n False\n ), \"Derivative with respect to W can't be called when n_dims < 4!\"\n if self.i_dim == j:\n ... | [
"0.6551897",
"0.646485",
"0.64178663",
"0.64106286",
"0.6382745",
"0.6354045",
"0.63523704",
"0.6345646",
"0.6331496",
"0.63267994",
"0.6326617",
"0.63140196",
"0.63140196",
"0.6313484",
"0.6305103",
"0.6294662",
"0.6289381",
"0.6286769",
"0.6270342",
"0.62632966",
"0.6260843... | 0.0 | -1 |
One dimensional exponential cutoff power law model function | def evaluate(x, amplitude, x_0, alpha, x_cutoff):
xx = x / x_0
return amplitude * xx ** (-alpha) * np.exp(-x / x_cutoff) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def powerlaw(E,alpha,A):\n\n\treturn A*E**alpha",
"def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)",
"def dd_xpowalpha(cls,grid,alpha,cutoff=False):\n grid.l.info('bc.hom: Setting initial data to (-x)^alpha.')\n ... | [
"0.6795391",
"0.66082",
"0.6514522",
"0.6512951",
"0.6474245",
"0.63665336",
"0.6313782",
"0.62870765",
"0.628231",
"0.62377995",
"0.6200624",
"0.614855",
"0.6140678",
"0.6140613",
"0.61380404",
"0.61372375",
"0.61360735",
"0.6134497",
"0.6130171",
"0.6122109",
"0.61198056",
... | 0.6441985 | 5 |
One dimensional exponential cutoff power law derivative with respect to parameters | def fit_deriv(x, amplitude, x_0, alpha, x_cutoff):
xx = x / x_0
xc = x / x_cutoff
d_amplitude = xx ** (-alpha) * np.exp(-xc)
d_x_0 = alpha * amplitude * d_amplitude / x_0
d_alpha = -amplitude * d_amplitude * np.log(xx)
d_x_cutoff = amplitude * x * d_amplitude / x_cutoff ** 2
return [d_amplitude, d_x_0, d_alpha, d_x_cutoff] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)",
"def exponential(self, data=[], init_lambdas=[1,0.75], max_iteration=500):\r\n xaxis = np.arange(1, len(data)+1)\r\n data = np.array(data)\r\n idx = 1\r\n ... | [
"0.6435805",
"0.641947",
"0.63531476",
"0.6331413",
"0.6303507",
"0.6297258",
"0.62600297",
"0.62595487",
"0.6257403",
"0.6225996",
"0.619326",
"0.6160021",
"0.6141522",
"0.61281365",
"0.6099849",
"0.6092616",
"0.6091917",
"0.6058767",
"0.6058701",
"0.6036378",
"0.60332775",
... | 0.6778236 | 0 |
One dimensional log parabola model function | def evaluate(x, amplitude, x_0, alpha, beta):
xx = x / x_0
exponent = -alpha - beta * np.log(xx)
return amplitude * xx ** exponent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])",
"def _perplexity(self, X, log_w):\n return np.exp(-log_w/X.sum())",
"def nlogl... | [
"0.68354905",
"0.68036896",
"0.67386776",
"0.66810524",
"0.6678433",
"0.6672779",
"0.6672465",
"0.66694707",
"0.6639666",
"0.6583274",
"0.6557876",
"0.6509242",
"0.6490352",
"0.6488276",
"0.645247",
"0.6448294",
"0.6431051",
"0.6431051",
"0.64194",
"0.640911",
"0.64002174",
... | 0.0 | -1 |
One dimensional log parabola derivative with respect to parameters | def fit_deriv(x, amplitude, x_0, alpha, beta):
xx = x / x_0
log_xx = np.log(xx)
exponent = -alpha - beta * log_xx
d_amplitude = xx ** exponent
d_beta = -amplitude * d_amplitude * log_xx ** 2
d_x_0 = amplitude * d_amplitude * (beta * log_xx / x_0 - exponent / x_0)
d_alpha = -amplitude * d_amplitude * log_xx
return [d_amplitude, d_x_0, d_alpha, d_beta] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MvNormalLogp():\n cov = pt.matrix(\"cov\")\n cov.tag.test_value = floatX(np.eye(3))\n delta = pt.matrix(\"delta\")\n delta.tag.test_value = floatX(np.zeros((2, 3)))\n\n cholesky = Cholesky(lower=True, on_error=\"nan\")\n\n n, k = delta.shape\n n, k = f(n), f(k)\n chol_cov = cholesky(cov... | [
"0.69615203",
"0.6887294",
"0.6852058",
"0.6715104",
"0.6654081",
"0.66425574",
"0.66307074",
"0.6591338",
"0.6572366",
"0.65332234",
"0.65331346",
"0.65201646",
"0.65035284",
"0.64703155",
"0.6436214",
"0.6433464",
"0.64074075",
"0.6404806",
"0.6395806",
"0.6379538",
"0.6374... | 0.5986274 | 84 |
Generate strong password to add to csv file and clipboard. | def generate_pw():
chars = string.ascii_letters + string.digits + '!@#$%^&*()'
password = ''.join(random.choice(chars) for i in range(16))
pyperclip.copy(password)
print('Password copied to clipboard.')
return password | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def password_generate_strong(self, ctx, delimeter: str = \"\"):\n d = delimeter\n rc = random.choice\n rr = random.randint\n await ctx.send(\n d.join(rc(RANDOM_WORDS).capitalize() for i in range(3)) + f\"{d}{rr(1,1000)}\"\n )",
"def giveReadablePassword():\n ... | [
"0.6699509",
"0.66523397",
"0.66337395",
"0.65883833",
"0.6544499",
"0.651341",
"0.64864033",
"0.6481383",
"0.64227664",
"0.63991195",
"0.63651586",
"0.63424796",
"0.6329188",
"0.6299538",
"0.62843406",
"0.6273658",
"0.62399065",
"0.6230091",
"0.6219999",
"0.6194473",
"0.6178... | 0.7241065 | 0 |
Add new account to pw.csv and generate a strong password. | def main(script):
try:
# ensure user entered account name and user name
account_name = sys.argv[1]
user_name = sys.argv[2]
except IndexError:
print('python add_pw.py [account name] [user name]')
else:
# read in csv file
pw_file = open('pw.csv')
pw_object = csv.reader(pw_file)
# ensure account does not already exist in pw.csv
for row in pw_object:
if row[0] == account_name:
print('Account already exists.')
break
# append account name, user name, and password generated by function
else:
with open('pw.csv', 'a', newline='') as csvfile:
writer = csv.writer(csvfile)
password = generate_pw()
writer.writerow([account_name, user_name, password]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_password():\n new_pass = generate_password()\n entry_pass.delete(0, END)\n entry_pass.insert(0, new_pass)",
"def add_user(self, user, pw):\n self.db.execute(\"INSERT INTO user_credentials VALUES (?, ?)\", [user, pw])\n self.db.commit()",
"def save_password(self, new_password):\n... | [
"0.68463534",
"0.6339493",
"0.6226887",
"0.6119043",
"0.6009385",
"0.59483135",
"0.58453876",
"0.5821747",
"0.5782089",
"0.5744898",
"0.5735216",
"0.57338196",
"0.573278",
"0.57301116",
"0.5707284",
"0.5689022",
"0.5674017",
"0.5670386",
"0.56640315",
"0.56365216",
"0.5633996... | 0.6759446 | 1 |
'o' contains a single object ['b','yttywetywe'] | def to_server(self, o):
assert type(o) == str
# add to queue
self.toserverqueue.put(o, block=False)
# send now, if appropriate
if self.buffer_tx==False:
self.periodicTimer.fireNow() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def object_here(obj=None): #py:object_here\n if obj is not None:\n ans = RUR._object_here_(obj)\n else:\n ans = RUR._object_here_()\n return list(ans) # convert from JS list-like object to proper Python list",
"def iterencode(self, o):\n if self.check_circular:\n marker... | [
"0.56176996",
"0.5485273",
"0.5438254",
"0.54378515",
"0.54331356",
"0.5427594",
"0.5410083",
"0.5350562",
"0.53243625",
"0.5319603",
"0.5232624",
"0.52030325",
"0.51990336",
"0.5178645",
"0.51718277",
"0.51699454",
"0.515686",
"0.51475954",
"0.51456654",
"0.514488",
"0.51199... | 0.0 | -1 |
Send one HTTP POST request to server to (1) send the elements from toserverqueue to the server (2) receive the objects from the server and rearm. | def _poll_server(self, o=None):
# send objects
try:
# create HTTP body
body = {
'id': self.id,
'token': self.token,
'ttl': self.polling_period+3,
}
# objects
o = []
while True:
try:
e = self.toserverqueue.get(block=False)
except Queue.Empty:
break
else:
o += [e]
if o:
body['o'] = o
# send to server
r = requests.post(
self.server_url,
json = body,
).json()
r = convertToString(r)
except requests.exceptions.ConnectionError as err:
self._set_is_connected(False)
logger.error(err)
except Exception as err:
self._set_is_connected(False)
logger.error(err)
else:
self._set_is_connected(True)
if r['o']:
self.from_server_cb(r['o']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _client(self):\n while True:\n body = self.queue.get(True)\n print \"Sending %s bytes (%s/%s)\" % (len(body), self.queue.qsize(), self.queue.maxsize)\n\n try:\n req = urllib2.Request(self.endpoint, body)\n urllib2.urlopen(req).read()\n ... | [
"0.63026744",
"0.6272743",
"0.62231123",
"0.61339027",
"0.6106243",
"0.6011678",
"0.59978294",
"0.5916277",
"0.588042",
"0.5807718",
"0.5794925",
"0.57784057",
"0.5756853",
"0.57314724",
"0.570634",
"0.5697248",
"0.5667771",
"0.56608444",
"0.56563604",
"0.56539094",
"0.562724... | 0.59547377 | 7 |
This function just responds to the browser ULR | def home():
return render_template('index.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def webinterface(self):\n raise cherrypy.HTTPRedirect(self.url('', True))",
"def lro_handling(self) -> global___Snippet.LroResponseHandling:",
"def respond(self, resp):\n self.push(resp + '\\r\\n')\n self.logline('==> %s' % resp)",
"def browser_iface():\n return 'Nothing to see here'"... | [
"0.5769322",
"0.576179",
"0.5676339",
"0.5662295",
"0.5662295",
"0.55862385",
"0.5506965",
"0.5477685",
"0.54589474",
"0.5399092",
"0.5390287",
"0.5390287",
"0.5381453",
"0.53710353",
"0.536323",
"0.5349364",
"0.53294426",
"0.53231996",
"0.5295247",
"0.5248364",
"0.52426815",... | 0.0 | -1 |
Add Site Static Resource Directory | def addMobileStaticResourceDir(self, dir: str) -> None:
self.__rootMobileResource.addFileSystemRoot(dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_dirs_to_static(static_webapp_name):\n static_dir = '$HOME/webapps/%s' % static_webapp_name\n with settings(warn_only=True):\n with cd(static_dir):\n run(\"mkdir static && mkdir media\")\n run(\"rm index.html\")\n run(\"touch index.html\")\n with cd(code_... | [
"0.71481174",
"0.6910498",
"0.66968936",
"0.66562533",
"0.66559666",
"0.65018547",
"0.64497256",
"0.6352136",
"0.6325666",
"0.6246173",
"0.6058434",
"0.6023625",
"0.5898131",
"0.5875398",
"0.58405364",
"0.5814434",
"0.5805225",
"0.57971865",
"0.5774547",
"0.57634854",
"0.5763... | 0.7166486 | 0 |
Add Site Resource Add a cusotom implementation of a served http resource. | def addMobileResource(self, pluginSubPath: bytes, resource: BasicResource) -> None:
pluginSubPath = pluginSubPath.strip(b'/')
self.__rootMobileResource.putChild(pluginSubPath, resource) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_site():\n log = current_app.log\n db = request.db\n Site = db.tables.Site\n Endpoint = db.tables.Endpoint\n site_data = {}\n endpoints = []\n try:\n if not request.data:\n return \"Missing POST data\", 400\n raw_site_data... | [
"0.6253832",
"0.62042636",
"0.62019485",
"0.59963995",
"0.5816037",
"0.5807638",
"0.5796633",
"0.5752867",
"0.5738871",
"0.5671778",
"0.56447417",
"0.5639989",
"0.5624698",
"0.55881715",
"0.55655074",
"0.5461416",
"0.54530823",
"0.54488623",
"0.5432111",
"0.53743726",
"0.5350... | 0.52065897 | 28 |
Site Root Resource This returns the root site resource for this plugin. | def rootMobileResource(self) -> BasicResource:
return self.__rootMobileResource | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def root(self):\n return Resource()",
"def get_root(self, *args, **kwargs):\n return self._resources_manager.get_root(*args, **kwargs)",
"def site(self):\n if not hasattr(self, '_site'):\n urltool = getToolByName(self.req.PARENTS[0], 'portal_url', None)\n if urltool i... | [
"0.7128751",
"0.6892363",
"0.678429",
"0.65742475",
"0.6537863",
"0.6498057",
"0.64581287",
"0.64400375",
"0.6385263",
"0.62711334",
"0.6235817",
"0.6215665",
"0.6187106",
"0.61689866",
"0.6154504",
"0.61263305",
"0.6093571",
"0.6084454",
"0.6069759",
"0.6053258",
"0.6003061"... | 0.67585224 | 3 |
Provides either a random DidYouKnow fact from wiki or else any number of specific DYKs. | async def dyk(self, ctx, *nums: int):
nums = nums or [random.randint(0, wiki_dyk.count - 1)]
em = discord.Embed(title='Did you know...\n', description='', color=0xffffff)
for item in ((n-1) % wiki_dyk.count if n else wiki_dyk.count - 1 for n in nums):
em.description += f'**#{item + 1}:** {wiki_dyk.trivia[item]}\n'
await ctx.send(embed=em) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randomHelmet():\n return random.choice(HELMETS)",
"def get_random_fact(url):\n facts = get_webpage(url)\n return facts[random.randint(0, len(facts))]",
"async def dogfact(self, ctx: DogbotContext):\n await ctx.send(random.choice(self.dogfacts))",
"def get_fortune():\n data_file = get_dat... | [
"0.6159103",
"0.595592",
"0.5825193",
"0.5651778",
"0.55767024",
"0.55524427",
"0.5543401",
"0.5500759",
"0.5500759",
"0.5500759",
"0.54952174",
"0.54726946",
"0.54506487",
"0.5439445",
"0.5428501",
"0.54166263",
"0.53925294",
"0.53677875",
"0.53525066",
"0.53501534",
"0.5328... | 0.5818779 | 3 |
Return the default logger for the module. | def logger():
return logging.getLogger(__name__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _logger():\n return logging.getLogger(module_name)",
"def get_module_logger():\n return logging.getLogger(__name__)",
"def get_logger():\n return logging.getLogger(__name__)",
"def getLogger():\n return GlobalLogger.logger",
"def _get_logger():\n return logging.Logger(__name__)",... | [
"0.8332255",
"0.8202088",
"0.8047881",
"0.7980913",
"0.7945653",
"0.78576833",
"0.7827138",
"0.7816803",
"0.77877396",
"0.7782513",
"0.77736753",
"0.77449965",
"0.77242976",
"0.7719314",
"0.76511186",
"0.76373756",
"0.76299536",
"0.7607513",
"0.75435734",
"0.75402004",
"0.753... | 0.7916416 | 5 |
Proxy for subprocess.call with logging. | def call(cmd, *args, **kwargs):
import subprocess
logger().info('call `%s`', ' '.join(cmd))
return subprocess.call(cmd, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _subprocess_call(*args, **kwargs):\n return subprocess.call(*args, **kwargs)",
"def call_subprocess_with_logging(command, my_env=None):\n logger.info(\"About to call : {0}\".format(command))\n return_code = 0\n try:\n if my_env:\n return_out = subprocess.check_output(command, st... | [
"0.70570767",
"0.64355564",
"0.6330634",
"0.63057506",
"0.62618166",
"0.6218107",
"0.61542827",
"0.6139648",
"0.60723656",
"0.6049053",
"0.6030424",
"0.60250443",
"0.6003652",
"0.597314",
"0.59305435",
"0.5910463",
"0.5904408",
"0.58928114",
"0.5857994",
"0.58190536",
"0.5814... | 0.6278796 | 4 |
Sets up a rate law following the HenriMichaelisMenten law. v = k_cat protein substrate / (k_m + substrate) | def MichaelisMentenKCat(
substrate: str,
protein: str,
enzmldoc,
k_cat: Dict[str, Any] = {"ontology": SBOTerm.K_CAT},
k_m: Dict[str, Any] = {"ontology": SBOTerm.K_M},
):
# Check if the given IDs are part of the EnzymeML document already
if substrate not in enzmldoc.getSpeciesIDs():
raise SpeciesNotFoundError(
species_id=substrate, enzymeml_part="Reactants/Proteins"
)
if protein not in enzmldoc.getSpeciesIDs():
raise SpeciesNotFoundError(
species_id=protein, enzymeml_part="Reactants/Proteins"
)
# Check if ontologies are added, if not add them
if k_m.get("ontology") is None:
k_m["ontology"] = SBOTerm.K_M
if k_cat.get("ontology") is None:
k_cat["ontology"] = SBOTerm.K_CAT
# Create the model using a factory
model = ModelFactory(
name="Michaelis-Menten Rate Law",
equation="k_cat * protein * substrate / (k_m + substrate)",
k_cat=k_cat,
k_m=k_m,
ontology=SBOTerm.MICHAELIS_MENTEN,
)
return model(protein=protein, substrate=substrate) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def birch_murnaghan(p, v):\n return p[0]+9.0/16*p[3]*p[1]*( ( (p[3]/v)**(2.0/3)-1 )**3*p[2]+\n ( (p[3]/v)**(2.0/3)-1 )**2*\n ( 6-4*(p[3]/v)**(2.0/3) ) )",
"def murnaghan(p, v):\n return p[0]+p[1]*v/p[2]*((p[3]/v)**p[2]/(p[2]-1)+1)-p[1]*p[3... | [
"0.5920097",
"0.579926",
"0.56057304",
"0.55859894",
"0.55132955",
"0.5480198",
"0.54527843",
"0.54427314",
"0.54189944",
"0.538485",
"0.53595084",
"0.53503376",
"0.5327499",
"0.5325421",
"0.52962947",
"0.5276504",
"0.52582276",
"0.5244729",
"0.5234504",
"0.5230446",
"0.52264... | 0.5424896 | 8 |
Sets up a rate law following the HenriMichaelisMenten law. v = vmax substrate / (k_m + substrate) | def MichaelisMentenVMax(
substrate: str,
enzmldoc,
vmax: Dict[str, Any] = {"ontology": SBOTerm.V_MAX},
k_m: Dict[str, Any] = {"ontology": SBOTerm.K_M},
):
# Check if the given IDs are part of the EnzymeML document already
if substrate not in enzmldoc.getSpeciesIDs():
raise SpeciesNotFoundError(
species_id=substrate, enzymeml_part="Reactants/Proteins"
)
# Check if ontologies are added, if not add them
if k_m.get("ontology") is None:
k_m["ontology"] = SBOTerm.K_M
if vmax.get("ontology") is None:
vmax["ontology"] = SBOTerm.V_MAX
# Create the model using a factory
model = ModelFactory(
name="Michaelis-Menten Rate Law",
equation="vmax * substrate / (k_m + substrate)",
vmax=vmax,
k_m=k_m,
ontology=SBOTerm.MICHAELIS_MENTEN,
)
return model(substrate=substrate) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def birch_murnaghan(p, v):\n return p[0]+9.0/16*p[3]*p[1]*( ( (p[3]/v)**(2.0/3)-1 )**3*p[2]+\n ( (p[3]/v)**(2.0/3)-1 )**2*\n ( 6-4*(p[3]/v)**(2.0/3) ) )",
"def murnaghan(p, v):\n return p[0]+p[1]*v/p[2]*((p[3]/v)**p[2]/(p[2]-1)+1)-p[1]*p[3... | [
"0.64286643",
"0.6351248",
"0.5775196",
"0.5764248",
"0.569532",
"0.5618492",
"0.55840904",
"0.55695754",
"0.55393964",
"0.5536443",
"0.5521898",
"0.55039316",
"0.5488269",
"0.54849935",
"0.5462513",
"0.54570895",
"0.5439389",
"0.5419699",
"0.54196864",
"0.54181284",
"0.54148... | 0.55910826 | 6 |
Normalize the features in the data set. | def normalize_features(array):
array_normalized = (array-array.mean())/array.std()
mu = array.mean()
sigma = array.std()
return array_normalized, mu, sigma | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalizeFeatureVector(self):\n # Normalize features\n total = 0.0\n for v in self.features.values(): total += abs(v)\n if total == 0.0: \n total = 1.0\n for k,v in self.features.iteritems():\n self.features[k] = float(v) / total",
"def _normalize(self... | [
"0.79551655",
"0.79528546",
"0.7853807",
"0.77867204",
"0.7698743",
"0.76595855",
"0.76581943",
"0.7635334",
"0.76207286",
"0.7542891",
"0.75298584",
"0.74793464",
"0.74740255",
"0.7413795",
"0.7320142",
"0.7320142",
"0.7318681",
"0.73162293",
"0.7313582",
"0.72916085",
"0.72... | 0.7046461 | 27 |
Compute the cost function given a set of features / values, and the values for our thetas. | def compute_cost(features, values, theta):
npoints = len(values)
sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()
cost = sum_of_square_errors / (2*npoints)
return cost | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_cost(features, values, theta):\r\n \r\n # your code here\r\n error = (values - features.dot(theta))\r\n cost = error.dot(error) \r\n return cost",
"def compute_cost(features, values, theta):\r\n m = len(values)\r\n sum_of_square_errors = numpy.square(numpy.dot(features, thet... | [
"0.74634284",
"0.72324276",
"0.7181755",
"0.69701",
"0.69247854",
"0.6471834",
"0.6227543",
"0.6182345",
"0.617613",
"0.6167203",
"0.6144014",
"0.6132684",
"0.61300564",
"0.6123157",
"0.6107986",
"0.6094501",
"0.60778195",
"0.6051131",
"0.60425967",
"0.60174876",
"0.60173744"... | 0.71723294 | 3 |
Perform gradient descent given a data set with an arbitrary number of features. | def gradient_descent(features, values, theta, alpha, num_iterations):
# number of points
npoints = len(values)
# intialize cost history
cost_history = []
# num_interations iterations
for iiter in range(num_iterations):
# compute and store cost
cost = compute_cost(features, values, theta)
cost_history.append(cost)
# update values of theta
values_predicted = np.dot(features, theta)
theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))
return theta, pandas.Series(cost_history) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient_descent(features, labels, alpha, num_iters):\n # Initial settings of weights\n weights = [0, 0, 0]\n\n # Length of dataset\n N = len(features[0])\n\n # Take 100 gradient steps\n gradient_losses = [0, 0, 0]\n\n # Take num_iters steps of gradient descent\n for step in range(num_i... | [
"0.75024587",
"0.7380757",
"0.7227321",
"0.7210996",
"0.7183001",
"0.712503",
"0.6942265",
"0.6937524",
"0.68507755",
"0.68019944",
"0.6660215",
"0.66235965",
"0.65996253",
"0.65692246",
"0.6564588",
"0.65573347",
"0.6539201",
"0.65332645",
"0.6500159",
"0.6479878",
"0.643247... | 0.7039808 | 6 |
This function is for viewing the plot of your cost history. | def plot_cost_history(alpha, cost_history):
cost_df = pandas.DataFrame({
'Cost_History': cost_history,
'Iteration': range(len(cost_history))
})
return ggplot(cost_df, aes('Iteration', 'Cost_History')) + geom_point() + ggtitle('Cost History for alpha = %.3f' % alpha ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_costs(j_history):\n plt.figure(figsize=(14, 8))\n plt.plot(range(len(j_history)), j_history)\n plt.grid(True)\n plt.title('J (Cost)')\n plt.xlabel('Iteration')\n plt.ylabel('Cost function')\n plt.xlim([0, 1.05 * ITERATIONS])\n plt.ylim([4, 7])\n plt.show()\n plt.close()",
"... | [
"0.745946",
"0.7305429",
"0.6926057",
"0.68891627",
"0.6870632",
"0.65292275",
"0.65152884",
"0.65122676",
"0.650241",
"0.6492996",
"0.646902",
"0.6411578",
"0.64004505",
"0.63721967",
"0.63554156",
"0.6354006",
"0.63402677",
"0.6333534",
"0.63082844",
"0.63080597",
"0.629246... | 0.7419536 | 1 |
Delete the index from Elastic Search | def trigger_delete(cls, instance):
es_client.delete(instance.blog.index_name(), 'blog_post_index', instance.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_index(self):\n es = self.get_es()\n if es.head(self.es_index):\n es.delete(self.es_index)",
"def _delete_index( env, logger ):\n global adapter_glob\n if adapter_glob is not None:\n adapter = adapter_glob\n else:\n logger.warning( u\"Connecting to index.... | [
"0.84657955",
"0.8269354",
"0.81989384",
"0.7981969",
"0.78138375",
"0.78138286",
"0.77492446",
"0.7635957",
"0.7554919",
"0.7533688",
"0.75277823",
"0.74774957",
"0.73601156",
"0.7322131",
"0.7238156",
"0.71974444",
"0.70426786",
"0.7019291",
"0.6958277",
"0.69546735",
"0.69... | 0.64396274 | 33 |
Delete the index from Elastic Search | def trigger_delete(cls, instance):
es_client.delete(instance.blog.index_name(), 'blog_page_index', instance.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_index(self):\n es = self.get_es()\n if es.head(self.es_index):\n es.delete(self.es_index)",
"def _delete_index( env, logger ):\n global adapter_glob\n if adapter_glob is not None:\n adapter = adapter_glob\n else:\n logger.warning( u\"Connecting to index.... | [
"0.84657955",
"0.8269354",
"0.81989384",
"0.7981969",
"0.78138375",
"0.78138286",
"0.77492446",
"0.7635957",
"0.7554919",
"0.7533688",
"0.75277823",
"0.74774957",
"0.73601156",
"0.7322131",
"0.7238156",
"0.71974444",
"0.70426786",
"0.7019291",
"0.6958277",
"0.69546735",
"0.69... | 0.6270193 | 44 |
Searches inside all the indices | def search(text):
s = Search()
result = _search(s, text)
_print_results(result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(query, idx):\n\n if len(query) == 0:\n return []\n ordered = {}\n for e in query:\n ordered[e] = len(idx[e])\n ordered = sorted(ordered.items(), key = lambda d: d[1])\n results = idx[ordered[0][0]]\n i = 1\n while i < len(ordered):\n results = intersect(results,... | [
"0.67821324",
"0.65260226",
"0.6520989",
"0.6491237",
"0.6243144",
"0.61972666",
"0.6069781",
"0.60370374",
"0.60119206",
"0.60016865",
"0.5995763",
"0.5986045",
"0.5966168",
"0.5955528",
"0.592799",
"0.589361",
"0.5850095",
"0.58489054",
"0.58428663",
"0.5826654",
"0.5807836... | 0.0 | -1 |
Searches inside the index for umbra3d | def search_umbra(text):
result = _search_blog('umbra3d', text)
_print_results(result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clustering_dbscan_o3d():\n pass",
"def cloud_index():\n import alltheitems.cloud\n return alltheitems.cloud.index()",
"def test_figure3(self):\n\n ssearcher = SimpleSearcher.from_prebuilt_index('msmarco-passage')\n encoder = TctColBertQueryEncoder('castorini/tct_colbert-msmarco')\n ... | [
"0.5886022",
"0.55750906",
"0.5477457",
"0.51528597",
"0.5148673",
"0.5101667",
"0.50694734",
"0.4972866",
"0.4953324",
"0.49039114",
"0.48821348",
"0.48311734",
"0.4818827",
"0.4813475",
"0.47986737",
"0.47905108",
"0.4765872",
"0.47636506",
"0.47565117",
"0.47055826",
"0.46... | 0.6636374 | 0 |
Searches inside the index for postman | def search_postman(text):
result = _search_blog('postman', text)
_print_results(result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(es_object, index_name, search):\n res = es_object.search(index=index_name, body=search)\n pprint(res)",
"def search_v1(query_tokens, inverted_index):\n return []",
"def fetch_all(): \n client, index_name = connection_es()\n res = client.search(index = index_name+\"*\")\n return ... | [
"0.67847615",
"0.6660635",
"0.66422635",
"0.66095644",
"0.65551525",
"0.6506054",
"0.64736253",
"0.6453532",
"0.6433664",
"0.63998264",
"0.63600475",
"0.63524884",
"0.6313629",
"0.62886024",
"0.62773657",
"0.6242144",
"0.6226204",
"0.6226116",
"0.62253296",
"0.62253296",
"0.6... | 0.5915123 | 60 |
Parse a date string from VocaDB API | def _parse_date(date_str: str) -> datetime:
datetime_obj = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%SZ")
return f"<t:{int(datetime_obj.timestamp())}:d>" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_date(str_date):\n return ciso8601.parse_datetime(str_date)",
"def parse_date(date):\n # MediaWiki API dates are always of the format\n # YYYY-MM-DDTHH:MM:SSZ\n # (see $formats in wfTimestamp() in includes/GlobalFunctions.php)\n return datetime.strptime(date, '%Y-%m-%dT%... | [
"0.680809",
"0.67152417",
"0.65661365",
"0.6514984",
"0.6471285",
"0.6438476",
"0.6424507",
"0.6418622",
"0.6410768",
"0.6408324",
"0.63828737",
"0.6381386",
"0.6373164",
"0.6363841",
"0.63582087",
"0.635436",
"0.634703",
"0.6330038",
"0.62913615",
"0.6277557",
"0.6273731",
... | 0.66212666 | 2 |
Fetch data from VocaDB API and prompt the user to select an entry | async def _fetch_data(self, ctx: commands.Context, query: str):
params = {
"query": query,
"maxResults": 10,
"sort": "FavoritedTimes",
"preferAccurateMatches": "true",
"nameMatchMode": "Words",
"fields": "Artists,Lyrics,Names,ThumbUrl",
}
headers = {
"User-Agent": f"Red-DiscordBot/{red_version} Fixator10-cogs/VocaDB/{self.__version__}"
}
try:
async with self.session.get(BASE_API_URL, params=params, headers=headers) as resp:
if resp.status != 200:
return f"https://http.cat/{resp.status}"
result = await resp.json()
except asyncio.TimeoutError:
return "Request timed out"
all_items = result.get("items")
if not all_items:
return None
filtered_items = [x for x in all_items if x.get("lyrics")]
if not filtered_items:
return None
if len(filtered_items) == 1:
return filtered_items[0]
items = "\n".join(
f"**`[{i}]`** {x.get('defaultName')} - {x.get('artistString')}"
f" (published: {self._parse_date(x.get('publishDate'))})"
for i, x in enumerate(filtered_items, start=1)
)
prompt = await ctx.send(
f"Found below **{len(filtered_items)}** result(s). Pick one in 60 seconds:\n\n{items}"
)
def check(msg: discord.Message) -> bool:
return bool(
msg.content.isdigit()
and int(msg.content) in range(len(filtered_items) + 1)
and msg.author.id == ctx.author.id
and msg.channel.id == ctx.channel.id
)
try:
choice = await self.bot.wait_for("message", timeout=60.0, check=check)
except asyncio.TimeoutError:
choice = None
if choice is None or choice.content.strip() == "0":
with contextlib.suppress(discord.NotFound, discord.HTTPException):
await prompt.edit(content="Cancelled.", delete_after=5.0)
return None
choice = int(choice.content.strip()) - 1
with contextlib.suppress(discord.NotFound, discord.HTTPException):
await prompt.delete()
return filtered_items[choice] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get():\n id_num = int(input('Enter the ID number of the item you wish to retrieve\\n'))\n db_actions.retrieve(id_num)",
"def get_user_input():\n st.sidebar.header('Parámetros de entrada') \n acti2 = st.sidebar.selectbox('Código de Actividad Económica', ['ACABADO DE PRODUCTOS TEXTILES',\n ... | [
"0.590885",
"0.56969845",
"0.56191784",
"0.5579956",
"0.55592823",
"0.5529667",
"0.5518773",
"0.55171174",
"0.551635",
"0.5444369",
"0.53913987",
"0.53488976",
"0.5306791",
"0.52756387",
"0.5254248",
"0.5252376",
"0.5200848",
"0.5175717",
"0.51679784",
"0.5167819",
"0.5120613... | 0.48027787 | 72 |
Create an embed with the song info | def _info_embed(self, colour, data: Dict[str, Any]) -> discord.Embed:
minutes = data.get("lengthSeconds", 0) // 60
seconds = data.get("lengthSeconds", 0) % 60
pub_date = self._parse_date(data.get("publishDate"))
all_artists = ", ".join(
f"[{x.get('name')}](https://vocadb.net/Ar/{x.get('id')}) ({x.get('categories')})"
for x in data.get("artists")
)
embed = discord.Embed(colour=colour)
embed.title = f"{data.get('defaultName')} - {data.get('artistString')}"
embed.url = f"https://vocadb.net/S/{data.get('id')}"
embed.set_thumbnail(url=data.get("thumbUrl", ""))
embed.add_field(name="Duration", value=f"{minutes} minutes, {seconds} seconds")
favorites, score = (data.get("favoritedTimes", 0), data.get("ratingScore", 0))
embed.add_field(name="Published On", value=pub_date)
embed.add_field(name="Statistics", value=f"{favorites} favourite(s), {score} total score")
embed.add_field(name="Artist(s)", value=all_artists)
embed.set_footer(text="Powered by VocaDB")
return embed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _create_embed(self, event, info):\n\n e = discord.Embed(url=info.get(\"url\"))\n e.title = \"%s %s!\" % (info.get(\"streamer\"), info.get(\"live_status\"))\n e.add_field(name=\"Stream title\", value=info.get(\"title\"), inline=False)\n e.add_field(name=\"Begin:\", value=event.... | [
"0.7574429",
"0.6955898",
"0.6697787",
"0.6493446",
"0.63093257",
"0.6292664",
"0.6217672",
"0.6171954",
"0.6141338",
"0.6098868",
"0.6069204",
"0.5961678",
"0.5946134",
"0.5936363",
"0.59200823",
"0.5897257",
"0.58952886",
"0.58319783",
"0.5789473",
"0.5774787",
"0.5751909",... | 0.6323162 | 4 |
Create an embed with the lyrics | def _lyrics_embed(colour, page: Dict[str, Any], data: Dict[str, Any]) -> discord.Embed:
title = [
x.get("value")
for x in data.get("names")
if x.get("language") == LANGUAGE_MAP.get(page["cultureCode"])
]
em = discord.Embed(
title=title[0] if title else data.get("defaultName"),
colour=colour,
)
em.set_thumbnail(url=data.get("thumbUrl") or "")
if data.get("id"):
em.url = f"https://vocadb.net/S/{data['id']}"
em.description = page["value"][:4090] if page.get("value") else "No lyrics found."
if page.get("url"):
em.add_field(
name="Source",
value=f"[{page.get('source') or 'Source'}]({page['url']})",
)
return em | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embed():",
"async def _create_embed(self, event, info):\n\n e = discord.Embed(url=info.get(\"url\"))\n e.title = \"%s %s!\" % (info.get(\"streamer\"), info.get(\"live_status\"))\n e.add_field(name=\"Stream title\", value=info.get(\"title\"), inline=False)\n e.add_field(name=\"Begi... | [
"0.70255935",
"0.63106394",
"0.62139446",
"0.61759347",
"0.60498273",
"0.60261035",
"0.5952487",
"0.59314024",
"0.5826032",
"0.5814283",
"0.57923996",
"0.5775373",
"0.57529444",
"0.5735012",
"0.56990874",
"0.56855226",
"0.56756103",
"0.5667003",
"0.56360406",
"0.5626547",
"0.... | 0.7571321 | 0 |
Fetch Vocaloid song lyrics from VocaDB.net database | async def vocadb(self, ctx: commands.Context, *, query: str):
await ctx.trigger_typing()
data = await self._fetch_data(ctx, query)
if type(data) == str:
return await ctx.send(data)
if not data:
return await ctx.send("No results found.")
await ctx.send(embed=self._info_embed(await ctx.embed_colour(), data))
# Added a small delay to improve UX for initial embed
await asyncio.sleep(2.0)
embeds = []
for i, page in enumerate(data["lyrics"], start=1):
language = f"Language: {LANGUAGE_MAP.get(page.get('cultureCode', 'na'))}"
emb = self._lyrics_embed(await ctx.embed_colour(), page, data)
emb.set_footer(text=f"{language} • Page {i} of {len(data['lyrics'])}")
embeds.append(emb)
controls = {"\N{CROSS MARK}": close_menu} if len(embeds) == 1 else DEFAULT_CONTROLS
await menu(ctx, embeds, controls=controls, timeout=90.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lyrics(self):\n return get_lyrics(self.artist, self.title,'')",
"def get_lyrics(self, artist, song):\n\n # Disable lyrics display\n self.status_bar.hide()\n self.lyrics_view.hide()\n self.scroll.hide()\n\n lyrics = None\n in_database = False\n\n if self... | [
"0.63000757",
"0.6130476",
"0.60185164",
"0.5984323",
"0.587224",
"0.58188677",
"0.5779001",
"0.5714484",
"0.57014984",
"0.5568323",
"0.5517398",
"0.55104864",
"0.5498643",
"0.54863167",
"0.5469233",
"0.54516006",
"0.543093",
"0.54292554",
"0.5408678",
"0.5388531",
"0.5296494... | 0.56197834 | 9 |
Fuse conv and bn into one module. | def _fuse_conv_bn(conv, bn):
conv_w = conv.weight
conv_b = conv.bias if conv.bias is not None else torch.zeros_like(
bn.running_mean)
factor = bn.weight / torch.sqrt(bn.running_var + bn.eps)
conv.weight = nn.Parameter(conv_w *
factor.reshape([conv.out_channels, 1, 1, 1]))
conv.bias = nn.Parameter((conv_b - bn.running_mean) * factor + bn.bias)
return conv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fuse_conv_bn(module):\n last_conv = None\n last_conv_name = None\n\n for name, child in module.named_children():\n if isinstance(child,\n (nn.modules.batchnorm._BatchNorm, nn.SyncBatchNorm)):\n if last_conv is None: # only fuse BN that is after Conv\n ... | [
"0.66424954",
"0.6055714",
"0.602726",
"0.59107614",
"0.5825306",
"0.57937133",
"0.57798207",
"0.5775232",
"0.5716006",
"0.56922126",
"0.5688817",
"0.5679025",
"0.566316",
"0.56493765",
"0.56161374",
"0.5604259",
"0.5571019",
"0.5565932",
"0.5558572",
"0.5545696",
"0.5540742"... | 0.651783 | 1 |
Recursively fuse conv and bn in a module. During inference, the functionary of batch norm layers is turned off but only the mean and var alone channels are used, which exposes the chance to fuse it with the preceding conv layers to save computations and simplify network structures. | def fuse_conv_bn(module):
last_conv = None
last_conv_name = None
for name, child in module.named_children():
if isinstance(child,
(nn.modules.batchnorm._BatchNorm, nn.SyncBatchNorm)):
if last_conv is None: # only fuse BN that is after Conv
continue
fused_conv = _fuse_conv_bn(last_conv, child)
module._modules[last_conv_name] = fused_conv
# To reduce changes, set BN as Identity instead of deleting it.
module._modules[name] = nn.Identity()
last_conv = None
elif isinstance(child, nn.Conv2d):
last_conv = child
last_conv_name = name
else:
fuse_conv_bn(child)
return module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fuse_conv_bn(conv, bn):\n conv_w = conv.weight\n conv_b = conv.bias if conv.bias is not None else torch.zeros_like(\n bn.running_mean)\n\n factor = bn.weight / torch.sqrt(bn.running_var + bn.eps)\n conv.weight = nn.Parameter(conv_w *\n factor.reshape([conv.out_... | [
"0.695171",
"0.6805263",
"0.6269793",
"0.62578046",
"0.6063939",
"0.6063939",
"0.60563296",
"0.6027096",
"0.60044354",
"0.5954461",
"0.5929739",
"0.5882636",
"0.58481455",
"0.5835012",
"0.5830163",
"0.57766056",
"0.57479167",
"0.5734447",
"0.57262725",
"0.5723586",
"0.5721918... | 0.7612941 | 0 |
When updating from a dictionary, this is processed for any key that does not match a ``ConfigurationProperty``. | def update_default_from_dict(self, key, value):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, config_dict):\r\n self._update(config_dict, allow_new_keys=True)",
"def _update(self, config_dict, allow_new_keys=True):\n if not config_dict:\n return\n\n for k, v in six.iteritems(config_dict):\n if k not in self.__dict__.keys():\n if allow... | [
"0.63395983",
"0.6195475",
"0.61581475",
"0.61513746",
"0.6097584",
"0.5982047",
"0.5815127",
"0.580773",
"0.578081",
"0.5776933",
"0.5750993",
"0.5738719",
"0.5706137",
"0.5621806",
"0.56125647",
"0.5599297",
"0.5510102",
"0.5506825",
"0.5498179",
"0.5492065",
"0.5476959",
... | 0.58367 | 6 |
When merging from a dictionary, this is processed for any key that does not match a ``ConfigurationProperty``. | def merge_default_from_dict(self, key, value, lists_only=False):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(target_config, other_config):\n for key, value in other_config.items():\n if key not in target_config or not isinstance(value, dict):\n target_config[key] = value\n else:\n merge(target_config[key], other_config[key])",
"def test_merge_overwrite_missing_source_key... | [
"0.59852463",
"0.58540046",
"0.57954663",
"0.5752213",
"0.57376033",
"0.5702366",
"0.5665245",
"0.5632572",
"0.55908483",
"0.55750465",
"0.5550517",
"0.5546977",
"0.5520356",
"0.55015045",
"0.5499027",
"0.54877573",
"0.5457098",
"0.54544103",
"0.5435976",
"0.54214597",
"0.536... | 0.5641025 | 7 |
Updates this configuration object from a dictionary. | def update_from_dict(self, dct):
if not dct:
return
all_props = self.__class__.CONFIG_PROPERTIES
for key, value in six.iteritems(dct):
attr_config = all_props.get(key)
if attr_config:
setattr(self, key, value)
else:
self.update_default_from_dict(key, value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, config_dict):\r\n self._update(config_dict, allow_new_keys=True)",
"def update(self, config_dict):\n self._update(config_dict, allow_new_keys=True)",
"def update_from_dict(self, dictionary):\n for key in dictionary:\n setattr(self, key, dictionary[key])\n ret... | [
"0.7539606",
"0.7526402",
"0.73409635",
"0.6924898",
"0.6826344",
"0.68139464",
"0.67985266",
"0.6760424",
"0.6756888",
"0.66938514",
"0.65406144",
"0.6525585",
"0.6479391",
"0.64561343",
"0.6436355",
"0.6408912",
"0.6408051",
"0.63989556",
"0.63800776",
"0.63728046",
"0.6356... | 0.7746895 | 0 |
Updates this configuration object from another. | def update_from_obj(self, obj, copy=False):
obj.clean()
obj_config = obj._config
all_props = self.__class__.CONFIG_PROPERTIES
if copy:
for key, value in six.iteritems(obj_config):
attr_config = all_props.get(key)
if attr_config:
attr_type = attr_config.attr_type
if attr_type:
if issubclass(attr_type, list):
self._config[key] = value[:]
elif attr_type is dict:
self._config[key] = value.copy()
else:
self._config[key] = value
self._modified.discard(key)
else:
filtered_dict = {key: value
for key, value in six.iteritems(obj_config)
if key in all_props}
self._config.update(filtered_dict)
self._modified.difference_update(filtered_dict.keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, other: Mapping[str, Any]) -> None:\n self._config.update(self._flatten_dict(other))",
"def update(self, other):\n _merge_dicts(self, other)",
"def merge(self, other_config):\n # Make a copy of the current attributes in the config object.\n config_options = copy.copy... | [
"0.79346645",
"0.697184",
"0.6949921",
"0.6621027",
"0.6513877",
"0.6501808",
"0.6463023",
"0.64405686",
"0.6436044",
"0.62805444",
"0.62770504",
"0.62714624",
"0.6265465",
"0.6204351",
"0.61828285",
"0.61200017",
"0.61178195",
"0.6052243",
"0.60450506",
"0.60440445",
"0.6012... | 0.6128411 | 15 |
Merges a dictionary into this configuration object. | def merge_from_dict(self, dct, lists_only=False):
if not dct:
return
self.clean()
all_props = self.__class__.CONFIG_PROPERTIES
for key, value in six.iteritems(dct):
attr_config = all_props.get(key)
if attr_config:
attr_type, default, input_func, merge_func = attr_config[:4]
if (merge_func is not False and value != default and
(not lists_only or (attr_type and issubclass(attr_type, list)))):
if input_func:
value = input_func(value)
self._merge_value(attr_type, merge_func, key, value)
else:
self.merge_default_from_dict(key, value, lists_only=lists_only) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_config(self_config, indict):\n\n self_config.merge(indict)\n patch_config(self_config, indict)",
"def update_config(self, update_dict):\n self.config = recursive_merge_dicts(self.config, update_dict)",
"def merge(target_config, other_config):\n for key, value in other_config.items():\... | [
"0.72250795",
"0.70428866",
"0.6939675",
"0.6870766",
"0.67551553",
"0.662299",
"0.6565024",
"0.647432",
"0.6393523",
"0.6344991",
"0.6342676",
"0.626442",
"0.6260575",
"0.6257758",
"0.62464523",
"0.6230818",
"0.6222192",
"0.6182466",
"0.6168279",
"0.61122817",
"0.6098302",
... | 0.6414965 | 8 |
Merges a configuration object into this one. | def merge_from_obj(self, obj, lists_only=False):
self.clean()
obj.clean()
obj_config = obj._config
all_props = self.__class__.CONFIG_PROPERTIES
for key, value in six.iteritems(obj_config):
attr_config = all_props[key]
attr_type, default, __, merge_func = attr_config[:4]
if (merge_func is not False and value != default and
(not lists_only or (attr_type and issubclass(attr_type, list)))):
self._merge_value(attr_type, merge_func, key, value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(self, other_config):\n # Make a copy of the current attributes in the config object.\n config_options = copy.copy(self._user_provided_options)\n\n # Merge in the user provided options from the other config\n config_options.update(other_config._user_provided_options)\n\n ... | [
"0.76882917",
"0.67406607",
"0.6626241",
"0.65219",
"0.6375062",
"0.6338064",
"0.6310122",
"0.63097996",
"0.6292221",
"0.62915736",
"0.622043",
"0.61334",
"0.6007048",
"0.5979473",
"0.5954268",
"0.5950543",
"0.5942655",
"0.5942226",
"0.5904852",
"0.5901438",
"0.58915347",
"... | 0.5562985 | 45 |
Updates the configuration with the contents of the given configuration object or dictionary. In case of a dictionary, only valid attributes for this class are considered. Existing attributes are replaced with the new values. The object is not cleaned before or after, i.e. may accept invalid input. In case of an update by object, that object is cleaned before the update, so that updated values should be validated. However, alreadystored values are not cleaned before or after. | def update(self, values, copy_instance=False):
if isinstance(values, self.__class__):
self.update_from_obj(values, copy=copy_instance)
elif isinstance(values, dict):
self.update_from_dict(values)
else:
raise ValueError("{0} or dictionary expected; found '{1}'.".format(self.__class__.__name__,
type(values).__name__)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update(self, config_dict, allow_new_keys=True):\r\n if not config_dict:\r\n return\r\n\r\n for k, v in six.iteritems(config_dict):\r\n if k not in self.__dict__:\r\n if allow_new_keys:\r\n self.__setattr__(k, v)\r\n else:\r\n raise KeyError('Key `{}` does not ex... | [
"0.7369526",
"0.72188014",
"0.71054125",
"0.6892814",
"0.68874276",
"0.68512803",
"0.641856",
"0.63729274",
"0.6282296",
"0.61824185",
"0.6173597",
"0.61599773",
"0.61506504",
"0.6055091",
"0.6051019",
"0.6051019",
"0.6043906",
"0.60201603",
"0.59867066",
"0.59764946",
"0.596... | 0.55972207 | 51 |
Merges listbased attributes into one list including unique elements from both lists. When ``lists_only`` is set to ``False``, updates dictionaries and overwrites singlevalue attributes. The resulting configuration is 'clean', i.e. input values converted and validated. If the conversion is not possible, a ``ValueError`` is raised. | def merge(self, values, lists_only=False):
if isinstance(values, self.__class__):
self.merge_from_obj(values, lists_only=lists_only)
elif isinstance(values, dict):
self.merge_from_dict(values, lists_only=lists_only)
else:
raise ValueError("{0} or dictionary expected; found '{1}'.".format(self.__class__.__name__,
type(values).__name__)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_from_obj(self, obj, lists_only=False):\n self.clean()\n obj.clean()\n obj_config = obj._config\n all_props = self.__class__.CONFIG_PROPERTIES\n for key, value in six.iteritems(obj_config):\n attr_config = all_props[key]\n attr_type, default, __, me... | [
"0.65139383",
"0.5578662",
"0.5572278",
"0.55066985",
"0.5469693",
"0.53935814",
"0.5371809",
"0.53107864",
"0.5277536",
"0.5260815",
"0.5229918",
"0.52003044",
"0.5156324",
"0.5125335",
"0.5069357",
"0.50458443",
"0.5019574",
"0.4998074",
"0.49735352",
"0.49711102",
"0.49676... | 0.6129385 | 1 |
Creates a copy of the current instance. | def copy(self):
return self.__class__(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n cls = self.__class__\n result = cls.__new__(cls)\n result.__dict__.update(self.__dict__)\n return result",
"def copy(self):\n return self.__class__(dict(self))",
"def copy(self):\n\t\ttemp = self.__class__()\n\t\ttemp.copy_from(self)\n\t\treturn temp",
"de... | [
"0.8445658",
"0.83826053",
"0.8367299",
"0.83550745",
"0.8290682",
"0.82799333",
"0.8262882",
"0.823516",
"0.8217232",
"0.8166611",
"0.8156989",
"0.81500196",
"0.8146055",
"0.8143642",
"0.81333435",
"0.81235075",
"0.8090402",
"0.8090402",
"0.80738163",
"0.8067191",
"0.8032540... | 0.86091197 | 1 |
Cleans the input values of this configuration object. Fields that have gotten updated through properties are converted to configuration values that match the format needed by functions using them. For example, for listlike values it means that input of single strings is transformed into a singleentry list. If this conversion fails, a ``ValueError`` is raised. | def clean(self):
all_props = self.__class__.CONFIG_PROPERTIES
for prop_name in self._modified:
attr_config = all_props.get(prop_name)
if attr_config and attr_config.input_func:
self._config[prop_name] = attr_config.input_func(self._config[prop_name])
self._modified.clear() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self, value):\n value = self.validate_to_python(value)\n self.run_validators(value)\n return value",
"def clean(self, value):\n value = self.validate_to_python(value)\n self.run_validators(value)\n return value",
"def clean(cls, value):\n return",
"d... | [
"0.60418636",
"0.60418636",
"0.59051543",
"0.5863725",
"0.5829741",
"0.5760881",
"0.5721319",
"0.5714525",
"0.5582324",
"0.5558668",
"0.5509648",
"0.5507196",
"0.55028373",
"0.54199827",
"0.54151857",
"0.5408943",
"0.5379859",
"0.53760797",
"0.5363679",
"0.53535485",
"0.53409... | 0.6916164 | 0 |
Whether the current object is 'clean', i.e. has no nonconverted input. | def is_clean(self):
return not self._modified | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self) -> bool:\n raise NotImplementedError()",
"def __bool__(self):\n return self.isValid()",
"def __bool__(self):\n return self.is_valid",
"def is_valid(self):\n self.clean()\n return not bool(self.errors)",
"def is_raw(self):\n return not self._isReduce... | [
"0.6872073",
"0.63761157",
"0.63610554",
"0.6312004",
"0.63031477",
"0.63022435",
"0.6240924",
"0.61812806",
"0.61137867",
"0.60905904",
"0.60698545",
"0.6046526",
"0.60410285",
"0.603819",
"0.6018456",
"0.60071707",
"0.60055494",
"0.5978157",
"0.5974375",
"0.59508747",
"0.59... | 0.73114955 | 0 |
Returns a copy of the configuration dictionary. Changes in this should not reflect on the original object. | def as_dict(self):
self.clean()
d = OrderedDict()
all_props = self.__class__.CONFIG_PROPERTIES
for attr_name, attr_config in six.iteritems(all_props):
value = self._config[attr_name]
attr_type = attr_config.attr_type
if attr_type:
if value:
if issubclass(attr_type, list):
if issubclass(attr_type, NamedTupleList):
d[attr_name] = [i._asdict() for i in value]
else:
d[attr_name] = value[:]
elif attr_type is dict:
d[attr_name] = dict(value)
elif value is not NotSet:
d[attr_name] = value
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __copy__(self):\n d = dict()\n d.update(self.items())\n return d",
"def copy(self):\n return self.from_dict(self.to_dict(True))",
"def get(self) -> dict:\n return clone(self.__dict__)",
"def clone(self) -> 'ContainerConfig':\n return deepcopy(self)",
"def copy(... | [
"0.74385566",
"0.7369222",
"0.73497945",
"0.7333246",
"0.7279644",
"0.7213318",
"0.72081774",
"0.7177167",
"0.71266174",
"0.70725924",
"0.70725346",
"0.7034118",
"0.69861895",
"0.69729465",
"0.69077206",
"0.69053024",
"0.68810904",
"0.68651885",
"0.6863838",
"0.6860341",
"0.6... | 0.0 | -1 |
Prepares a new picking for this stock request as it could not be assigned to another picking. This method is designed to be inherited. | def _prepare_picking_values(self):
return {
'origin': self.doc_num,
'company_id': self.company_id.id,
'move_type': 'direct',
'partner_id': self.partner_id.id,
'picking_type_id': self.picking_type_id.id,
'location_id': self.location_id.id,
'location_dest_id': self.location_dest_id.id,
'picking_type_code': self.request_type_code
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_chained_picking(self, cr, uid, pick_name, picking, purchase_type, move, context=None):\n res = super(stock_move, self)._create_chained_picking(cr, uid, pick_name, picking, purchase_type, move, context=context)\n if picking.purchase_id:\n self.pool.get('stock.picking').write(cr,... | [
"0.6094836",
"0.5825267",
"0.5737362",
"0.5558884",
"0.55338615",
"0.5362217",
"0.53577745",
"0.53384507",
"0.5322603",
"0.531471",
"0.5305547",
"0.5271691",
"0.52530354",
"0.5203157",
"0.517102",
"0.51381963",
"0.50887847",
"0.5068953",
"0.5053527",
"0.50466454",
"0.5034907"... | 0.54961354 | 5 |
Get the vocab file and casing info from the Hub module. | def create_tokenizer_from_hub_module(bert_path, sess):
bert_module = hub.Module(bert_path)
tokenization_info = bert_module(signature="tokenization_info", as_dict=True)
vocab_file, do_lower_case = tf.print(
[tokenization_info["vocab_file"], tokenization_info["do_lower_case"]]
)
return FullTokenizer(vocab_file=vocab_file, do_lower_case=do_lower_case) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_vocab():\n if data_dir is not None and vocab_filename is not None:\n vocab_filepath = os.path.join(data_dir, vocab_filename)\n if tf.gfile.Exists(vocab_filepath):\n tf.logging.info(\"Found vocab file: %s\", vocab_filepath)\n vocab_symbolizer = text_encoder.SubwordTextEncoder(voca... | [
"0.6443318",
"0.63813704",
"0.6220464",
"0.61732",
"0.5963318",
"0.5917839",
"0.59003973",
"0.5888739",
"0.58854616",
"0.5765365",
"0.56868184",
"0.5684578",
"0.5683986",
"0.56751275",
"0.55819345",
"0.5499176",
"0.5480448",
"0.5460594",
"0.5460213",
"0.54520303",
"0.544654",... | 0.506715 | 58 |
Converts a single `InputExample` into a single `InputFeatures`. | def convert_single_example(tokenizer, example, max_seq_length=256):
if isinstance(example, PaddingInputExample):
input_ids = [0] * max_seq_length
input_mask = [0] * max_seq_length
segment_ids = [0] * max_seq_length
label = 0
return input_ids, input_mask, segment_ids, label
tokens_a = tokenizer.tokenize(example.text_a)
if len(tokens_a) > max_seq_length - 2:
tokens_a = tokens_a[0: (max_seq_length - 2)]
tokens = []
segment_ids = []
tokens.append("[CLS]")
segment_ids.append(0)
for token in tokens_a:
tokens.append(token)
segment_ids.append(0)
tokens.append("[SEP]")
segment_ids.append(0)
# print('Tokens', tokens[:3])
input_ids = tokenizer.convert_tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1] * len(input_ids)
# Zero-pad up to the sequence length.
while len(input_ids) < max_seq_length:
input_ids.append(0)
input_mask.append(0)
segment_ids.append(0)
assert len(input_ids) == max_seq_length
assert len(input_mask) == max_seq_length
assert len(segment_ids) == max_seq_length
return input_ids, input_mask, segment_ids, example.label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_single_example(ex_index, example, label_list, max_seq_length,\n tokenizer):\n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n\n input_ids, segment_ids, input_mask = \\\n tokenizer.encode_text(text_a=example.text_a,\n ... | [
"0.71971315",
"0.70364904",
"0.7011036",
"0.689469",
"0.68478036",
"0.65458274",
"0.6541168",
"0.64461863",
"0.6425648",
"0.63981766",
"0.6375564",
"0.6332188",
"0.6307511",
"0.6293627",
"0.6263605",
"0.6238047",
"0.6184619",
"0.6152681",
"0.61517704",
"0.61352295",
"0.613507... | 0.0 | -1 |
Convert a set of `InputExample`s to a list of `InputFeatures`. | def convert_examples_to_features(tokenizer, examples, max_seq_length=256):
input_ids, input_masks, segment_ids, labels = [], [], [], []
# for example in tqdm(examples, desc="Converting examples to features"):
for example in examples:
input_id, input_mask, segment_id, label = convert_single_example(
tokenizer, example, max_seq_length
)
input_ids.append(input_id)
input_masks.append(input_mask)
segment_ids.append(segment_id)
labels.append(label)
assert len(examples) == len(labels)
return (
np.array(input_ids),
np.array(input_masks),
np.array(segment_ids),
np.array(labels).reshape(-1, 1),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_examples_to_features(examples, tokenizer, is_training, args):\n all_features = []\n positive_features = 0\n negative_features = 0\n logger.info(\"Converting a list of NqExamples into InputFeatures ...\")\n for index, example in enumerate(tqdm(examples)):\n example_index = example[... | [
"0.73133975",
"0.7042608",
"0.69537765",
"0.6883128",
"0.68623626",
"0.685001",
"0.68385124",
"0.6820685",
"0.6765126",
"0.67010623",
"0.66909826",
"0.66590303",
"0.6587141",
"0.6575663",
"0.655151",
"0.64223295",
"0.64164066",
"0.6334047",
"0.6323665",
"0.6314246",
"0.628306... | 0.69446 | 3 |
Returns the rank of the current process. | def rank() -> int:
return dist.get_rank() if dist.is_initialized() else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rank(self):\n return self.lib.calculate_rank()",
"def rank(self):\n if self._rank is None:\n self._rank = self.prufer_rank()\n return self._rank",
"def get_rank(self):\n return int(self._rank)",
"def get_rank(self):\n return self.__rank",
"def get_rank(self... | [
"0.80822533",
"0.80002564",
"0.7949877",
"0.79325294",
"0.79249567",
"0.7893032",
"0.78871316",
"0.7856118",
"0.7848769",
"0.7848769",
"0.7848769",
"0.7848769",
"0.7848769",
"0.7839193",
"0.77974236",
"0.7764616",
"0.7760686",
"0.76716596",
"0.76598537",
"0.7500097",
"0.74324... | 0.7283091 | 26 |
Returns the current world size (number of distributed processes). | def world_size() -> int:
return dist.get_world_size() if dist.is_initialized() else 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_world_size() -> int:\n return collective.get_world_size()",
"def get_world_size():\n if not torch.distributed.is_available():\n return 1\n if not torch.distributed.is_initialized():\n return 1\n return torch.distributed.get_world_size()",
"def size():\n return int(os.enviro... | [
"0.86169875",
"0.8585714",
"0.80531013",
"0.78157955",
"0.7763954",
"0.72711486",
"0.7219287",
"0.69150424",
"0.68911326",
"0.68068975",
"0.671325",
"0.668719",
"0.6650058",
"0.65553606",
"0.6534457",
"0.6533206",
"0.64964646",
"0.6494468",
"0.6457273",
"0.6454149",
"0.644345... | 0.86466646 | 0 |
Gathers this tensor from all processes. Supports backprop. | def gather(input: torch.Tensor) -> Tuple[torch.Tensor]:
return GatherLayer.apply(input) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, sess):\n\n sess.run(self.sync) # copy weights from shared to local\n rollout = self.pull_batch_from_queue()\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\n\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\n\n if should_comp... | [
"0.60234517",
"0.59920496",
"0.59397244",
"0.59397244",
"0.5855692",
"0.5820956",
"0.5770425",
"0.57674265",
"0.57518774",
"0.56285346",
"0.56285346",
"0.56052834",
"0.55982333",
"0.5576598",
"0.55694216",
"0.5524458",
"0.55227476",
"0.5519531",
"0.55187434",
"0.54854375",
"0... | 0.0 | -1 |
Returns an (n, n world_size) zero matrix with the diagonal for the rank of this process set to 1. Example output where n=3, the current process has rank 1, and there are | def eye_rank(n: int, device: Optional[torch.device] = None) -> torch.Tensor:
rows = torch.arange(n, device=device, dtype=torch.long)
cols = rows + rank() * n
diag_mask = torch.zeros((n, n * world_size()), dtype=torch.bool)
diag_mask[(rows, cols)] = True
return diag_mask | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_game(n):\n matrix = []\n\n for i in range(n):\n matrix.append([0] * n)\n return matrix",
"def make_blank_world():\n\t\tblank_array = [[Blank() for j in range(y_size + 1)] for i in range(x_size + 1)]\n\t\treturn blank_array",
"def start_points(n, world):\n world[0, 0] ... | [
"0.61408174",
"0.5977178",
"0.58118933",
"0.56802106",
"0.56438154",
"0.5553707",
"0.554472",
"0.5500732",
"0.54714006",
"0.54591256",
"0.5432492",
"0.54102844",
"0.5402189",
"0.5370259",
"0.53477335",
"0.5346161",
"0.5288265",
"0.5276366",
"0.52738804",
"0.52572614",
"0.5255... | 0.57331735 | 3 |
Decorator that only runs the function on the process with rank 0. | def rank_zero_only(fn):
def wrapped(*args, **kwargs):
if rank() == 0:
return fn(*args, **kwargs)
return wrapped | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rank_zero_only(fn):\n\n @wraps(fn)\n def wrapped_fn(self, *args, **kwargs):\n if self.rank == 0:\n fn(self, *args, **kwargs)\n\n return wrapped_fn",
"def _message_when_root(func):\n\n def decorated(*args, **kwargs):\n from armi import MPI_RANK\n\n if MPI_RANK == 0:... | [
"0.78528255",
"0.66583896",
"0.6142544",
"0.6070626",
"0.6058951",
"0.60186154",
"0.5988285",
"0.5949869",
"0.5930045",
"0.5898354",
"0.5718907",
"0.5713488",
"0.5649635",
"0.55312955",
"0.5502004",
"0.5497844",
"0.547936",
"0.5471152",
"0.539442",
"0.5339954",
"0.53384835",
... | 0.78286487 | 1 |
Equivalent to print, but only runs on the process with rank 0. | def print_rank_zero(*args, **kwargs) -> None:
print(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l_print_no_barrier(*args):\n print(comm.rank, ':', end=' ')\n for i in args:\n print(i, end=' ')\n # noinspection PyArgumentList\n print()",
"def print_on_master(self, msg: str, process_group: ProcessGroup = None):\n rank = dist.get_rank(group=process_group)\n if rank == 0:\n... | [
"0.67231727",
"0.671745",
"0.6413891",
"0.63975346",
"0.6320614",
"0.6140222",
"0.59592324",
"0.5801671",
"0.5788699",
"0.5557892",
"0.54468316",
"0.53032565",
"0.5294671",
"0.5267618",
"0.5237459",
"0.52162343",
"0.51678485",
"0.5136221",
"0.5076834",
"0.5038921",
"0.5038565... | 0.7382136 | 0 |
Returns a list of the methods the free energy is to be estimated with. | def getMethods(string):
all_methods = ['TI','TI-CUBIC','DEXP','IEXP','GINS','GDEL','BAR','UBAR','RBAR','MBAR']
methods = ['TI','TI-CUBIC','DEXP','IEXP','BAR','MBAR']
if (numpy.array(['Sire']) == P.software.title()).any():
methods = ['TI','TI-CUBIC']
if not string:
return methods
def addRemove(string):
operation = string[0]
string = string[1:]+'+'
method = ''
for c in string:
if c.isalnum():
method += c
elif c=='_':
method += '-'
elif (c=='-' or c=='+'):
if method in all_methods:
if operation=='-':
if method in methods:
methods.remove(method)
else:
if not method in methods:
methods.append(method)
method = ''
operation = c
else:
parser.error("\nThere is no '%s' in the list of supported methods." % method)
else:
parser.error("\nUnknown character '%s' in the method string is found." % c)
return
if string=='ALL':
methods = all_methods
else:
primo = string[0]
if primo.isalpha():
methods = string.replace('+', ' ').replace('_', '-').split()
methods = [m for m in methods if m in all_methods]
elif primo=='+' or primo=='-':
addRemove(string)
else:
parser.error("\nUnknown character '%s' in the method string is found." % primo)
return methods | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available_methods():\n return {mc.method_id: mc for mc in MethodFactory.method_classes}",
"def list_methods(self):\n return list(self.methods.keys())",
"def get_available_shipping_methods(self):\n return [\n m for m\n in ShippingMethod.objects.available(shop=self.... | [
"0.62939",
"0.62060606",
"0.6165162",
"0.6080959",
"0.6052875",
"0.5965192",
"0.5954748",
"0.58911914",
"0.58881974",
"0.586676",
"0.584898",
"0.5769478",
"0.5767808",
"0.5711987",
"0.5688772",
"0.5688331",
"0.5685699",
"0.5681339",
"0.567954",
"0.5675728",
"0.56619275",
"0... | 0.5259336 | 45 |
Identifies uncorrelated samples and updates the arrays of the reduced potential energy and dhdlt retaining data entries of these samples only. 'sta' and 'fin' are the starting and final snapshot positions to be read, both are arrays of dimension K. | def uncorrelate(sta, fin, do_dhdl=False):
if not P.uncorr_threshold:
if P.software.title()=='Sire':
return dhdlt, nsnapshots, None
return dhdlt, nsnapshots, u_klt
u_kln = numpy.zeros([K,K,max(fin-sta)], numpy.float64) # u_kln[k,m,n] is the reduced potential energy of uncorrelated sample index n from state k evaluated at state m
N_k = numpy.zeros(K, int) # N_k[k] is the number of uncorrelated samples from state k
g = numpy.zeros(K,float) # autocorrelation times for the data
if do_dhdl:
dhdl = numpy.zeros([K,n_components,max(fin-sta)], float) #dhdl is value for dhdl for each component in the file at each time.
print "\n\nNumber of correlated and uncorrelated samples:\n\n%6s %12s %12s %12s\n" % ('State', 'N', 'N_k', 'N/N_k')
UNCORR_OBSERVABLE = {'Gromacs':P.uncorr,'Amber':'dhdl', 'Sire':'dhdl', 'Desmond':'dE', 'Gomc':P.uncorr}[P.software.title()]
if UNCORR_OBSERVABLE == 'dhdl':
# Uncorrelate based on dhdl values at a given lambda.
for k in range(K):
# Sum up over those energy components that are changing.
# if there are repeats, we need to use the lchange[k] from the last repeated state.
lastl = k
for l in range(K):
if numpy.array_equal(lv[k],lv[l]):
lastl = l
dhdl_sum = numpy.sum(dhdlt[k, lchange[lastl], sta[k]:fin[k]], axis=0)
# Determine indices of uncorrelated samples from potential autocorrelation analysis at state k
#NML: Set statistical inefficiency (g) = 1 if vector is all 0
if not numpy.any(dhdl_sum):
#print "WARNING: Found all zeros for Lambda={}\n Setting statistical inefficiency g=1.".format(k)
g[k] = 1
else:
# (alternatively, could use the energy differences -- here, we will use total dhdl).
g[k] = pymbar.timeseries.statisticalInefficiency(dhdl_sum)
indices = sta[k] + numpy.array(pymbar.timeseries.subsampleCorrelatedData(dhdl_sum, g=g[k])) # indices of uncorrelated samples
N_uncorr = len(indices) # number of uncorrelated samples
# Handle case where we end up with too few.
if N_uncorr < P.uncorr_threshold:
if do_dhdl:
print "WARNING: Only %s uncorrelated samples found at lambda number %s; proceeding with analysis using correlated samples..." % (N_uncorr, k)
indices = sta[k] + numpy.arange(len(dhdl_sum))
N = len(indices)
else:
N = N_uncorr
N_k[k] = N # Store the number of uncorrelated samples from state k.
if not (u_klt is None):
for l in range(K):
u_kln[k,l,0:N] = u_klt[k,l,indices]
if do_dhdl:
print "%6s %12s %12s %12.2f" % (k, N_uncorr, N_k[k], g[k])
for n in range(n_components):
dhdl[k,n,0:N] = dhdlt[k,n,indices]
if UNCORR_OBSERVABLE == 'dhdl_all':
# Uncorrelate based on dhdl values at a given lambda.
for k in range(K):
# Sum up over the energy components; notice, that only the relevant data is being used in the third dimension.
dhdl_sum = numpy.sum(dhdlt[k,:,sta[k]:fin[k]], axis=0)
# Determine indices of uncorrelated samples from potential autocorrelation analysis at state k
# (alternatively, could use the energy differences -- here, we will use total dhdl).
g[k] = pymbar.timeseries.statisticalInefficiency(dhdl_sum)
indices = sta[k] + numpy.array(pymbar.timeseries.subsampleCorrelatedData(dhdl_sum, g=g[k])) # indices of uncorrelated samples
N = len(indices) # number of uncorrelated samples
# Handle case where we end up with too few.
if N < P.uncorr_threshold:
if do_dhdl:
print "WARNING: Only %s uncorrelated samples found at lambda number %s; proceeding with analysis using correlated samples..." % (N, k)
indices = sta[k] + numpy.arange(len(dhdl_sum))
N = len(indices)
N_k[k] = N # Store the number of uncorrelated samples from state k.
if not (u_klt is None):
for l in range(K):
u_kln[k,l,0:N] = u_klt[k,l,indices]
if do_dhdl:
print "%6s %12s %12s %12.2f" % (k, fin[k], N_k[k], g[k])
for n in range(n_components):
dhdl[k,n,0:N] = dhdlt[k,n,indices]
if UNCORR_OBSERVABLE == 'dE':
# Uncorrelate based on energy differences between lambdas.
for k in range(K):
# Sum up over the energy components as above using only the relevant data; here we use energy differences
# Determine indices of uncorrelated samples from potential autocorrelation analysis at state k
dE = u_klt[k,k+1,sta[k]:fin[k]] if not k==K-1 else u_klt[k,k-1,sta[k]:fin[k]]
g[k] = pymbar.timeseries.statisticalInefficiency(dE)
indices = sta[k] + numpy.array(pymbar.timeseries.subsampleCorrelatedData(dE, g=g[k])) # indices of uncorrelated samples
N = len(indices) # number of uncorrelated samples
# Handle case where we end up with too few.
if N < P.uncorr_threshold:
print "WARNING: Only %s uncorrelated samples found at lambda number %s; proceeding with analysis using correlated samples..." % (N, k)
indices = sta[k] + numpy.arange(len(dE))
N = len(indices)
N_k[k] = N # Store the number of uncorrelated samples from state k.
if not (u_klt is None):
for l in range(K):
u_kln[k,l,0:N] = u_klt[k,l,indices]
if do_dhdl:
return (dhdl, N_k, u_kln)
return (N_k, u_kln) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data_stoichometry(fasta, bams, regions, features, samples, fracs, \n maxReads=1000, strands=\"+-\", nn=1):\n # get storage\n k = 2*nn+1\n fi = 0\n sam = pysam.AlignmentFile(bams[0])\n region2data = {}\n sample2idx = {s: i for i, s in enumerate(samples)}; print(s... | [
"0.5908855",
"0.54569936",
"0.5322768",
"0.5313147",
"0.5301625",
"0.53015983",
"0.5290556",
"0.52887326",
"0.528543",
"0.5255901",
"0.52539086",
"0.52324796",
"0.52108496",
"0.52033883",
"0.5170586",
"0.5168382",
"0.5167442",
"0.51477975",
"0.5144637",
"0.5129123",
"0.511288... | 0.68044555 | 0 |
Computes the MBAR free energy given the reduced potential and the number of relevant entries in it. | def estimatewithMBAR(u_kln, N_k, reltol, regular_estimate=False):
def plotOverlapMatrix(O):
"""Plots the probability of observing a sample from state i (row) in state j (column).
For convenience, the neigboring state cells are fringed in bold."""
max_prob = O.max()
fig = pl.figure(figsize=(K/2.,K/2.))
fig.add_subplot(111, frameon=False, xticks=[], yticks=[])
for i in range(K):
if i!=0:
pl.axvline(x=i, ls='-', lw=0.5, color='k', alpha=0.25)
pl.axhline(y=i, ls='-', lw=0.5, color='k', alpha=0.25)
for j in range(K):
if O[j,i] < 0.005:
ii = ''
elif O[j,i] > 0.995:
ii = '1.00'
else:
ii = ("%.2f" % O[j,i])[1:]
alf = O[j,i]/max_prob
pl.fill_between([i,i+1], [K-j,K-j], [K-(j+1),K-(j+1)], color='k', alpha=alf)
pl.annotate(ii, xy=(i,j), xytext=(i+0.5,K-(j+0.5)), size=8, textcoords='data', va='center', ha='center', color=('k' if alf < 0.5 else 'w'))
if P.bSkipLambdaIndex:
ks = [int(l) for l in P.bSkipLambdaIndex.split('-')]
ks = numpy.delete(numpy.arange(K+len(ks)), ks)
else:
ks = range(K)
for i in range(K):
pl.annotate(ks[i], xy=(i+0.5, 1), xytext=(i+0.5, K+0.5), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.annotate(ks[i], xy=(-0.5, K-(j+0.5)), xytext=(-0.5, K-(i+0.5)), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.annotate('$\lambda$', xy=(-0.5, K-(j+0.5)), xytext=(-0.5, K+0.5), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.plot([0,K], [0,0], 'k-', lw=4.0, solid_capstyle='butt')
pl.plot([K,K], [0,K], 'k-', lw=4.0, solid_capstyle='butt')
pl.plot([0,0], [0,K], 'k-', lw=2.0, solid_capstyle='butt')
pl.plot([0,K], [K,K], 'k-', lw=2.0, solid_capstyle='butt')
cx = sorted(2*range(K+1))
cy = sorted(2*range(K+1), reverse=True)
pl.plot(cx[2:-1], cy[1:-2], 'k-', lw=2.0)
pl.plot(numpy.array(cx[2:-3])+1, cy[1:-4], 'k-', lw=2.0)
pl.plot(cx[1:-2], numpy.array(cy[:-3])-1, 'k-', lw=2.0)
pl.plot(cx[1:-4], numpy.array(cy[:-5])-2, 'k-', lw=2.0)
pl.xlim(-1, K)
pl.ylim(0, K+1)
pl.savefig(os.path.join(P.output_directory, 'O_MBAR.pdf'), bbox_inches='tight', pad_inches=0.0)
pl.close(fig)
return
if regular_estimate:
print "\nEstimating the free energy change with MBAR..."
MBAR = pymbar.mbar.MBAR(u_kln, N_k, verbose = P.verbose, relative_tolerance = reltol, initialize = P.init_with)
# Get matrix of dimensionless free energy differences and uncertainty estimate.
(Deltaf_ij, dDeltaf_ij, theta_ij ) = MBAR.getFreeEnergyDifferences(uncertainty_method='svd-ew', return_theta = True)
if P.verbose:
print "Matrix of free energy differences\nDeltaf_ij:\n%s\ndDeltaf_ij:\n%s" % (Deltaf_ij, dDeltaf_ij)
if regular_estimate:
if P.overlap:
print "The overlap matrix is..."
O = MBAR.computeOverlap()[2]
for k in range(K):
line = ''
for l in range(K):
line += ' %5.2f ' % O[k, l]
print line
plotOverlapMatrix(O)
print "\nFor a nicer figure look at 'O_MBAR.pdf'"
return (Deltaf_ij, dDeltaf_ij)
return (Deltaf_ij[0,K-1]/P.beta_report, dDeltaf_ij[0,K-1]/P.beta_report) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bethe_free_energy(self, potential):\n xn, xe, lpn, lpe, alpha = self(None, full_out=False)\n fn, fe = potential((xn, xe))\n bfe = -(tf.reduce_sum((fn + self.tw * lpn) * self.wn * alpha, [2, 3, 4]) +\n tf.reduce_sum((fe - lpe) * self.we * alpha, [2, 3, 4]))\n return bf... | [
"0.6321866",
"0.6285089",
"0.62403625",
"0.6177378",
"0.61164016",
"0.5873943",
"0.58185613",
"0.58177686",
"0.5722714",
"0.56651354",
"0.56518394",
"0.56394243",
"0.55663705",
"0.55481577",
"0.55286837",
"0.5522224",
"0.54651517",
"0.5449803",
"0.5437534",
"0.54333156",
"0.5... | 0.0 | -1 |
Plots the probability of observing a sample from state i (row) in state j (column). For convenience, the neigboring state cells are fringed in bold. | def plotOverlapMatrix(O):
max_prob = O.max()
fig = pl.figure(figsize=(K/2.,K/2.))
fig.add_subplot(111, frameon=False, xticks=[], yticks=[])
for i in range(K):
if i!=0:
pl.axvline(x=i, ls='-', lw=0.5, color='k', alpha=0.25)
pl.axhline(y=i, ls='-', lw=0.5, color='k', alpha=0.25)
for j in range(K):
if O[j,i] < 0.005:
ii = ''
elif O[j,i] > 0.995:
ii = '1.00'
else:
ii = ("%.2f" % O[j,i])[1:]
alf = O[j,i]/max_prob
pl.fill_between([i,i+1], [K-j,K-j], [K-(j+1),K-(j+1)], color='k', alpha=alf)
pl.annotate(ii, xy=(i,j), xytext=(i+0.5,K-(j+0.5)), size=8, textcoords='data', va='center', ha='center', color=('k' if alf < 0.5 else 'w'))
if P.bSkipLambdaIndex:
ks = [int(l) for l in P.bSkipLambdaIndex.split('-')]
ks = numpy.delete(numpy.arange(K+len(ks)), ks)
else:
ks = range(K)
for i in range(K):
pl.annotate(ks[i], xy=(i+0.5, 1), xytext=(i+0.5, K+0.5), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.annotate(ks[i], xy=(-0.5, K-(j+0.5)), xytext=(-0.5, K-(i+0.5)), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.annotate('$\lambda$', xy=(-0.5, K-(j+0.5)), xytext=(-0.5, K+0.5), size=10, textcoords=('data', 'data'), va='center', ha='center', color='k')
pl.plot([0,K], [0,0], 'k-', lw=4.0, solid_capstyle='butt')
pl.plot([K,K], [0,K], 'k-', lw=4.0, solid_capstyle='butt')
pl.plot([0,0], [0,K], 'k-', lw=2.0, solid_capstyle='butt')
pl.plot([0,K], [K,K], 'k-', lw=2.0, solid_capstyle='butt')
cx = sorted(2*range(K+1))
cy = sorted(2*range(K+1), reverse=True)
pl.plot(cx[2:-1], cy[1:-2], 'k-', lw=2.0)
pl.plot(numpy.array(cx[2:-3])+1, cy[1:-4], 'k-', lw=2.0)
pl.plot(cx[1:-2], numpy.array(cy[:-3])-1, 'k-', lw=2.0)
pl.plot(cx[1:-4], numpy.array(cy[:-5])-2, 'k-', lw=2.0)
pl.xlim(-1, K)
pl.ylim(0, K+1)
pl.savefig(os.path.join(P.output_directory, 'O_MBAR.pdf'), bbox_inches='tight', pad_inches=0.0)
pl.close(fig)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __draw(self, state:dict):\n _, ax = plt.subplots()\n ax.set_axis_off()\n tb = Table(ax, bbox=[0,0,1,1])\n\n width = height = 1.0 /9 \n\n\n for key in self.state.keys():\n # Add cells\n i,j = self.__display_table_map[key]\n tb.add_cell(i, j, wi... | [
"0.62075657",
"0.6059904",
"0.60067856",
"0.5875241",
"0.58613783",
"0.5835459",
"0.57914424",
"0.5699644",
"0.5671611",
"0.56513095",
"0.5606568",
"0.5569045",
"0.5562588",
"0.55362916",
"0.5512227",
"0.550696",
"0.54794586",
"0.5475376",
"0.54668474",
"0.54337996",
"0.54149... | 0.0 | -1 |
Fills out the results table linewise. | def printLine(str1, str2, d1=None, d2=None):
print str1,
text = str1
for name in P.methods:
if d1 == 'plain':
print str2,
text += ' ' + str2
if d1 == 'name':
print str2 % (name, P.units),
text += ' ' + str2 % (name, P.units)
if d1 and d2:
print str2 % (d1[name]/P.beta_report, d2[name]/P.beta_report),
text += ' ' + str2 % (d1[name]/P.beta_report, d2[name]/P.beta_report)
print ''
outtext.append(text + '\n')
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_table(self):\n self.col_widths = []\n self.result = \"\"",
"def generate_table(self, rows):\n ...",
"def fill_table(self, executer, tree, cursor, table):\n counter = 0\n table_content = executer.lots_of_eggs(cursor, table)\n for line in table_content:\n ... | [
"0.65478563",
"0.6272289",
"0.62374914",
"0.6087662",
"0.5902959",
"0.58083314",
"0.57289517",
"0.5723789",
"0.5701637",
"0.56659144",
"0.56502664",
"0.563632",
"0.5613999",
"0.5606675",
"0.55917966",
"0.5551868",
"0.5539367",
"0.55313087",
"0.5485055",
"0.5482998",
"0.547419... | 0.0 | -1 |
Plots the free energy change computed using the equilibrated snapshots between the proper target time frames (f_ts and r_ts) in both forward (data points are stored in F_df and F_ddf) and reverse (data points are stored in R_df and R_ddf) directions. | def plotdFvsTime(f_ts, r_ts, F_df, R_df, F_ddf, R_ddf):
fig = pl.figure(figsize=(8,6))
ax = fig.add_subplot(111)
pl.setp(ax.spines['bottom'], color='#D2B9D3', lw=3, zorder=-2)
pl.setp(ax.spines['left'], color='#D2B9D3', lw=3, zorder=-2)
for dire in ['top', 'right']:
ax.spines[dire].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
max_fts = max(f_ts)
rr_ts = [aa/max_fts for aa in f_ts[::-1]]
f_ts = [aa/max_fts for aa in f_ts]
r_ts = [aa/max_fts for aa in r_ts]
line0 = pl.fill_between([r_ts[0], f_ts[-1]], R_df[0]-R_ddf[0], R_df[0]+R_ddf[0], color='#D2B9D3', zorder=-5)
for i in range(len(f_ts)):
line1 = pl.plot([f_ts[i]]*2, [F_df[i]-F_ddf[i], F_df[i]+F_ddf[i]], color='#736AFF', ls='-', lw=3, solid_capstyle='round', zorder=1)
line11 = pl.plot(f_ts, F_df, color='#736AFF', ls='-', lw=3, marker='o', mfc='w', mew=2.5, mec='#736AFF', ms=12, zorder=2)
for i in range(len(rr_ts)):
line2 = pl.plot([rr_ts[i]]*2, [R_df[i]-R_ddf[i], R_df[i]+R_ddf[i]], color='#C11B17', ls='-', lw=3, solid_capstyle='round', zorder=3)
line22 = pl.plot(rr_ts, R_df, color='#C11B17', ls='-', lw=3, marker='o', mfc='w', mew=2.5, mec='#C11B17', ms=12, zorder=4)
pl.xlim(r_ts[0], f_ts[-1])
pl.xticks(r_ts[::2] + f_ts[-1:], fontsize=10)
pl.yticks(fontsize=10)
leg = pl.legend((line1[0], line2[0]), (r'$Forward$', r'$Reverse$'), loc=1, prop=FP(size=18), frameon=False)
pl.xlabel(r'$\mathrm{Fraction\/of\/the\/simulation\/step}$', fontsize=16, color='#151B54')
pl.ylabel(r'$\mathrm{\Delta G\/%s}$' % P.units, fontsize=16, color='#151B54')
pl.xticks(f_ts, ['%.2f' % i for i in f_ts])
pl.tick_params(axis='x', color='#D2B9D3')
pl.tick_params(axis='y', color='#D2B9D3')
pl.savefig(os.path.join(P.output_directory, 'dF_t.pdf'))
pl.close(fig)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')... | [
"0.6313317",
"0.6141398",
"0.6133596",
"0.61213934",
"0.58762604",
"0.5865189",
"0.5831045",
"0.5801431",
"0.57747483",
"0.5743009",
"0.57139415",
"0.56994927",
"0.56850445",
"0.5679581",
"0.5657056",
"0.5632359",
"0.56177044",
"0.5578176",
"0.5577838",
"0.55500615",
"0.55456... | 0.65924156 | 0 |
Plots the free energy differences evaluated for each pair of adjacent states for all methods. | def plotdFvsLambda1():
x = numpy.arange(len(df_allk))
if x[-1]<8:
fig = pl.figure(figsize = (8,6))
else:
fig = pl.figure(figsize = (len(x),6))
width = 1./(len(P.methods)+1)
elw = 30*width
colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}
lines = tuple()
for name in P.methods:
y = [df_allk[i][name]/P.beta_report for i in x]
ye = [ddf_allk[i][name]/P.beta_report for i in x]
line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.1*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))
lines += (line[0],)
pl.xlabel('States', fontsize=12, color='#151B54')
pl.ylabel('$\Delta G$ '+P.units, fontsize=12, color='#151B54')
pl.xticks(x+0.5*width*len(P.methods), tuple(['%d--%d' % (i, i+1) for i in x]), fontsize=8)
pl.yticks(fontsize=8)
pl.xlim(x[0], x[-1]+len(lines)*width)
ax = pl.gca()
for dir in ['right', 'top', 'bottom']:
ax.spines[dir].set_color('none')
ax.yaxis.set_ticks_position('left')
for tick in ax.get_xticklines():
tick.set_visible(False)
leg = pl.legend(lines, tuple(P.methods), loc=3, ncol=2, prop=FP(size=10), fancybox=True)
leg.get_frame().set_alpha(0.5)
pl.title('The free energy change breakdown', fontsize = 12)
pl.savefig(os.path.join(P.output_directory, 'dF_state_long.pdf'), bbox_inches='tight')
pl.close(fig)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vis_difference(self):\n print(self.init_vec)\n\n init = self.init_output.numpy()\n\n alphas = np.linspace(0, 1, 20)\n for i, alpha in enumerate(alphas):\n\n display.clear_output(wait=True)\n norm = [torch.linalg.norm(torch.tensor(\n self.init_vec... | [
"0.6425327",
"0.6316091",
"0.6314955",
"0.60346085",
"0.5971509",
"0.59265935",
"0.585417",
"0.58146745",
"0.5805727",
"0.5739992",
"0.5732385",
"0.57270944",
"0.57151026",
"0.560639",
"0.5592231",
"0.5590342",
"0.55784935",
"0.5556301",
"0.55454224",
"0.55395085",
"0.5513448... | 0.5443678 | 29 |
Plots the free energy differences evaluated for each pair of adjacent states for all methods. The layout is approximately 'nb' bars per subplot. | def plotdFvsLambda2(nb=10):
x = numpy.arange(len(df_allk))
if len(x) < nb:
return
xs = numpy.array_split(x, len(x)/nb+1)
mnb = max([len(i) for i in xs])
fig = pl.figure(figsize = (8,6))
width = 1./(len(P.methods)+1)
elw = 30*width
colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431', 'IEXP':'#FF3030', 'GINS':'#EAC117', 'GDEL':'#347235', 'BAR':'#6698FF', 'UBAR':'#817339', 'RBAR':'#C11B17', 'MBAR':'#F9B7FF'}
ndx = 1
for x in xs:
lines = tuple()
ax = pl.subplot(len(xs), 1, ndx)
for name in P.methods:
y = [df_allk[i][name]/P.beta_report for i in x]
ye = [ddf_allk[i][name]/P.beta_report for i in x]
line = pl.bar(x+len(lines)*width, y, width, color=colors[name], yerr=ye, lw=0.05*elw, error_kw=dict(elinewidth=elw, ecolor='black', capsize=0.5*elw))
lines += (line[0],)
for dir in ['left', 'right', 'top', 'bottom']:
if dir == 'left':
ax.yaxis.set_ticks_position(dir)
else:
ax.spines[dir].set_color('none')
pl.yticks(fontsize=10)
ax.xaxis.set_ticks([])
for i in x+0.5*width*len(P.methods):
ax.annotate('$\mathrm{%d-%d}$' % (i, i+1), xy=(i, 0), xycoords=('data', 'axes fraction'), xytext=(0, -2), size=10, textcoords='offset points', va='top', ha='center')
pl.xlim(x[0], x[-1]+len(lines)*width + (mnb - len(x)))
ndx += 1
leg = ax.legend(lines, tuple(P.methods), loc=0, ncol=2, prop=FP(size=8), title='$\mathrm{\Delta G\/%s\/}\mathit{vs.}\/\mathrm{lambda\/pair}$' % P.units, fancybox=True)
leg.get_frame().set_alpha(0.5)
pl.savefig(os.path.join(P.output_directory, 'dF_state.pdf'), bbox_inches='tight')
pl.close(fig)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n... | [
"0.6250733",
"0.6131744",
"0.61037934",
"0.6092076",
"0.60732573",
"0.59801644",
"0.59770113",
"0.5963969",
"0.59115875",
"0.58646387",
"0.5833313",
"0.58220226",
"0.5787901",
"0.57865995",
"0.5741407",
"0.5739193",
"0.57294893",
"0.57286334",
"0.5718547",
"0.57135636",
"0.56... | 0.62457854 | 1 |
Plots the ave_dhdl array as a function of the lambda value. If (TI and TICUBIC in methods) plots the TI integration area and the TICUBIC interpolation curve, elif (only one of them in methods) plots the integration area of the method. | def plotTI():
min_dl = dlam[dlam != 0].min()
S = int(0.4/min_dl)
fig = pl.figure(figsize = (8,6))
ax = fig.add_subplot(1,1,1)
ax.spines['bottom'].set_position('zero')
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
for k, spine in ax.spines.items():
spine.set_zorder(12.2)
xs, ndx, dx = [0], 0, 0.001
colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']
min_y, max_y = 0, 0
lines = tuple()
## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper
lv_names2 = []
for j in range(n_components):
y = ave_dhdl[:,j]
if not (y == 0).all():
lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())
for j in range(n_components):
y = ave_dhdl[:,j]
if not (y == 0).all():
# Get the coordinates.
lj = lchange[:,j]
x = lv[:,j][lj]
y = y[lj]/P.beta_report
if 'TI' in P.methods:
# Plot the TI integration area.
ss = 'TI'
for i in range(len(x)-1):
min_y = min(y.min(), min_y)
max_y = max(y.max(), max_y)
#pl.plot(x,y)
if i%2==0:
pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)
else:
pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)
xlegend = [-100*wnum for wnum in range(len(lv_names2))]
pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper
if 'TI-CUBIC' in P.methods and not cubspl[j]==0:
# Plot the TI-CUBIC interpolation curve.
ss += ' and TI-CUBIC'
xnew = numpy.arange(0, 1+dx, dx)
ynew = cubspl[j].interpolate(y, xnew)
min_y = min(ynew.min(), min_y)
max_y = max(ynew.max(), max_y)
pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)
else:
# Plot the TI-CUBIC integration area.
ss = 'TI-CUBIC'
for i in range(len(x)-1):
xnew = numpy.arange(x[i], x[i+1]+dx, dx)
ynew = cubspl[j].interpolate(y, xnew)
ynew[0], ynew[-1] = y[i], y[i+1]
min_y = min(ynew.min(), min_y)
max_y = max(ynew.max(), max_y)
if i%2==0:
pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)
else:
pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)
# Store the abscissa values and update the subplot index.
xs += (x+ndx).tolist()[1:]
ndx += 1
# Make sure the tick labels are not overcrowded.
xs = numpy.array(xs)
dl_mat = numpy.array([xs-i for i in xs])
ri = range(len(xs))
def getInd(r=ri, z=[0]):
primo = r[0]
min_dl=ndx*0.02*2**(primo>10)
if dl_mat[primo].max()<min_dl:
return z
for i in r:
for j in range(len(xs)):
if dl_mat[i,j]>min_dl:
z.append(j)
return getInd(ri[j:], z)
xt = [i if (i in getInd()) else '' for i in range(K)]
pl.xticks(xs[1:], xt[1:], fontsize=10)
pl.yticks(fontsize=10)
#ax = pl.gca()
#for label in ax.get_xticklabels():
# label.set_bbox(dict(fc='w', ec='None', alpha=0.5))
# Remove the abscissa ticks and set up the axes limits.
for tick in ax.get_xticklines():
tick.set_visible(False)
pl.xlim(0, ndx)
min_y *= 1.01
max_y *= 1.01
pl.ylim(min_y, max_y)
for i,j in zip(xs[1:], xt[1:]):
pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')
if ndx>1:
lenticks = len(ax.get_ymajorticklabels()) - 1
if min_y<0: lenticks -= 1
if lenticks < 5:
from matplotlib.ticker import AutoMinorLocator as AML
ax.yaxis.set_minor_locator(AML())
pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)
pl.ylabel(r'$\mathrm{\langle{\frac{ \partial U } { \partial \lambda }}\rangle_{\lambda}\/%s}$' % P.units, fontsize=20, color='#151B54')
pl.annotate('$\mathit{\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')
if not P.software.title()=='Sire':
lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)
for l in lege.legendHandles:
l.set_linewidth(10)
pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))
pl.close(fig)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plotdFvsLambda1():\n x = numpy.arange(len(df_allk))\n if x[-1]<8:\n fig = pl.figure(figsize = (8,6))\n else:\n fig = pl.figure(figsize = (len(x),6))\n width = 1./(len(P.methods)+1)\n elw = 30*width\n colors = {'TI':'#C45AEC', 'TI-CUBIC':'#33CC33', 'DEXP':'#F87431',... | [
"0.5631575",
"0.56224716",
"0.55810195",
"0.5569204",
"0.544854",
"0.54324406",
"0.5401097",
"0.5397317",
"0.53738916",
"0.53561234",
"0.5292456",
"0.52792794",
"0.52540356",
"0.52267444",
"0.5214065",
"0.52021885",
"0.5194347",
"0.5180309",
"0.5170628",
"0.51551074",
"0.5147... | 0.5738737 | 0 |
A graphical representation of what Bennett calls 'CurveFitting Method'. | def plotCFM(u_kln, N_k, num_bins=100):
print "Plotting the CFM figure..."
def leaveTicksOnlyOnThe(xdir, ydir, axis):
dirs = ['left', 'right', 'top', 'bottom']
axis.xaxis.set_ticks_position(xdir)
axis.yaxis.set_ticks_position(ydir)
return
def plotdg_vs_dU(yy, df_allk, ddf_allk):
sq = (len(yy))**0.5
h = int(sq)
w = h + 1 + 1*(sq-h>0.5)
scale = round(w/3., 1)+0.4 if len(yy)>13 else 1
sf = numpy.ceil(scale*3) if scale>1 else 0
fig = pl.figure(figsize = (8*scale,6*scale))
matplotlib.rc('axes', facecolor = '#E3E4FA')
matplotlib.rc('axes', edgecolor = 'white')
if P.bSkipLambdaIndex:
ks = [int(l) for l in P.bSkipLambdaIndex.split('-')]
ks = numpy.delete(numpy.arange(K+len(ks)), ks)
else:
ks = range(K)
for i, (xx_i, yy_i) in enumerate(yy):
ax = pl.subplot(h, w, i+1)
ax.plot(xx_i, yy_i, color='r', ls='-', lw=3, marker='o', mec='r')
leaveTicksOnlyOnThe('bottom', 'left', ax)
ax.locator_params(axis='x', nbins=5)
ax.locator_params(axis='y', nbins=6)
ax.fill_between(xx_i, df_allk[i]['BAR'] - ddf_allk[i]['BAR'], df_allk[i]['BAR'] + ddf_allk[i]['BAR'], color='#D2B9D3', zorder=-1)
ax.annotate(r'$\mathrm{%d-%d}$' % (ks[i], ks[i+1]), xy=(0.5, 0.9), xycoords=('axes fraction', 'axes fraction'), xytext=(0, -2), size=14, textcoords='offset points', va='top', ha='center', color='#151B54', bbox = dict(fc='w', ec='none', boxstyle='round', alpha=0.5))
pl.xlim(xx_i.min(), xx_i.max())
pl.annotate(r'$\mathrm{\Delta U_{i,i+1}\/(reduced\/units)}$', xy=(0.5, 0.03), xytext=(0.5, 0), xycoords=('figure fraction', 'figure fraction'), size=20+sf, textcoords='offset points', va='center', ha='center', color='#151B54')
pl.annotate(r'$\mathrm{\Delta g_{i+1,i}\/(reduced\/units)}$', xy=(0.06, 0.5), xytext=(0, 0.5), rotation=90, xycoords=('figure fraction', 'figure fraction'), size=20+sf, textcoords='offset points', va='center', ha='center', color='#151B54')
pl.savefig(os.path.join(P.output_directory, 'cfm.pdf'))
pl.close(fig)
return
def findOptimalMinMax(ar):
c = zip(*numpy.histogram(ar, bins=10))
thr = int(ar.size/8.)
mi, ma = ar.min(), ar.max()
for (i,j) in c:
if i>thr:
mi = j
break
for (i,j) in c[::-1]:
if i>thr:
ma = j
break
return mi, ma
def stripZeros(a, aa, b, bb):
z = numpy.array([a, aa[:-1], b, bb[:-1]])
til = 0
for i,j in enumerate(a):
if j>0:
til = i
break
z = z[:, til:]
til = 0
for i,j in enumerate(b[::-1]):
if j>0:
til = i
break
z = z[:, :len(a)+1-til]
a, aa, b, bb = z
return a, numpy.append(aa, 100), b, numpy.append(bb, 100)
K = len(u_kln)
yy = []
for k in range(0, K-1):
upto = min(N_k[k], N_k[k+1])
righ = -u_kln[k,k+1, : upto]
left = u_kln[k+1,k, : upto]
min1, max1 = findOptimalMinMax(righ)
min2, max2 = findOptimalMinMax(left)
mi = min(min1, min2)
ma = max(max1, max2)
(counts_l, xbins_l) = numpy.histogram(left, bins=num_bins, range=(mi, ma))
(counts_r, xbins_r) = numpy.histogram(righ, bins=num_bins, range=(mi, ma))
counts_l, xbins_l, counts_r, xbins_r = stripZeros(counts_l, xbins_l, counts_r, xbins_r)
counts_r, xbins_r, counts_l, xbins_l = stripZeros(counts_r, xbins_r, counts_l, xbins_l)
with numpy.errstate(divide='ignore', invalid='ignore'):
log_left = numpy.log(counts_l) - 0.5*xbins_l[:-1]
log_righ = numpy.log(counts_r) + 0.5*xbins_r[:-1]
diff = log_left - log_righ
yy.append((xbins_l[:-1], diff))
plotdg_vs_dU(yy, df_allk, ddf_allk)
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_fitted_curve(self):\n\t\tcxpX, cxpY = self.curveCXP.cxp_X, self.curveCXP.cxp_Y\n\t\tfittedX, fittedY = self.fitted_X, self.fitted_Y\n\t\tself.curveFig.plot(cxpX, cxpY, 'o', fittedX, fittedY)\n\t\tpass",
"def plot_fitting_coefficients(self):\n from matplotlib import pyplot as plt\n coeff = ... | [
"0.7055758",
"0.66392714",
"0.65292656",
"0.6458982",
"0.62626904",
"0.62592036",
"0.61264443",
"0.6093298",
"0.6078136",
"0.6074372",
"0.60485107",
"0.60373193",
"0.6032992",
"0.6027297",
"0.5985532",
"0.59401494",
"0.59209955",
"0.5901951",
"0.5901479",
"0.58885133",
"0.585... | 0.0 | -1 |
Searches for winning sequence in columns. | def check_columns(self, win: list) -> bool:
for row in range(self.size):
column = [self.tags[x][row] for x in range(self.size)]
for j in range(len(column) - len(win) + 1):
if win == column[j:j+self.win_condition]:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def col_win(board, player):\n for row in board.T:\n if check_row(row, player):\n return True\n return False",
"def check_columns():\n global game_still_going\n # Check if any of the rows have all the same value.\n column1 = board[0] == board[3] == board[6] != '_'\n column2 = b... | [
"0.6576831",
"0.6555307",
"0.64840585",
"0.6481743",
"0.6447641",
"0.63892657",
"0.6347227",
"0.63392514",
"0.629483",
"0.62593347",
"0.6223977",
"0.6137701",
"0.60959685",
"0.6069051",
"0.60535437",
"0.6050567",
"0.60471857",
"0.603175",
"0.59898293",
"0.5885481",
"0.5832774... | 0.6735366 | 0 |
Searches for winning sequence in rows. | def check_rows(self, win: list) -> bool:
for row in self.tags:
for j in range(len(row) - len(win) + 1):
if win == row[j:j+self.win_condition]:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_next_win(self, player):\n for i, j, k in self.winning_cases:\n if self.game_board[i] == player and \\\n self.game_board[j] == player and \\\n self.game_board[k] == ' ':\n return k\n elif self.game_board[j] == player and \\\n ... | [
"0.6718347",
"0.6526012",
"0.6286749",
"0.6253905",
"0.62017727",
"0.61693555",
"0.6116269",
"0.6089422",
"0.6063677",
"0.60391885",
"0.6026189",
"0.59956145",
"0.59509",
"0.5940875",
"0.5902935",
"0.58904356",
"0.5852451",
"0.58488286",
"0.58410406",
"0.5821735",
"0.58202726... | 0.65215236 | 2 |
Check for winning sequence in all possible diagonals that are at least as long as winning condition. | def check_diagonals(self, win: list) -> bool:
for i in range(self.size - self.win_condition + 1):
# [x x ]
# [ x x ]
# [ x x]
# [ x]
diagonal = []
x = i
y = 0
for j in range(self.size - i):
diagonal.append(self.tags[x][y])
x += 1
y += 1
for j in range(len(diagonal) - len(win) + 1):
if win == diagonal[j:j + self.win_condition]:
return True
# [x ]
# [x x ]
# [ x x ]
# [ x x]
diagonal = []
x = 0
y = i
for j in range(self.size - i):
diagonal.append(self.tags[x][y])
x += 1
y += 1
for j in range(len(diagonal) - len(win) + 1):
if win == diagonal[j:j + self.win_condition]:
return True
# [ x x]
# [ x x ]
# [x x ]
# [x ]
diagonal = []
x = self.size - 1 - i
y = 0
for j in range(self.size - i):
diagonal.append(self.tags[x][y])
x -= 1
y += 1
for j in range(len(diagonal) - len(win) + 1):
if win == diagonal[j:j + self.win_condition]:
return True
# [ x]
# [ x x]
# [ x x ]
# [x x ]
diagonal = []
x = self.size - 1
y = 0 + i
for j in range(self.size - i):
diagonal.append(self.tags[x][y])
x -= 1
y += 1
for j in range(len(diagonal) - len(win) + 1):
if win == diagonal[j:j + self.win_condition]:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_winning(self, curr_state):\n rows = [[0,1,2], [3,4,5], [6,7,8]]\n columns = [[0,3,6], [1,4,7], [2,5,8]]\n diagonal = [[0,4,8], [2,4,6]]\n total_checks = rows + columns + diagonal\n for row in total_checks:\n sum = 0\n count = 0\n for pos in... | [
"0.69447654",
"0.68922657",
"0.6877511",
"0.6859907",
"0.6785897",
"0.6660476",
"0.66416174",
"0.66363674",
"0.6619749",
"0.6578498",
"0.65732425",
"0.65712273",
"0.653169",
"0.6508",
"0.6497785",
"0.64893246",
"0.64755654",
"0.6452486",
"0.6433075",
"0.64247596",
"0.64144456... | 0.73726594 | 0 |
Checks if in any dimension the winning line is achieved. | def check_if_win(self, tag: str) -> bool:
win_line = [tag]*self.win_condition
return self.check_rows(win_line) or self.check_columns(win_line) or self.check_diagonals(win_line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isLineAt(self, x, y, dx, dy):\n\n initialValue = self.board[x][y]\n #checks a cell to see if there is a piece there\n if initialValue != 0:\n #loops though 3 times in a certain direction to see\n #if there is a winning configuration\n for i in range(3):\n ... | [
"0.7173354",
"0.70985824",
"0.6997996",
"0.6947743",
"0.68140584",
"0.6719319",
"0.6712507",
"0.6712507",
"0.6701225",
"0.6684429",
"0.6665015",
"0.665667",
"0.66564786",
"0.662193",
"0.6610499",
"0.6598199",
"0.65881664",
"0.6571598",
"0.6556325",
"0.6543641",
"0.6531366",
... | 0.6457668 | 27 |
Checks if the board is fully packed with figures, which in practice means => if the tags array is full. | def full_board(self) -> bool:
counter = 0
for column in self.tags:
if None in column:
counter += 1
return counter == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _board_is_full(self):\n return (self.get_counts()[0] + self.get_counts()[1] == self._num_rows * self._num_cols)",
"def is_full(board):\r\n return False",
"def is_full(board):\n return False",
"def check_grid_full(self):\n for row in self.game_state:\n for e in row:\n ... | [
"0.6820874",
"0.676673",
"0.6736874",
"0.6717051",
"0.6591668",
"0.65669096",
"0.6556075",
"0.6527779",
"0.6506026",
"0.6469064",
"0.64647114",
"0.6442245",
"0.6417079",
"0.6390676",
"0.63876194",
"0.637983",
"0.6371609",
"0.6350671",
"0.6347817",
"0.6293271",
"0.62686855",
... | 0.74219203 | 0 |
Checks for empty spaces in the tags list. If the empty space is found it's coordinates are being packed into tuple and into new list. | def check_for_moves(self) -> list:
avail_moves = []
for x in range(self.size):
for y in range(self.size):
if self.tags[x][y] is None:
avail_moves.append((x, y))
return avail_moves | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _preprocess(self, tagged: List[Tuple]) -> Tuple:\n ori = \" \".join([tag[0] for tag in tagged])\n tags = [tag[1] for tag in tagged]\n # Mapping into general tagset\n tags = [self._map[tag] if tag in self._map else \"X\" for tag in tags]\n return \" \".join(tags), ori",
"def... | [
"0.56815004",
"0.5611002",
"0.54052174",
"0.5345678",
"0.53289914",
"0.5290784",
"0.5282728",
"0.52795637",
"0.52427185",
"0.5172312",
"0.5162299",
"0.5155179",
"0.5121523",
"0.5118857",
"0.5089582",
"0.50675386",
"0.5064925",
"0.506162",
"0.50472486",
"0.50319785",
"0.500313... | 0.56864506 | 0 |
Function mashes together classes functionality and performs the AI's move. It recursively calls the minimax algorithm and after finding the best move it adds tag into the tags list. | def bot_handle_move(self) -> None:
best_value = -INFINITY # default best value for maximizing player (bot in this app is a maximizing player)
available_moves = self.check_for_moves() # for more info check the minimax algorithm theory
depth = int(1.4*self.size - self.win_condition) # (depth) decides of how deep into recursion the algorithm will
best_move = None # get. 1.4 seems to be the best consensus between time of
# execution and accuracy of moves
for move in available_moves:
self.tags[move[0]][move[1]] = 'o'
move_value = self.minimax(depth, -INFINITY, INFINITY, False)
self.tags[move[0]][move[1]] = None
if move_value > best_value:
best_value = move_value
best_move = move
self.tags[best_move[0]][best_move[1]] = 'o' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_move(self):\n\n # get relavent information\n affinity = self.get_affinity()\n sample_space = self.get_game_space()\n depth_limit = self.__search_depth\n\n # run a minimax search and get the best value\n bestval = MinimaxTree.alphabeta(self, sample_space, affinity,... | [
"0.55172825",
"0.53830636",
"0.537255",
"0.53636533",
"0.53437847",
"0.53437847",
"0.52932066",
"0.5251569",
"0.5240633",
"0.5203933",
"0.51793545",
"0.5154717",
"0.50856817",
"0.5070792",
"0.50352716",
"0.50260264",
"0.4998866",
"0.49944788",
"0.4988436",
"0.4984612",
"0.497... | 0.62191063 | 0 |
Minimax algorithm equipped in prunning functionality and wrapped into Ticktactoe game environment. | def minimax(self, depth: int, alpha: float, beta: float, maximizing_player: bool) -> float:
if self.check_if_win('x' if maximizing_player is True else 'o'):
return -10 if maximizing_player else 10
if self.full_board():
return 1
if depth == 0:
return 0
available_moves = self.check_for_moves()
if maximizing_player:
max_eval = -INFINITY
for move in available_moves:
self.tags[move[0]][move[1]] = 'o'
evaluation = self.minimax(depth - 1, alpha, beta, False)
self.tags[move[0]][move[1]] = None
max_eval = max(max_eval, evaluation)
alpha = max(alpha, evaluation)
if beta <= alpha:
break
return max_eval
else:
min_eval = INFINITY
for move in available_moves:
self.tags[move[0]][move[1]] = 'x'
evaluation = self.minimax(depth - 1, alpha, beta, True)
self.tags[move[0]][move[1]] = None
min_eval = min(min_eval, evaluation)
beta = min(beta, evaluation)
if beta <= alpha:
break
return min_eval | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterative_minimax_strategy(game: Any) -> Any:\n s = Stack()\n id0 = 0\n d = {0: Tree([id0, game, None])}\n s.add(0)\n\n while not s.is_empty():\n id1 = s.remove()\n item = [id1]\n if d[id1].children == []:\n for move in d[id1].value[1].current_state.get_possible_m... | [
"0.70844316",
"0.7019589",
"0.6996672",
"0.6943626",
"0.69175905",
"0.6854551",
"0.68362564",
"0.6793055",
"0.6789411",
"0.6709212",
"0.66958034",
"0.66800773",
"0.6658891",
"0.6658891",
"0.6573327",
"0.6429762",
"0.6422315",
"0.6422285",
"0.64213127",
"0.6387401",
"0.6386032... | 0.0 | -1 |
Summary This function encapsulates the routine to generate backprojected and cortical views for the magnocellular pathway retinal ganglion cells | def showNonOpponency(C,theta):
GI = retina.gauss_norm_img(x, y, dcoeff[i], dloc[i], imsize=imgsize,rgb=False)
# Sample using the other recepetive field, note there is no temporal response with still images
S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True)
#backproject the imagevectors
ncentreV,nsurrV = rgc.nonopponency(C,S,theta)
ninverse = retina.inverse(ncentreV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)
ninv_crop = retina.crop(ninverse,x,y,dloc[i])
ninverse2 = retina.inverse(nsurrV,x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)
ninv_crop2 = retina.crop(ninverse2,x,y,dloc[i])
# place descriptive text onto generated images
cv2.putText(ninv_crop,"R+G + ",(xx,yy), font, 1,(255,255,255),2)
cv2.putText(ninv_crop2,"R+G - ",(xx,yy), font, 1,(255,255,255),2)
merged = np.concatenate((ninv_crop, ninv_crop2),axis=1)
# create cortical maps of the imagevectors
lposnon, rposnon = cortex.cort_img(ncentreV, L, L_loc, R, R_loc, cort_size, G)
lnegnon, rnegnon = cortex.cort_img(nsurrV, L, L_loc, R, R_loc, cort_size, G)
pos_cort_img = np.concatenate((np.rot90(lposnon),np.rot90(rposnon,k=3)),axis=1)
neg_cort_img = np.concatenate((np.rot90(lnegnon),np.rot90(rnegnon,k=3)),axis=1)
mergecort = np.concatenate((pos_cort_img,neg_cort_img),axis=1)
return merged, mergecort | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_marginals_cristobal(rep=0, epoch=300, zoom=False):\n samples_path = paths.eICU_synthetic_dir + 'samples_eICU_cdgan_synthetic_dataset_r' + str(rep) + '_' + str(epoch) + '.pk'\n samples = np.load(samples_path)\n labels_path = paths.eICU_synthetic_dir + 'labels_eICU_cdgan_synthetic_dataset_r' + str(... | [
"0.57697564",
"0.56456137",
"0.5626997",
"0.54784644",
"0.5438757",
"0.5425025",
"0.5424559",
"0.5415921",
"0.5378045",
"0.5369334",
"0.5367731",
"0.536001",
"0.53513986",
"0.5345884",
"0.52968204",
"0.52847725",
"0.5271479",
"0.52679116",
"0.5252435",
"0.5250521",
"0.5245161... | 0.0 | -1 |
Summary This function encapsulates the routine to generate rectified backprojected views of all opponent retinal ganglion cells | def showBPImg(pV,nV):
# object arrays of the positive and negative images
inv_crop = np.empty(8, dtype=object)
inv_crop2 = np.empty(8, dtype=object)
for t in range(8):
# backprojection functions
inverse = retina.inverse(pV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)
inv_crop[t] = retina.crop(inverse,x,y,dloc[i])
inverse2 = retina.inverse(nV[:,t,:],x,y,dcoeff[i],dloc[i], GI, imsize=imgsize,rgb=True)
inv_crop2[t] = retina.crop(inverse2,x,y,dloc[i])
# place descriptions
cv2.putText(inv_crop[t],types[t] + " + ",(xx,yy), font, 1,(0,255,255),2)
cv2.putText(inv_crop2[t],types[t] + " - ",(xx,yy), font, 1,(0,255,255),2)
# stack all images into a grid
posRG = np.vstack((inv_crop[:4]))
negRG = np.vstack((inv_crop2[:4]))
posYB = np.vstack((inv_crop[4:]))
negYB = np.vstack((inv_crop2[4:]))
merge = np.concatenate((posRG,negRG,posYB,negYB),axis=1)
return merge | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_obs_grid(self):\n\n topX, topY, botX, botY = self.get_view_exts()\n\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\n\n # for i in range(self.agent_dir + 1):\n # grid = grid.rotate_left()\n\n # Process occluders and visibility\n ... | [
"0.60112906",
"0.56915206",
"0.5676106",
"0.56413585",
"0.5641",
"0.56370586",
"0.5621993",
"0.55501646",
"0.55181795",
"0.5482959",
"0.541228",
"0.540904",
"0.5401558",
"0.54013026",
"0.5396132",
"0.538648",
"0.53705466",
"0.533314",
"0.530924",
"0.5304909",
"0.5286061",
"... | 0.51816034 | 42 |
Summary This function encapsulates the routine to generate rectified cortical views of all opponent retinal ganglion cells | def showCortexImg(pV,nV):
# object arrays of the positive and negative images
pos_cort_img = np.empty(8, dtype=object)
neg_cort_img = np.empty(8, dtype=object)
for t in range(8):
# cortical mapping functions
lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)
lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)
pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)
neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)
# stack all images into a grid
posRGcort = np.vstack((pos_cort_img[:4]))
negRGcort = np.vstack((neg_cort_img[:4]))
posYBcort = np.vstack((pos_cort_img[4:]))
negYBcort = np.vstack((neg_cort_img[4:]))
mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)
return mergecort | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_obs_grid(self):\n\n topX, topY, botX, botY = self.get_view_exts()\n\n grid = self.grid.slice(topX, topY, self.agent_view_size, self.agent_view_size)\n\n # for i in range(self.agent_dir + 1):\n # grid = grid.rotate_left()\n\n # Process occluders and visibility\n ... | [
"0.60586804",
"0.59049714",
"0.58672416",
"0.58215404",
"0.5733954",
"0.5612951",
"0.55945617",
"0.55556804",
"0.5546608",
"0.55396324",
"0.5498219",
"0.5490474",
"0.54275817",
"0.54215384",
"0.54196",
"0.54184324",
"0.5405503",
"0.53821653",
"0.53821653",
"0.537462",
"0.5356... | 0.5189932 | 41 |
Summary Display function that generates the final output images using opencv windows | def imagetest(thetainput,doubleopponencyinput):
theta = thetainput
rgcMode = doubleopponencyinput
C = retina.sample(img,x,y,coeff[i],loc[i],rgb=True) # CENTRE
S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True) # SURROUND
if rgcMode == 0:
pV,nV = rgc.opponency(C,S,theta)
else:
pV,nV = rgc.doubleopponency(C,S,theta)
cv2.namedWindow("Input", cv2.WINDOW_NORMAL)
cv2.imshow("Input", img)
rIntensity,cIntensity = showNonOpponency(C,theta)
cv2.namedWindow("Intensity Responses", cv2.WINDOW_NORMAL)
cv2.imshow("Intensity Responses", rIntensity)
cv2.namedWindow("Intensity Responses Cortex", cv2.WINDOW_NORMAL)
cv2.imshow("Intensity Responses Cortex", cIntensity)
cv2.waitKey(0)
#Generate backprojected images
if showInverse:
rOpponent = showBPImg(pV,nV)
cv2.namedWindow("Backprojected Opponent Cells Output", cv2.WINDOW_NORMAL)
cv2.imshow("Backprojected Opponent Cells Output", rOpponent)
cv2.waitKey(0)
# Cortex
if showCortex:
cOpponent = showCortexImg(pV,nV)
cv2.namedWindow("Cortex Opponent Cells Output", cv2.WINDOW_NORMAL)
cv2.imshow("Cortex Opponent Cells Output", cOpponent)
cv2.waitKey(0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show(self, name='Detections'):\n cv2.imshow(name, self.get_image())\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def show(self) -> None:\n cv.imshow(str(self.__class__), self.output_image)",
"def display_img(title,img):\r\n cv2.namedWindow('img', cv2.WINDOW_NORMAL)\r\n cv... | [
"0.71970654",
"0.7002493",
"0.6995437",
"0.6975558",
"0.69294494",
"0.69176483",
"0.69103956",
"0.68500286",
"0.6783941",
"0.6769802",
"0.67669165",
"0.6740594",
"0.6729734",
"0.6711798",
"0.66964775",
"0.6684703",
"0.66664636",
"0.66619647",
"0.66425073",
"0.6603232",
"0.660... | 0.0 | -1 |
Summary Display function that generates the final output images using MatplotLib windows | def imagetestplt(thetainput,doubleopponencyinput):
theta = thetainput
rgcMode = doubleopponencyinput
C = retina.sample(img,x,y,coeff[i],loc[i],rgb=True) # CENTRE(sharp retina)
S = retina.sample(img,x,y,dcoeff[i],dloc[i],rgb=True) # SURROUND(blurred retina)
if rgcMode == 0:
pV,nV = rgc.opponency(C,S,theta)
else:
pV,nV = rgc.doubleopponency(C,S,theta)
rIntensity,cIntensity = showNonOpponency(C,theta)
# Construct window plots
plt.subplot(3,1,1), plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)), plt.title('Original test image')
plt.xticks([]), plt.yticks([])
plt.subplot(3,1,2), plt.imshow(cv2.cvtColor(rIntensity, cv2.COLOR_BGR2RGB)), plt.title('Backprojected R+G Intensity Response')
plt.xticks([]), plt.yticks([])
plt.subplot(3,1,3), plt.imshow(cv2.cvtColor(cIntensity, cv2.COLOR_BGR2RGB)), plt.title('Cortical R+G Intensity Response')
plt.xticks([]), plt.yticks([])
# format float to string
thetastring = "%.2f" % theta
plt.suptitle('Rectified DoG Intensity Images. Threshold:' + thetastring, fontsize=16)
plt.show()
#Generate backprojected images
if showInverse:
rOpponent = showBPImg(pV,nV)
plt.imshow(cv2.cvtColor(rOpponent, cv2.COLOR_BGR2RGB)), plt.title('Backprojected Opponent Cells Output')
plt.xticks([]), plt.yticks([])
plt.show()
# Cortex
if showCortex:
cOpponent = showCortexImg(pV,nV)
plt.imshow(cv2.cvtColor(cOpponent, cv2.COLOR_BGR2RGB)), plt.title('Cortex Opponent Cells Output')
plt.xticks([]), plt.yticks([])
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n... | [
"0.6950144",
"0.6822228",
"0.6799319",
"0.6795833",
"0.6745523",
"0.6712222",
"0.66112965",
"0.6607922",
"0.65862733",
"0.6581138",
"0.65078765",
"0.6487054",
"0.64790344",
"0.646684",
"0.64635116",
"0.64561826",
"0.64561826",
"0.64561826",
"0.6436497",
"0.64337176",
"0.64246... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.