attacker:\\r\\n debug.write(\\\"Userid is not the same as the attacker\\\", 2)\\r\\n if attacker.isdigit() and int(attacker) > 0:\\r\\n debug.write(\\\"Attacker is not of world spawn\\\", 2)\\r\\n if event_var['es_userteam'] <> event_var['es_attacker']:\\r\\n \\\"\\\"\\\" If one of the players is a bot and is not legible for experience, return \\\"\\\"\\\"\\r\\n debug.write(\\\"Users are on different teams\\\", 2)\\r\\n if not canReceiveExperience(userid, attacker):\\r\\n return\\r\\n debug.write(\\\"Adding the experience\\\", 1)\\r\\n player = players[attacker]\\r\\n player.addXp( int(killXp) * players[userid]['level'], \\\"making a kill\\\" )\\r\\n if event_var['headshot'] and int(event_var['headshot']):\\r\\n player.addXp( int(headshotXp), \\\"scoring a headshot\\\" )\\r\\n weapon = event_var['weapon']\\r\\n if weapon in weaponXp:\\r\\n if weaponXp[weapon][1]:\\r\\n useN = \\\"n\\\" if weapon[0] in (\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\") else \\\"\\\"\\r\\n player.addXp( weaponXp[weapon][1], \\\"killing a player with a%s %s\\\" % ( useN, weapon ))\\r\\n debug.write(\\\"Resetting player to default attributes\\\", 1)\\r\\n players[userid].resetPlayerDefaultAttributes()\\r\\n debug.write(\\\"[SourceRPG] player_death handled\\\", 1)\",\n \"def remove_record_failure():\\n\\t\\tpass\",\n \"def shutdown_session(exception=None):\\n get_db().remove()\",\n \"def die(self):\\n print(\\\"Company\\\", self.ticker, \\\"left the universe\\\")\\n del self\\n Company.population -= 1\",\n \"def close_db(error):\\n if hasattr(g, 'pg_db'):\\n g.pg_db.close()\",\n \"def teardown_request(exception):\\n\\tdb = getattr(g, 'db', None)\\n\\tif db is not None:\\n\\t\\tdb.close()\\n\\telse:\\n\\t\\tprint \\\"DB was null!\\\"\",\n \"def close_db(error):\\n if hasattr(g, 'postgres_db'):\\n g.postgres_db.close()\",\n \"def die(errmsg):\\n eprint(errmsg)\\n exit(1)\",\n \"def get_death(self):\\r\\n if self.dead:\\r\\n self.dead = False\\r\\n return True\\r\\n return False\",\n \"def die(msg='Something bad happened'):\\n warn(msg)\\n sys.exit(1)\",\n \"def die(msg='Something bad happened'):\\n warn(msg)\\n sys.exit(1)\",\n \"def die(msg='Something bad happened'):\\n warn(msg)\\n sys.exit(1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72399086","0.701081","0.67726815","0.6647561","0.662502","0.65819335","0.64344263","0.62199175","0.6132314","0.60777444","0.59452045","0.59283155","0.5908845","0.5903316","0.5892717","0.5827417","0.5791009","0.5779763","0.5734716","0.56824976","0.568101","0.56657857","0.56290025","0.5613495","0.5610152","0.5606694","0.56007427","0.5595927","0.55896306","0.5587981","0.55576515","0.5516976","0.5516976","0.5506498","0.5499584","0.5491998","0.54746985","0.54706705","0.54485095","0.5445183","0.54440707","0.5434269","0.5432182","0.54160553","0.54121214","0.5401635","0.5400925","0.53978497","0.53932035","0.53877336","0.53877336","0.53877336","0.5385575","0.53733087","0.5369737","0.53690267","0.53683186","0.53630203","0.5363001","0.53528374","0.53528374","0.53528374","0.53528374","0.5350967","0.53391993","0.53339756","0.53330624","0.5317814","0.5307474","0.5293581","0.52837145","0.5280996","0.527913","0.52785337","0.52780235","0.52725685","0.52703434","0.52641964","0.52548504","0.52547747","0.5251411","0.5248756","0.5245715","0.52430093","0.52378786","0.5234633","0.5231738","0.522989","0.522989","0.5225908","0.52239794","0.52221763","0.522073","0.5219074","0.52159435","0.5210658","0.52106047","0.5207991","0.5202329","0.5202329","0.5202329"],"string":"[\n \"0.72399086\",\n \"0.701081\",\n \"0.67726815\",\n \"0.6647561\",\n \"0.662502\",\n \"0.65819335\",\n \"0.64344263\",\n \"0.62199175\",\n \"0.6132314\",\n \"0.60777444\",\n \"0.59452045\",\n \"0.59283155\",\n \"0.5908845\",\n \"0.5903316\",\n \"0.5892717\",\n \"0.5827417\",\n \"0.5791009\",\n \"0.5779763\",\n \"0.5734716\",\n \"0.56824976\",\n \"0.568101\",\n \"0.56657857\",\n \"0.56290025\",\n \"0.5613495\",\n \"0.5610152\",\n \"0.5606694\",\n \"0.56007427\",\n \"0.5595927\",\n \"0.55896306\",\n \"0.5587981\",\n \"0.55576515\",\n \"0.5516976\",\n \"0.5516976\",\n \"0.5506498\",\n \"0.5499584\",\n \"0.5491998\",\n \"0.54746985\",\n \"0.54706705\",\n \"0.54485095\",\n \"0.5445183\",\n \"0.54440707\",\n \"0.5434269\",\n \"0.5432182\",\n \"0.54160553\",\n \"0.54121214\",\n \"0.5401635\",\n \"0.5400925\",\n \"0.53978497\",\n \"0.53932035\",\n \"0.53877336\",\n \"0.53877336\",\n \"0.53877336\",\n \"0.5385575\",\n \"0.53733087\",\n \"0.5369737\",\n \"0.53690267\",\n \"0.53683186\",\n \"0.53630203\",\n \"0.5363001\",\n \"0.53528374\",\n \"0.53528374\",\n \"0.53528374\",\n \"0.53528374\",\n \"0.5350967\",\n \"0.53391993\",\n \"0.53339756\",\n \"0.53330624\",\n \"0.5317814\",\n \"0.5307474\",\n \"0.5293581\",\n \"0.52837145\",\n \"0.5280996\",\n \"0.527913\",\n \"0.52785337\",\n \"0.52780235\",\n \"0.52725685\",\n \"0.52703434\",\n \"0.52641964\",\n \"0.52548504\",\n \"0.52547747\",\n \"0.5251411\",\n \"0.5248756\",\n \"0.5245715\",\n \"0.52430093\",\n \"0.52378786\",\n \"0.5234633\",\n \"0.5231738\",\n \"0.522989\",\n \"0.522989\",\n \"0.5225908\",\n \"0.52239794\",\n \"0.52221763\",\n \"0.522073\",\n \"0.5219074\",\n \"0.52159435\",\n \"0.5210658\",\n \"0.52106047\",\n \"0.5207991\",\n \"0.5202329\",\n \"0.5202329\",\n \"0.5202329\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89488,"cells":{"query":{"kind":"string","value":"log a win in the database"},"document":{"kind":"string","value":"def ajax_victory(request, game_id):\n\tmyGame = tools.getGameFromGameId(int(game_id))\n\n\ttools.logVictory(myGame)\n\n\tresponse = {\n\t\t\"status\": \"OK\",\n\t\t\"message\": \"logged victory\"\n\t}\n\n\treturn HttpResponse(json.dumps(response), content_type=\"application/json\")"},"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 log(self, game: str, outcome: str):\n current_time = datetime.now()\n self.user.record.append([current_time.strftime(\"%c\"), game, outcome, self.user.balance])","def event_player_wins(self) -> None:\n win_amount = self.user.bet\n print(\"Congratulations, you win:\", win_amount)\n self.user.win_balance(self.user.bet)","def reportMatch(winner, loser):\n db = connect()\n db_cursor = db.cursor()\n db_cursor.execute(\"INSERT INTO matches(winner, loser) VALUES(%s,%s)\", (winner,loser))\n db.commit()\n db.close()","def reportMatch(winner, loser):\n dbConn = connect()\n c = dbConn.cursor()\n c.execute(\"INSERT INTO match (winner, loser) VALUES (%s,%s)\", (winner, loser))\n dbConn.commit()\n dbConn.close()","def InsertLog():","def reportMatch(winner, loser):\n executeNonQuery(\"INSERT INTO matches (winner, loser) VALUES (%s, %s);\", (winner,loser))","def log_result(winner_darter_id, loser_darter_id,reported_at):\n \n query = \"INSERT INTO matches(winner_darter_id,loser_darter_id,reported_at, created_at, updated_at) VALUES(%s,%s,%s,%s,%s)\"\n value = [(winner_darter_id, loser_darter_id, reported_at, CURRENT_EPOCH_TIME, CURRENT_EPOCH_TIME)]\n \n db.insert(query,value)","def on_win(data):\n print(str(data))\n update_score_db(data['winner'], data['loser'])\n users, scores = calculate_scores()\n socketio.emit('leaderboard_info', {'users': users, 'scores': scores})","def Log(self, msg):\n self.DBExecute(\"INSERT INTO Log (class, instance, event) VALUES (%s, %s, %s)\",\n self.__class__.__name__, self._instance, msg)\n print '%s/%s: %s' % (self.__class__.__name__, self._instance, msg)","def report_match(winner, loser):\n\n DB = connect()\n c = DB.cursor()\n c.execute(\"INSERT INTO matches (winner, loser) VALUES (%s,%s);\", (winner, loser))\n DB.commit()\n DB.close()","def reportMatch(winner, loser):\n conn, c = connect()\n c.execute(\"INSERT INTO matches (winner, loser) VALUES (%s, %s);\",\n (winner, loser,))\n conn.commit()\n conn.close()","def reportMatch(winner, loser):\n \n cursor.execute(\"insert into matches (winnerid, loserid) values (%s, %s)\" % (winner, loser))\n gc.commit()","def reportMatch(winner, loser):\n conn = connect()\n cursor = conn.cursor()\n cursor.execute(\"INSERT INTO results VALUES (%s, %s, true)\",\n (winner, loser))\n cursor.execute(\"INSERT INTO results VALUES (%s, %s, false)\",\n (loser, winner))\n conn.commit()\n conn.close()","def win(self):\n print \"\\n{0} has escaped the dungeon, as few before have. {0} survived {1} rooms.\\n\".format(self.name, self.roomCt)\n exit()","def reportMatch(winner, loser):\n DB = connect()\n c = DB.cursor()\n #updates number of wins and the number of matches played for the winner\n c.execute(\"UPDATE players SET wins = wins + 1, matches = matches +1 WHERE id = (%s)\", (bleach.clean(winner), ))\n #updates the number of matches for the loser\n c.execute(\"UPDATE players SET matches = matches + 1 WHERE id = (%s)\", (bleach.clean(loser), ))\n #add a match to matches table\n c.execute(\"UPDATE matches SET winner = (%s), loser = (%s)\", (bleach.clean(winner), bleach.clean(loser)))\n DB.commit()\n DB.close()","def reportMatch(winner, loser):\n c.execute(\"INSERT INTO matchup(winner,loser) VALUES (?,?)\", (winner,loser,));\n c.execute(\"UPDATE players SET wins = wins + 1, matches = matches + 1 WHERE id = ?\", (winner,));\n c.execute(\"UPDATE players SET matches=matches+1 WHERE id =?\", (loser,));\n print \"Player #id %d was the winner and player #id %d was the loser\" % (winner,loser)\n return","def event_house_wins(self) -> None:\n print(\"You lose\")\n self.user.lose_balance(self.user.bet)","def add_account(self, log, pword):\r\n #Placeholder : insert variables in sqlite3\r\n self.curs.execute(f\"\"\"INSERT INTO main_table VALUES (?, ?)\"\"\", (log, pword))\r\n self.conn.commit()","def reportMatch(winner, loser):\n conn = connect()\n c = conn.cursor()\n # Inserts \"winner_id\" and \"loser_id\" into the table \"matches\"\n c.execute(\"INSERT INTO matches (winner_id, loser_id) VALUES (%s,%s)\",\n (winner, loser))\n conn.commit()\n conn.close()","def reportMatch(winner, loser):\n print \"\\n\"\n print \"\\t\\t\\tReporting match.....\", \"winner:\", winner, \"\\tloser:\", loser\n\n cur1 = conn.cursor()\n \n # Query parameter to prevent SQL injection.\n query = \"INSERT into matches(winner,loser) values (%s,%s); \"\n data = (winner, loser, )\n cur1.execute(query, data) # Note: no % operator\n cur1.execute(\"commit;\")\n\n print \"\\n\"\n print \"\\t\\t\\tMatch reported\\n\"\n\n rows1 = playerStandings()\n\n print \"\\t\\t\\tUpdated Standings after reporting match:\\n\"\n #print (rows)\n for row1 in rows1:\n print \"\\t\\t\\t\", row1\n print \"\\n\"","def player_win(self):\r\n\r\n self.summary = (\" \" * 83) + \"YOU WIN\"\r\n print(\"Player wins against opponent.\\n\")\r\n self.player_wins += 1","def reportMatch(winner, loser):\n db, cursor = connect()\n cursor.execute(\"UPDATE players SET matches = matches + 1 WHERE id = %d or id = %d\" % (winner, loser) ); \n db.commit() \n cursor.execute(\"UPDATE players SET wins = wins + 1 WHERE id = %d\" % (winner, ) ) \n db.commit() \n cursor.execute(\"INSERT INTO matches (winner_id, loser_id ) VALUES ( %s, %s) \", (winner, loser))\n db.commit()\n db.close()","def reportMatch(winner, loser, is_draw=False):\n with _connect_db() as (conn, cur):\n cur.execute(\"\"\"INSERT INTO matches VALUES (%s, %s, %s);\"\"\",\n (winner, loser, is_draw))\n conn.commit()","def reportMatch(winner, loser):\n DB = connect()\n c = DB.cursor()\n c.execute(\"SELECT id FROM matches WHERE pID1 = %s and pID2= %s or pID2 = %s and pID1= %s\", (winner,loser,))\n result= c.fetchone()\n c.execute(\"INSERT INTO wins VALUES(%s,%s,%s)\",(winner,loser,result[0],))\n DB.commit()\n DB.close()","def reportMatch(winner, loser):\n db = connect()\n c = db.cursor()\n query = (\"INSERT INTO results(matchId, winner, loser) \\\n VALUES (default, %s, %s);\")\n c.execute(query, (winner, loser,))\n db.commit()\n db.close()","def event_player_blackjack(self) -> None:\n win_amount = self.user.bet + 1.5\n print(\"Congratulations, you win:\", win_amount)\n self.user.win_balance(win_amount)","def magic_logon(self,parameter_s=''):\n \n self.switch_log(1)","def reportMatch(winner, loser):\n conn, c = connect()\n\n q = \"INSERT INTO MATCHES VALUES (default, %s, %s);\"\n data = ((winner,), (loser,))\n c.execute(q, data)\n conn.commit()\n conn.close()","def reportMatch(winner, loser, draw):\n # gets connection to tournament database in conn object\n conn = connect()\n # gets the cursor to execute queries\n c = conn.cursor()\n # sql insert query to add new MATCH record in the MATCH table with\n # passing winner or loser player id and true or false for draw\n # When there is draw, both winner and loser columns will have IDs of\n # both players which later on gets counted as 0.5 points for each player\n # while 1 for winner and 0 for loser\n query = \"INSERT INTO MATCH (winner, loser, draw) VALUES (%s, %s, %s);\"\n args = (winner, loser, draw)\n # executing insert query to add new Match information\n c.execute(query, args)\n # commits the changes performed on MATCH table after adding new match\n conn.commit()\n # closing connection to tournament database\n conn.close()","def record(self, result: str):\n if result == \"win\":\n self.wins += 1\n elif result == \"lose\":\n self.losses += 1\n elif result == \"draw\":\n self.draws += 1","def on_b(self):\r\n self.log()","async def monsave(self, ctx, *, entry):\r\n\r\n self.connect()\r\n discord_id = str(ctx.message.author.id)\r\n\r\n self.database.entries.insert_one({\r\n \"discord_id\": discord_id,\r\n \"entry\": entry\r\n })\r\n\r\n await ctx.send('You have successfully saved this entry in the Viking database.')","def writing_log(self, conn, message):\n c = conn.cursor()\n c.execute(\"INSERT INTO logs VALUES('\" + str(datetime.now()) + \"', ' \" + message + \"')\")\n conn.commit()","def reportMatch(winner, loser):\n \n if not winner or not loser:\n print \"one or no players specified for report match\"\n else:\n query = \"INSERT INTO matches \\\n (playeroneid, losingplayerid) \\\n VALUES (%s,%s)\"\n values = (winner, loser)\n results = executeQuery({\n 'dbname': 'tournament', \n 'query' : query, \n 'type' : 'insert', \n 'values' : values\n })","def log_to_db(data):\n from helpers.database import Database\n query = '''INSERT INTO Error Values(null, \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\");'''\n\n try:\n db = Database().get_db()\n conn = db.cursor()\n conn.execute(query % (data.type, data.content, data.timestamp,\n data.field, data.dataset, data.link))\n db.commit()\n return True\n\n except sqlite3.Error as er:\n print(er)\n return False\n\n finally:\n db.close()","def win_round(bank, report):\n print(f\"\\nYOU WIN THIS ROUND!!!\\n\"\n f\"You get to collect {WIN_BONUS()}x the bet you placed!\\n\"\n f\"Hope you can use this towards your student loans ;)\\n\")\n bank.collect(WIN_BONUS())\n report.record(result=\"win\")","def on_right(self):\r\n self.log()","def Win(self):\n print ( 10*\"*\")\n print (\"Player \" + self.character + \" says:\")\n print (\"I Won\")\n print ( 10*\"*\")","def log_dialogue_input(log_dict, dynamodb_table):\n if not isinstance(log_dict, dict):\n raise NameError(f\"Logging information must be dictionary, not type {type(log_dict)}\")\n\n # Log in PST\n log_dict[\"time\"] = pst()\n if dynamodb_table is not None:\n try:\n dynamodb_table.put_item(Item=log_dict)\n app.logger.info(\"DB write successful\")\n except Exception as e:\n app.logger.info(f\"Could not write to database: {e}\")\n # If no db is specified, write logs to info\n app.logger.info(log_dict)","def you_won(self):\n self.end_of_level()\n self.message_holder.add_widget(self.you_win_label)\n Clock.schedule_once(self.goto_next_level, 5)","def log(self, *args, **kwargs):\n self.game_view.log(*args, **kwargs)","def log(self,):\n if self.request.user.is_anonymous():\n self.fail()\n else:\n self.success()\n if conf.LOGIN_GUARD_FREQUENCY_ALERT_ON:\n self.alert()","def reportMatch(winner, loser):\n # Keeping things orderly by always inserting player IDs lowest to highest\n player1ID = min(winner, loser)\n player2ID = max(winner, loser)\n\n dbconnection = connect()\n dbcursor = dbconnection.cursor()\n\n # Use string insertion method with tuple to prevent SQL injection attacks\n dbcursor.execute(\"\"\"INSERT INTO matches (player_1_id, player_2_id,\n winner_id) VALUES (%s, %s, %s)\"\"\",\n (str(player1ID), str(player2ID), str(winner),))\n\n dbconnection.commit()\n dbconnection.close()","def win(self):\n self.die()","def run_game_log(player, game_log):\n\n\tgame_log.update_room_type()\n\tcurrent_msg = game_log.get_current_message()\n\n\tprint('HP: {} GOLD: {}'.format(player.stats['HP'], player.stats['GOLD']))\n\tprint('CURRENT ROOM: {}\\n'.format(game_log.current_room))\n\tprint(\"{}'s LOG: {}\".format(player.info['Name'].upper(), current_msg))","def reportMatch(matchid, winner, loser, tie , bye):\n DB = dbc()\n c = DB.cursor()\n if bye != 0:\n c.execute('UPDATE matches \\\n SET win = (win+1), \\\n total_matches = (total_matches+1), \\\n score = (score+3), \\\n bye = 1 \\\n WHERE playerid = %s AND matchid = %s', (bye, matchid))\n if tie == 1:\n c.execute('UPDATE matches \\\n SET total_matches = (total_matches+1), \\\n score = (score+1), \\\n played = array_append(played, %s) \\\n WHERE playerid = %s AND matchid = %s', (loser, winner, matchid))\n c.execute('UPDATE matches \\\n SET total_matches = (total_matches+1), \\\n score = (score+1), \\\n played = array_append(played, %s) \\\n WHERE playerid = %s AND matchid = %s', (winner, loser, matchid))\n elif tie == 0:\n c.execute('UPDATE matches \\\n SET win = (win+1), \\\n total_matches = (total_matches+1), \\\n score = (score+3), \\\n played = array_append(played, %s) \\\n WHERE playerid = %s AND matchid = %s', (loser, winner, matchid))\n c.execute('UPDATE matches \\\n SET total_matches = (total_matches+1), \\\n score = (score+0), \\\n played = array_append(played, %s) \\\n WHERE playerid = %s AND matchid = %s', (winner, loser, matchid))\n DB.commit()\n DB.close()","def on_left(self):\r\n self.log()","def saveBoard(phone,board,win,loss,draw):\r\n cursor = cnx.cursor()\r\n query = (\"UPDATE connectfour SET board=%s,win=%s,loss=%s,draw=%s,updated=CURRENT_TIMESTAMP WHERE phone=%s\")\r\n cursor.execute(query, (board.save(),win,loss,draw,phone))\r\n cursor.close()\r\n cnx.commit()","def make_record(self):\n answer = self.input('enter your name: ')\n if answer:\n print('hi ' + answer + '! Your answer has been recorded.')\n self.record_score(answer, len(self.board.tiles.blacks))\n self.game_on = False\n else:\n self.game_on = False # Canceled dialog will turn off","def checkForWin (self):\r\n\t\tw = self.getWinner()\r\n\t\tif w:\r\n\t\t\tself.printBoard()\r\n\t\t\traise Exception(w + ' won!')","def on_x(self):\r\n self.log()","def log_lesson(request):\n user = User.objects.get(email=request.user.email)\n user_info = UserInformation.objects.get(user=user)\n lesson_set = user_info.current_lesson_set\n lesson = Lesson.objects.get(lesson_index=user_info.current_lesson_index)\n main_set = user_info.current_main_set\n\n print(\"lesson_logged\")\n\n lesson_to_log = LessonLog.objects.create(user=user,\n time_stamp=timezone.now(),\n lesson_set_key=lesson_set,\n lesson_key=lesson,\n lesson_index=lesson.lesson_index,\n main_set_key=main_set)\n lesson_to_log.save()","def log(self, msg):\n\n\t\tself.eyetribe.log_message(msg)","def log(self, message):","def winner(data):\n global WIN, LOSS\n print(str(data))\n\n #winner = models.Joined.query.filter_by(username=data['winner']).first()\n #loser = models.Joined.query.filter_by(username=data['loser']).first()\n\n users, scores = add_winning_user(data)\n SOCKETIO.emit(\"User_List\", {'users': users, 'score': scores})\n\n print(users)\n print(scores)\n\n WIN.append(str(data['winner']))\n print(WIN)\n LOSS.append(str(data['loser']))\n print(LOSS)\n\n SOCKETIO.emit('Winner', data, broadcast=True, include_self=True)\n return str(data['winner'])","def enter_contest(self, message, db_session):\n username = self.ts.get_user(message)\n user = db_session.query(db.User).filter(db.User.name == username).one_or_none()\n if user:\n print('user found')\n if user.entered_in_contest:\n self._add_to_whisper_queue(user.name, 'You\\'re already entered into the contest, you can\\'t enter again.')\n else:\n user.entered_in_contest = True\n self._add_to_whisper_queue(user.name, 'You\\'re entered into the contest!')\n else:\n print('user created')\n user = db.User(entered_in_contest=True, name=username)\n # user.name = username\n db_session.add(user)\n print(user.name)\n self._add_to_whisper_queue(username, 'You\\'re entered into the contest!')","def win(self):\n self.score += 1\n self.ids['score'].text = 'SCORE: ' + str(self.score)","def congratulations(username):\n global score_dictinary\n global counter_dictinary\n \n # Handle POST request\n if request.method == \"POST\":\n winners = mongo.db.winners\n currentWinner = {\n 'name': username,\n 'score': score_dictinary[username]\n }\n winners.insert_one(currentWinner)\n counter_dictinary[username] = 0\n score_dictinary[username] = 0\n return redirect(\"/\")\n return render_template(\"win.html\", username=username)","def log_request(req: 'flask_request', res: str) -> None:\n #raise Exception(\"Something awful just happened.\")\n #sleep(15)\n try:\n with UseDatabase(app.config['dbconfig']) as cursor:\n _SQL = \"\"\"insert into log\n (phrase, letters, ip, browser_string, results)\n values\n (%s, %s, %s, %s, %s)\"\"\"\n cursor.execute(_SQL, (req.form['phrase'],\n req.form['letters'],\n req.remote_addr,\n req.user_agent.browser,\n res))\n except ConnectionError as err:\n print('Is your database switched on? Error:', str(err))\n except CredentialsError as err:\n print('Is your credentials correct? Error:', str(err))\n except SQLError as err:\n print('Is your query correct? Error:', str(err))\n except Exception as err:\n print('Something went wrong:', str(err))\n return 'Error'","def game_ended(self):\r\n time.sleep(0.1)\r\n\r\n print('Game has ended going into leader boards')\r\n for client in self.watcher_list: # Tells all watchers the game is over\r\n # noinspection PyBroadException\r\n try:\r\n self.game_over_socket(client)\r\n except Exception:\r\n print('a watcher has crashed - game over information to it not sent')\r\n\r\n if self.painter_chosen:\r\n # noinspection PyBroadException\r\n try:\r\n self.game_over_socket(self.painter_socket) # if a painter is logged tells him the game is over\r\n except Exception:\r\n print('painter logged off/crashed , did not send winning screen')\r\n\r\n print(self.database_information) # paintings details at the end of the game that go into the database\r\n\r\n '''\r\n this part waits 5 seconds for all of the watchers to confirm they have entered their guesses into the\r\n self.guess_list variable , if 1 or more haven't done it in under 5 seconds the server does not keep\r\n their guesses in the database \r\n '''\r\n time_counter = 0\r\n game_watcher_guesses_data = ''\r\n while True:\r\n time_counter += 1\r\n\r\n time.sleep(1) # this while loop can run up to 5 times , with this its about 5 seconds\r\n print(self.watchers_enter_database)\r\n print(self.watchers_logged)\r\n print(self.watchers_were_logged) # whenever a watcher starts the thread that at the end of he gets\r\n # uploaded into the database self.watchers_were_logged grows by 1 , which is why we use it to\r\n # compare to self.watchers_enter_database which at the end of said thread grows by 1\r\n\r\n if self.watchers_enter_database >= self.watchers_were_logged or time_counter > 4:\r\n # makes sure all watchers have entered their information into the database\r\n for user in self.guess_list:\r\n for guess in user:\r\n game_watcher_guesses_data += guess + ' ; '\r\n if time_counter > 4: # 1 or more users timed out and took more than 5 seconds to confirm\r\n print('One or more of the users data has not entered the database because they timed out')\r\n game_watcher_guesses_data += 'Note - 1 or more users have timed out of the game ;'\r\n conn = sqlite3.connect('scribble_database.db')\r\n conn.execute(\"INSERT INTO paintings VALUES (NULL, ?, ?, ?);\",\r\n (self.guess_word, self.database_information, game_watcher_guesses_data))\r\n conn.commit()\r\n conn.close()\r\n print('Record created successfully')\r\n for sock in self.watcher_list:\r\n # noinspection PyBroadException\r\n try:\r\n sock.send('database updated'.encode()) # tells the watchers the database has been\r\n # updated and that they can now send the server the reset signal\r\n except Exception:\r\n print('watcher crashed or logged off , database confirmation not sent to it')\r\n # the database had been updated with this game's information\r\n break","async def save_battle_log(self, log_data: dict):\n\n if len(log_data) == 1:\n # One user is the bot.\n user = log_data[0][\"user\"]\n partial_logs = await self.config.user(user).partial_battle_log()\n partial_log_json = partial_logs[-1]\n\n partial_log = await PartialBattleLogEntry.from_json(partial_log_json, self.bot)\n player_extras = {\n \"brawler_trophies\": log_data[0][\"trophies\"],\n \"reward_trophies\": log_data[0][\"reward\"]\n }\n opponent_extras = {\n \"brawler_trophies\": log_data[0][\"trophies\"] + random.randint(-20, 20),\n \"reward_trophies\": 0\n }\n log_entry = BattleLogEntry(partial_log, player_extras, opponent_extras).to_json()\n async with self.config.user(user).battle_log() as battle_log:\n battle_log.append(log_entry)\n else:\n for i in [0, 1]:\n if i == 0:\n other = 1\n else:\n other = 0\n\n user = log_data[i][\"user\"]\n partial_logs = await self.config.user(user).partial_battle_log()\n partial_log_json = partial_logs[-1]\n\n partial_log = await PartialBattleLogEntry.from_json(partial_log_json, self.bot)\n player_extras = {\n \"brawler_trophies\": log_data[i][\"trophies\"],\n \"reward_trophies\": log_data[i][\"reward\"]\n }\n opponent_extras = {\n \"brawler_trophies\": log_data[other][\"trophies\"],\n \"reward_trophies\": log_data[other][\"reward\"]\n }\n log_entry = BattleLogEntry(partial_log, player_extras, opponent_extras).to_json()\n async with self.config.user(user).battle_log() as battle_log:\n battle_log.append(log_entry)","def log(self, msg):\n logging.info(\"Logging Message\")\n ml = self.monk_logs\n today = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M\")\n ml.insert({today: {\"log\": msg,\n \"sentiment\": self.get_sentiment(msg),\n \"weather\": Weather.get_weather()}})","def checkForWin(self):\n w = self.getWinner()\n if w == PLAYER or w == AI:\n # self.printBoard()\n # print('%d'%w + ' won!')\n return\n if w == Tie:\n # print('Tie')\n return","async def logadd(self, ctx):\n if await check_if_logged(server_id=ctx.guild.id):\n if not await check_if_logged(channel_id=ctx.channel.id):\n c.execute(\"SELECT COUNT(*) FROM logging.servers WHERE channelid = %s\", (ctx.channel.id,))\n if fetch_one() == 0:\n logging_id = await get_logging_id(ctx.guild.id)\n c.execute(\"INSERT INTO logging.channels (channelid, server) VALUES(%s, %s)\", (ctx.channel.id, logging_id))\n DBconn.commit()\n await ctx.send(f\"> **This channel is now being logged.**\")\n else:\n await ctx.send(f\"> **This channel can not be logged since log messages are sent here.**\")\n else:\n await ctx.send(f\"> **This channel is already being logged.**\")\n else:\n await ctx.send(f\"> **The server must be logged in order to log a channel.**\")","def go(self):\n roll = self.die.roll()\n self.record_roll(roll)\n self.player.record_roll(roll)\n # print(\"{} you rolled a {} and your turn score is {}\".format(self.player.name, roll, self.score))\n if not self.turn_over:\n self.turn_over = not self.player.go_again()","def on_a(self):\r\n self.log()","def reportMatch(winner, loser):\n db_conn = connect()\n db_cursor = db_conn.cursor()\n match_insert_stmt = \"insert into matches(winner_id,loser_id) values(%s,%s)\"\n db_cursor.execute(match_insert_stmt, (winner, loser))\n db_cursor.execute(\"select * from matches;\")\n registration_results = db_cursor.fetchall()\n db_conn.commit()\n db_conn.close()\n print registration_results\n return registration_results","def lose_round(report):\n print(\"You've lost this round, no money for you, sorry my friend :(\\n\")\n report.record(result=\"lose\")","def game_win(self):\n self.win = True\n self.msg.set_text(u'YOU WIN <Press Space>')\n self.msg.show(True)","def on_up(self):\r\n self.log()","def reportMatch(winner, loser):\n conn = psycopg2.connect(\"dbname=tournament\")\n c = conn.cursor() \n\n query = \"SELECT num_of_wins FROM match WHERE id = \" + str(winner)\n c.execute(query)\n num_of_wins_winner = c.fetchall()[0][0] + 1\n\n query = \"SELECT num_of_matches FROM match WHERE id = \" + str(winner)\n c.execute(query)\n num_of_matches_winner = c.fetchall()[0][0] + 1 \n\n query = \"SELECT num_of_matches FROM match WHERE id = \" + str(loser)\n c.execute(query)\n num_of_matches_loser = c.fetchall()[0][0] + 1 \n\n query = \"UPDATE match SET num_of_wins = \" + str(num_of_wins_winner) + \" WHERE id = \" + str(winner)\n c.execute(query) # Update num_of_wins for the winner.\n\n query = \"UPDATE match SET num_of_matches = \" + str(num_of_matches_winner) + \" WHERE id = \" + str(winner)\n c.execute(query) # Update num_of_matches for both the winner and loser.\n\n query = \"UPDATE match SET num_of_matches = \" + str(num_of_matches_loser) + \" WHERE id = \" + str(loser)\n c.execute(query)\n \n conn.commit()\n conn.close()","def _log_conversation(db_file, line):\n try:\n conn = sqlite3.connect(db_file)\n cur = conn.cursor()\n cur.execute(\"\"\"INSERT INTO {tn} ({c1}, {c2}, {time}) VALUES (\"{v1}\", \"{v2}\", \"{now}\")\"\"\".\n format(tn=TABLE_NAME, c1=INPUT_COLUMN, c2=OUTPUT_COLUMN, time='time',\n v1=' '.join(line.keys()), v2=' '.join(line.values()),\n now=str(datetime.datetime.now())))\n conn.commit()\n\n except Error as err:\n print(err)\n\n finally:\n conn.close()","def win(self, amount):\n self.balance += amount","def reportMatch(player1, player2, winner = None):\n #Check for Bye matchup (player1=player2)\n bye_match = False\n if player1 == player2:\n winner = player1\n bye_match = True\n\n #Generate random winner if no winner param is passed in\n if winner is None:\n rand = random.random()\n if rand < 0.5:\n winner = player1\n else:\n winner = player2\n\n conn, cur = connect()\n #Insert record of match\n query = \"\"\"INSERT INTO matches (player1_id, player2_id, winner)\n VALUES (%s, %s, %s)\"\"\"\n params = (player1, player2, winner,)\n try:\n cur.execute(query, params)\n except:\n print(\"Error encountered when inserting match record into the database\")\n\n #Save record of player having a bye in Players table\n if bye_match:\n query = \"UPDATE players SET had_bye = TRUE WHERE player_id = %s;\"\n param = (player1,)\n try:\n cur.execute(query, param)\n except:\n print(\"Error encountered when updating player's Bye round status.\")\n conn.commit()\n conn.close()","def logsession(session, request, toolid):\n sessionconfig = CONFIG[CONFIG['app']['dbserver']]\n sessionconn = dbconnect(sessionconfig)\n sessioncurr = sessionconn.cursor()\n params = {\n 'session_id': session['id'],\n 'session_server': socket.gethostname(),\n 'session_user': session['uni'],\n 'session_ip': request.environ['HTTP_X_FORWARDED_FOR'],\n 'session_user_agent': request.user_agent.string\n }\n LOG.error(\"Log session:\")\n sessionuq = \"\"\"update sessions\nset session_server = :session_server,\n session_user = :session_user,\n session_ip = :session_ip,\n session_user_agent = :session_user_agent,\n session_active = 1\nwhere session_id = :session_id\n\"\"\"\n res = sessioncurr.execute(sessionuq, params)\n if sessioncurr.rowcount < 1:\n sessionq = \"\"\"insert into sessions (\nsession_id, session_server, session_user, session_ip, session_user_agent,\nsession_start, session_active\n) values (\n:session_id, :session_server, :session_user, :session_ip, :session_user_agent,\nCURRENT_TIMESTAMP, 1\n)\n\"\"\"\n try:\n sessioncurr.execute(sessionq, params)\n except cx_Oracle.DatabaseError as err:\n LOG.error(\"Database error in logging sessions: %s\", err)\n LOG.error(\"Logged session (insert)\")\n else:\n LOG.error(\"Logged session (update)\")\n\n params = {\n 'tool_id': toolid,\n 'site_id': session['lis_course_offering_sourcedid'],\n 'session_id': session['id']\n }\n toolq = \"\"\"insert into lti_tool_access (\ntool_id, site_id, session_id, visited_on\n) values (\n:tool_id, :site_id, :session_id, CURRENT_TIMESTAMP\n)\n\"\"\"\n try:\n sessioncurr.execute(toolq, params)\n except cx_Oracle.DatabaseError as err:\n LOG.error(\"Database error logging tool access: %s\", err)\n sessionconn.commit()\n\n sessioncurr.close()\n sessionconn.close()","def record_tie(cls):\n d = {}\n for row in range(0, cls.size):\n for col in range(0, cls.size):\n token = cls.board[row][col]\n d[token] = token\n if cls.winner is None and cls.empty not in list(d.keys()):\n cls.winner = 'Tie'","def on_R1(self):\r\n self.log()","def insertEvent(self,ip_addr,userID,event_time,event_success):\n self.cur.execute('INSERT INTO login VALUES(?,?,?,?)', (ip_addr,userID,event_time,event_success))","def on_L1(self):\r\n self.log()","def on_sync(self):\r\n self.log()","def update_log_pushed(conn, id_):\n cursor = conn.cursor()\n cursor.execute('UPDATE timelogs SET pushed = 1 WHERE id = ?;', (id_,))","def logusers(sessionid, toolid, users):\n uconfig = CONFIG[CONFIG['app']['dbserver']]\n uconn = dbconnect(uconfig)\n ucurr = uconn.cursor()\n useruq = \"\"\"update photoauth\nset time = CURRENT_TIMESTAMP,\n role = :role,\n avatar_url = :avatar_url,\n path = :path\nwhere session_id = :session_id\n and tool_id = :tool_id\n and user_id = :user_id\n\"\"\"\n\n userq = \"\"\"insert into photoauth (\nsession_id, tool_id, user_id, role, avatar_url, path, time\n) values (\n:session_id, :tool_id, :user_id, :role, :avatar_url, :path, CURRENT_TIMESTAMP\n)\n\"\"\"\n for user in users:\n avatar_url = ''\n role = ''\n if 'avatar_url' in user:\n avatar_url = user['avatar_url']\n if 'enrollments' in user:\n role = user['enrollments'][0]['role']\n params = {\n 'session_id': sessionid,\n 'tool_id': toolid,\n 'user_id': user['sis_user_id'],\n 'role': role,\n 'avatar_url': avatar_url,\n 'path': user['fbpath']\n }\n res = ucurr.execute(useruq, params)\n if ucurr.rowcount < 1:\n try:\n ucurr.execute(userq, params)\n except cx_Oracle.DatabaseError as err:\n LOG.debug(\n \"Database error in logging students (insert): %s\", err\n )\n\n uconn.commit()\n ucurr.close()\n uconn.close()","def WIN_BONUS() -> int:\n return 2","def is_game_over(cls):\n cls.record_winner()\n cls.record_tie()","def board_status(board):\n if terminal(board):\n victor = winner(board)\n if victor is not None:\n emit(\"game_over\", \"winner: \" + victor)\n else:\n emit(\"game_over\", \"Draw\")","def log(self, obj, action):\n action_dict = {'time': time.time(),\n 'action': action}\n self.log_data[obj.get_obj_id()]['actions'].append(action_dict)","def saveDatabase():\r\n debug.write(\"saveDatabase processing\", 1)\r\n \"\"\" Only process if turbo mode is off \"\"\"\r\n if not currentTurboMode:\r\n debug.write(\"turbo mode off, process the save\", 1)\r\n \"\"\" Update all the player's stats gained and commit the database\"\"\"\r\n for player in players:\r\n debug.write(\"Commiting indivudal players to the virtual database: %s\" % player.name, 2)\r\n player.commit()\r\n debug.write(\"Attempting to save the database itself\", 1)\r\n database.save()\r\n debug.write(\"SQLite database saved\", 1)\r\n debug.write(\"Creating the event\", 1)\r\n \"\"\" Create and fire the event \"\"\"\r\n values = {\"type\":(\"setstring\", str(saveType))}\r\n gamethread.delayed(0, fireEvent, (\"sourcerpg_databasesaved\", values))\r\n debug.write(\"Event fired\", 1)\r\n \r\n \"\"\" Create a loop if we need to \"\"\"\r\n if str( saveType ) == \"intervals\":\r\n gamethread.delayedname(float(saveLength), 'sourcerpg_databasesave', saveDatabase)\r\n debug.write(\"saveDatabase processed\", 1)","async def trainer_won(ctx, user: discord.User):\r\n \r\n trainer_data = load_file(file_path_trainer)\r\n user_id = \"{}\".format(user.id)\r\n \r\n file = trainer_data[\"Trainers\"][user_id]\r\n wins = file[\"Wins\"] +1\r\n file[\"Wins\"] = wins\r\n update_data(file_path_trainer, trainer_data)\r\n \r\n await bot.say(user.mention + \"'s victory has been added to the trainer log.\")","def handleWin(self, winningplayer):\n self.board.drawWinBoard(winningplayer, self.istournament)\n self.board = None\n self.ui.game = None\n if self.istournament:\n if winningplayer == 1:\n self.ui.tournament.setWinner(1)\n if winningplayer == -1:\n self.ui.tournament.setWinner(2)\n\n threading.Timer(3, self.ui.displayCurrentTournament).start()","def log_message(self, msg):\n\t\tself.logView.log_message(msg)","def whLogOut(self, whAdr=0):\n\n\t\tlogOutCmd = chr(whAdr) + '\\x02'\n\t\tlogging.info(u'Разрываем соединение с прибром учета: %s' % str(whAdr))\n\t\tans = self.cmdWR(logOutCmd)\n\t\tif ans and self._whAnsCheck(whAdr, ans):\n\t\t\tlogging.debug(u'Соединение со счетчиком %s разорвано!' % (str(whAdr), ))\n\t\t\tlogOut = True\n\t\telse:\n\t\t\tlogging.error(u'Не удалось установить разорвать соединение со счетчиком %s' % str(whAdr))\n\t\t\tlogOut = False\n\t\treturn logOut","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 test_create_log(self):\n message = \"Message is {0}\".format(random.random())\n resp = gracedb.writeLog(eventId, message)\n self.assertEqual(resp.status, 201)\n new_log_uri = resp.getheader('Location')\n new_log = resp.json()\n self.assertEqual(new_log_uri, new_log['self'])\n check_new_log = gracedb.get(new_log_uri).json()\n self.assertEqual(check_new_log['comment'], message)","def test_log_unlog_game(self):\n url = reverse('log-game')\n data = {\n 'igdb': self.game.igdb,\n 'name': self.game.name,\n 'slug': self.game.slug,\n 'cover_id': self.game.cover_id,\n 'backdrop_id': self.game.backdrop_id\n }\n\n log = self.client.post(url, data, format='json')\n self.assertEqual(True, log.data['value'])\n\n unlog = self.client.post(url, data, format='json')\n self.assertEqual(False, unlog.data['value'])","def log(cmdDict, kind, error=None):\n\n cmdDict['timestamp'] = str(int(time.time() * 1000))\n cmdDict['logType'] = kind\n cmdDict['_id'] = cmdDict['transactionNumber'] + cmdDict['user'] + cmdDict['command'] + cmdDict['timestamp'] + cmdDict['logType']\n\n if (error != None):\n cmdDict['errorMessage'] = error\n\n try:\n Database.insert(TRANSACT_COLLECT, cmdDict)\n\n except pymongo.errors.PyMongoError as err:\n print(f\"ERROR! Could not log command into database. Failed with: {err}\")","def logP(self, history, word):","def log_request(req: 'flask_request', res: str) -> None:\n\n _DBCONFIG = {'user': 'vsearch',\n 'password': 'vsearchpasswd',\n 'host': 'hfrey.de',\n 'database': 'vsearchlogDB'}\n\n conn = mysql.connector.connect(**_DBCONFIG)\n cursor = conn.cursor()\n\n _SQL = \"\"\"insert into log (phrase, letters, ip, browser_string, results)\n values\n (%s, %s, %s, %s, %s)\"\"\"\n cursor.execute(_SQL, (req.form['phrase'], req.form['letters'], req.remote_addr, req.user_agent.browser, res, ))\n\n cursor.close()\n conn.commit()\n conn.close()","def trackNewPayment(violation):\n data = db.Database(filename=\"IFB299.db\")\n payment = dict(Citation_Number = violation[\"Citation_Number\"], Citation_Type = violation[\"Violation_Type\"], Payment_status = \"Pending\")\n data.insertFinePayment(payment)\n data.close()","def __write_event(self, handle, nbr):\n try:\n event = self.database.get_event_from_handle(handle)\n self.__write_row(nbr, handle, event)\n except:\n event = \"NOT FOUND\"\n self.__write_row(nbr, handle, event)","def record_roll(self, roll):\n if roll == 1:\n self.turn_over = True\n self.score = 0\n else:\n self.score += roll","def on_R2(self):\r\n self.log()"],"string":"[\n \"def log(self, game: str, outcome: str):\\n current_time = datetime.now()\\n self.user.record.append([current_time.strftime(\\\"%c\\\"), game, outcome, self.user.balance])\",\n \"def event_player_wins(self) -> None:\\n win_amount = self.user.bet\\n print(\\\"Congratulations, you win:\\\", win_amount)\\n self.user.win_balance(self.user.bet)\",\n \"def reportMatch(winner, loser):\\n db = connect()\\n db_cursor = db.cursor()\\n db_cursor.execute(\\\"INSERT INTO matches(winner, loser) VALUES(%s,%s)\\\", (winner,loser))\\n db.commit()\\n db.close()\",\n \"def reportMatch(winner, loser):\\n dbConn = connect()\\n c = dbConn.cursor()\\n c.execute(\\\"INSERT INTO match (winner, loser) VALUES (%s,%s)\\\", (winner, loser))\\n dbConn.commit()\\n dbConn.close()\",\n \"def InsertLog():\",\n \"def reportMatch(winner, loser):\\n executeNonQuery(\\\"INSERT INTO matches (winner, loser) VALUES (%s, %s);\\\", (winner,loser))\",\n \"def log_result(winner_darter_id, loser_darter_id,reported_at):\\n \\n query = \\\"INSERT INTO matches(winner_darter_id,loser_darter_id,reported_at, created_at, updated_at) VALUES(%s,%s,%s,%s,%s)\\\"\\n value = [(winner_darter_id, loser_darter_id, reported_at, CURRENT_EPOCH_TIME, CURRENT_EPOCH_TIME)]\\n \\n db.insert(query,value)\",\n \"def on_win(data):\\n print(str(data))\\n update_score_db(data['winner'], data['loser'])\\n users, scores = calculate_scores()\\n socketio.emit('leaderboard_info', {'users': users, 'scores': scores})\",\n \"def Log(self, msg):\\n self.DBExecute(\\\"INSERT INTO Log (class, instance, event) VALUES (%s, %s, %s)\\\",\\n self.__class__.__name__, self._instance, msg)\\n print '%s/%s: %s' % (self.__class__.__name__, self._instance, msg)\",\n \"def report_match(winner, loser):\\n\\n DB = connect()\\n c = DB.cursor()\\n c.execute(\\\"INSERT INTO matches (winner, loser) VALUES (%s,%s);\\\", (winner, loser))\\n DB.commit()\\n DB.close()\",\n \"def reportMatch(winner, loser):\\n conn, c = connect()\\n c.execute(\\\"INSERT INTO matches (winner, loser) VALUES (%s, %s);\\\",\\n (winner, loser,))\\n conn.commit()\\n conn.close()\",\n \"def reportMatch(winner, loser):\\n \\n cursor.execute(\\\"insert into matches (winnerid, loserid) values (%s, %s)\\\" % (winner, loser))\\n gc.commit()\",\n \"def reportMatch(winner, loser):\\n conn = connect()\\n cursor = conn.cursor()\\n cursor.execute(\\\"INSERT INTO results VALUES (%s, %s, true)\\\",\\n (winner, loser))\\n cursor.execute(\\\"INSERT INTO results VALUES (%s, %s, false)\\\",\\n (loser, winner))\\n conn.commit()\\n conn.close()\",\n \"def win(self):\\n print \\\"\\\\n{0} has escaped the dungeon, as few before have. {0} survived {1} rooms.\\\\n\\\".format(self.name, self.roomCt)\\n exit()\",\n \"def reportMatch(winner, loser):\\n DB = connect()\\n c = DB.cursor()\\n #updates number of wins and the number of matches played for the winner\\n c.execute(\\\"UPDATE players SET wins = wins + 1, matches = matches +1 WHERE id = (%s)\\\", (bleach.clean(winner), ))\\n #updates the number of matches for the loser\\n c.execute(\\\"UPDATE players SET matches = matches + 1 WHERE id = (%s)\\\", (bleach.clean(loser), ))\\n #add a match to matches table\\n c.execute(\\\"UPDATE matches SET winner = (%s), loser = (%s)\\\", (bleach.clean(winner), bleach.clean(loser)))\\n DB.commit()\\n DB.close()\",\n \"def reportMatch(winner, loser):\\n c.execute(\\\"INSERT INTO matchup(winner,loser) VALUES (?,?)\\\", (winner,loser,));\\n c.execute(\\\"UPDATE players SET wins = wins + 1, matches = matches + 1 WHERE id = ?\\\", (winner,));\\n c.execute(\\\"UPDATE players SET matches=matches+1 WHERE id =?\\\", (loser,));\\n print \\\"Player #id %d was the winner and player #id %d was the loser\\\" % (winner,loser)\\n return\",\n \"def event_house_wins(self) -> None:\\n print(\\\"You lose\\\")\\n self.user.lose_balance(self.user.bet)\",\n \"def add_account(self, log, pword):\\r\\n #Placeholder : insert variables in sqlite3\\r\\n self.curs.execute(f\\\"\\\"\\\"INSERT INTO main_table VALUES (?, ?)\\\"\\\"\\\", (log, pword))\\r\\n self.conn.commit()\",\n \"def reportMatch(winner, loser):\\n conn = connect()\\n c = conn.cursor()\\n # Inserts \\\"winner_id\\\" and \\\"loser_id\\\" into the table \\\"matches\\\"\\n c.execute(\\\"INSERT INTO matches (winner_id, loser_id) VALUES (%s,%s)\\\",\\n (winner, loser))\\n conn.commit()\\n conn.close()\",\n \"def reportMatch(winner, loser):\\n print \\\"\\\\n\\\"\\n print \\\"\\\\t\\\\t\\\\tReporting match.....\\\", \\\"winner:\\\", winner, \\\"\\\\tloser:\\\", loser\\n\\n cur1 = conn.cursor()\\n \\n # Query parameter to prevent SQL injection.\\n query = \\\"INSERT into matches(winner,loser) values (%s,%s); \\\"\\n data = (winner, loser, )\\n cur1.execute(query, data) # Note: no % operator\\n cur1.execute(\\\"commit;\\\")\\n\\n print \\\"\\\\n\\\"\\n print \\\"\\\\t\\\\t\\\\tMatch reported\\\\n\\\"\\n\\n rows1 = playerStandings()\\n\\n print \\\"\\\\t\\\\t\\\\tUpdated Standings after reporting match:\\\\n\\\"\\n #print (rows)\\n for row1 in rows1:\\n print \\\"\\\\t\\\\t\\\\t\\\", row1\\n print \\\"\\\\n\\\"\",\n \"def player_win(self):\\r\\n\\r\\n self.summary = (\\\" \\\" * 83) + \\\"YOU WIN\\\"\\r\\n print(\\\"Player wins against opponent.\\\\n\\\")\\r\\n self.player_wins += 1\",\n \"def reportMatch(winner, loser):\\n db, cursor = connect()\\n cursor.execute(\\\"UPDATE players SET matches = matches + 1 WHERE id = %d or id = %d\\\" % (winner, loser) ); \\n db.commit() \\n cursor.execute(\\\"UPDATE players SET wins = wins + 1 WHERE id = %d\\\" % (winner, ) ) \\n db.commit() \\n cursor.execute(\\\"INSERT INTO matches (winner_id, loser_id ) VALUES ( %s, %s) \\\", (winner, loser))\\n db.commit()\\n db.close()\",\n \"def reportMatch(winner, loser, is_draw=False):\\n with _connect_db() as (conn, cur):\\n cur.execute(\\\"\\\"\\\"INSERT INTO matches VALUES (%s, %s, %s);\\\"\\\"\\\",\\n (winner, loser, is_draw))\\n conn.commit()\",\n \"def reportMatch(winner, loser):\\n DB = connect()\\n c = DB.cursor()\\n c.execute(\\\"SELECT id FROM matches WHERE pID1 = %s and pID2= %s or pID2 = %s and pID1= %s\\\", (winner,loser,))\\n result= c.fetchone()\\n c.execute(\\\"INSERT INTO wins VALUES(%s,%s,%s)\\\",(winner,loser,result[0],))\\n DB.commit()\\n DB.close()\",\n \"def reportMatch(winner, loser):\\n db = connect()\\n c = db.cursor()\\n query = (\\\"INSERT INTO results(matchId, winner, loser) \\\\\\n VALUES (default, %s, %s);\\\")\\n c.execute(query, (winner, loser,))\\n db.commit()\\n db.close()\",\n \"def event_player_blackjack(self) -> None:\\n win_amount = self.user.bet + 1.5\\n print(\\\"Congratulations, you win:\\\", win_amount)\\n self.user.win_balance(win_amount)\",\n \"def magic_logon(self,parameter_s=''):\\n \\n self.switch_log(1)\",\n \"def reportMatch(winner, loser):\\n conn, c = connect()\\n\\n q = \\\"INSERT INTO MATCHES VALUES (default, %s, %s);\\\"\\n data = ((winner,), (loser,))\\n c.execute(q, data)\\n conn.commit()\\n conn.close()\",\n \"def reportMatch(winner, loser, draw):\\n # gets connection to tournament database in conn object\\n conn = connect()\\n # gets the cursor to execute queries\\n c = conn.cursor()\\n # sql insert query to add new MATCH record in the MATCH table with\\n # passing winner or loser player id and true or false for draw\\n # When there is draw, both winner and loser columns will have IDs of\\n # both players which later on gets counted as 0.5 points for each player\\n # while 1 for winner and 0 for loser\\n query = \\\"INSERT INTO MATCH (winner, loser, draw) VALUES (%s, %s, %s);\\\"\\n args = (winner, loser, draw)\\n # executing insert query to add new Match information\\n c.execute(query, args)\\n # commits the changes performed on MATCH table after adding new match\\n conn.commit()\\n # closing connection to tournament database\\n conn.close()\",\n \"def record(self, result: str):\\n if result == \\\"win\\\":\\n self.wins += 1\\n elif result == \\\"lose\\\":\\n self.losses += 1\\n elif result == \\\"draw\\\":\\n self.draws += 1\",\n \"def on_b(self):\\r\\n self.log()\",\n \"async def monsave(self, ctx, *, entry):\\r\\n\\r\\n self.connect()\\r\\n discord_id = str(ctx.message.author.id)\\r\\n\\r\\n self.database.entries.insert_one({\\r\\n \\\"discord_id\\\": discord_id,\\r\\n \\\"entry\\\": entry\\r\\n })\\r\\n\\r\\n await ctx.send('You have successfully saved this entry in the Viking database.')\",\n \"def writing_log(self, conn, message):\\n c = conn.cursor()\\n c.execute(\\\"INSERT INTO logs VALUES('\\\" + str(datetime.now()) + \\\"', ' \\\" + message + \\\"')\\\")\\n conn.commit()\",\n \"def reportMatch(winner, loser):\\n \\n if not winner or not loser:\\n print \\\"one or no players specified for report match\\\"\\n else:\\n query = \\\"INSERT INTO matches \\\\\\n (playeroneid, losingplayerid) \\\\\\n VALUES (%s,%s)\\\"\\n values = (winner, loser)\\n results = executeQuery({\\n 'dbname': 'tournament', \\n 'query' : query, \\n 'type' : 'insert', \\n 'values' : values\\n })\",\n \"def log_to_db(data):\\n from helpers.database import Database\\n query = '''INSERT INTO Error Values(null, \\\"%s\\\", \\\"%s\\\", \\\"%s\\\", \\\"%s\\\", \\\"%s\\\", \\\"%s\\\");'''\\n\\n try:\\n db = Database().get_db()\\n conn = db.cursor()\\n conn.execute(query % (data.type, data.content, data.timestamp,\\n data.field, data.dataset, data.link))\\n db.commit()\\n return True\\n\\n except sqlite3.Error as er:\\n print(er)\\n return False\\n\\n finally:\\n db.close()\",\n \"def win_round(bank, report):\\n print(f\\\"\\\\nYOU WIN THIS ROUND!!!\\\\n\\\"\\n f\\\"You get to collect {WIN_BONUS()}x the bet you placed!\\\\n\\\"\\n f\\\"Hope you can use this towards your student loans ;)\\\\n\\\")\\n bank.collect(WIN_BONUS())\\n report.record(result=\\\"win\\\")\",\n \"def on_right(self):\\r\\n self.log()\",\n \"def Win(self):\\n print ( 10*\\\"*\\\")\\n print (\\\"Player \\\" + self.character + \\\" says:\\\")\\n print (\\\"I Won\\\")\\n print ( 10*\\\"*\\\")\",\n \"def log_dialogue_input(log_dict, dynamodb_table):\\n if not isinstance(log_dict, dict):\\n raise NameError(f\\\"Logging information must be dictionary, not type {type(log_dict)}\\\")\\n\\n # Log in PST\\n log_dict[\\\"time\\\"] = pst()\\n if dynamodb_table is not None:\\n try:\\n dynamodb_table.put_item(Item=log_dict)\\n app.logger.info(\\\"DB write successful\\\")\\n except Exception as e:\\n app.logger.info(f\\\"Could not write to database: {e}\\\")\\n # If no db is specified, write logs to info\\n app.logger.info(log_dict)\",\n \"def you_won(self):\\n self.end_of_level()\\n self.message_holder.add_widget(self.you_win_label)\\n Clock.schedule_once(self.goto_next_level, 5)\",\n \"def log(self, *args, **kwargs):\\n self.game_view.log(*args, **kwargs)\",\n \"def log(self,):\\n if self.request.user.is_anonymous():\\n self.fail()\\n else:\\n self.success()\\n if conf.LOGIN_GUARD_FREQUENCY_ALERT_ON:\\n self.alert()\",\n \"def reportMatch(winner, loser):\\n # Keeping things orderly by always inserting player IDs lowest to highest\\n player1ID = min(winner, loser)\\n player2ID = max(winner, loser)\\n\\n dbconnection = connect()\\n dbcursor = dbconnection.cursor()\\n\\n # Use string insertion method with tuple to prevent SQL injection attacks\\n dbcursor.execute(\\\"\\\"\\\"INSERT INTO matches (player_1_id, player_2_id,\\n winner_id) VALUES (%s, %s, %s)\\\"\\\"\\\",\\n (str(player1ID), str(player2ID), str(winner),))\\n\\n dbconnection.commit()\\n dbconnection.close()\",\n \"def win(self):\\n self.die()\",\n \"def run_game_log(player, game_log):\\n\\n\\tgame_log.update_room_type()\\n\\tcurrent_msg = game_log.get_current_message()\\n\\n\\tprint('HP: {} GOLD: {}'.format(player.stats['HP'], player.stats['GOLD']))\\n\\tprint('CURRENT ROOM: {}\\\\n'.format(game_log.current_room))\\n\\tprint(\\\"{}'s LOG: {}\\\".format(player.info['Name'].upper(), current_msg))\",\n \"def reportMatch(matchid, winner, loser, tie , bye):\\n DB = dbc()\\n c = DB.cursor()\\n if bye != 0:\\n c.execute('UPDATE matches \\\\\\n SET win = (win+1), \\\\\\n total_matches = (total_matches+1), \\\\\\n score = (score+3), \\\\\\n bye = 1 \\\\\\n WHERE playerid = %s AND matchid = %s', (bye, matchid))\\n if tie == 1:\\n c.execute('UPDATE matches \\\\\\n SET total_matches = (total_matches+1), \\\\\\n score = (score+1), \\\\\\n played = array_append(played, %s) \\\\\\n WHERE playerid = %s AND matchid = %s', (loser, winner, matchid))\\n c.execute('UPDATE matches \\\\\\n SET total_matches = (total_matches+1), \\\\\\n score = (score+1), \\\\\\n played = array_append(played, %s) \\\\\\n WHERE playerid = %s AND matchid = %s', (winner, loser, matchid))\\n elif tie == 0:\\n c.execute('UPDATE matches \\\\\\n SET win = (win+1), \\\\\\n total_matches = (total_matches+1), \\\\\\n score = (score+3), \\\\\\n played = array_append(played, %s) \\\\\\n WHERE playerid = %s AND matchid = %s', (loser, winner, matchid))\\n c.execute('UPDATE matches \\\\\\n SET total_matches = (total_matches+1), \\\\\\n score = (score+0), \\\\\\n played = array_append(played, %s) \\\\\\n WHERE playerid = %s AND matchid = %s', (winner, loser, matchid))\\n DB.commit()\\n DB.close()\",\n \"def on_left(self):\\r\\n self.log()\",\n \"def saveBoard(phone,board,win,loss,draw):\\r\\n cursor = cnx.cursor()\\r\\n query = (\\\"UPDATE connectfour SET board=%s,win=%s,loss=%s,draw=%s,updated=CURRENT_TIMESTAMP WHERE phone=%s\\\")\\r\\n cursor.execute(query, (board.save(),win,loss,draw,phone))\\r\\n cursor.close()\\r\\n cnx.commit()\",\n \"def make_record(self):\\n answer = self.input('enter your name: ')\\n if answer:\\n print('hi ' + answer + '! Your answer has been recorded.')\\n self.record_score(answer, len(self.board.tiles.blacks))\\n self.game_on = False\\n else:\\n self.game_on = False # Canceled dialog will turn off\",\n \"def checkForWin (self):\\r\\n\\t\\tw = self.getWinner()\\r\\n\\t\\tif w:\\r\\n\\t\\t\\tself.printBoard()\\r\\n\\t\\t\\traise Exception(w + ' won!')\",\n \"def on_x(self):\\r\\n self.log()\",\n \"def log_lesson(request):\\n user = User.objects.get(email=request.user.email)\\n user_info = UserInformation.objects.get(user=user)\\n lesson_set = user_info.current_lesson_set\\n lesson = Lesson.objects.get(lesson_index=user_info.current_lesson_index)\\n main_set = user_info.current_main_set\\n\\n print(\\\"lesson_logged\\\")\\n\\n lesson_to_log = LessonLog.objects.create(user=user,\\n time_stamp=timezone.now(),\\n lesson_set_key=lesson_set,\\n lesson_key=lesson,\\n lesson_index=lesson.lesson_index,\\n main_set_key=main_set)\\n lesson_to_log.save()\",\n \"def log(self, msg):\\n\\n\\t\\tself.eyetribe.log_message(msg)\",\n \"def log(self, message):\",\n \"def winner(data):\\n global WIN, LOSS\\n print(str(data))\\n\\n #winner = models.Joined.query.filter_by(username=data['winner']).first()\\n #loser = models.Joined.query.filter_by(username=data['loser']).first()\\n\\n users, scores = add_winning_user(data)\\n SOCKETIO.emit(\\\"User_List\\\", {'users': users, 'score': scores})\\n\\n print(users)\\n print(scores)\\n\\n WIN.append(str(data['winner']))\\n print(WIN)\\n LOSS.append(str(data['loser']))\\n print(LOSS)\\n\\n SOCKETIO.emit('Winner', data, broadcast=True, include_self=True)\\n return str(data['winner'])\",\n \"def enter_contest(self, message, db_session):\\n username = self.ts.get_user(message)\\n user = db_session.query(db.User).filter(db.User.name == username).one_or_none()\\n if user:\\n print('user found')\\n if user.entered_in_contest:\\n self._add_to_whisper_queue(user.name, 'You\\\\'re already entered into the contest, you can\\\\'t enter again.')\\n else:\\n user.entered_in_contest = True\\n self._add_to_whisper_queue(user.name, 'You\\\\'re entered into the contest!')\\n else:\\n print('user created')\\n user = db.User(entered_in_contest=True, name=username)\\n # user.name = username\\n db_session.add(user)\\n print(user.name)\\n self._add_to_whisper_queue(username, 'You\\\\'re entered into the contest!')\",\n \"def win(self):\\n self.score += 1\\n self.ids['score'].text = 'SCORE: ' + str(self.score)\",\n \"def congratulations(username):\\n global score_dictinary\\n global counter_dictinary\\n \\n # Handle POST request\\n if request.method == \\\"POST\\\":\\n winners = mongo.db.winners\\n currentWinner = {\\n 'name': username,\\n 'score': score_dictinary[username]\\n }\\n winners.insert_one(currentWinner)\\n counter_dictinary[username] = 0\\n score_dictinary[username] = 0\\n return redirect(\\\"/\\\")\\n return render_template(\\\"win.html\\\", username=username)\",\n \"def log_request(req: 'flask_request', res: str) -> None:\\n #raise Exception(\\\"Something awful just happened.\\\")\\n #sleep(15)\\n try:\\n with UseDatabase(app.config['dbconfig']) as cursor:\\n _SQL = \\\"\\\"\\\"insert into log\\n (phrase, letters, ip, browser_string, results)\\n values\\n (%s, %s, %s, %s, %s)\\\"\\\"\\\"\\n cursor.execute(_SQL, (req.form['phrase'],\\n req.form['letters'],\\n req.remote_addr,\\n req.user_agent.browser,\\n res))\\n except ConnectionError as err:\\n print('Is your database switched on? Error:', str(err))\\n except CredentialsError as err:\\n print('Is your credentials correct? Error:', str(err))\\n except SQLError as err:\\n print('Is your query correct? Error:', str(err))\\n except Exception as err:\\n print('Something went wrong:', str(err))\\n return 'Error'\",\n \"def game_ended(self):\\r\\n time.sleep(0.1)\\r\\n\\r\\n print('Game has ended going into leader boards')\\r\\n for client in self.watcher_list: # Tells all watchers the game is over\\r\\n # noinspection PyBroadException\\r\\n try:\\r\\n self.game_over_socket(client)\\r\\n except Exception:\\r\\n print('a watcher has crashed - game over information to it not sent')\\r\\n\\r\\n if self.painter_chosen:\\r\\n # noinspection PyBroadException\\r\\n try:\\r\\n self.game_over_socket(self.painter_socket) # if a painter is logged tells him the game is over\\r\\n except Exception:\\r\\n print('painter logged off/crashed , did not send winning screen')\\r\\n\\r\\n print(self.database_information) # paintings details at the end of the game that go into the database\\r\\n\\r\\n '''\\r\\n this part waits 5 seconds for all of the watchers to confirm they have entered their guesses into the\\r\\n self.guess_list variable , if 1 or more haven't done it in under 5 seconds the server does not keep\\r\\n their guesses in the database \\r\\n '''\\r\\n time_counter = 0\\r\\n game_watcher_guesses_data = ''\\r\\n while True:\\r\\n time_counter += 1\\r\\n\\r\\n time.sleep(1) # this while loop can run up to 5 times , with this its about 5 seconds\\r\\n print(self.watchers_enter_database)\\r\\n print(self.watchers_logged)\\r\\n print(self.watchers_were_logged) # whenever a watcher starts the thread that at the end of he gets\\r\\n # uploaded into the database self.watchers_were_logged grows by 1 , which is why we use it to\\r\\n # compare to self.watchers_enter_database which at the end of said thread grows by 1\\r\\n\\r\\n if self.watchers_enter_database >= self.watchers_were_logged or time_counter > 4:\\r\\n # makes sure all watchers have entered their information into the database\\r\\n for user in self.guess_list:\\r\\n for guess in user:\\r\\n game_watcher_guesses_data += guess + ' ; '\\r\\n if time_counter > 4: # 1 or more users timed out and took more than 5 seconds to confirm\\r\\n print('One or more of the users data has not entered the database because they timed out')\\r\\n game_watcher_guesses_data += 'Note - 1 or more users have timed out of the game ;'\\r\\n conn = sqlite3.connect('scribble_database.db')\\r\\n conn.execute(\\\"INSERT INTO paintings VALUES (NULL, ?, ?, ?);\\\",\\r\\n (self.guess_word, self.database_information, game_watcher_guesses_data))\\r\\n conn.commit()\\r\\n conn.close()\\r\\n print('Record created successfully')\\r\\n for sock in self.watcher_list:\\r\\n # noinspection PyBroadException\\r\\n try:\\r\\n sock.send('database updated'.encode()) # tells the watchers the database has been\\r\\n # updated and that they can now send the server the reset signal\\r\\n except Exception:\\r\\n print('watcher crashed or logged off , database confirmation not sent to it')\\r\\n # the database had been updated with this game's information\\r\\n break\",\n \"async def save_battle_log(self, log_data: dict):\\n\\n if len(log_data) == 1:\\n # One user is the bot.\\n user = log_data[0][\\\"user\\\"]\\n partial_logs = await self.config.user(user).partial_battle_log()\\n partial_log_json = partial_logs[-1]\\n\\n partial_log = await PartialBattleLogEntry.from_json(partial_log_json, self.bot)\\n player_extras = {\\n \\\"brawler_trophies\\\": log_data[0][\\\"trophies\\\"],\\n \\\"reward_trophies\\\": log_data[0][\\\"reward\\\"]\\n }\\n opponent_extras = {\\n \\\"brawler_trophies\\\": log_data[0][\\\"trophies\\\"] + random.randint(-20, 20),\\n \\\"reward_trophies\\\": 0\\n }\\n log_entry = BattleLogEntry(partial_log, player_extras, opponent_extras).to_json()\\n async with self.config.user(user).battle_log() as battle_log:\\n battle_log.append(log_entry)\\n else:\\n for i in [0, 1]:\\n if i == 0:\\n other = 1\\n else:\\n other = 0\\n\\n user = log_data[i][\\\"user\\\"]\\n partial_logs = await self.config.user(user).partial_battle_log()\\n partial_log_json = partial_logs[-1]\\n\\n partial_log = await PartialBattleLogEntry.from_json(partial_log_json, self.bot)\\n player_extras = {\\n \\\"brawler_trophies\\\": log_data[i][\\\"trophies\\\"],\\n \\\"reward_trophies\\\": log_data[i][\\\"reward\\\"]\\n }\\n opponent_extras = {\\n \\\"brawler_trophies\\\": log_data[other][\\\"trophies\\\"],\\n \\\"reward_trophies\\\": log_data[other][\\\"reward\\\"]\\n }\\n log_entry = BattleLogEntry(partial_log, player_extras, opponent_extras).to_json()\\n async with self.config.user(user).battle_log() as battle_log:\\n battle_log.append(log_entry)\",\n \"def log(self, msg):\\n logging.info(\\\"Logging Message\\\")\\n ml = self.monk_logs\\n today = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M\\\")\\n ml.insert({today: {\\\"log\\\": msg,\\n \\\"sentiment\\\": self.get_sentiment(msg),\\n \\\"weather\\\": Weather.get_weather()}})\",\n \"def checkForWin(self):\\n w = self.getWinner()\\n if w == PLAYER or w == AI:\\n # self.printBoard()\\n # print('%d'%w + ' won!')\\n return\\n if w == Tie:\\n # print('Tie')\\n return\",\n \"async def logadd(self, ctx):\\n if await check_if_logged(server_id=ctx.guild.id):\\n if not await check_if_logged(channel_id=ctx.channel.id):\\n c.execute(\\\"SELECT COUNT(*) FROM logging.servers WHERE channelid = %s\\\", (ctx.channel.id,))\\n if fetch_one() == 0:\\n logging_id = await get_logging_id(ctx.guild.id)\\n c.execute(\\\"INSERT INTO logging.channels (channelid, server) VALUES(%s, %s)\\\", (ctx.channel.id, logging_id))\\n DBconn.commit()\\n await ctx.send(f\\\"> **This channel is now being logged.**\\\")\\n else:\\n await ctx.send(f\\\"> **This channel can not be logged since log messages are sent here.**\\\")\\n else:\\n await ctx.send(f\\\"> **This channel is already being logged.**\\\")\\n else:\\n await ctx.send(f\\\"> **The server must be logged in order to log a channel.**\\\")\",\n \"def go(self):\\n roll = self.die.roll()\\n self.record_roll(roll)\\n self.player.record_roll(roll)\\n # print(\\\"{} you rolled a {} and your turn score is {}\\\".format(self.player.name, roll, self.score))\\n if not self.turn_over:\\n self.turn_over = not self.player.go_again()\",\n \"def on_a(self):\\r\\n self.log()\",\n \"def reportMatch(winner, loser):\\n db_conn = connect()\\n db_cursor = db_conn.cursor()\\n match_insert_stmt = \\\"insert into matches(winner_id,loser_id) values(%s,%s)\\\"\\n db_cursor.execute(match_insert_stmt, (winner, loser))\\n db_cursor.execute(\\\"select * from matches;\\\")\\n registration_results = db_cursor.fetchall()\\n db_conn.commit()\\n db_conn.close()\\n print registration_results\\n return registration_results\",\n \"def lose_round(report):\\n print(\\\"You've lost this round, no money for you, sorry my friend :(\\\\n\\\")\\n report.record(result=\\\"lose\\\")\",\n \"def game_win(self):\\n self.win = True\\n self.msg.set_text(u'YOU WIN <Press Space>')\\n self.msg.show(True)\",\n \"def on_up(self):\\r\\n self.log()\",\n \"def reportMatch(winner, loser):\\n conn = psycopg2.connect(\\\"dbname=tournament\\\")\\n c = conn.cursor() \\n\\n query = \\\"SELECT num_of_wins FROM match WHERE id = \\\" + str(winner)\\n c.execute(query)\\n num_of_wins_winner = c.fetchall()[0][0] + 1\\n\\n query = \\\"SELECT num_of_matches FROM match WHERE id = \\\" + str(winner)\\n c.execute(query)\\n num_of_matches_winner = c.fetchall()[0][0] + 1 \\n\\n query = \\\"SELECT num_of_matches FROM match WHERE id = \\\" + str(loser)\\n c.execute(query)\\n num_of_matches_loser = c.fetchall()[0][0] + 1 \\n\\n query = \\\"UPDATE match SET num_of_wins = \\\" + str(num_of_wins_winner) + \\\" WHERE id = \\\" + str(winner)\\n c.execute(query) # Update num_of_wins for the winner.\\n\\n query = \\\"UPDATE match SET num_of_matches = \\\" + str(num_of_matches_winner) + \\\" WHERE id = \\\" + str(winner)\\n c.execute(query) # Update num_of_matches for both the winner and loser.\\n\\n query = \\\"UPDATE match SET num_of_matches = \\\" + str(num_of_matches_loser) + \\\" WHERE id = \\\" + str(loser)\\n c.execute(query)\\n \\n conn.commit()\\n conn.close()\",\n \"def _log_conversation(db_file, line):\\n try:\\n conn = sqlite3.connect(db_file)\\n cur = conn.cursor()\\n cur.execute(\\\"\\\"\\\"INSERT INTO {tn} ({c1}, {c2}, {time}) VALUES (\\\"{v1}\\\", \\\"{v2}\\\", \\\"{now}\\\")\\\"\\\"\\\".\\n format(tn=TABLE_NAME, c1=INPUT_COLUMN, c2=OUTPUT_COLUMN, time='time',\\n v1=' '.join(line.keys()), v2=' '.join(line.values()),\\n now=str(datetime.datetime.now())))\\n conn.commit()\\n\\n except Error as err:\\n print(err)\\n\\n finally:\\n conn.close()\",\n \"def win(self, amount):\\n self.balance += amount\",\n \"def reportMatch(player1, player2, winner = None):\\n #Check for Bye matchup (player1=player2)\\n bye_match = False\\n if player1 == player2:\\n winner = player1\\n bye_match = True\\n\\n #Generate random winner if no winner param is passed in\\n if winner is None:\\n rand = random.random()\\n if rand < 0.5:\\n winner = player1\\n else:\\n winner = player2\\n\\n conn, cur = connect()\\n #Insert record of match\\n query = \\\"\\\"\\\"INSERT INTO matches (player1_id, player2_id, winner)\\n VALUES (%s, %s, %s)\\\"\\\"\\\"\\n params = (player1, player2, winner,)\\n try:\\n cur.execute(query, params)\\n except:\\n print(\\\"Error encountered when inserting match record into the database\\\")\\n\\n #Save record of player having a bye in Players table\\n if bye_match:\\n query = \\\"UPDATE players SET had_bye = TRUE WHERE player_id = %s;\\\"\\n param = (player1,)\\n try:\\n cur.execute(query, param)\\n except:\\n print(\\\"Error encountered when updating player's Bye round status.\\\")\\n conn.commit()\\n conn.close()\",\n \"def logsession(session, request, toolid):\\n sessionconfig = CONFIG[CONFIG['app']['dbserver']]\\n sessionconn = dbconnect(sessionconfig)\\n sessioncurr = sessionconn.cursor()\\n params = {\\n 'session_id': session['id'],\\n 'session_server': socket.gethostname(),\\n 'session_user': session['uni'],\\n 'session_ip': request.environ['HTTP_X_FORWARDED_FOR'],\\n 'session_user_agent': request.user_agent.string\\n }\\n LOG.error(\\\"Log session:\\\")\\n sessionuq = \\\"\\\"\\\"update sessions\\nset session_server = :session_server,\\n session_user = :session_user,\\n session_ip = :session_ip,\\n session_user_agent = :session_user_agent,\\n session_active = 1\\nwhere session_id = :session_id\\n\\\"\\\"\\\"\\n res = sessioncurr.execute(sessionuq, params)\\n if sessioncurr.rowcount < 1:\\n sessionq = \\\"\\\"\\\"insert into sessions (\\nsession_id, session_server, session_user, session_ip, session_user_agent,\\nsession_start, session_active\\n) values (\\n:session_id, :session_server, :session_user, :session_ip, :session_user_agent,\\nCURRENT_TIMESTAMP, 1\\n)\\n\\\"\\\"\\\"\\n try:\\n sessioncurr.execute(sessionq, params)\\n except cx_Oracle.DatabaseError as err:\\n LOG.error(\\\"Database error in logging sessions: %s\\\", err)\\n LOG.error(\\\"Logged session (insert)\\\")\\n else:\\n LOG.error(\\\"Logged session (update)\\\")\\n\\n params = {\\n 'tool_id': toolid,\\n 'site_id': session['lis_course_offering_sourcedid'],\\n 'session_id': session['id']\\n }\\n toolq = \\\"\\\"\\\"insert into lti_tool_access (\\ntool_id, site_id, session_id, visited_on\\n) values (\\n:tool_id, :site_id, :session_id, CURRENT_TIMESTAMP\\n)\\n\\\"\\\"\\\"\\n try:\\n sessioncurr.execute(toolq, params)\\n except cx_Oracle.DatabaseError as err:\\n LOG.error(\\\"Database error logging tool access: %s\\\", err)\\n sessionconn.commit()\\n\\n sessioncurr.close()\\n sessionconn.close()\",\n \"def record_tie(cls):\\n d = {}\\n for row in range(0, cls.size):\\n for col in range(0, cls.size):\\n token = cls.board[row][col]\\n d[token] = token\\n if cls.winner is None and cls.empty not in list(d.keys()):\\n cls.winner = 'Tie'\",\n \"def on_R1(self):\\r\\n self.log()\",\n \"def insertEvent(self,ip_addr,userID,event_time,event_success):\\n self.cur.execute('INSERT INTO login VALUES(?,?,?,?)', (ip_addr,userID,event_time,event_success))\",\n \"def on_L1(self):\\r\\n self.log()\",\n \"def on_sync(self):\\r\\n self.log()\",\n \"def update_log_pushed(conn, id_):\\n cursor = conn.cursor()\\n cursor.execute('UPDATE timelogs SET pushed = 1 WHERE id = ?;', (id_,))\",\n \"def logusers(sessionid, toolid, users):\\n uconfig = CONFIG[CONFIG['app']['dbserver']]\\n uconn = dbconnect(uconfig)\\n ucurr = uconn.cursor()\\n useruq = \\\"\\\"\\\"update photoauth\\nset time = CURRENT_TIMESTAMP,\\n role = :role,\\n avatar_url = :avatar_url,\\n path = :path\\nwhere session_id = :session_id\\n and tool_id = :tool_id\\n and user_id = :user_id\\n\\\"\\\"\\\"\\n\\n userq = \\\"\\\"\\\"insert into photoauth (\\nsession_id, tool_id, user_id, role, avatar_url, path, time\\n) values (\\n:session_id, :tool_id, :user_id, :role, :avatar_url, :path, CURRENT_TIMESTAMP\\n)\\n\\\"\\\"\\\"\\n for user in users:\\n avatar_url = ''\\n role = ''\\n if 'avatar_url' in user:\\n avatar_url = user['avatar_url']\\n if 'enrollments' in user:\\n role = user['enrollments'][0]['role']\\n params = {\\n 'session_id': sessionid,\\n 'tool_id': toolid,\\n 'user_id': user['sis_user_id'],\\n 'role': role,\\n 'avatar_url': avatar_url,\\n 'path': user['fbpath']\\n }\\n res = ucurr.execute(useruq, params)\\n if ucurr.rowcount < 1:\\n try:\\n ucurr.execute(userq, params)\\n except cx_Oracle.DatabaseError as err:\\n LOG.debug(\\n \\\"Database error in logging students (insert): %s\\\", err\\n )\\n\\n uconn.commit()\\n ucurr.close()\\n uconn.close()\",\n \"def WIN_BONUS() -> int:\\n return 2\",\n \"def is_game_over(cls):\\n cls.record_winner()\\n cls.record_tie()\",\n \"def board_status(board):\\n if terminal(board):\\n victor = winner(board)\\n if victor is not None:\\n emit(\\\"game_over\\\", \\\"winner: \\\" + victor)\\n else:\\n emit(\\\"game_over\\\", \\\"Draw\\\")\",\n \"def log(self, obj, action):\\n action_dict = {'time': time.time(),\\n 'action': action}\\n self.log_data[obj.get_obj_id()]['actions'].append(action_dict)\",\n \"def saveDatabase():\\r\\n debug.write(\\\"saveDatabase processing\\\", 1)\\r\\n \\\"\\\"\\\" Only process if turbo mode is off \\\"\\\"\\\"\\r\\n if not currentTurboMode:\\r\\n debug.write(\\\"turbo mode off, process the save\\\", 1)\\r\\n \\\"\\\"\\\" Update all the player's stats gained and commit the database\\\"\\\"\\\"\\r\\n for player in players:\\r\\n debug.write(\\\"Commiting indivudal players to the virtual database: %s\\\" % player.name, 2)\\r\\n player.commit()\\r\\n debug.write(\\\"Attempting to save the database itself\\\", 1)\\r\\n database.save()\\r\\n debug.write(\\\"SQLite database saved\\\", 1)\\r\\n debug.write(\\\"Creating the event\\\", 1)\\r\\n \\\"\\\"\\\" Create and fire the event \\\"\\\"\\\"\\r\\n values = {\\\"type\\\":(\\\"setstring\\\", str(saveType))}\\r\\n gamethread.delayed(0, fireEvent, (\\\"sourcerpg_databasesaved\\\", values))\\r\\n debug.write(\\\"Event fired\\\", 1)\\r\\n \\r\\n \\\"\\\"\\\" Create a loop if we need to \\\"\\\"\\\"\\r\\n if str( saveType ) == \\\"intervals\\\":\\r\\n gamethread.delayedname(float(saveLength), 'sourcerpg_databasesave', saveDatabase)\\r\\n debug.write(\\\"saveDatabase processed\\\", 1)\",\n \"async def trainer_won(ctx, user: discord.User):\\r\\n \\r\\n trainer_data = load_file(file_path_trainer)\\r\\n user_id = \\\"{}\\\".format(user.id)\\r\\n \\r\\n file = trainer_data[\\\"Trainers\\\"][user_id]\\r\\n wins = file[\\\"Wins\\\"] +1\\r\\n file[\\\"Wins\\\"] = wins\\r\\n update_data(file_path_trainer, trainer_data)\\r\\n \\r\\n await bot.say(user.mention + \\\"'s victory has been added to the trainer log.\\\")\",\n \"def handleWin(self, winningplayer):\\n self.board.drawWinBoard(winningplayer, self.istournament)\\n self.board = None\\n self.ui.game = None\\n if self.istournament:\\n if winningplayer == 1:\\n self.ui.tournament.setWinner(1)\\n if winningplayer == -1:\\n self.ui.tournament.setWinner(2)\\n\\n threading.Timer(3, self.ui.displayCurrentTournament).start()\",\n \"def log_message(self, msg):\\n\\t\\tself.logView.log_message(msg)\",\n \"def whLogOut(self, whAdr=0):\\n\\n\\t\\tlogOutCmd = chr(whAdr) + '\\\\x02'\\n\\t\\tlogging.info(u'Разрываем соединение с прибром учета: %s' % str(whAdr))\\n\\t\\tans = self.cmdWR(logOutCmd)\\n\\t\\tif ans and self._whAnsCheck(whAdr, ans):\\n\\t\\t\\tlogging.debug(u'Соединение со счетчиком %s разорвано!' % (str(whAdr), ))\\n\\t\\t\\tlogOut = True\\n\\t\\telse:\\n\\t\\t\\tlogging.error(u'Не удалось установить разорвать соединение со счетчиком %s' % str(whAdr))\\n\\t\\t\\tlogOut = False\\n\\t\\treturn logOut\",\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 test_create_log(self):\\n message = \\\"Message is {0}\\\".format(random.random())\\n resp = gracedb.writeLog(eventId, message)\\n self.assertEqual(resp.status, 201)\\n new_log_uri = resp.getheader('Location')\\n new_log = resp.json()\\n self.assertEqual(new_log_uri, new_log['self'])\\n check_new_log = gracedb.get(new_log_uri).json()\\n self.assertEqual(check_new_log['comment'], message)\",\n \"def test_log_unlog_game(self):\\n url = reverse('log-game')\\n data = {\\n 'igdb': self.game.igdb,\\n 'name': self.game.name,\\n 'slug': self.game.slug,\\n 'cover_id': self.game.cover_id,\\n 'backdrop_id': self.game.backdrop_id\\n }\\n\\n log = self.client.post(url, data, format='json')\\n self.assertEqual(True, log.data['value'])\\n\\n unlog = self.client.post(url, data, format='json')\\n self.assertEqual(False, unlog.data['value'])\",\n \"def log(cmdDict, kind, error=None):\\n\\n cmdDict['timestamp'] = str(int(time.time() * 1000))\\n cmdDict['logType'] = kind\\n cmdDict['_id'] = cmdDict['transactionNumber'] + cmdDict['user'] + cmdDict['command'] + cmdDict['timestamp'] + cmdDict['logType']\\n\\n if (error != None):\\n cmdDict['errorMessage'] = error\\n\\n try:\\n Database.insert(TRANSACT_COLLECT, cmdDict)\\n\\n except pymongo.errors.PyMongoError as err:\\n print(f\\\"ERROR! Could not log command into database. Failed with: {err}\\\")\",\n \"def logP(self, history, word):\",\n \"def log_request(req: 'flask_request', res: str) -> None:\\n\\n _DBCONFIG = {'user': 'vsearch',\\n 'password': 'vsearchpasswd',\\n 'host': 'hfrey.de',\\n 'database': 'vsearchlogDB'}\\n\\n conn = mysql.connector.connect(**_DBCONFIG)\\n cursor = conn.cursor()\\n\\n _SQL = \\\"\\\"\\\"insert into log (phrase, letters, ip, browser_string, results)\\n values\\n (%s, %s, %s, %s, %s)\\\"\\\"\\\"\\n cursor.execute(_SQL, (req.form['phrase'], req.form['letters'], req.remote_addr, req.user_agent.browser, res, ))\\n\\n cursor.close()\\n conn.commit()\\n conn.close()\",\n \"def trackNewPayment(violation):\\n data = db.Database(filename=\\\"IFB299.db\\\")\\n payment = dict(Citation_Number = violation[\\\"Citation_Number\\\"], Citation_Type = violation[\\\"Violation_Type\\\"], Payment_status = \\\"Pending\\\")\\n data.insertFinePayment(payment)\\n data.close()\",\n \"def __write_event(self, handle, nbr):\\n try:\\n event = self.database.get_event_from_handle(handle)\\n self.__write_row(nbr, handle, event)\\n except:\\n event = \\\"NOT FOUND\\\"\\n self.__write_row(nbr, handle, event)\",\n \"def record_roll(self, roll):\\n if roll == 1:\\n self.turn_over = True\\n self.score = 0\\n else:\\n self.score += roll\",\n \"def on_R2(self):\\r\\n self.log()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67273533","0.6163771","0.6120701","0.6114181","0.6078899","0.6041982","0.6039192","0.6013895","0.5989878","0.5979451","0.5954383","0.5947308","0.59428173","0.5881893","0.5870078","0.58621216","0.5859779","0.5834164","0.57967937","0.5786986","0.5754396","0.57491577","0.56980133","0.5694441","0.56761336","0.5669489","0.5660757","0.5657889","0.5600747","0.5552106","0.55476624","0.5542903","0.5537577","0.5523537","0.55074203","0.55035436","0.54863065","0.54824454","0.54794705","0.5468576","0.54374945","0.5427799","0.5423669","0.5410744","0.5382729","0.53707623","0.53678733","0.53664887","0.5352462","0.5346269","0.5343229","0.5341633","0.53394747","0.5337264","0.5332775","0.53316385","0.5319732","0.53047794","0.52997166","0.5285704","0.5281514","0.52799696","0.5275432","0.5266937","0.52442694","0.524262","0.52350146","0.5233391","0.5208442","0.52075005","0.51941305","0.5189001","0.51846766","0.5183","0.517242","0.5169122","0.51483345","0.5146154","0.5141678","0.5139655","0.5138172","0.51381004","0.51315236","0.5116724","0.5111417","0.5101126","0.51007324","0.50951666","0.50928116","0.50919527","0.50897396","0.5079975","0.50703156","0.5066387","0.50563127","0.50463176","0.5046008","0.50419337","0.50413936","0.50396764","0.5033156"],"string":"[\n \"0.67273533\",\n \"0.6163771\",\n \"0.6120701\",\n \"0.6114181\",\n \"0.6078899\",\n \"0.6041982\",\n \"0.6039192\",\n \"0.6013895\",\n \"0.5989878\",\n \"0.5979451\",\n \"0.5954383\",\n \"0.5947308\",\n \"0.59428173\",\n \"0.5881893\",\n \"0.5870078\",\n \"0.58621216\",\n \"0.5859779\",\n \"0.5834164\",\n \"0.57967937\",\n \"0.5786986\",\n \"0.5754396\",\n \"0.57491577\",\n \"0.56980133\",\n \"0.5694441\",\n \"0.56761336\",\n \"0.5669489\",\n \"0.5660757\",\n \"0.5657889\",\n \"0.5600747\",\n \"0.5552106\",\n \"0.55476624\",\n \"0.5542903\",\n \"0.5537577\",\n \"0.5523537\",\n \"0.55074203\",\n \"0.55035436\",\n \"0.54863065\",\n \"0.54824454\",\n \"0.54794705\",\n \"0.5468576\",\n \"0.54374945\",\n \"0.5427799\",\n \"0.5423669\",\n \"0.5410744\",\n \"0.5382729\",\n \"0.53707623\",\n \"0.53678733\",\n \"0.53664887\",\n \"0.5352462\",\n \"0.5346269\",\n \"0.5343229\",\n \"0.5341633\",\n \"0.53394747\",\n \"0.5337264\",\n \"0.5332775\",\n \"0.53316385\",\n \"0.5319732\",\n \"0.53047794\",\n \"0.52997166\",\n \"0.5285704\",\n \"0.5281514\",\n \"0.52799696\",\n \"0.5275432\",\n \"0.5266937\",\n \"0.52442694\",\n \"0.524262\",\n \"0.52350146\",\n \"0.5233391\",\n \"0.5208442\",\n \"0.52075005\",\n \"0.51941305\",\n \"0.5189001\",\n \"0.51846766\",\n \"0.5183\",\n \"0.517242\",\n \"0.5169122\",\n \"0.51483345\",\n \"0.5146154\",\n \"0.5141678\",\n \"0.5139655\",\n \"0.5138172\",\n \"0.51381004\",\n \"0.51315236\",\n \"0.5116724\",\n \"0.5111417\",\n \"0.5101126\",\n \"0.51007324\",\n \"0.50951666\",\n \"0.50928116\",\n \"0.50919527\",\n \"0.50897396\",\n \"0.5079975\",\n \"0.50703156\",\n \"0.5066387\",\n \"0.50563127\",\n \"0.50463176\",\n \"0.5046008\",\n \"0.50419337\",\n \"0.50413936\",\n \"0.50396764\",\n \"0.5033156\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89489,"cells":{"query":{"kind":"string","value":"log level progress for stat keeping"},"document":{"kind":"string","value":"def ajax_progress(request, game_id, user_id, depth):\n\tmyGame = tools.getGameFromGameId(int(game_id))\n\tmyUser = tools.getUserFromUserId(int(user_id))\n\n\ttools.logProgress(myGame, myUser, int(depth))\n\n\tresponse = {\n\t\t\"status\": \"OK\",\n\t\t\"message\": \"logged progress\"\n\t}\n\n\treturn HttpResponse(json.dumps(response), content_type=\"application/json\")"},"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 _log_progress(self):\n self.num_of_requests_in_pipeline += 1\n if self.num_of_requests_in_pipeline % 20 == 0:\n print('-' * 200)\n print(f'DB PIPELINE: {self.num_of_requests_in_pipeline} items wenth though pipeline.')\n print('-' * 200)","def transfer_progress(self, stats):","def _log_progress(self, t):\n\n # Run the update only 2 step before the actual logging happens in order to\n # make sure that the most recent possible values will be stored in\n # self.summary. This is a hacky workaround in order to support OffPolicyAgent\n # which runs 2 threads without coordination\n if (t+2) % self.log_freq == 0 and self.learn_started:\n episode_rewards = self.env_monitor.get_episode_rewards()\n self.episode_rewards = np.asarray(episode_rewards)\n if self.episode_rewards.size > 0:\n self.mean_ep_rew = np.mean(episode_rewards[-self.stats_n:])\n self.best_mean_ep_rew = max(self.best_mean_ep_rew, self.mean_ep_rew)\n\n if t % self.log_freq == 0 and self.learn_started:\n stats_logger.info(\"\")\n for s, lambda_v in self.log_info:\n stats_logger.info(s.format(lambda_v(t)))\n stats_logger.info(\"\")\n\n if self.summary:\n # Log with TensorBoard\n self.tb_writer.add_summary(self.summary, global_step=t)","def updates(_progress, _tag, _summary):\n log.msg(\"%d%%: %s\" % (_progress, _summary))","def _print_progress(counter):\n\tif(slogviz.config.interactive):\n\t\tprint('parse log file entry nr: {}'.format(counter),end='\\r')","def log_progress(*, extra=\"\", force=False):\n toc = time.perf_counter()\n if (\n not force\n and counts[\"done\"] < log_progress.last_log_count + LOG_COUNT_INTERVAL\n and toc < log_progress.last_log_time + LOG_TIME_INTERVAL\n ):\n # don't need to log yet\n return\n counts_str = \", \".join(\n f\"{key}={value}\" for key, value in sorted(counts.items())\n )\n delta_n = counts[\"done\"] - log_progress.last_log_count\n delta_t = toc - log_progress.last_log_time\n rate = delta_n / delta_t\n app_log.info(\n f\"{label} counts{' ' + extra if extra else ''} (elapsed={toc-tic:.0f}s {rate:.1f} it/s): {counts_str}\"\n )\n log_progress.last_log_count = counts[\"done\"]\n log_progress.last_log_time = toc","def reportProgress(self):\n \n pass","def _printProgress(self, progress):\n if not self._quiet:\n sys.stdout.write('\\rWriting store to CSV: [{0:50s}] {1:.2f}% '.format('#' * int(progress * 50.0), progress * 100.0))\n sys.stdout.flush()","def getProgress(self):","def status(self):\n\t\tstatus = self.thread.status()\n#\t\tprint_array(status)\n\t\tmessage = [\"------ RSYNC PROGRESS ------ \"]\n\t\tif self.log_message:\n\t\t\tmessage.append(self.log_message)\n\t\tmessage.append(\"Current file: %s\" % status['current_file'])\n\t\tmessage.append(\"\\tBytes Copied: %s\" % status['bytes_copied'])\n\t\tmessage.append(\"\\tPercent Done: %s\" % status['percent_done'])\n\t\tmessage.append(\"\\tTransfer Rate: %s\" % status['transfer_rate'])\n\t\tmessage.append(\"\\tTime Remaining: %s\" % status['est_remain'])\n\t\tmessage.append(\"\\tTransfer Number: %s\" % status['xfer_num'])\n\t\tmessage.append(\"\\tTransfers Remaining: %s\" % status['xfer_remain'])\n\t\tmessage.append(\"\\tTransfers Total: %s\" % status['xfer_total'])\n\t\tmessage.append(\"\\t----------------------------------\")\n\t\ttry:\n\t\t\toverall_percent = int(round((int(status['xfer_num'])*1.0)/int(status['xfer_total']),2)*100)\n\t\texcept: overall_percent = 0\n\t\tmessage.append(\"\\tTotal Rsync done: %s%%\\n\" % overall_percent)\n\t\tp = open(self.progress_file,'w+',0)\n\t\tfor line in message:\n\t\t\t#print line\n\t\t\tp.write(\"%s\\n\" % line)\n\t\tp.flush()\n\t\tp.close()","def _print_progress(self):\n \n print 'Completed %d of %d' %(self.progress_id, self.total_work)\n self.progress_id += 1","def doProgress(self,progress,message):\n pass","def _print_stat(self):\n if 0 < self.print_stats_interval < time.monotonic() - self.last_stat_print_time:\n if self._file_paths:\n self._log_file_processing_stats(self._file_paths)\n self.last_stat_print_time = time.monotonic()","def progress(self, id):","def progress(self, id):","def progress(self, arg, num_done, info=''):\n pass","def OnProgress(bytes_read, total_bytes, percent):\n sys.stdout.write(\"progress: %.2f%% \\r\" % (percent))\n sys.stdout.flush()","def progress_func(completed, total):\n if not self.log:\n return\n dots = (completed * dot_count) / total\n if dots > dot_count:\n dots = dot_count\n self.progress_lock.acquire()\n if self.dots_written < dot_count:\n dots_to_write = dots - self.dots_written\n self.dots_written = dots\n os.write(old_stdout, '.' * dots_to_write)\n self.progress_lock.release()","def hook_notifyprogress(self,operation,progress,progressLim=1.,\n subsystem=None):\n ui.notifydebug(operation+\"... (\"+str(progress)+\"/\"+str(progressLim)+\")\",\n subsystem)","def push_progress(self, status, object_id, progress):\n pass","def set_progress(self, progress: float):","def increase_progress(self, value):\r\n\r\n pass","def download_progress_hook(count, blockSize, totalSize):\n percent = int(count * blockSize * 100 / totalSize)\n\n global last_percent_reported\n if last_percent_reported != percent:\n if percent % 5 == 0:\n sys.stdout.write(\"%s%%\" % percent)\n sys.stdout.flush()\n else:\n sys.stdout.write(\".\")\n sys.stdout.flush()\n last_percent_reported = percent","def progress(transactionId, function):\n _log.info(f\"{transactionId.hex} PROGRESS {function}\")","def _progress(self, walker):\n\n raise NotImplementedError","def download_progress_hook(count, blockSize, totalSize):\n global last_percent_reported\n percent = int(count * blockSize * 100 / totalSize)\n\n if last_percent_reported != percent:\n if percent % 5 == 0:\n sys.stdout.write(\"%s%%\" % percent)\n sys.stdout.flush()\n else:\n sys.stdout.write(\".\")\n sys.stdout.flush()\n\n last_percent_reported = percent","def update_progressbar(self, count, value):\n self.status(\"Progress %s/%s\" % (value, count))","def progress_update(sent, total):\n l.debug(\"%d of %d Mb uploaded to Amazon S3.\", sent / 1000000, total / 1000000)","def update_progress(self, done):\r\n if done % 100 == 0:\r\n print >>sys.stderr, \" %d processed, run time %d secs\" % (done, (datetime.now() - self.started_at).seconds)","def progress_msg(processed, total):\n if total > 1:\n percent = int((float(processed) / total) * 100)\n stderr.write(\"\\r[%d/%d] %d%%\" % (processed, total, percent))\n stderr.flush()","def report_step_progress(self, step):\n pass","def log(self, i):\n if i % 100 == 0:\n sys.stderr.write(\"process \" + str(os.getpid()) + \": at timestep \" + str(i) + \"\\n\")","def print_progress(self, info_dict):\n if self.n_print != 0:\n t = info_dict['t']\n if t == 1 or t % self.n_print == 0:\n string = 'Iteration {0}'.format(str(t).rjust(len(str(self.n_iter))))\n string += ' [{0}%]'.format(str(int(t / self.n_iter * 100)).rjust(3))\n print(string)","def report_build_progress(self, build_id, current, total, group_name='',\n status_line=''):\n pass","def progressUpdate(clusterid):\n progress_update.updateProgress(clusterid)","def _count_progress(self, count, done=False):\n if self.blank:\n return\n self.current_count = count\n now = time.time()\n if now - self.last_time < 1 and not done:\n return\n self.f.write('\b'*len(str(self.last_count))+str(count))\n self.f.flush()\n self.last_count = count\n self.last_time = now\n if done:\n self.f.write('\\n')\n self.f.flush()","def progress(x):\n global progress_x, title_global\n xp = int(x * 40 // 100) \n sys.stdout.write(\"\\r\" + title_global + \": [\" + \"#\" * xp + \"-\" * (40 - xp) + \"] %02d%%\" %x)\n sys.stdout.flush()\n progress_x = x","def _print_progress(self):\n if self.current_training_size % 1000 == 0:\n print(self.current_training_size, end='')\n elif self.current_training_size % 100 == 0:\n print('.', end='')","def _setProgress(self):\n\n self.progress = (self.iteration, self.iterationCount)","def progress_bar(self, count, total, status):\n\n bar_len = 50\n filled_len = int(round(bar_len * count / float(total)))\n\n file_size_bytes = f\"{count:,}/{total:,} Bytes\"\n transfer_percent = round(100.0 * count / float(total), 2)\n file_bar = '=' * filled_len + '-' * (bar_len - filled_len)\n\n prefix = f\"[{self.LOGGER.host}:{self.LOGGER.port}]\"\n sys.stdout.write(f\"{prefix} -> |{file_bar}| {file_size_bytes} | {transfer_percent}% | {status}...\\r\")\n sys.stdout.flush()\n\n if count >= total: print()","def progress_info(self, message, params, current=None, total=None):\n self._clear()\n if current is not None and total is not None:\n if self._last_time is None or (datetime.datetime.now() - self._last_time).seconds > 1:\n self._update_time(current, total)\n\n print(message.format(*params) + \" ETA {}\".format(self._remaining_time), end=\"\\r\")","def dl_progress(count, block_size, total_size):\n percent = int(count*block_size*100/total_size)\n sys.stdout.write(\"\\r\" + 'Progress:' + \"...%d%%\" % percent)\n sys.stdout.flush()","def GetProgress(self):\n return self.new_progress","def update_progress(self, progress, message):\n assert 0 <= progress < 100\n self._progress = int(progress)\n self.logger.info(\n \"status: STARTED %d%% %s\", self._progress, message or \"\"\n )\n self._callback('on_progress_update', self._progress, message)\n return self.update_response(\n self.encoder.encode_started(self._progress, message)\n )","def progress(self, loaded, total, msg=''):\n\n self.fire('progress', {\n 'loaded': loaded,\n 'total': total,\n 'msg': msg\n })","def status(self) -> NoReturn:\n\n curr_status= self.percent_done()\n while(curr_status < 100):\n\n update_status(name=self.name, status=curr_status)\n time.sleep(0.5)\n\n curr_status = self.percent_done()\n\n update_status(name=self.name, status=curr_status)","def get_progress(self):\n ret = self.state + \"\\n\"\n self.reset_progress()\n return ret","def progress(self, *args, **kwargs):\n kwargs['logger'] = self\n return Progress(*args, **kwargs)","def _progress(self, num_completed_batches, data_loader):\n return '[{}/{} ({:.0f}%)]'.format(num_completed_batches, len(data_loader),\n 100.0 * num_completed_batches / len(data_loader))","def _on_progress(self, num):\n self._num_progresses += num\n self._log.info(\"Progress incrementing by {}\".format(num))\n self._host_comms.send_msg(\"progress\", num)","def log_stats_thread(root):\n start = time.time()\n\n while True:\n time.sleep(3)\n timenow = time.time()\n elapsed = str(timedelta(seconds = timenow - start))\n inodesps = inodecount[root] / (timenow - start)\n logger.info('CRAWL STATS (path {0}, files {1}, dirs {2}, elapsed {3}, perf {4:.3f} inodes/s, {5} paths still scanning {6}, memory usage {7})'.format(\n root, filecount[root], dircount[root], elapsed, inodesps, len(scan_paths), scan_paths, get_mem_usage()))\n dps = total_doc_count[root] / (timenow - start)\n logger.info('ES UPLOAD STATS (path {0}, uploaded {1} docs, elapsed {2}, perf {3:.3f} docs/s)'.format(\n root, total_doc_count[root], elapsed, dps))","def progress(count, total, status=''):\n bar_len = 60\n filled_len = int(round(bar_len * count / float(total)))\n\n percents = round(100.0 * count / float(total), 1)\n bar = '=' * filled_len + '-' * (bar_len - filled_len)\n \n if count >= total: \n sys.stdout.write('[%s] %s%s ...%s%s\\r' % (bar, percents, '%', status, '\\n'))\n sys.stdout.flush()\n else:\n sys.stdout.write('[%s] %s%s ...%s\\r' % (bar, percents, '%', status))\n sys.stdout.flush()","def logStats(self, msg):\n self.logLinesStats.append(msg)","def status(self, message=None):\n self.i += 1\n self.last_message = message\n\n if self.silent:\n return\n\n if self.skip > 1 and self.i % self.skip != 0:\n return\n\n if self.adapt:\n # Set skip to the reciprocal of per-instance time to schedule\n # status updates at approximately 1/sec.\n # We use i-1 instead of i to compensate for cases in which\n # status() is called prior to slow processing, resulting in\n # skip getting set to a large value from the outset.\n self.skip = int((self.i - 1) / (time.time() - self.start))\n\n self.display(\"[{0:.2g}s{1}]\".format(\n (time.time() - self.start) / self.i,\n ' on avg' if self.i > 1 else ''),\n message=str(message) if message is not None else None,\n msg_color=self.active_color,\n timing_color=self.active_color)","def logger_callback(df_complete, psz_message, p_progress_arg):\r\n try:\r\n current_time = time.time()\r\n if ((current_time - logger_callback.last_time) > 5.0 or\r\n (df_complete == 1.0 and\r\n logger_callback.total_time >= 5.0)):\r\n LOGGER.info(message, df_complete * 100)\r\n logger_callback.last_time = current_time\r\n logger_callback.total_time += current_time\r\n except AttributeError:\r\n logger_callback.last_time = time.time()\r\n logger_callback.total_time = 0.0","def report_scenario_progress(self):\n pass","def printStatus(level,text):\n\tglobal t0\n\tpre = \"[{0:>7.2f}] \".format(time.time()-t0)\n\tfor x in range(0,level):\n\t\tpre += \"-\"\n\tpre += \"> \"\n\tprint(pre+text)","def print_progress(self, i, current_params):\n for split in range(1,11):\n if i == (round(self.iterations/10*split)-1):\n post = -self.full_neg_posterior(current_params)\n approx = self.create_normal_logq(current_params)\n diff = post - approx\n if not self.quiet_progress:\n print(str(split) + \"0% done : ELBO is \" + str(diff) + \", p(y,z) is \" + str(post) + \", q(z) is \" + str(approx))","def printProgress(self, percentage):\n #print '%s\\r' % ' '*20, # clean up row\n #print '%3d%% ' % percentage, # ending with comma prevents newline from being appended\n sys.stdout.flush()","def print_progress(self, i, current_params):\n for split in range(1,11):\n if i == (round(self.iterations/10*split)-1):\n post = -self.neg_posterior(current_params)\n approx = self.create_normal_logq(current_params)\n diff = post - approx\n if not self.quiet_progress:\n print(str(split) + \"0% done : ELBO is \" + str(diff) + \", p(y,z) is \" + str(post) + \", q(z) is \" + str(approx))","def updateProgress (self, iteration, total, prefix='Progress', suffix='complete', decimals=1, length=100, fill='█', printEnd=\"\\r\"):\n if iteration == 0:\n self.start_time = timer()\n ETC = '' #Estimated Time to Completion\n if (iteration/total)*100 >= self.updates[self.update_counter]:\n elapsed = timer() - self.start_time\n if iteration != 0:\n minutes = int((elapsed * total/iteration - elapsed)//60)\n seconds = int((elapsed * total/iteration - elapsed)%60)\n ETC = \"(~{:d} mins {:d}s left)\".format(minutes, seconds)\n percent = (\"{0:.\" + str(decimals) + \"f}\").format(100 * (iteration / float(total)))\n filledLength = int(length * iteration // total)\n bar = fill * filledLength + '-' * (length - filledLength)\n # Unfortunately \\r doesn't work in the pycharm console, so we have to reprint the whole bar everytime,\n # clogging the console.\n #print(f'\\r{prefix} |{bar}| {percent}% {suffix} {ETC}', end = printEnd)\n print(f'{prefix} |{bar}| {percent}% {suffix} {ETC}')\n # Print New Line on Complete\n if iteration == total:\n print()\n self.update_counter += 1","def progress_status(self):\n from tqdm import tqdm\n pbar_a = tqdm(total=len(self.jobs), position=0)\n pbar_a.set_description('Submitted jobs ...')\n pbar_b = tqdm(total=self.n_submit_script, position=1)\n pbar_b.set_description('Running jobs ...')\n pbar_c = tqdm(total=self.n_submit_script, position=2)\n pbar_c.set_description('Completed jobs ...')\n pbar_d = tqdm(total=self.n_submit_script, position=3)\n pbar_d.set_description('Failed? jobs ...')\n while self.n_completed < self.n_submit_script:\n pbar_a.n = self.n_submitted\n pbar_b.n = self.n_running\n pbar_c.n = self.n_completed\n pbar_d.n = self.n_failed + self.n_unknown\n pbar_a.refresh()\n pbar_b.refresh()\n pbar_c.refresh()\n pbar_d.refresh()\n sleep(5)\n self.update_status()","def progress(x):\n global progress_x\n x = int(x * 40 // 100)\n sys.stdout.write(\"#\" * (x - progress_x))\n sys.stdout.flush()\n progress_x = x\n return 0","def PrintProgress(self):\n print ' Examined %d nodes, found %d unique...' % (\n self.nodes_examined, self.unique_nodes\n )","async def progress(current, total, event, start, type_of_ps, file_name=None):\n now = time.time()\n diff = now - start\n if round(diff % 10.00) == 0 or current == total:\n percentage = current * 100 / total\n speed = current / diff\n elapsed_time = round(diff) * 1000\n time_to_completion = round((total - current) / speed) * 1000\n estimated_total_time = elapsed_time + time_to_completion\n progress_str = \"{0}{1} {2}%\\n\".format(\n \"\".join(\"■\" for i in range(math.floor(percentage / 10))),\n \"\".join(\"□\" for i in range(10 - math.floor(percentage / 10))),\n round(percentage, 2),\n )\n tmp = progress_str + \"{0} of {1}\\nETA: {2}\".format(\n humanbytes(current), humanbytes(total), time_formatter(estimated_total_time)\n )\n if file_name:\n await event.edit(\n \"{}\\nFile Name: `{}`\\n{}\".format(type_of_ps, file_name, tmp)\n )\n else:\n await event.edit(\"{}\\n{}\".format(type_of_ps, tmp))","def _print_status(self):","def notify_progress(self, progress_data):\n pass # pragma: no cover","def progress(loss, epoch, batch, batch_size, dataset_size):\n batches = math.ceil(float(dataset_size) / batch_size)\n count = batch * batch_size\n bar_len = 40\n filled_len = int(round(bar_len * count / float(dataset_size)))\n\n bar = '=' * filled_len + '-' * (bar_len - filled_len)\n\n status = 'Epoch {}, Loss: {:.4f}'.format(epoch, loss)\n _progress_str = \"\\r \\r [{}] ...{}\".format(bar, status)\n sys.stdout.write(_progress_str)\n sys.stdout.flush()\n\n if batch == batches:\n print()","def check_progress_logs(self, job_id: str, sleep_time: int = 45) -> Dict:\n sys.stdout.write(\n \"\"\"\n @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n @@@@.####.@@(.@@/((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n @@@@@.####.&(@.,((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n @@@@@@*####....((((.@@@@@@@@@@..*@@@@@@@.@@@@@@@@/.@@@@@@@@..@@@@@..@@@@@@..........@@@@@@..@@@@@@@@@@@@@@@@@.../@@@@@@@\n @@@@@@@(###.%@.(((.@@@@@@@@@@@.@*.(@@@@@.@@@@@@@@/.@@@@@@@@@@..@..@@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@@@..@@.,@@@@@@\n @@@@@@@@/#.....,(.@@@@@@@@@@@@.@@@,./@@@.@@@@@@@@/.@@@@@@@@@@@...@@@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@@.*@@@@..@@@@@\n @@@@@@@(###(.%*(((.@@@@@@@@@@@.@@@@@/.(@.@@@@@@@@/.@@@@@@@@@*.@@&.,@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@..........@@@@\n @@@@@@,####....((((.@@@@@@@@@@.@@@@@@@...@@@@@@@@/.@@@@@@@(./@@@@@..&@@@@@@@@@..@@@@@@@@@@......@@@@@@@@/.@@@@@@@@@,.@@@\n @@@@@.####.@,&.,((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n @@@@.####.@@@*@@/((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n Have some coffee while you wait...\n ( (\n ) )\n ........\n | |]\n \\ /\n `----'\n \"\"\"\n )\n sys.stdout.write(f'\\nSetting up Nixtla infrastructure (this will take up 5 mins)...\\n')\n\n idx_logs = 0\n in_progress = True\n while in_progress:\n resp = self.get_status(job_id)\n status = resp['status']\n logs = json.loads(resp['logs'])\n\n if status != 'InProgress' and not logs:\n time.sleep(30)\n resp = self.get_status(job_id)\n status = resp['status']\n logs = json.loads(resp['logs'])\n\n if logs:\n #if logs != latest_logs:\n for log in logs[idx_logs:]:\n sys.stdout.write(f'{log}\\n')\n #latest_logs = logs\n idx_logs = len(logs)\n\n in_progress = status == 'InProgress'\n\n time.sleep(sleep_time)\n\n return status","def output_stats(self):\n elapsed = self.timer.elapsed.total_seconds()\n count = self.copied + self.errored\n total = self.total\n # Time per key in milliseconds\n avg = round(elapsed / count * 1000, 3)\n # Time remaining in seconds\n remaining = 1.0 * elapsed / count * (total - count)\n # Time remaining in minutes\n remaining = round(remaining / 60.0, 1)\n # Time taken in minutes\n elapsed = round(elapsed / 60.0, 1)\n\n self.log.info(f\"{self.prefix}: {avg}ms avg, {elapsed}min passed, \"\n f\"{remaining}min remaining. ({count:,}/{total:,})\")","def print_progress(self, current_stock_index):\n\n progress = float(current_stock_index + 1) / float(len(self.stock_list))\n progress_str = str(progress * 100)\n print(\"Progress:\", progress_str[:4], \"%\")\n\n elapsed_seconds = time.time() - self.start_time\n elapsed_minutes = float(elapsed_seconds) / 60.0\n\n remaining_minutes = (elapsed_minutes / progress) - elapsed_minutes\n print(str(remaining_minutes).split('.')[0], \"Minutes remaining, \",\n str(elapsed_minutes).split('.')[0], \"minutes elapsed.\")\n print()","def update_progress(progress, time):\n barLength = 30 # Modify this to change the length of the progress bar\n status = \"\"\n if isinstance(progress, int):\n progress = float(progress)\n if not isinstance(progress, float):\n progress = 0\n status = \"error: progress var must be float\\r\\n\"\n if progress < 0:\n progress = 0\n status = \"Halt...\\r\\n\"\n if progress >= 1:\n progress = 1\n status = \"Done...\\r\\n\"\n block = int(round(barLength * progress))\n text = \"\\rPercent: [{0}] {1:.2f}% --- {3:.2f} s. remain. {2}\".format(\n \"=\" * (block - 1) + \">\" + \" \" * (barLength - (block - 1) - 1), progress * 100, status, time)\n sys.stdout.write(text)\n sys.stdout.flush()","def get_progress(self, pr, id):\n\t\treturn round((self.handler.file_progress()[id] / pr.length) * 100, )","def _progress(self, size: float):\n downloaded = 0\n\n def progress(chunk):\n nonlocal downloaded\n downloaded += chunk\n done = int(50 * downloaded / size)\n sys.stdout.write(f'\\r[{\"=\" * done}{\" \" * (50-done)}]')\n sys.stdout.flush()\n\n return progress","def dump_step(self,status):\n\n L = self.level\n stats.add_to_stats(step=status.step, time=status.time, type='timing_step', value=time.time()-self.t0)\n stats.add_to_stats(step=status.step, time=status.time, type='niter', value=status.iter)\n stats.add_to_stats(step=status.step, time=status.time, type='residual', value=L.status.residual)\n\n pass","def report_step_progress(self, step):\n dot_status = self.dot_status[step.status.name]\n if step.status == Status.failed:\n if (step.exception and\n not isinstance(step.exception, AssertionError)):\n # -- ISA-ERROR: Some Exception\n dot_status = self.dot_status[\"error\"]\n step.feature = self.current_feature\n step.scenario = self.current_scenario\n self.failures.append(step)\n self.stream.write(dot_status)\n self.stream.flush()","def query_job_progress():\n pass","def print_status(self, id, pr, package, version, filename):\n\n\t\tprogress = self.get_progress(pr, id);\n\t\t\n\t\twhile progress != 100:\n\t\t\tself.write_line(\"STATUS {0} {1}%\".format(package, progress))\n\t\t\ttime.sleep(1)\n\t\t\tprogress = self.get_progress(pr, id);\n\n\t\tself.write_line(\"STATUS {0} {1}%\".format(package, progress))","def get_progress(self):\r\n return None","def on_sync(self):\r\n self.log()","def progress(self):\n return self.runProgress","def progress(self):\n return self.runProgress","def progressfunc(self, msg):\n (row, count, seriesid, process, statusmessage) = msg.data\n print(\"\\nProgress updated: \", time.ctime())\n print('\\tPROGRESS: count = ', count, \" row=\", row)\n # row = 0\n for item in range(self.m_dataViewListCtrlRunning.GetItemCount()):\n if self.m_dataViewListCtrlRunning.GetValue(row=item, col=1) == seriesid:\n row = item\n\n status = ''\n if count == 0:\n self.m_dataViewListCtrlRunning.AppendItem([process, seriesid, count, \"Pending\"])\n self.start[seriesid] = time.time()\n elif count < 0:\n if len(statusmessage) <= 0:\n statusmessage = \"Unknown\"\n self.m_dataViewListCtrlRunning.SetValue(\"ERROR: \" + statusmessage, row=row, col=3)\n self.m_btnRunProcess.Enable()\n self.m_stOutputlog.SetLabelText(statusmessage)\n elif count < 100:\n if len(statusmessage) <= 0:\n statusmessage = \"Running\"\n self.m_dataViewListCtrlRunning.SetValue(statusmessage, row=row, col=3)\n self.m_dataViewListCtrlRunning.SetValue(count, row=row, col=2)\n else:\n if seriesid in self.start:\n endtime = time.time() - self.start[seriesid]\n status = \"(%d secs)\" % endtime\n print(status)\n self.m_dataViewListCtrlRunning.SetValue(100, row=row, col=2)\n self.m_dataViewListCtrlRunning.SetValue(\"Done \" + status, row=row, col=3)\n self.m_btnRunProcess.Enable()","def progress(self, progress):\n\n self._progress = progress","def progress(self, progress):\n\n self._progress = progress","def update_progress(i, n):\n global _current_line\n prog = progress_string(i, n)\n if _current_line is not None:\n _current_line.update(prog)","def StatusUpdate(msg):\r\n if verbosity > 0:\r\n print msg","def progress(i, my_list, message=\"\"):\n\tmy_progress = (i / len(my_list)) * 100\n\tmy_progress = str(round(my_progress, 1)) + \"% \" + message\n\tsys.stdout.write('\\r')\n\tsys.stdout.write(my_progress)\n\tsys.stdout.flush()","def _download_progress(count, block_size, total_size):\n #pylint: disable=unused-argument\n if count == 0:\n return\n duration = time.time() - start_time\n progress_size = int(count * block_size)\n speed = int(progress_size / (1024 * duration))\n percent = min(int(count * block_size * 100 / total_size), 100)\n sys.stdout.write(\"\\r...%d%%, %.2f MB, %d KB/s, %d seconds passed\" %\n (percent, progress_size / (1024.0 * 1024), speed, duration))\n sys.stdout.flush()","def update_progress(job_title, progress):\n \n length = 20 # modify this to change the length\n block = int(round(length*progress))\n msg = \"\\r{0}: [{1}] {2}%\".format(job_title, \"#\"*block + \"-\"*(length-block), round(progress*100, 2))\n if progress >= 1: msg += \" DONE\\r\\n\"\n sys.stdout.write(msg)\n sys.stdout.flush()","def _download_progress(count, block_size, total_size):\n #pylint: disable=unused-argument\n if count == 0:\n return\n duration = time.time() - start_time\n progress_size = int(count * block_size)\n speed = int(progress_size / (1024 * duration))\n percent = min(int(count * block_size * 100 / total_size), 100)\n sys.stdout.write(\"\\r...%d%%, %d MB, %d KB/s, %d seconds passed\" %\n (percent, progress_size / (1024 * 1024), speed, duration))\n sys.stdout.flush()","def _PrintStatus(self):\n comment = 'iter %i' % (self.n_iter)\n self.gfile.write(fileio.GetPrintCoordsXyzString(\n self.mol.atoms, comment, 14, 8))\n self.PrintEnergy(self.n_iter)\n self.gfile.flush()\n self.efile.flush()","def wait_progress(self):\n pass","def wait_progress(self):\n pass","def updt(total, progress):\n barLength, status = 20, \"\"\n progress = float(progress) / float(total)\n if progress >= 1.:\n progress, status = 1, \"\\r\\n\"\n block = int(round(barLength * progress))\n text = \"\\r[{}] {:.0f}% {}\".format(\n \"#\" * block + \"-\" * (barLength - block), round(progress * 100, 0),\n status)\n sys.stdout.write(text)\n sys.stdout.flush()","def updt(total, progress):\n barLength, status = 20, \"\"\n progress = float(progress) / float(total)\n if progress >= 1.:\n progress, status = 1, \"\\r\\n\"\n block = int(round(barLength * progress))\n text = \"\\r[{}] {:.0f}% {}\".format(\n \"#\" * block + \"-\" * (barLength - block), round(progress * 100, 0),\n status)\n sys.stdout.write(text)\n sys.stdout.flush()","def _progressBar(self, percent, printEvery=10):\n floor = int(percent)\n sys.stdout.write('\\r' * (floor + 9))\n sys.stdout.write('[')\n sys.stdout.write('=' * (floor/printEvery))\n sys.stdout.write('>] {:02.2f}%'.format(percent))\n sys.stdout.flush()","def progress(self, msg):\n logging.info(\"UI-Test: \" + msg)\n with step(\"UI test progress: \" + msg):\n pass\n if len(self.state) > 0:\n self.state += \"\\n\"\n self.state += \"UI: \" + msg","def _print_progress(self):\n print(\n 'E {} S {} TR {:6.2f} G {:6.2f} Reg {:6.5f} Loss {:6.5f} AvgQ {:6.2f}'\n ' MinR {:6.2f} MaxR {:6.2f}'.format(\n self.episode, self.episode_step, self.tracker.total_reward, self.tracker.discounted_rewards,\n self.reg_loss_val, self.critic_loss_val, self.mean_q_val,\n self.tracker.min_reward, self.tracker.max_reward))","def update_progress(self, argv):\n data = {}\n arg_types = [{\n \"type\": \"cognitive\",\n \"rating\": argv.c,\n \"description\": argv.cd\n },\n {\n \"type\": \"emotional\",\n \"rating\": argv.e,\n \"description\": argv.ed\n }\n , {\n \"type\": \"physical\",\n \"rating\": argv.p,\n \"description\": argv.pd\n }\n\n ]\n\n for data_type in arg_types:\n if data_type[\"rating\"]:\n if 100 >= int(data_type[\"rating\"]) > 0:\n data[data_type[\"type\"]] = {\n \"rating\": data_type[\"rating\"],\n \"description\": data_type[\"description\"],\n \"sentiment\": self.get_sentiment(data_type[\"description\"])\n }\n else:\n logging.error(\"Invalid Rating, must be 1-10\")\n exit(1)\n today = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M\")\n insert_data = {today: {\"data\": data, \"weather\": Weather.get_weather()}}\n logging.info(\"Updating Progress\")\n self.prog_logs.insert(insert_data)","def recordLog(project, status, memo):\n path = getPath(project)\n log = open(path, 'a')\n writer = csv.writer(log, lineterminator='\\n')\n writer.writerow((time.time(), status, memo))\n log.close()\n if status == 'a':\n print(\"Tracking your time on \" + project)\n if status == 's':\n print(\"Tracking suspended on \" + project)\n if status == 't':\n print(\"Time shifted on \" + project)\n if not path == '.sourglass':\n store = open(os.path.join(basepath, 'last'), 'w')\n store.write(project)\n store.close"],"string":"[\n \"def _log_progress(self):\\n self.num_of_requests_in_pipeline += 1\\n if self.num_of_requests_in_pipeline % 20 == 0:\\n print('-' * 200)\\n print(f'DB PIPELINE: {self.num_of_requests_in_pipeline} items wenth though pipeline.')\\n print('-' * 200)\",\n \"def transfer_progress(self, stats):\",\n \"def _log_progress(self, t):\\n\\n # Run the update only 2 step before the actual logging happens in order to\\n # make sure that the most recent possible values will be stored in\\n # self.summary. This is a hacky workaround in order to support OffPolicyAgent\\n # which runs 2 threads without coordination\\n if (t+2) % self.log_freq == 0 and self.learn_started:\\n episode_rewards = self.env_monitor.get_episode_rewards()\\n self.episode_rewards = np.asarray(episode_rewards)\\n if self.episode_rewards.size > 0:\\n self.mean_ep_rew = np.mean(episode_rewards[-self.stats_n:])\\n self.best_mean_ep_rew = max(self.best_mean_ep_rew, self.mean_ep_rew)\\n\\n if t % self.log_freq == 0 and self.learn_started:\\n stats_logger.info(\\\"\\\")\\n for s, lambda_v in self.log_info:\\n stats_logger.info(s.format(lambda_v(t)))\\n stats_logger.info(\\\"\\\")\\n\\n if self.summary:\\n # Log with TensorBoard\\n self.tb_writer.add_summary(self.summary, global_step=t)\",\n \"def updates(_progress, _tag, _summary):\\n log.msg(\\\"%d%%: %s\\\" % (_progress, _summary))\",\n \"def _print_progress(counter):\\n\\tif(slogviz.config.interactive):\\n\\t\\tprint('parse log file entry nr: {}'.format(counter),end='\\\\r')\",\n \"def log_progress(*, extra=\\\"\\\", force=False):\\n toc = time.perf_counter()\\n if (\\n not force\\n and counts[\\\"done\\\"] < log_progress.last_log_count + LOG_COUNT_INTERVAL\\n and toc < log_progress.last_log_time + LOG_TIME_INTERVAL\\n ):\\n # don't need to log yet\\n return\\n counts_str = \\\", \\\".join(\\n f\\\"{key}={value}\\\" for key, value in sorted(counts.items())\\n )\\n delta_n = counts[\\\"done\\\"] - log_progress.last_log_count\\n delta_t = toc - log_progress.last_log_time\\n rate = delta_n / delta_t\\n app_log.info(\\n f\\\"{label} counts{' ' + extra if extra else ''} (elapsed={toc-tic:.0f}s {rate:.1f} it/s): {counts_str}\\\"\\n )\\n log_progress.last_log_count = counts[\\\"done\\\"]\\n log_progress.last_log_time = toc\",\n \"def reportProgress(self):\\n \\n pass\",\n \"def _printProgress(self, progress):\\n if not self._quiet:\\n sys.stdout.write('\\\\rWriting store to CSV: [{0:50s}] {1:.2f}% '.format('#' * int(progress * 50.0), progress * 100.0))\\n sys.stdout.flush()\",\n \"def getProgress(self):\",\n \"def status(self):\\n\\t\\tstatus = self.thread.status()\\n#\\t\\tprint_array(status)\\n\\t\\tmessage = [\\\"------ RSYNC PROGRESS ------ \\\"]\\n\\t\\tif self.log_message:\\n\\t\\t\\tmessage.append(self.log_message)\\n\\t\\tmessage.append(\\\"Current file: %s\\\" % status['current_file'])\\n\\t\\tmessage.append(\\\"\\\\tBytes Copied: %s\\\" % status['bytes_copied'])\\n\\t\\tmessage.append(\\\"\\\\tPercent Done: %s\\\" % status['percent_done'])\\n\\t\\tmessage.append(\\\"\\\\tTransfer Rate: %s\\\" % status['transfer_rate'])\\n\\t\\tmessage.append(\\\"\\\\tTime Remaining: %s\\\" % status['est_remain'])\\n\\t\\tmessage.append(\\\"\\\\tTransfer Number: %s\\\" % status['xfer_num'])\\n\\t\\tmessage.append(\\\"\\\\tTransfers Remaining: %s\\\" % status['xfer_remain'])\\n\\t\\tmessage.append(\\\"\\\\tTransfers Total: %s\\\" % status['xfer_total'])\\n\\t\\tmessage.append(\\\"\\\\t----------------------------------\\\")\\n\\t\\ttry:\\n\\t\\t\\toverall_percent = int(round((int(status['xfer_num'])*1.0)/int(status['xfer_total']),2)*100)\\n\\t\\texcept: overall_percent = 0\\n\\t\\tmessage.append(\\\"\\\\tTotal Rsync done: %s%%\\\\n\\\" % overall_percent)\\n\\t\\tp = open(self.progress_file,'w+',0)\\n\\t\\tfor line in message:\\n\\t\\t\\t#print line\\n\\t\\t\\tp.write(\\\"%s\\\\n\\\" % line)\\n\\t\\tp.flush()\\n\\t\\tp.close()\",\n \"def _print_progress(self):\\n \\n print 'Completed %d of %d' %(self.progress_id, self.total_work)\\n self.progress_id += 1\",\n \"def doProgress(self,progress,message):\\n pass\",\n \"def _print_stat(self):\\n if 0 < self.print_stats_interval < time.monotonic() - self.last_stat_print_time:\\n if self._file_paths:\\n self._log_file_processing_stats(self._file_paths)\\n self.last_stat_print_time = time.monotonic()\",\n \"def progress(self, id):\",\n \"def progress(self, id):\",\n \"def progress(self, arg, num_done, info=''):\\n pass\",\n \"def OnProgress(bytes_read, total_bytes, percent):\\n sys.stdout.write(\\\"progress: %.2f%% \\\\r\\\" % (percent))\\n sys.stdout.flush()\",\n \"def progress_func(completed, total):\\n if not self.log:\\n return\\n dots = (completed * dot_count) / total\\n if dots > dot_count:\\n dots = dot_count\\n self.progress_lock.acquire()\\n if self.dots_written < dot_count:\\n dots_to_write = dots - self.dots_written\\n self.dots_written = dots\\n os.write(old_stdout, '.' * dots_to_write)\\n self.progress_lock.release()\",\n \"def hook_notifyprogress(self,operation,progress,progressLim=1.,\\n subsystem=None):\\n ui.notifydebug(operation+\\\"... (\\\"+str(progress)+\\\"/\\\"+str(progressLim)+\\\")\\\",\\n subsystem)\",\n \"def push_progress(self, status, object_id, progress):\\n pass\",\n \"def set_progress(self, progress: float):\",\n \"def increase_progress(self, value):\\r\\n\\r\\n pass\",\n \"def download_progress_hook(count, blockSize, totalSize):\\n percent = int(count * blockSize * 100 / totalSize)\\n\\n global last_percent_reported\\n if last_percent_reported != percent:\\n if percent % 5 == 0:\\n sys.stdout.write(\\\"%s%%\\\" % percent)\\n sys.stdout.flush()\\n else:\\n sys.stdout.write(\\\".\\\")\\n sys.stdout.flush()\\n last_percent_reported = percent\",\n \"def progress(transactionId, function):\\n _log.info(f\\\"{transactionId.hex} PROGRESS {function}\\\")\",\n \"def _progress(self, walker):\\n\\n raise NotImplementedError\",\n \"def download_progress_hook(count, blockSize, totalSize):\\n global last_percent_reported\\n percent = int(count * blockSize * 100 / totalSize)\\n\\n if last_percent_reported != percent:\\n if percent % 5 == 0:\\n sys.stdout.write(\\\"%s%%\\\" % percent)\\n sys.stdout.flush()\\n else:\\n sys.stdout.write(\\\".\\\")\\n sys.stdout.flush()\\n\\n last_percent_reported = percent\",\n \"def update_progressbar(self, count, value):\\n self.status(\\\"Progress %s/%s\\\" % (value, count))\",\n \"def progress_update(sent, total):\\n l.debug(\\\"%d of %d Mb uploaded to Amazon S3.\\\", sent / 1000000, total / 1000000)\",\n \"def update_progress(self, done):\\r\\n if done % 100 == 0:\\r\\n print >>sys.stderr, \\\" %d processed, run time %d secs\\\" % (done, (datetime.now() - self.started_at).seconds)\",\n \"def progress_msg(processed, total):\\n if total > 1:\\n percent = int((float(processed) / total) * 100)\\n stderr.write(\\\"\\\\r[%d/%d] %d%%\\\" % (processed, total, percent))\\n stderr.flush()\",\n \"def report_step_progress(self, step):\\n pass\",\n \"def log(self, i):\\n if i % 100 == 0:\\n sys.stderr.write(\\\"process \\\" + str(os.getpid()) + \\\": at timestep \\\" + str(i) + \\\"\\\\n\\\")\",\n \"def print_progress(self, info_dict):\\n if self.n_print != 0:\\n t = info_dict['t']\\n if t == 1 or t % self.n_print == 0:\\n string = 'Iteration {0}'.format(str(t).rjust(len(str(self.n_iter))))\\n string += ' [{0}%]'.format(str(int(t / self.n_iter * 100)).rjust(3))\\n print(string)\",\n \"def report_build_progress(self, build_id, current, total, group_name='',\\n status_line=''):\\n pass\",\n \"def progressUpdate(clusterid):\\n progress_update.updateProgress(clusterid)\",\n \"def _count_progress(self, count, done=False):\\n if self.blank:\\n return\\n self.current_count = count\\n now = time.time()\\n if now - self.last_time < 1 and not done:\\n return\\n self.f.write('\\b'*len(str(self.last_count))+str(count))\\n self.f.flush()\\n self.last_count = count\\n self.last_time = now\\n if done:\\n self.f.write('\\\\n')\\n self.f.flush()\",\n \"def progress(x):\\n global progress_x, title_global\\n xp = int(x * 40 // 100) \\n sys.stdout.write(\\\"\\\\r\\\" + title_global + \\\": [\\\" + \\\"#\\\" * xp + \\\"-\\\" * (40 - xp) + \\\"] %02d%%\\\" %x)\\n sys.stdout.flush()\\n progress_x = x\",\n \"def _print_progress(self):\\n if self.current_training_size % 1000 == 0:\\n print(self.current_training_size, end='')\\n elif self.current_training_size % 100 == 0:\\n print('.', end='')\",\n \"def _setProgress(self):\\n\\n self.progress = (self.iteration, self.iterationCount)\",\n \"def progress_bar(self, count, total, status):\\n\\n bar_len = 50\\n filled_len = int(round(bar_len * count / float(total)))\\n\\n file_size_bytes = f\\\"{count:,}/{total:,} Bytes\\\"\\n transfer_percent = round(100.0 * count / float(total), 2)\\n file_bar = '=' * filled_len + '-' * (bar_len - filled_len)\\n\\n prefix = f\\\"[{self.LOGGER.host}:{self.LOGGER.port}]\\\"\\n sys.stdout.write(f\\\"{prefix} -> |{file_bar}| {file_size_bytes} | {transfer_percent}% | {status}...\\\\r\\\")\\n sys.stdout.flush()\\n\\n if count >= total: print()\",\n \"def progress_info(self, message, params, current=None, total=None):\\n self._clear()\\n if current is not None and total is not None:\\n if self._last_time is None or (datetime.datetime.now() - self._last_time).seconds > 1:\\n self._update_time(current, total)\\n\\n print(message.format(*params) + \\\" ETA {}\\\".format(self._remaining_time), end=\\\"\\\\r\\\")\",\n \"def dl_progress(count, block_size, total_size):\\n percent = int(count*block_size*100/total_size)\\n sys.stdout.write(\\\"\\\\r\\\" + 'Progress:' + \\\"...%d%%\\\" % percent)\\n sys.stdout.flush()\",\n \"def GetProgress(self):\\n return self.new_progress\",\n \"def update_progress(self, progress, message):\\n assert 0 <= progress < 100\\n self._progress = int(progress)\\n self.logger.info(\\n \\\"status: STARTED %d%% %s\\\", self._progress, message or \\\"\\\"\\n )\\n self._callback('on_progress_update', self._progress, message)\\n return self.update_response(\\n self.encoder.encode_started(self._progress, message)\\n )\",\n \"def progress(self, loaded, total, msg=''):\\n\\n self.fire('progress', {\\n 'loaded': loaded,\\n 'total': total,\\n 'msg': msg\\n })\",\n \"def status(self) -> NoReturn:\\n\\n curr_status= self.percent_done()\\n while(curr_status < 100):\\n\\n update_status(name=self.name, status=curr_status)\\n time.sleep(0.5)\\n\\n curr_status = self.percent_done()\\n\\n update_status(name=self.name, status=curr_status)\",\n \"def get_progress(self):\\n ret = self.state + \\\"\\\\n\\\"\\n self.reset_progress()\\n return ret\",\n \"def progress(self, *args, **kwargs):\\n kwargs['logger'] = self\\n return Progress(*args, **kwargs)\",\n \"def _progress(self, num_completed_batches, data_loader):\\n return '[{}/{} ({:.0f}%)]'.format(num_completed_batches, len(data_loader),\\n 100.0 * num_completed_batches / len(data_loader))\",\n \"def _on_progress(self, num):\\n self._num_progresses += num\\n self._log.info(\\\"Progress incrementing by {}\\\".format(num))\\n self._host_comms.send_msg(\\\"progress\\\", num)\",\n \"def log_stats_thread(root):\\n start = time.time()\\n\\n while True:\\n time.sleep(3)\\n timenow = time.time()\\n elapsed = str(timedelta(seconds = timenow - start))\\n inodesps = inodecount[root] / (timenow - start)\\n logger.info('CRAWL STATS (path {0}, files {1}, dirs {2}, elapsed {3}, perf {4:.3f} inodes/s, {5} paths still scanning {6}, memory usage {7})'.format(\\n root, filecount[root], dircount[root], elapsed, inodesps, len(scan_paths), scan_paths, get_mem_usage()))\\n dps = total_doc_count[root] / (timenow - start)\\n logger.info('ES UPLOAD STATS (path {0}, uploaded {1} docs, elapsed {2}, perf {3:.3f} docs/s)'.format(\\n root, total_doc_count[root], elapsed, dps))\",\n \"def progress(count, total, status=''):\\n bar_len = 60\\n filled_len = int(round(bar_len * count / float(total)))\\n\\n percents = round(100.0 * count / float(total), 1)\\n bar = '=' * filled_len + '-' * (bar_len - filled_len)\\n \\n if count >= total: \\n sys.stdout.write('[%s] %s%s ...%s%s\\\\r' % (bar, percents, '%', status, '\\\\n'))\\n sys.stdout.flush()\\n else:\\n sys.stdout.write('[%s] %s%s ...%s\\\\r' % (bar, percents, '%', status))\\n sys.stdout.flush()\",\n \"def logStats(self, msg):\\n self.logLinesStats.append(msg)\",\n \"def status(self, message=None):\\n self.i += 1\\n self.last_message = message\\n\\n if self.silent:\\n return\\n\\n if self.skip > 1 and self.i % self.skip != 0:\\n return\\n\\n if self.adapt:\\n # Set skip to the reciprocal of per-instance time to schedule\\n # status updates at approximately 1/sec.\\n # We use i-1 instead of i to compensate for cases in which\\n # status() is called prior to slow processing, resulting in\\n # skip getting set to a large value from the outset.\\n self.skip = int((self.i - 1) / (time.time() - self.start))\\n\\n self.display(\\\"[{0:.2g}s{1}]\\\".format(\\n (time.time() - self.start) / self.i,\\n ' on avg' if self.i > 1 else ''),\\n message=str(message) if message is not None else None,\\n msg_color=self.active_color,\\n timing_color=self.active_color)\",\n \"def logger_callback(df_complete, psz_message, p_progress_arg):\\r\\n try:\\r\\n current_time = time.time()\\r\\n if ((current_time - logger_callback.last_time) > 5.0 or\\r\\n (df_complete == 1.0 and\\r\\n logger_callback.total_time >= 5.0)):\\r\\n LOGGER.info(message, df_complete * 100)\\r\\n logger_callback.last_time = current_time\\r\\n logger_callback.total_time += current_time\\r\\n except AttributeError:\\r\\n logger_callback.last_time = time.time()\\r\\n logger_callback.total_time = 0.0\",\n \"def report_scenario_progress(self):\\n pass\",\n \"def printStatus(level,text):\\n\\tglobal t0\\n\\tpre = \\\"[{0:>7.2f}] \\\".format(time.time()-t0)\\n\\tfor x in range(0,level):\\n\\t\\tpre += \\\"-\\\"\\n\\tpre += \\\"> \\\"\\n\\tprint(pre+text)\",\n \"def print_progress(self, i, current_params):\\n for split in range(1,11):\\n if i == (round(self.iterations/10*split)-1):\\n post = -self.full_neg_posterior(current_params)\\n approx = self.create_normal_logq(current_params)\\n diff = post - approx\\n if not self.quiet_progress:\\n print(str(split) + \\\"0% done : ELBO is \\\" + str(diff) + \\\", p(y,z) is \\\" + str(post) + \\\", q(z) is \\\" + str(approx))\",\n \"def printProgress(self, percentage):\\n #print '%s\\\\r' % ' '*20, # clean up row\\n #print '%3d%% ' % percentage, # ending with comma prevents newline from being appended\\n sys.stdout.flush()\",\n \"def print_progress(self, i, current_params):\\n for split in range(1,11):\\n if i == (round(self.iterations/10*split)-1):\\n post = -self.neg_posterior(current_params)\\n approx = self.create_normal_logq(current_params)\\n diff = post - approx\\n if not self.quiet_progress:\\n print(str(split) + \\\"0% done : ELBO is \\\" + str(diff) + \\\", p(y,z) is \\\" + str(post) + \\\", q(z) is \\\" + str(approx))\",\n \"def updateProgress (self, iteration, total, prefix='Progress', suffix='complete', decimals=1, length=100, fill='█', printEnd=\\\"\\\\r\\\"):\\n if iteration == 0:\\n self.start_time = timer()\\n ETC = '' #Estimated Time to Completion\\n if (iteration/total)*100 >= self.updates[self.update_counter]:\\n elapsed = timer() - self.start_time\\n if iteration != 0:\\n minutes = int((elapsed * total/iteration - elapsed)//60)\\n seconds = int((elapsed * total/iteration - elapsed)%60)\\n ETC = \\\"(~{:d} mins {:d}s left)\\\".format(minutes, seconds)\\n percent = (\\\"{0:.\\\" + str(decimals) + \\\"f}\\\").format(100 * (iteration / float(total)))\\n filledLength = int(length * iteration // total)\\n bar = fill * filledLength + '-' * (length - filledLength)\\n # Unfortunately \\\\r doesn't work in the pycharm console, so we have to reprint the whole bar everytime,\\n # clogging the console.\\n #print(f'\\\\r{prefix} |{bar}| {percent}% {suffix} {ETC}', end = printEnd)\\n print(f'{prefix} |{bar}| {percent}% {suffix} {ETC}')\\n # Print New Line on Complete\\n if iteration == total:\\n print()\\n self.update_counter += 1\",\n \"def progress_status(self):\\n from tqdm import tqdm\\n pbar_a = tqdm(total=len(self.jobs), position=0)\\n pbar_a.set_description('Submitted jobs ...')\\n pbar_b = tqdm(total=self.n_submit_script, position=1)\\n pbar_b.set_description('Running jobs ...')\\n pbar_c = tqdm(total=self.n_submit_script, position=2)\\n pbar_c.set_description('Completed jobs ...')\\n pbar_d = tqdm(total=self.n_submit_script, position=3)\\n pbar_d.set_description('Failed? jobs ...')\\n while self.n_completed < self.n_submit_script:\\n pbar_a.n = self.n_submitted\\n pbar_b.n = self.n_running\\n pbar_c.n = self.n_completed\\n pbar_d.n = self.n_failed + self.n_unknown\\n pbar_a.refresh()\\n pbar_b.refresh()\\n pbar_c.refresh()\\n pbar_d.refresh()\\n sleep(5)\\n self.update_status()\",\n \"def progress(x):\\n global progress_x\\n x = int(x * 40 // 100)\\n sys.stdout.write(\\\"#\\\" * (x - progress_x))\\n sys.stdout.flush()\\n progress_x = x\\n return 0\",\n \"def PrintProgress(self):\\n print ' Examined %d nodes, found %d unique...' % (\\n self.nodes_examined, self.unique_nodes\\n )\",\n \"async def progress(current, total, event, start, type_of_ps, file_name=None):\\n now = time.time()\\n diff = now - start\\n if round(diff % 10.00) == 0 or current == total:\\n percentage = current * 100 / total\\n speed = current / diff\\n elapsed_time = round(diff) * 1000\\n time_to_completion = round((total - current) / speed) * 1000\\n estimated_total_time = elapsed_time + time_to_completion\\n progress_str = \\\"{0}{1} {2}%\\\\n\\\".format(\\n \\\"\\\".join(\\\"■\\\" for i in range(math.floor(percentage / 10))),\\n \\\"\\\".join(\\\"□\\\" for i in range(10 - math.floor(percentage / 10))),\\n round(percentage, 2),\\n )\\n tmp = progress_str + \\\"{0} of {1}\\\\nETA: {2}\\\".format(\\n humanbytes(current), humanbytes(total), time_formatter(estimated_total_time)\\n )\\n if file_name:\\n await event.edit(\\n \\\"{}\\\\nFile Name: `{}`\\\\n{}\\\".format(type_of_ps, file_name, tmp)\\n )\\n else:\\n await event.edit(\\\"{}\\\\n{}\\\".format(type_of_ps, tmp))\",\n \"def _print_status(self):\",\n \"def notify_progress(self, progress_data):\\n pass # pragma: no cover\",\n \"def progress(loss, epoch, batch, batch_size, dataset_size):\\n batches = math.ceil(float(dataset_size) / batch_size)\\n count = batch * batch_size\\n bar_len = 40\\n filled_len = int(round(bar_len * count / float(dataset_size)))\\n\\n bar = '=' * filled_len + '-' * (bar_len - filled_len)\\n\\n status = 'Epoch {}, Loss: {:.4f}'.format(epoch, loss)\\n _progress_str = \\\"\\\\r \\\\r [{}] ...{}\\\".format(bar, status)\\n sys.stdout.write(_progress_str)\\n sys.stdout.flush()\\n\\n if batch == batches:\\n print()\",\n \"def check_progress_logs(self, job_id: str, sleep_time: int = 45) -> Dict:\\n sys.stdout.write(\\n \\\"\\\"\\\"\\n @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n @@@@.####.@@(.@@/((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n @@@@@.####.&(@.,((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n @@@@@@*####....((((.@@@@@@@@@@..*@@@@@@@.@@@@@@@@/.@@@@@@@@..@@@@@..@@@@@@..........@@@@@@..@@@@@@@@@@@@@@@@@.../@@@@@@@\\n @@@@@@@(###.%@.(((.@@@@@@@@@@@.@*.(@@@@@.@@@@@@@@/.@@@@@@@@@@..@..@@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@@@..@@.,@@@@@@\\n @@@@@@@@/#.....,(.@@@@@@@@@@@@.@@@,./@@@.@@@@@@@@/.@@@@@@@@@@@...@@@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@@.*@@@@..@@@@@\\n @@@@@@@(###(.%*(((.@@@@@@@@@@@.@@@@@/.(@.@@@@@@@@/.@@@@@@@@@*.@@&.,@@@@@@@@@@@..@@@@@@@@@@..@@@@@@@@@@@@@@..........@@@@\\n @@@@@@,####....((((.@@@@@@@@@@.@@@@@@@...@@@@@@@@/.@@@@@@@(./@@@@@..&@@@@@@@@@..@@@@@@@@@@......@@@@@@@@/.@@@@@@@@@,.@@@\\n @@@@@.####.@,&.,((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n @@@@.####.@@@*@@/((((.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n\\n Have some coffee while you wait...\\n ( (\\n ) )\\n ........\\n | |]\\n \\\\ /\\n `----'\\n \\\"\\\"\\\"\\n )\\n sys.stdout.write(f'\\\\nSetting up Nixtla infrastructure (this will take up 5 mins)...\\\\n')\\n\\n idx_logs = 0\\n in_progress = True\\n while in_progress:\\n resp = self.get_status(job_id)\\n status = resp['status']\\n logs = json.loads(resp['logs'])\\n\\n if status != 'InProgress' and not logs:\\n time.sleep(30)\\n resp = self.get_status(job_id)\\n status = resp['status']\\n logs = json.loads(resp['logs'])\\n\\n if logs:\\n #if logs != latest_logs:\\n for log in logs[idx_logs:]:\\n sys.stdout.write(f'{log}\\\\n')\\n #latest_logs = logs\\n idx_logs = len(logs)\\n\\n in_progress = status == 'InProgress'\\n\\n time.sleep(sleep_time)\\n\\n return status\",\n \"def output_stats(self):\\n elapsed = self.timer.elapsed.total_seconds()\\n count = self.copied + self.errored\\n total = self.total\\n # Time per key in milliseconds\\n avg = round(elapsed / count * 1000, 3)\\n # Time remaining in seconds\\n remaining = 1.0 * elapsed / count * (total - count)\\n # Time remaining in minutes\\n remaining = round(remaining / 60.0, 1)\\n # Time taken in minutes\\n elapsed = round(elapsed / 60.0, 1)\\n\\n self.log.info(f\\\"{self.prefix}: {avg}ms avg, {elapsed}min passed, \\\"\\n f\\\"{remaining}min remaining. ({count:,}/{total:,})\\\")\",\n \"def print_progress(self, current_stock_index):\\n\\n progress = float(current_stock_index + 1) / float(len(self.stock_list))\\n progress_str = str(progress * 100)\\n print(\\\"Progress:\\\", progress_str[:4], \\\"%\\\")\\n\\n elapsed_seconds = time.time() - self.start_time\\n elapsed_minutes = float(elapsed_seconds) / 60.0\\n\\n remaining_minutes = (elapsed_minutes / progress) - elapsed_minutes\\n print(str(remaining_minutes).split('.')[0], \\\"Minutes remaining, \\\",\\n str(elapsed_minutes).split('.')[0], \\\"minutes elapsed.\\\")\\n print()\",\n \"def update_progress(progress, time):\\n barLength = 30 # Modify this to change the length of the progress bar\\n status = \\\"\\\"\\n if isinstance(progress, int):\\n progress = float(progress)\\n if not isinstance(progress, float):\\n progress = 0\\n status = \\\"error: progress var must be float\\\\r\\\\n\\\"\\n if progress < 0:\\n progress = 0\\n status = \\\"Halt...\\\\r\\\\n\\\"\\n if progress >= 1:\\n progress = 1\\n status = \\\"Done...\\\\r\\\\n\\\"\\n block = int(round(barLength * progress))\\n text = \\\"\\\\rPercent: [{0}] {1:.2f}% --- {3:.2f} s. remain. {2}\\\".format(\\n \\\"=\\\" * (block - 1) + \\\">\\\" + \\\" \\\" * (barLength - (block - 1) - 1), progress * 100, status, time)\\n sys.stdout.write(text)\\n sys.stdout.flush()\",\n \"def get_progress(self, pr, id):\\n\\t\\treturn round((self.handler.file_progress()[id] / pr.length) * 100, )\",\n \"def _progress(self, size: float):\\n downloaded = 0\\n\\n def progress(chunk):\\n nonlocal downloaded\\n downloaded += chunk\\n done = int(50 * downloaded / size)\\n sys.stdout.write(f'\\\\r[{\\\"=\\\" * done}{\\\" \\\" * (50-done)}]')\\n sys.stdout.flush()\\n\\n return progress\",\n \"def dump_step(self,status):\\n\\n L = self.level\\n stats.add_to_stats(step=status.step, time=status.time, type='timing_step', value=time.time()-self.t0)\\n stats.add_to_stats(step=status.step, time=status.time, type='niter', value=status.iter)\\n stats.add_to_stats(step=status.step, time=status.time, type='residual', value=L.status.residual)\\n\\n pass\",\n \"def report_step_progress(self, step):\\n dot_status = self.dot_status[step.status.name]\\n if step.status == Status.failed:\\n if (step.exception and\\n not isinstance(step.exception, AssertionError)):\\n # -- ISA-ERROR: Some Exception\\n dot_status = self.dot_status[\\\"error\\\"]\\n step.feature = self.current_feature\\n step.scenario = self.current_scenario\\n self.failures.append(step)\\n self.stream.write(dot_status)\\n self.stream.flush()\",\n \"def query_job_progress():\\n pass\",\n \"def print_status(self, id, pr, package, version, filename):\\n\\n\\t\\tprogress = self.get_progress(pr, id);\\n\\t\\t\\n\\t\\twhile progress != 100:\\n\\t\\t\\tself.write_line(\\\"STATUS {0} {1}%\\\".format(package, progress))\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\tprogress = self.get_progress(pr, id);\\n\\n\\t\\tself.write_line(\\\"STATUS {0} {1}%\\\".format(package, progress))\",\n \"def get_progress(self):\\r\\n return None\",\n \"def on_sync(self):\\r\\n self.log()\",\n \"def progress(self):\\n return self.runProgress\",\n \"def progress(self):\\n return self.runProgress\",\n \"def progressfunc(self, msg):\\n (row, count, seriesid, process, statusmessage) = msg.data\\n print(\\\"\\\\nProgress updated: \\\", time.ctime())\\n print('\\\\tPROGRESS: count = ', count, \\\" row=\\\", row)\\n # row = 0\\n for item in range(self.m_dataViewListCtrlRunning.GetItemCount()):\\n if self.m_dataViewListCtrlRunning.GetValue(row=item, col=1) == seriesid:\\n row = item\\n\\n status = ''\\n if count == 0:\\n self.m_dataViewListCtrlRunning.AppendItem([process, seriesid, count, \\\"Pending\\\"])\\n self.start[seriesid] = time.time()\\n elif count < 0:\\n if len(statusmessage) <= 0:\\n statusmessage = \\\"Unknown\\\"\\n self.m_dataViewListCtrlRunning.SetValue(\\\"ERROR: \\\" + statusmessage, row=row, col=3)\\n self.m_btnRunProcess.Enable()\\n self.m_stOutputlog.SetLabelText(statusmessage)\\n elif count < 100:\\n if len(statusmessage) <= 0:\\n statusmessage = \\\"Running\\\"\\n self.m_dataViewListCtrlRunning.SetValue(statusmessage, row=row, col=3)\\n self.m_dataViewListCtrlRunning.SetValue(count, row=row, col=2)\\n else:\\n if seriesid in self.start:\\n endtime = time.time() - self.start[seriesid]\\n status = \\\"(%d secs)\\\" % endtime\\n print(status)\\n self.m_dataViewListCtrlRunning.SetValue(100, row=row, col=2)\\n self.m_dataViewListCtrlRunning.SetValue(\\\"Done \\\" + status, row=row, col=3)\\n self.m_btnRunProcess.Enable()\",\n \"def progress(self, progress):\\n\\n self._progress = progress\",\n \"def progress(self, progress):\\n\\n self._progress = progress\",\n \"def update_progress(i, n):\\n global _current_line\\n prog = progress_string(i, n)\\n if _current_line is not None:\\n _current_line.update(prog)\",\n \"def StatusUpdate(msg):\\r\\n if verbosity > 0:\\r\\n print msg\",\n \"def progress(i, my_list, message=\\\"\\\"):\\n\\tmy_progress = (i / len(my_list)) * 100\\n\\tmy_progress = str(round(my_progress, 1)) + \\\"% \\\" + message\\n\\tsys.stdout.write('\\\\r')\\n\\tsys.stdout.write(my_progress)\\n\\tsys.stdout.flush()\",\n \"def _download_progress(count, block_size, total_size):\\n #pylint: disable=unused-argument\\n if count == 0:\\n return\\n duration = time.time() - start_time\\n progress_size = int(count * block_size)\\n speed = int(progress_size / (1024 * duration))\\n percent = min(int(count * block_size * 100 / total_size), 100)\\n sys.stdout.write(\\\"\\\\r...%d%%, %.2f MB, %d KB/s, %d seconds passed\\\" %\\n (percent, progress_size / (1024.0 * 1024), speed, duration))\\n sys.stdout.flush()\",\n \"def update_progress(job_title, progress):\\n \\n length = 20 # modify this to change the length\\n block = int(round(length*progress))\\n msg = \\\"\\\\r{0}: [{1}] {2}%\\\".format(job_title, \\\"#\\\"*block + \\\"-\\\"*(length-block), round(progress*100, 2))\\n if progress >= 1: msg += \\\" DONE\\\\r\\\\n\\\"\\n sys.stdout.write(msg)\\n sys.stdout.flush()\",\n \"def _download_progress(count, block_size, total_size):\\n #pylint: disable=unused-argument\\n if count == 0:\\n return\\n duration = time.time() - start_time\\n progress_size = int(count * block_size)\\n speed = int(progress_size / (1024 * duration))\\n percent = min(int(count * block_size * 100 / total_size), 100)\\n sys.stdout.write(\\\"\\\\r...%d%%, %d MB, %d KB/s, %d seconds passed\\\" %\\n (percent, progress_size / (1024 * 1024), speed, duration))\\n sys.stdout.flush()\",\n \"def _PrintStatus(self):\\n comment = 'iter %i' % (self.n_iter)\\n self.gfile.write(fileio.GetPrintCoordsXyzString(\\n self.mol.atoms, comment, 14, 8))\\n self.PrintEnergy(self.n_iter)\\n self.gfile.flush()\\n self.efile.flush()\",\n \"def wait_progress(self):\\n pass\",\n \"def wait_progress(self):\\n pass\",\n \"def updt(total, progress):\\n barLength, status = 20, \\\"\\\"\\n progress = float(progress) / float(total)\\n if progress >= 1.:\\n progress, status = 1, \\\"\\\\r\\\\n\\\"\\n block = int(round(barLength * progress))\\n text = \\\"\\\\r[{}] {:.0f}% {}\\\".format(\\n \\\"#\\\" * block + \\\"-\\\" * (barLength - block), round(progress * 100, 0),\\n status)\\n sys.stdout.write(text)\\n sys.stdout.flush()\",\n \"def updt(total, progress):\\n barLength, status = 20, \\\"\\\"\\n progress = float(progress) / float(total)\\n if progress >= 1.:\\n progress, status = 1, \\\"\\\\r\\\\n\\\"\\n block = int(round(barLength * progress))\\n text = \\\"\\\\r[{}] {:.0f}% {}\\\".format(\\n \\\"#\\\" * block + \\\"-\\\" * (barLength - block), round(progress * 100, 0),\\n status)\\n sys.stdout.write(text)\\n sys.stdout.flush()\",\n \"def _progressBar(self, percent, printEvery=10):\\n floor = int(percent)\\n sys.stdout.write('\\\\r' * (floor + 9))\\n sys.stdout.write('[')\\n sys.stdout.write('=' * (floor/printEvery))\\n sys.stdout.write('>] {:02.2f}%'.format(percent))\\n sys.stdout.flush()\",\n \"def progress(self, msg):\\n logging.info(\\\"UI-Test: \\\" + msg)\\n with step(\\\"UI test progress: \\\" + msg):\\n pass\\n if len(self.state) > 0:\\n self.state += \\\"\\\\n\\\"\\n self.state += \\\"UI: \\\" + msg\",\n \"def _print_progress(self):\\n print(\\n 'E {} S {} TR {:6.2f} G {:6.2f} Reg {:6.5f} Loss {:6.5f} AvgQ {:6.2f}'\\n ' MinR {:6.2f} MaxR {:6.2f}'.format(\\n self.episode, self.episode_step, self.tracker.total_reward, self.tracker.discounted_rewards,\\n self.reg_loss_val, self.critic_loss_val, self.mean_q_val,\\n self.tracker.min_reward, self.tracker.max_reward))\",\n \"def update_progress(self, argv):\\n data = {}\\n arg_types = [{\\n \\\"type\\\": \\\"cognitive\\\",\\n \\\"rating\\\": argv.c,\\n \\\"description\\\": argv.cd\\n },\\n {\\n \\\"type\\\": \\\"emotional\\\",\\n \\\"rating\\\": argv.e,\\n \\\"description\\\": argv.ed\\n }\\n , {\\n \\\"type\\\": \\\"physical\\\",\\n \\\"rating\\\": argv.p,\\n \\\"description\\\": argv.pd\\n }\\n\\n ]\\n\\n for data_type in arg_types:\\n if data_type[\\\"rating\\\"]:\\n if 100 >= int(data_type[\\\"rating\\\"]) > 0:\\n data[data_type[\\\"type\\\"]] = {\\n \\\"rating\\\": data_type[\\\"rating\\\"],\\n \\\"description\\\": data_type[\\\"description\\\"],\\n \\\"sentiment\\\": self.get_sentiment(data_type[\\\"description\\\"])\\n }\\n else:\\n logging.error(\\\"Invalid Rating, must be 1-10\\\")\\n exit(1)\\n today = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M\\\")\\n insert_data = {today: {\\\"data\\\": data, \\\"weather\\\": Weather.get_weather()}}\\n logging.info(\\\"Updating Progress\\\")\\n self.prog_logs.insert(insert_data)\",\n \"def recordLog(project, status, memo):\\n path = getPath(project)\\n log = open(path, 'a')\\n writer = csv.writer(log, lineterminator='\\\\n')\\n writer.writerow((time.time(), status, memo))\\n log.close()\\n if status == 'a':\\n print(\\\"Tracking your time on \\\" + project)\\n if status == 's':\\n print(\\\"Tracking suspended on \\\" + project)\\n if status == 't':\\n print(\\\"Time shifted on \\\" + project)\\n if not path == '.sourglass':\\n store = open(os.path.join(basepath, 'last'), 'w')\\n store.write(project)\\n store.close\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.714131","0.71269464","0.70470834","0.69629145","0.6934919","0.6782616","0.67440385","0.6740498","0.6710249","0.6569314","0.65626985","0.6546168","0.6487","0.64472675","0.64472675","0.6433927","0.6432851","0.64311254","0.64308006","0.64246374","0.6358968","0.63481957","0.63139206","0.63096714","0.6308268","0.62942904","0.62872124","0.62835574","0.6233952","0.6195045","0.6174087","0.6138721","0.6138207","0.6127225","0.61258405","0.61215556","0.61117345","0.6104801","0.60899734","0.6076188","0.60577476","0.60554624","0.60537636","0.60528666","0.6043975","0.60398334","0.6023831","0.6020455","0.60198826","0.60134","0.59970134","0.5987782","0.5985909","0.5965256","0.59611756","0.59606737","0.5936426","0.59331197","0.59300023","0.59236336","0.5912029","0.59109825","0.59007525","0.5893043","0.58669806","0.5862214","0.58620685","0.5861372","0.585956","0.5858035","0.58497405","0.5849681","0.58382505","0.58237445","0.5819406","0.58115715","0.58080524","0.58079404","0.5789819","0.5786167","0.57771844","0.57771844","0.57754916","0.5775337","0.5775337","0.5754763","0.575205","0.57518536","0.57458806","0.5745424","0.574231","0.5736985","0.5734482","0.5734482","0.57315874","0.57315874","0.5731094","0.5727048","0.5727026","0.5723922","0.57237756"],"string":"[\n \"0.714131\",\n \"0.71269464\",\n \"0.70470834\",\n \"0.69629145\",\n \"0.6934919\",\n \"0.6782616\",\n \"0.67440385\",\n \"0.6740498\",\n \"0.6710249\",\n \"0.6569314\",\n \"0.65626985\",\n \"0.6546168\",\n \"0.6487\",\n \"0.64472675\",\n \"0.64472675\",\n \"0.6433927\",\n \"0.6432851\",\n \"0.64311254\",\n \"0.64308006\",\n \"0.64246374\",\n \"0.6358968\",\n \"0.63481957\",\n \"0.63139206\",\n \"0.63096714\",\n \"0.6308268\",\n \"0.62942904\",\n \"0.62872124\",\n \"0.62835574\",\n \"0.6233952\",\n \"0.6195045\",\n \"0.6174087\",\n \"0.6138721\",\n \"0.6138207\",\n \"0.6127225\",\n \"0.61258405\",\n \"0.61215556\",\n \"0.61117345\",\n \"0.6104801\",\n \"0.60899734\",\n \"0.6076188\",\n \"0.60577476\",\n \"0.60554624\",\n \"0.60537636\",\n \"0.60528666\",\n \"0.6043975\",\n \"0.60398334\",\n \"0.6023831\",\n \"0.6020455\",\n \"0.60198826\",\n \"0.60134\",\n \"0.59970134\",\n \"0.5987782\",\n \"0.5985909\",\n \"0.5965256\",\n \"0.59611756\",\n \"0.59606737\",\n \"0.5936426\",\n \"0.59331197\",\n \"0.59300023\",\n \"0.59236336\",\n \"0.5912029\",\n \"0.59109825\",\n \"0.59007525\",\n \"0.5893043\",\n \"0.58669806\",\n \"0.5862214\",\n \"0.58620685\",\n \"0.5861372\",\n \"0.585956\",\n \"0.5858035\",\n \"0.58497405\",\n \"0.5849681\",\n \"0.58382505\",\n \"0.58237445\",\n \"0.5819406\",\n \"0.58115715\",\n \"0.58080524\",\n \"0.58079404\",\n \"0.5789819\",\n \"0.5786167\",\n \"0.57771844\",\n \"0.57771844\",\n \"0.57754916\",\n \"0.5775337\",\n \"0.5775337\",\n \"0.5754763\",\n \"0.575205\",\n \"0.57518536\",\n \"0.57458806\",\n \"0.5745424\",\n \"0.574231\",\n \"0.5736985\",\n \"0.5734482\",\n \"0.5734482\",\n \"0.57315874\",\n \"0.57315874\",\n \"0.5731094\",\n \"0.5727048\",\n \"0.5727026\",\n \"0.5723922\",\n \"0.57237756\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89490,"cells":{"query":{"kind":"string","value":"Main function This is the flow of actions of this main"},"document":{"kind":"string","value":"def main(argv):\n # 0: Initial steps\n print_configuration_info() \n # fix random seed for reproducibility\n np.random.seed(7)\n # Make an instance of the class Utils\n utils = Utils()\n\n # Obtain the file number\n maxnumber = utils.find_file_maxnumber(RESULTS + DATASET + '/')\n filenumber = maxnumber + 1\n print('file number: ', filenumber)\n \n # 1: Load data (X and y_emb)\n print('Loading data')\n\n # Load activity_dict where every activity name has its associated word embedding\n with open(ACTIVITY_EMBEDDINGS) as f:\n activity_dict = json.load(f)\n \n # Load the activity indices\n with open(ACTIVITY_TO_INT) as f:\n activity_to_int_dict = json.load(f)\n \n # Load the index to activity relations \n with open(INT_TO_ACTIVITY) as f:\n int_to_activity = json.load(f)\n\n # Load embedding matrix, X and y sequences (for y, load both, the embedding and index version)\n embedding_matrix = np.load(EMBEDDING_WEIGHTS) \n X = np.load(X_FILE)\n #y_emb = np.load(Y_EMB_FILE)\n # We need the following two lines for StratifiedKFold\n y_index_one_hot = np.load(Y_INDEX_FILE) \n y_index = np.argmax(y_index_one_hot, axis=1)\n\n # To use oversampling methods in imbalance-learn, we need an activity_index:embedding relation\n # Build it using INT_TO_ACTIVITY and ACTIVITY_EMBEDDINGS files\n activity_index_to_embedding = {}\n for key in int_to_activity:\n activity_index_to_embedding[key] = activity_dict[int_to_activity[key]]\n\n\n max_sequence_length = X.shape[1] # TODO: change this to fit the maximum sequence length of all the datasets\n #total_activities = y_train.shape[1]\n ACTION_MAX_LENGTH = embedding_matrix.shape[1]\n TOTAL_ACTIVITIES = y_index_one_hot.shape[1]\n \n print('X shape:', X.shape) \n print('y index shape:', y_index.shape)\n \n print('max sequence length:', max_sequence_length)\n print('features per action:', embedding_matrix.shape[0])\n print('Action max length:', ACTION_MAX_LENGTH) \n print('Total activities:', TOTAL_ACTIVITIES)\n \n\n # 2: Generate K partitions of the dataset (KFold cross-validation) \n # TODO: Decide between KFold or StratifiedKFold\n # if StratifiedKFold \n skf = StratifiedKFold(n_splits=FOLDS)\n \n # if KFold\n #kf = KFold(n_splits = FOLDS)\n\n fold = 0\n # 4: For each partition (train, test):\n metrics_per_fold = utils.init_metrics_per_fold()\n \n #for train, test in kf.split(X):\n for train, test in skf.split(X, y_index):\n print(\"%d Train: %s, test: %s\" % (fold, len(train), len(test))) \n X_train = X[train]\n y_train = y_index_one_hot[train]\n y_train_index = y_index[train]\n X_val = X[test]\n y_val = y_index_one_hot[test] \n print('Activity distribution %s' % Counter(y_index)) \n\n # 3.1: Build the LSTM model\n print('Building model...')\n sys.stdout.flush()\n \n model = Sequential()\n \n model.add(Embedding(input_dim=embedding_matrix.shape[0], output_dim=embedding_matrix.shape[1], weights=[embedding_matrix], input_length=max_sequence_length, trainable=False))\n # Change input shape when using embeddings\n model.add(LSTM(512, return_sequences=False, recurrent_dropout=DROPOUT, dropout=DROPOUT, input_shape=(max_sequence_length, embedding_matrix.shape[1]))) \n # For regression use a linear dense layer with embedding_matrix.shape[1] size (300 in this case)\n # TODO: consider the need of normalization before calculating the loss (we may use a Lambda layer with L2 norm) \n model.add(Dense(TOTAL_ACTIVITIES))\n model.add(Activation('softmax'))\n # TODO: check different regression losses; cosine_proximity could be the best one for us? \n #model.compile(loss='mean_squared_error', optimizer='adam', metrics=['mse', 'mae'])\n model.compile(loss=LOSS, optimizer='adam', metrics=['accuracy', 'mse', 'mae'])\n print('Model built')\n print(model.summary())\n sys.stdout.flush()\n \n # 3.2: Manage imbalanced data in the training set (SMOTE?) -> Conf option TREAT_IMBALANCE\n # NOTE: We may have a problem with SMOTE, since there are some classes with only 1-3 samples and SMOTE needs n_samples < k_neighbors (~5)\n # NOTE: RandomOverSampler could do the trick, however it generates just copies of current samples\n # TODO: Think about a combination between RandomOverSampler for n_samples < 5 and SMOTE?\n # TODO: First attempt without imbalance management\n if(TREAT_IMBALANCE == True):\n ros = RandomOverSampler(random_state=42) # sampling_strategy={4:10, 12:10, 14:10, 8:10, 13:10}\n print('Original dataset samples for training %s' % len(y_train_index))\n print('Original dataset shape for training %s' % Counter(y_train_index))\n X_train_res, y_train_index_res = ros.fit_resample(X_train, y_train_index)\n print('Resampled dataset samples for training %s' % len(y_train_index_res))\n print('Resampled dataset shape for training %s' % Counter(y_train_index_res))\n y_train_res = np_utils.to_categorical(y_train_index_res)\n \n print(\"y_train_res shape: \", y_train_res.shape)\n else:\n X_train_res = X_train\n y_train_res = y_train\n \n # 3.3: Train the model with the imbalance-corrected training set and use the test set to validate\n print('Training...') \n sys.stdout.flush()\n # Define the callbacks to be used (EarlyStopping and ModelCheckpoint)\n # TODO: Do we need EarlyStopping here?\n #earlystopping = EarlyStopping(monitor='val_loss', patience=100, verbose=0) \n # TODO: improve file naming for multiple architectures\n weights_file = WEIGHTS + DATASET + '/' + str(filenumber).zfill(2) + '-' + EXPERIMENT_ID + '-fold' + str(fold) + WEIGHTS_FILE_ROOT\n modelcheckpoint = ModelCheckpoint(weights_file, monitor='val_loss', save_best_only=True, verbose=0)\n callbacks = [modelcheckpoint]\n history = model.fit(X_train_res, y_train_res, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(X_val, y_val), shuffle=True, callbacks=callbacks)\n # 3.4: Store the generated learning curves and metrics with the best model (ModelCheckpoint?) -> Conf option SAVE\n plot_filename = PLOTS + DATASET + '/' + str(filenumber).zfill(2) + '-' + EXPERIMENT_ID + '-fold' + str(fold)\n #plot_training_info(['loss'], True, history.history, plot_filename)\n if SAVE == True:\n utils.plot_training_info(['loss'], True, history.history, plot_filename)\n print(\"Plots saved in \" + PLOTS + DATASET + '/')\n print(\"Training finished\")\n \n # Print the best val_loss\n min_val_loss = min(history.history['val_loss'])\n print(\"Validation loss: \" + str(min_val_loss)+ \" (epoch \" + str(history.history['val_loss'].index(min_val_loss))+\")\") \n model.load_weights(weights_file)\n yp = model.predict(X_val, batch_size=BATCH_SIZE, verbose=1)\n # yp has the activity predictions (one-hot vectors) \n ypreds = np.argmax(yp, axis=1)\n\n # Calculate the metrics \n ytrue = np.argmax(y_val, axis=1)\n print(\"ytrue shape: \", ytrue.shape)\n print(\"ypreds shape: \", ypreds.shape)\n \n # Use scikit-learn metrics to calculate confusion matrix, accuracy, precision, recall and F-Measure\n \"\"\"\n cm = confusion_matrix(ytrue, ypreds)\n \n # Normalize the confusion matrix by row (i.e by the number of samples\n # in each class)\n cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n np.set_printoptions(precision=3, linewidth=1000, suppress=True)\n \n # Save also the cm to a txt file\n results_file_root = RESULTS + DATASET + '/' + str(filenumber).zfill(2) + '-' + EXPERIMENT_ID + '-fold' + str(fold)\n np.savetxt(results_file_root + '-cm.txt', cm, fmt='%.0f') \n \n np.savetxt(results_file_root+'-cm-normalized.txt', cm_normalized, fmt='%.3f')\n print(\"Confusion matrices saved in \" + RESULTS + DATASET + '/')\n \"\"\"\n # Plot non-normalized confusion matrix -> Conf option SAVE\n if SAVE == True:\n results_file_root = RESULTS + DATASET + '/' + str(filenumber).zfill(2) + '-' + EXPERIMENT_ID + '-fold' + str(fold)\n utils.plot_heatmap(ytrue, ypreds, classes=activity_to_int_dict.keys(),\n title='Confusion matrix, without normalization, fold ' + str(fold),\n path=results_file_root + '-cm.png')\n\n # Plot normalized confusion matrix\n utils.plot_heatmap(ytrue, ypreds, classes=activity_to_int_dict.keys(), normalize=True,\n title='Normalized confusion matrix, fold ' + str(fold),\n path=results_file_root + '-cm-normalized.png')\n\n \n #Dictionary with the values for the metrics (precision, recall and f1)\n metrics = utils.calculate_evaluation_metrics(ytrue, ypreds) \n metrics_per_fold = utils.update_metrics_per_fold(metrics_per_fold, metrics)\n # Update fold counter\n fold += 1\n\n # 5: Calculate the mean and std for the metrics obtained for each partition and store (always) \n metrics_per_fold = utils.calculate_aggregate_metrics_per_fold(metrics_per_fold) \n metrics_filename = RESULTS + DATASET + '/' + str(filenumber).zfill(2) + '-' + EXPERIMENT_ID + '-complete-metrics.json'\n with open(metrics_filename, 'w') as fp:\n json.dump(metrics_per_fold, fp, indent=4)\n print(\"Metrics saved in \" + metrics_filename)\n #print(metrics_per_fold)"},"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 main(self):\r\n pass","def main(self):","def main(self) -> None:\n pass","def main():\n pass","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():\n return","def main(self, params):\n pass","def main():\n\tpass","def main() -> None:","def main() -> None:","def main() -> None:","def main() -> None:","def run(self):\n\t\t\n\t\tpass","def main():\n Main()","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def Run():\r\n pass","def main():\n\t\t# KISS mockup of class operation\n\t\tself.log_in()\n\t\tself.get_token()\t\t# Access token for Facebook API\n\t\tself.get_post()\n\t\tself.get_comments()\n\t\tself.get_hashtags()\t\t# Filter comments that contain Hashtag\n\t\tself.comment_in_json()\t# JSON file where the comments we have replied to are stored\n\t\tself.author_following()\n\t\tself.post_reply()\t\t\n\t\tself.post_video()","def main(self, **kwargs) -> None:\n ...","def run(self): \r\n return","def run(self):\r\n pass","def main():\n\n pass","def run(self):\n \n pass","def main(self):\n\n self.setRecordAudio(True)\n self.general()\n sleep(1)\n self.introduction()\n sleep(1)\n self.get_name()\n sleep(1)\n self.get_age()\n sleep(1)\n self.get_origin()\n sleep(1)\n self.get_company()\n sleep(1)\n self.get_travel_route()\n sleep(1)\n self.get_entrance()\n sleep(1)\n self.get_documentation()\n sleep(1)\n self.sayAnimated(\n 'OK ' + self.name + '. We would like to know why you came to The Netherlands. Can you please answer the following '\n 'questions with yes, or, no?')\n self.speechLock.acquire()\n self.stopListening()\n self.get_exclusion()\n sleep(1)\n self.get_conflict()\n sleep(1)\n self.get_inhumanity()\n sleep(1)\n self.get_family()\n sleep(1)\n\n # end interview and save answers\n self.wrapup()\n self.store_story()","def main(cls):\n raise NotImplementedError","def main():\n print(\"It works!!! ;-)\")\n ###TODO### do something with the various methods/functions of this file","def main(args):","def main(args):","def main(self):\n pass","def run():\n main()","def RUN(self):","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def main():\n pass","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):\n self.print_welcome()\n self.handle_inputs()","def main() -> None:\n return"],"string":"[\n \"def main(self):\\r\\n pass\",\n \"def main(self):\",\n \"def main(self) -> None:\\n pass\",\n \"def main():\\n pass\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\\n return\",\n \"def main(self, params):\\n pass\",\n \"def main():\\n\\tpass\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def run(self):\\n\\t\\t\\n\\t\\tpass\",\n \"def main():\\n Main()\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def Run():\\r\\n pass\",\n \"def main():\\n\\t\\t# KISS mockup of class operation\\n\\t\\tself.log_in()\\n\\t\\tself.get_token()\\t\\t# Access token for Facebook API\\n\\t\\tself.get_post()\\n\\t\\tself.get_comments()\\n\\t\\tself.get_hashtags()\\t\\t# Filter comments that contain Hashtag\\n\\t\\tself.comment_in_json()\\t# JSON file where the comments we have replied to are stored\\n\\t\\tself.author_following()\\n\\t\\tself.post_reply()\\t\\t\\n\\t\\tself.post_video()\",\n \"def main(self, **kwargs) -> None:\\n ...\",\n \"def run(self): \\r\\n return\",\n \"def run(self):\\r\\n pass\",\n \"def main():\\n\\n pass\",\n \"def run(self):\\n \\n pass\",\n \"def main(self):\\n\\n self.setRecordAudio(True)\\n self.general()\\n sleep(1)\\n self.introduction()\\n sleep(1)\\n self.get_name()\\n sleep(1)\\n self.get_age()\\n sleep(1)\\n self.get_origin()\\n sleep(1)\\n self.get_company()\\n sleep(1)\\n self.get_travel_route()\\n sleep(1)\\n self.get_entrance()\\n sleep(1)\\n self.get_documentation()\\n sleep(1)\\n self.sayAnimated(\\n 'OK ' + self.name + '. We would like to know why you came to The Netherlands. Can you please answer the following '\\n 'questions with yes, or, no?')\\n self.speechLock.acquire()\\n self.stopListening()\\n self.get_exclusion()\\n sleep(1)\\n self.get_conflict()\\n sleep(1)\\n self.get_inhumanity()\\n sleep(1)\\n self.get_family()\\n sleep(1)\\n\\n # end interview and save answers\\n self.wrapup()\\n self.store_story()\",\n \"def main(cls):\\n raise NotImplementedError\",\n \"def main():\\n print(\\\"It works!!! ;-)\\\")\\n ###TODO### do something with the various methods/functions of this file\",\n \"def main(args):\",\n \"def main(args):\",\n \"def main(self):\\n pass\",\n \"def run():\\n main()\",\n \"def RUN(self):\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def main():\\n pass\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\\n self.print_welcome()\\n self.handle_inputs()\",\n \"def main() -> None:\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8427905","0.8220689","0.8114415","0.80345976","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.80257344","0.7791478","0.76838374","0.76785403","0.74717957","0.74717957","0.74717957","0.74717957","0.73975044","0.7394754","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.73616153","0.7300883","0.72763574","0.7271297","0.72692853","0.72529125","0.7234551","0.71973556","0.7191198","0.716282","0.7155955","0.7155143","0.7155143","0.714217","0.714002","0.71374196","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.7133725","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.71223867","0.70103073","0.700507"],"string":"[\n \"0.8427905\",\n \"0.8220689\",\n \"0.8114415\",\n \"0.80345976\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.80257344\",\n \"0.7791478\",\n \"0.76838374\",\n \"0.76785403\",\n \"0.74717957\",\n \"0.74717957\",\n \"0.74717957\",\n \"0.74717957\",\n \"0.73975044\",\n \"0.7394754\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.73616153\",\n \"0.7300883\",\n \"0.72763574\",\n \"0.7271297\",\n \"0.72692853\",\n \"0.72529125\",\n \"0.7234551\",\n \"0.71973556\",\n \"0.7191198\",\n \"0.716282\",\n \"0.7155955\",\n \"0.7155143\",\n \"0.7155143\",\n \"0.714217\",\n \"0.714002\",\n \"0.71374196\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.7133725\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.71223867\",\n \"0.70103073\",\n \"0.700507\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89491,"cells":{"query":{"kind":"string","value":"Dummy function to print configuration parameters expressed as global variables in the script"},"document":{"kind":"string","value":"def print_configuration_info():\n print(\"Selected dataset:\", DATASET) \n print(\"Dataset base directory:\", BASE_INPUT_DIR) \n print(\"Daytime option:\", DAYTIME) \n print(\"Nones option:\", NONES) \n print(\"Selected action/activity representation:\", OP)\n print(\"Number of epochs: \", EPOCHS)\n print(\"Number of folds for cross-validation: \", FOLDS)\n print(\"Input directory for data files:\", INPUT_DIR) \n print(\"Embedding matrix file:\", EMBEDDING_WEIGHTS)\n print(\"Action sequences (X) file:\", X_FILE) \n print(\"Word embedding file for activities:\", ACTIVITY_EMBEDDINGS) \n print(\"Activity to int mappings:\", ACTIVITY_TO_INT)\n print(\"Int to activity mappings:\", INT_TO_ACTIVITY) \n print(\"Experiment ID:\", EXPERIMENT_ID)\n print(\"Treat imbalance data:\", TREAT_IMBALANCE)\n print(\"Save intermediate plots:\", SAVE)\n print(\"Batch size:\", BATCH_SIZE)\n print(\"Dropout:\", DROPOUT)\n print(\"Loss:\", LOSS)"},"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 printConf(self):\n print \"\"\n for pname, pvalue in self.neededParams.items():\n print pname, pvalue\n for pname, pvalue in self.optionalParams.items():\n print pname, pvalue","def printSettings():\n print \">>>\\n>>> SettingsTool: global variables:\"\n for variable, value in globals().items():\n if variable.count('__')>1: continue\n print \">>> %-16s = %s\"%(variable,value)\n print \">>>\"","def print_configuration():\n configlog.info(\"-\" * 50)\n configlog.info(\"Initializing with the following configuration\")\n configlog.info(\"Check constants.py to change any of the following\")\n configlog.info(\"-\" * 50)\n configlog.info(\"COMPANY_NAME: {}\".format(COMPANY_NAME))\n configlog.info(\"ACTIVITY_TYPE_FILTER: {}\".format(ACTIVITY_TYPE_FILTER))\n configlog.info(\"APPLY_ACTIVITY_FILTER: {}\".format(APPLY_ACTIVITY_FILTER))\n configlog.info(\"-\" * 50)\n configlog.info(\"Assuming an input dataset with the following features\")\n configlog.info(\"-\" * 50)\n configlog.info(\"BUDGET_COLUMN_NAME: {}\".format(BUDGET_COLUMN_NAME))\n configlog.info(\"COMPANY_COLUMN_NAME: {}\".format(COMPANY_COLUMN_NAME))\n configlog.info(\"ACTIVITY_COLUMN_NAME: {}\".format(ACTIVITY_COLUMN_NAME))\n configlog.info(\"COUNTRY_COLUMN_NAME: {}\".format(COUNTRY_COLUMN_NAME))\n configlog.info(\"-\" * 50)\n configlog.info(\"Fallback data sources\")\n configlog.info(\"-\" * 50)\n configlog.info(\"DEFAULT_URL: {}\".format(DEFAULT_URL))\n configlog.info(\"DEFAULT_LOCAL_DATA_PATH: {}\".format(DEFAULT_LOCAL_DATA_PATH))\n configlog.info(\"-\" * 50)","def print_params(env) -> None:\n dict_pretty_print(env.config['parameters'])","def printConfig():\n # Why not log instead? Are we asking user to confirm settings?\n pass # until implemented","def print_params():\n\n help_out = convert_phil_to_text(master_phil, att_level=1)\n txt_out = convert_phil_to_text(master_phil)\n\n return help_out, txt_out","def magic_config(self,parameter_s=''):\n \n page('Current configuration structure:\\n'+\n pformat(self.rc.dict()))","def show_parameters(args):\n\n logging.basicConfig(format='%(message)s', level=args.logging)\n\n logging.info('\\n#{0}'.format('-'*60))\n logging.info('BUILD CONFIG : {0}'.format(args.config))\n logging.info('BUNDLE FILE : {0}'.format(args.bfile))","def show_config(config, args):\n pprint.pprint(config)","def print_params(self):\n\n logger.info('SimulatedMaps has been initialised with the following attributes:')\n for key in self.params.keys():\n logger.info('{} = {}'.format(key, self.params[key]))","def print_ofpt_get_config_request(msg):\n pass","def display_parameters(self):\n ips = GAConfig[\"initial_population_size\"]\n ps = GAConfig[\"population_size\"]\n nomp = GAConfig[\"num_mating_pairs\"]\n mf = GAConfig[\"base_mutation_factor\"]\n ne = GAConfig[\"num_evolutions\"]\n noc = GAConfig[\"num_categories\"]\n nog = len(self.phones)\n\n display_string = \"\"\"\n Genetic Algorithm Parameters\n ----------------------------\n Initial Population Size %s\n Population Size %s\n Number of Mating Pairs %s\n Base Mutation Factor %s\n Number of Evolutions %s\n Number of Categories %s\n Number of Genes %s\n \"\"\" % (ips, ps, nomp, mf, ne, noc, nog)\n\n print(display_string)","def print_config(self):\n for key in self._config.keys():\n print('[{0}] = {1}'.format(key, self._config[key]))","def print_settings(config):\n print(\"----------------------------------------\")\n print(\"SETTINGS\")\n print(\"----------------------------------------\")\n for key, value in config:\n print(\"%s=%s\" % (key, value))\n print(\"----------------------------------------\")","def test_print_config(self) -> None:\n out = io.StringIO()\n with contextlib.redirect_stdout(out):\n self.config.print()\n self.assertEqual(\n out.getvalue().rstrip(),\n \"{}: {}\\n{}\".format(\"q2\", \"abcdefghij\", \"^\".rjust(7)),\n )","def print_config(C):\n print(\"Corpus Preprocessing would be done for these Configuations:\")\n if(C.STEMMING == True):\n print(\"Corpus tokens would be Stemmed\")\n else:\n print(\"NO STEMMING on corpus\")\n if(C.LEMMATIZATION == True):\n print(\"Corpus tokens would be Lemmatized\")\n else:\n print(\"NO LEMMATIZATION on corpus\")\n print(\"Term Frequency list would be stored in \", C.TF_LIST)\n print(\"Inverse Document Frequency would be stored in \", C.IDF_DICT)\n print(\"Inverse Mapping would be stored in \", C.INVERSE_MAPPING)\n print(\"Extracted Document title list would be stored in \", C.DOC_TITLE_LIST)\n print(\"\")","def config(ctx):\n if not ctx.invoked_subcommand:\n cfg = ctx.obj['cfg']\n for section in cfg.sections():\n print(\"[\", section, \"]\")\n for option in cfg[section]:\n print(option, \" = \", cfg[section][option])","def handle_config():\n print \"\"\"graph_title Title to appear at top of graph\ngraph_vlabel Graph vertical label (unit)\ngraph_args --base 1000 --lower-limit 0\ngraph_category Category\ngraph_info Some explanatory text about the graph\nquantity1.label Brief label for quantity 'quantity1'\nquantity1.draw LINE2\nquantity1.info More descriptive explanatory text about quantity 'quantity1'\nquantity1.warning 60\nquantity1.critical 180\n\"\"\"\n return 0","def print_vars(self):\n COMPSsConfiguration.print_vars(self)\n print(\"[INFO] - compss_modules: \" + str(self.compss_module))\n print(\"[INFO] - remote_dir: \" + str(self.remote_working_dir))\n print(\"[INFO] - queue: \" + str(self.queue))\n print(\"[INFO] - qos: \" + str(self.qos))\n print(\"[INFO] - batch: \" + str(self.batch))","def show_parameters(self):\n with np.printoptions(precision=3, suppress=True):\n print('number of wind phase = {}'.format(self.ncomp))\n print('galactic parameter = {}'.format(self.scaling_field))\n print('reference height = {}'.format(self.z0))\n for p in ['cool_params','hot_params','params','ref_params','scaling_params']:\n params = getattr(self,p)\n print(p)\n for k,v in params.items():\n print(' {} = {}'.format(k,v))","def display_parameters(self):\n\n self.logging.debug(\"============\")\n for attr in self.parm_list:\n self.logging.debug(attr.label + \" (\" + attr.when + \")\" + \" = \" + str(attr.value))\n self.logging.debug(\"============\")","def configuration():","def print_parameter(args, parser):\n print(\"Default parameter\")\n\n for para in vars(args):\n text = str(para) + \" : \"\n print(text + str(parser.get_default(para)))","def print_config(self):\n for key in CONFIG_KEYS:\n print('--- ' + key + ' ---')\n print(CONFIG_KEYS[key])","def print_cfg(self, out=stdout):\n print(self.cmaboss_sim.str_cfg(), file=out)","def print_defaults():\n print 'area_bounds :', default_area_bounds\n print 'area_bounds_format :', default_area_bounds_format\n print 'area_bounds_range :', default_area_bounds_range\n print 'years_bounds :', default_years_are_bounds\n print 'dates_are_bounds :', default_dates_are_bounds\n print 'init_date_str_format :', default_init_date_str_format\n print 'member_name :', default_member_name\n print 'period_name :', default_period_name\n print 'initialistion_time_name :', default_initialistion_time_name","def antenny_config_print_values(self):\n return self.antenny_config.print_values()","def print_config_option(args, run):\n print_config(run)\n print(\"-\" * 79)","def do_config():\n\n tracking = get_tracking()\n for unit in (\"ppm\", \"sec\"):\n\ttunit = unit\n\tif unit == \"sec\":\n\t tunit = \"seconds\"\n\tprint \"multigraph chrony_%s\" % unit\n\tprint \"graph_title NTP (Chrony) Statistics (%s)\" % unit\n\tprint \"graph_vlabel %s\" % unit\n\tprint \"graph_args --base 1000\"\n\tprint \"graph_category time\"\n\tprint \"graph_info NTP (Chrony) tracking statistics (the ones measured in %s)\" % tunit\n\tfor key in tracking[tunit]:\n\t item = tracking[tunit][key]\n\t print \"\"\"%s.label %s\n%s.draw LINE2\n%s.info %s\"\"\" % (key, item[\"label\"], key, key, item[\"label\"])\n\tprint\n return 0","def config():","def config():","def process_configuration(self):\n print \"I \",self.I","def __build_global_cfg(globalcfg):\n cfglst = []\n\n # Set Global configuration\n gbl_prefix = 'keylset global_config '\n __append_line(cfglst, '#Generated from Cafe')\n timestamp = time.strftime(\"%m-%d-%y %H:%M:%S\", time.localtime())\n __append_line(cfglst, '#TimeStamp: ' + timestamp)\n __append_line(cfglst, gbl_prefix + 'ChassisName {' + globalcfg['ChassisName'] + '}')\n __append_line(cfglst, gbl_prefix + 'RandomSeed ' + str(random.randint(1, 999999999)))\n __append_line(cfglst, \"\")\n __append_line(cfglst, '#LogsAndResultsInfo Global Options')\n # TODO: Remove hardcoded log directory\n __append_line(cfglst, gbl_prefix + 'LogsDir C:/Users/Testmin/VeriWave/WaveApps/Results')\n __append_line(cfglst, gbl_prefix + 'GeneratePdfReport True')\n __append_line(cfglst, \"\")\n __append_line(cfglst, '#Test Traffic Global Options')\n __append_line(cfglst, gbl_prefix + 'Source {' + globalcfg['Source'] + '}')\n __append_line(cfglst, gbl_prefix + 'Destination {' + globalcfg['Destination'] + '}')\n __append_line(cfglst, gbl_prefix + 'Ports {' + globalcfg['Ports'] + '}')\n # __append_line(cfglst, gbl_prefix + 'MappingOption 0')\n __append_line(cfglst, gbl_prefix + 'PayloadData None')\n # __append_line(cfglst, gbl_prefix + 'DestinationPort ' + globalcfg['DestinationPort'])\n # __append_line(cfglst, gbl_prefix + 'SourcePort ' + globalcfg['SourcePort'])\n #__append_line(cfglst, gbl_prefix + 'TestList {unicast_unidirectional_throughput}')\n __append_line(cfglst, gbl_prefix + 'TestList {' + globalcfg['TestList'] + '}')\n __append_line(cfglst, gbl_prefix + 'Direction {' + globalcfg['Direction'] + '}')\n # Assumption there always be a WiFi group present\n __append_line(cfglst, gbl_prefix + 'Channel {' + globalcfg['Channel'] + '}')\n __append_line(cfglst, gbl_prefix + 'WirelessGroupCount ' + str(globalcfg['WirelessGroupCount']))\n __append_line(cfglst, gbl_prefix + 'FlowType UDP')\n __append_line(cfglst, gbl_prefix + 'ArpNumRetries 5')\n __append_line(cfglst, gbl_prefix + 'ArpRate 100')\n __append_line(cfglst, gbl_prefix + 'ArpTimeout 5')\n __append_line(cfglst, gbl_prefix + 'NumTrials 1')\n if 'SettleTime' in globalcfg:\n __append_line(cfglst, gbl_prefix + 'SettleTime ' + globalcfg['SettleTime'])\n else:\n __append_line(cfglst, gbl_prefix + 'SettleTime 3')\n if 'LossTolerance' in globalcfg:\n __append_line(cfglst, gbl_prefix + 'LossTolerance ' + globalcfg['LossTolerance'])\n if 'TrialDuration' in globalcfg:\n __append_line(cfglst, gbl_prefix + 'TrialDuration ' + globalcfg['TrialDuration'])\n __append_line(cfglst, gbl_prefix + 'TestDurationSec ' + globalcfg['TrialDuration'])\n __append_line(cfglst, \"\")\n\n return cfglst","def printParameter (a,b):\n print(a)\n print(b)\n print(\"this is formating of {} and {}\".format(a,b))","def print_params(self):\n s = self._list_params()+\"\\n\"\n if 'scale_params' in self.__dict__.keys():\n s += self.scale_params._list_params()+\"\\n\"\n if 'atmospheric_params' in self.__dict__.keys():\n if self.atmospheric_params is not None:\n s += self.atmospheric_params._list_params()+\"\\n\"\n\n if 'atemperature_params' in self.__dict__.keys():\n if self.atemperature_params is not None:\n s += self.atemperature_params._list_params()+\"\\n\"\n\n if 'oceanic_params' in self.__dict__.keys():\n if self.oceanic_params is not None:\n s += self.oceanic_params._list_params()+\"\\n\"\n\n if 'ground_params' in self.__dict__.keys():\n if self.ground_params is not None:\n s += self.ground_params._list_params()+\"\\n\"\n\n if 'gotemperature_params' in self.__dict__.keys():\n if self.gotemperature_params is not None:\n s += self.gotemperature_params._list_params() + \"\\n\"\n\n print(\"Qgs v0.2.8 parameters summary\")\n print(\"=============================\\n\")\n print(s)","def printInfo():\n utils = CONFIG['utils']\n mytime = utils.mytime()\n logIt(\"Todays date: \" + mytime + \"\\n\")\n logIt(\" Number is: \" + str(CONFIG['number']) + \"\\n\")\n logIt(\" Host is: \" + str(CONFIG['host']) + \"\\n\")\n logIt(\" Port is: \" + str(CONFIG['port']) + \"\\n\")\n logIt(\" Log file is: \" + str(CONFIG['logfile']) + \"\\n\")\n logIt(\" Stdout flag is: \" + str(CONFIG['stdout']) + \"\\n\")\n logIt(\" Debug flag is: \" + str(CONFIG['debug']) + \"\\n\")","def print_params(self):\n print(self._list_params())","def print_config(config, logger):\n for k, v in config.items():\n logger.info(\"{}:\\t{}\".format(k.ljust(15), v))","def print_config(_run):\n final_config = _run.config\n config_mods = _run.config_modifications\n print(_format_config(final_config, config_mods))","def show_config(args):\n args = args.__dict__\n\n log.warning('tomolog status start')\n for section, name in zip(SECTIONS, NICE_NAMES):\n entries = sorted((k for k in args.keys() if k.replace('_', '-') in SECTIONS[section]))\n if entries:\n for entry in entries:\n value = args[entry] if args[entry] != None else \"-\"\n log.info(\" {:<16} {}\".format(entry, value))\n\n log.warning('tomolog status end')","def print_config_value(self, name, prefix='- ', separator=': '):\r\n\r\n value_out = 'None'\r\n if name in self.config_values and self.config_values[name] is not None:\r\n value_out = self.config_values[name]\r\n print(prefix + name + separator + value_out)","def print_settings(self, title=None):\n if title:\n print(title)\n print('Contents of imagenode.yaml:')\n pprint.pprint(self.config)\n print()","def testcliparams(c, name=\"def\"):\n print(name)","def display_sim_parameters(self):\n pprint.pprint(vars(self))\n return","def printMe(self):\n tempDict = self.whoAreYou()\n for key in tempDict.keys():\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))\n tempDict = self.getInitParams()\n self.raiseADebug(' Initialization Parameters:')\n for key in tempDict.keys():\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))\n tempDict = self.myCurrentSetting()\n self.raiseADebug(' Current Setting:')\n for key in tempDict.keys():\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))","def print_config_values(self, prefix='- '):\r\n print('Configuration values from ' + self.config_dir)\r\n self.print_config_value(self.CONFIG_NAME_USER, prefix=prefix)\r\n self.print_config_value(self.CONFIG_NAME_PATH, prefix=prefix)\r\n self.print_config_value(self.CONFIG_NAME_PROXY, prefix=prefix)\r\n self.print_config_value(self.CONFIG_NAME_COMPETITION, prefix=prefix)","def print_usage():\n print 'USAGE: %s [options]' % os.path.abspath(__file__)\n print 'EXAMPLE1: %s # FOR DEFAULTS' % os.path.abspath(__file__)\n print 'EXAMPLE2: %s 121f03=tweek hirap=towelie details=False # TWO SMALL SETS' % os.path.abspath(__file__)\n print 'EXAMPLE3: %s 121f03=tweek details=True # ONE DETAILED SET' % os.path.abspath(__file__)\n print 'EXAMPLE4: %s details=True # SHOWS MAX INFO' % os.path.abspath(__file__)","def test():\n conf = AppConf()\n\n for section in conf.sections():\n print(section)\n for option, value in conf.items(section):\n print(\" {option:15}: {value}\".format(option=option, value=value))","def test_dump_config(self):\n config = easydms.config.Config()\n print(config)","def do_display_config(self, *arg):\n try:\n if self.pocs and self.pocs.config:\n pprint(self.pocs.config)\n else:\n print_warning(\"No config file for POCS.\")\n\n except AttributeError:\n print_warning(\"Please run `setup_pocs` before trying to run `display_config`\")","def display(self):\n print(\"{}, {}\".format(self.label, self.params))","def print_variables(self):\n\n logging.debug(\n \"The broker address \" + str(\n self.broker_address) + \" transport \" + self.tTransport + \" the port is \" + str(\n self.tPort))","def view(self,\n print_global_settings=True,\n print_general_settings=True,\n print_tmp_vals=False,\n print_results=True,\n **kws\n ):\n\n print(self.name)\n\n if print_global_settings:\n print(\"Global settings:\")\n pprint.pprint(self.global_settings)\n print()\n\n if print_general_settings:\n print(\"General settings:\")\n pprint.pprint(self.settings[self.name]['General'])\n print()\n\n for i, x in enumerate(self.routine_template):\n print(f\"Step {i}, {x[0].__name__} ({x[1]})\")\n print(\"Settings:\")\n pprint.pprint(x[2], indent=4)\n\n if print_tmp_vals:\n try:\n print(\"Temporary values:\")\n pprint.pprint(x[3], indent=4)\n except IndexError:\n pass\n print()\n\n if print_results:\n print_step_results(self)","def print_corr2_params():\n treecorr.config.print_params(corr2_valid_params)","def print_testvals(self):\n print(self.use_planck)","def log_environment_variables():\n\n LOGGER.info(f\"bucket: {BUCKET}\")\n LOGGER.info(f\"config_s3_key: {CONFIG_S3_KEY}\")\n LOGGER.info(f\"previously_valid_urls_s3_key: {PREVIOUSLY_VALID_URLS_S3_KEY}\")\n LOGGER.info(f\"logging_level: {LOGGING_LEVEL}\")\n LOGGER.info(f\"default_email_subject: {DEFAULT_EMAIL_SUBJECT}\")\n LOGGER.info(f\"default_from_email: {DEFAULT_FROM_EMAIL}\")\n LOGGER.info(f\"default_to_email: {DEFAULT_TO_EMAIL}\")\n LOGGER.info(f\"default_url: {DEFAULT_URL}\")\n LOGGER.info(f\"default_start_value: {DEFAULT_START_VALUE}\")\n LOGGER.info(f\"default_look_ahead: {DEFAULT_LOOK_AHEAD}\")\n LOGGER.info(f\"default_slide_window: {DEFAULT_SLIDE_WINDOW}\")","def config( **kwargs ):","def module_config_info():\n\n print(\"consumes\", CONSUMES)\n module_config_template()","def showconfig():\n print(yaml.dump(CONFIG))","def print_configs(opts, header=''):\n if header:\n print('\\n###############################################################\\n')\n print('\\t########\\t {} \\t########\\n'.format(header))\n print('###############################################################\\n')\n\n for field in opts._fields:\n if len(field) < 8:\n print('\\t{}\\t\\t\\t:\\t{}\\n'.format(field, getattr(opts, field)))\n else:\n print('\\t{}\\t\\t:\\t{}\\n'.format(field, getattr(opts, field)))","def do_config(self, line: str):\n if self._real_module is None:\n print(\"'config' command depends on using a module. See 'use' for help.\")\n return\n\n settings = self._real_module.params()\n if line != '':\n value = settings.get(line, None)\n if value is not None:\n print(value[\"Value\"])\n else:\n print(settings)","def print_settings(args, clear=True):\n s = \" # GPSeq analysis of FISH signals v%s\\n\" % version\n\n s += \"\"\"\n --- INPUT =======\n\n FISH table : %s\n Image folder : %s\n Output folder : %s\n\n Mask folder : %s\n Mask prefix : '%s'\n\n --- ANALYSIS ====\n\n Dilation : %d\n Aspect (Z Y X) : %s\n Distance type : %s\nSkipped channels : %s\n Pole fraction : %.3f\n #bins : %d\n\n --- FLAGS =======\n\n 2D masks : '%s'\n Labeled : %r\n Compressed : %r\n Dilate over Z : %r\nUse dilation only\nfor dot assignment : %r\n\n Plot all : %r\nPlot compartments : %r\n\n --- ADVANCED ====\n\n Input regexp : %s\n Delim : '%s'\n Threads : %d\n Debug mode : %r\n \"\"\" % (\n args.dotCoords,\n args.imdir,\n args.outdir,\n args.mask_folder,\n args.mask_prefix,\n args.dilate,\n str(args.aspect),\n args.dist_type,\n str(args.skip_channels),\n args.pole,\n args.nbins,\n args.manual_2d_masks,\n args.labeled,\n args.compressed,\n args.doZdilation,\n args.dilate_for_assignment_only,\n not args.noplot,\n not args.no_compartment_plot,\n args.inreg,\n args.delim,\n args.threads,\n args.DEBUG_MODE,\n )\n\n if clear:\n print(\"\\033[H\\033[J%s\" % s)\n else:\n print(s)\n return s","def printing_vars(self):\n print(\"Name is \", self.name)","def config(self) -> NamedTuple:","def print(self):\n for attr in inspect.getmembers(self):\n if not attr[0].startswith('_') and not inspect.ismethod(attr[1]):\n if attr[0] not in ('lyapunov_hybrid_system'):\n print(f\"{attr[0]}: {attr[1]}\")\n if self.enable_wandb:\n wandb.config.update({attr[0]: f\"{attr[1]}\"})","def test_print_configs(self, print_config: MagicMock) -> None:\n tape1 = TMTape(\n tape=\"01010101\",\n blank_symbol=\".\",\n current_position=0,\n )\n tape2 = TMTape(\n tape=\"x1010101\",\n blank_symbol=\".\",\n current_position=-1,\n )\n tape3 = TMTape(\n tape=\"yx1010101\",\n blank_symbol=\".\",\n current_position=-2,\n )\n configs = [\n TMConfiguration(\"q0\", tape1),\n TMConfiguration(\"q1\", tape2),\n TMConfiguration(\"q2\", tape3),\n MTMConfiguration(\"q1\", (tape1, tape2, tape3)),\n ]\n out = io.StringIO()\n with contextlib.redirect_stdout(out):\n tmtools.print_configs(configs) # type: ignore\n self.assertEqual(print_config.call_args_list, [call(), call(), call()])","def print_all_params(self, disp=True):\n descriptions = {'general': {}}\n for name, param in self.params.items():\n descriptions['general'][name] = param.get_description()\n\n for comp, comp_obj in self.components.items():\n descriptions[comp] = {}\n for name in comp_obj.get_params():\n descriptions[comp][name] = comp_obj.get_param_description(name)\n return self._print_params(descriptions, disp)","def _dumpConfiguration(self):\n print \"Writing configuration:\"\n print \" - title = \" + self.title\n print \" - executablePath = \" + self.exePath\n print \" - configPath = \" + self.configPath\n print \" - outputName = \" + self.outputName\n print \" - branch = \" + self.branch\n print \" - branchName = \" + self.branchName\n print \" - buildid = \" + self.buildid\n print \" - currentDate = \" + self.currentDate\n print \" - testDate = \" + self.testDate\n print \" - resultsServer = \" + self.resultsServer\n print \" - resultsLink = \" + self.resultsLink\n print \" - activeTests = \" + self.activeTests\n if self.symbolsPath:\n print \" - symbolsPath = \" + self.symbolsPath","def load_standard_parameters(self):\n paradic = {'x':'0',\n 'y':'0',\n 'n_oct':'8',\n 'n_spo':'3',\n 'sigma_min':'0.8',\n 'delta_min':'0.5',\n 'sigma_in':'0.5',\n 'C_DoG':'0.015',\n 'C_edge':'10',\n 'n_bins':'36',\n 'lambda_ori':'1.5',\n 't':'0.8',\n 'n_hist':'4',\n 'n_ori':'8',\n 'lambda_descr':'6',\n 'flag_match':'1',\n 'C_match':'0.6'}\n self.cfg['param']['paradic'] = paradic\n self.cfg.save()","def print_conf(self, item):\n\t\toutput = \"\"\n\t\t## Header, to go on all files\n\t\toutput += \"# Configuration file %s\\n\" % item['meta']['filename']\n\t\toutput += \"# Edited by PyNag on %s\\n\" % time.ctime()\n\n\t\t## Some hostgroup information\n\t\tif item['meta'].has_key('hostgroup_list'):\n\t\t\toutput += \"# Hostgroups: %s\\n\" % \",\".join(item['meta']['hostgroup_list'])\n\n\t\t## Some hostgroup information\n\t\tif item['meta'].has_key('service_list'):\n\t\t\toutput += \"# Services: %s\\n\" % \",\".join(item['meta']['service_list'])\n\n\t\t## Some hostgroup information\n\t\tif item['meta'].has_key('service_members'):\n\t\t\toutput += \"# Service Members: %s\\n\" % \",\".join(item['meta']['service_members'])\n\n\t\tif len(item['meta']['template_fields']) != 0:\n\t\t\toutput += \"# Values from templates:\\n\"\n\t\tfor k in item['meta']['template_fields']:\n\t\t\toutput += \"#\\t %-30s %-30s\\n\" % (k, item[k])\n\t\toutput += \"\\n\"\n\t\toutput += \"define %s {\\n\" % item['meta']['object_type']\n\t\tfor k, v in item.iteritems():\n\t\t\tif k != 'meta':\n\t\t\t\tif k not in item['meta']['template_fields']:\n\t\t\t\t\toutput += \"\\t %-30s %-30s\\n\" % (k,v)\n\t\t\n\t\toutput += \"}\\n\\n\"\n\t\treturn output","def getDefaultParams():\n defpar = [\n # coordinate system\n ['crd_sys', \"'sph'\", 'Coordinate system'],\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\n ['ny', '[10,30, 30, 10]',\n 'Number of grid points in the second dimension'],\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\n 'Number of radial grid points'],\n ['nz', '[361]', 'Number of grid points in the third dimension'],\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\n # star related\n ['tstar', '[3900.0]', 'Temperature of star'],\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\n ['rstar', '[2.5*rs]', 'Radius of star'],\n # gas density \n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \n ['ring_r', '[50*au]', 'location of gaussian ring'], \n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \n ['cutgdens', '1e-30', 'cut for density'], \n ['Rt', '100*au', 'radius for scale height'], \n ['Ht', '10*au', 'scale height'], \n ['qheight', '1.25', 'height power-law'], \n # gas species\n ['gasspec_mol_name', \"['12co']\", 'name of molecule'],\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\n ['gasspec_mol_dbase_type', \"['leiden']\", ''],\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\n # dust density\n # flat power-law parts\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\n # Lynden-Bell parts\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \n ['dLB_sig0', '[1e2]', 'surface density'], \n # ring parts\n ['dring_r', '[50*au]', 'location of gaussian ring'],\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\n ['cutddens', '1e-30', 'cut for dust density'],\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \n ['dHt', '[10*au]', 'scale height for each grain size'], \n ['dqheight', '[1.25]', 'scale height power-law for dust'], \n # temperature\n ['T0mid', '50', 'mid plane temperature at Rt'],\n ['T0atm', '50', 'atmosphere temperature at Rt'],\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\n ['qmid', '-0.5', 'midplane temperature exponent'],\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\n ['hdel', '2', 'temperature transition exponent '],\n ['cuttemp', '10', 'temperature cut'], \n # alignment\n ['altype', \"'toroidal'\", 'alignment type']\n ]\n\n return defpar","def print_config(config_dic, logger):\n for k, v in config_dic.items():\n logger.info(\"{}:\\t{}\".format(k.ljust(15), v))","def print_args():\n for key, value in vars(ARGS).items():\n print(key + ' : ' + str(value))","def get_diameters():\n return Global_Module.global_diameters","def _debug_print(self, cfg, list_iterstore):\n def __print_params(iterstore, edataset):\n if (edataset not in iterstore): return\n gen = iterstore[edataset]\n if (gen is not None):\n if (gen._params is not None):\n print('{} : {}'.format(edataset, gen))\n print(\"\\tIterator Parameters: (iter_param, iter_pp_param)\")\n print(\"\\t-------------------------------------------------\")\n for key, val in gen._params.items():\n if (key.startswith('_')): continue\n print('\\t{} : {}'.format(key, val))\n \n if (gen._pp_params is not None):\n print(\"\\t-------------------------------------------------\")\n for key, val in gen._pp_params.items():\n if (key.startswith('_')): continue\n print('\\t{} : {}'.format(key, val))\n print(\"\")\n\n if (list_iterstore is None):\n return\n\n print(\"\\nNNCfg\")\n print(\"=====\")\n for key, val in cfg.__dict__.items():\n if (key.startswith('_')): continue\n print('\\t{} : {}'.format(key, val))\n\n for i, iterstore in enumerate(list_iterstore):\n print(\"\\nIterator Store:{}\".format(i))\n print(\"=================\")\n __print_params(iterstore, Dataset.TR)\n __print_params(iterstore, Dataset.VAL)\n __print_params(iterstore, Dataset.TE)\n __print_params(iterstore, Dataset.TR_OUT)\n __print_params(iterstore, Dataset.VAL_OUT)\n __print_params(iterstore, Dataset.TE_OUT)","def printme(parameters): # create a function called printme using def\n print(parameters) # prints anything that is stored inside parameters\n return","def config(self) -> Dict[str, Any]:","def pre_process_information(self):\n self.logger.debug(\n colorama.Fore.BLUE\n + \"jsnapy.cfg file location used : %s\" % get_config_location(),\n extra=self.log_detail,\n )\n self.logger.debug(\n colorama.Fore.BLUE\n + \"Configuration file location used : %s\"\n % get_path(\"DEFAULT\", \"config_file_path\"),\n extra=self.log_detail,\n )","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def fullDebug():\r\n global CurrentState\r\n global CurrentInput\r\n global RESPONSEOPTIONS\r\n print(\"___________________________\")\r\n print(\"\\n*Current Input:\", CurrentInput)\r\n print(\"*Current State: \", CurrentState)\r\n print(\"\\n*Response Options: \", RESPONSEOPTIONS)\r\n print(\"___________________________\")","def required_test_config_variables(cls) -> Tuple[str, ...]:\n return (\"shell_cmd\", \"expect\", \"known_logline\")","def PrintConfigs():\n print '\\n\\n-----IO Box Inputs---------------------------------'\n print 'Monitor Inputs: %s' %MonitorInputLst \n print 'Assign Inputs to Alarm Type'\n for ik in InputAssignment.keys():\n print ' %s: %s' %(ik, InputAssignment[ik])\n print '\\n\\n-----Emails----------------------------------------'\n print 'MailHost(smtp) server: %s' %MailHost\n print 'Send notification email to: '\n cnt = 0\n pstr = ' '\n for m in MailList:\n pstr += m\n if cnt == 1:\n pstr += '\\n '\n cnt = 0\n else:\n cnt += 1\n print pstr\n print 'Emails sent from: %s' %FromEmail \n print '\\n\\n-----Wave files------------------------------------'\n print 'Play wave files with: %s' %WavCmd \n print 'Play wave files %s times' %WavRepititions\n print 'Wave file sounds for defined alarm types\\n' \n for ak in AlarmSounds.keys():\n print ' %s: %s' %(ak,AlarmSounds[ak])\n print '\\n\\n-----Zip files-------------------------------------'\n print 'Zip files with command %s' %ZipCmd \n print '\\n\\n-----Camera information----------------------------'\n print 'Directories'\n for ck in camDirs.keys():\n print ' %s: %s' %(ck, camDirs[ck])\n print 'Images per cam'\n for nk in NumCamImages.keys():\n print ' %s: %s' %(nk, NumCamImages[nk])\n print 'Camera image delay: %s' %IMAGE_DELAY\n print '\\n\\n-----Remote commands-------------------------------'\n for rk in RemoteCMDS.keys():\n print ' %s: %s' %(rk, RemoteCMDS[rk])\n print '\\n\\n-----Other-----------------------------------------'\n print 'Sleep time between alarm/drive executions: %s' %ALARMSLEEP\n print 'Quiet: %s' %QUIET\n print '\\n\\n'\n print 'Usage: HomeAutomation: -d = run -c = print configuration\\n\\n'","def print_node_params(self, node=None, disp=True):\n string = ''\n\n for comp in self.get_node_components(node):\n comp = comp[len(node) + 1:]\n string += self.print_comp_param(node, comp, disp=False)\n\n if disp:\n print(string)\n else:\n return string","def print_config(self, cfg, hide_password=True, history=False, module_id=None):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tcp = self.config_parser\n\t\ts = ''\n\t\tkeys1 = list(cfg.keys())\n\t\tif keys1:\n\t\t\tkeys1.sort()\n\t\tfor k in keys1:\n\t\t\tif module_id is not None and k != module_id:\n\t\t\t\tcontinue\n\t\t\tif isinstance(k, str) and isinstance(cfg[k], dict):\n\t\t\t\ts += '\\n[' + k + ']\\n'\n\t\t\t\tkeys2 = list(cfg[k].keys())\n\t\t\t\tif keys2:\n\t\t\t\t\tkeys2.sort()\n\t\t\t\tfor k1 in keys2:\n\t\t\t\t\tline = ''\n\t\t\t\t\tline += k1 + ':'\n\t\t\t\t\t# If we want to hide passwords, we do so using a sha512\n\t\t\t\t\t# done an aritrary number of times (27).\n\t\t\t\t\tif hide_password and (k1 == 'password' or k1 == 'passphrase'):\n\t\t\t\t\t\tp = hashlib.sha512(cfg[k][k1]).hexdigest()\n\t\t\t\t\t\ti = 27\n\t\t\t\t\t\twhile i > 0:\n\t\t\t\t\t\t\ti -= 1\n\t\t\t\t\t\t\tp = hashlib.sha512(s).hexdigest()\n\t\t\t\t\t\tline += p\n\t\t\t\t\telse:\n\t\t\t\t\t\tif type(cfg[k][k1] == bool):\n\t\t\t\t\t\t\tline += str(cfg[k][k1])\n\t\t\t\t\t\telif type(cfg[k][k1] == str):\n\t\t\t\t\t\t\tline += cfg[k][k1]\n\t\t\t\t\tif history:\n\t\t\t\t\t\ttry:\n\t\t\t\t\t\t\tline += (30-len(line)) * ' ' + ' # ' + cp.whereset(k, k1)\n\t\t\t\t\t\texcept Exception:\n\t\t\t\t\t\t\t# Assume this is because it was never set by a config parser.\n\t\t\t\t\t\t\tline += (30-len(line)) * ' ' + ' # ' + \"defaults in code\"\n\t\t\t\t\ts += line + '\\n'\n\t\treturn s","def get_config(context):\n conf_vars = ['disqus_developer', 'disqus_identifier', 'disqus_url', 'disqus_title']\n \n output = []\n for item in conf_vars:\n if item in context:\n output.append('\\tvar %s = \"%s\";' % (item, context[item]))\n return '\\n'.join(output)","def main(config, debug):\n config.debug = debug\n if config.debug:\n click.echo('Debug info...')","def print_config(self):\n for pod in self.pods:\n for lb in pod.limbs:\n print '%s limb %s ' % (pod.name, lb.name)\n for br in lb.branches:\n br.printInfo()\n sys.stdout.flush()","def config(self):\n\t\tsys.stderr.write(\"Base class method called: config() This souldn't happen.\\n\")","def __str__(self):\n\n print(\"\")\n s = \"NAME : \"+self._name+\"\\n\\n\"\n s += \"PARAMS :\"\n print(s)\n\n for key, val in self.params.items():\n l = (21-len(key))//7\n print(\"{0}\".format(key)+\"\\t\"*l+\":\\t{0}\".format(val))\n\n s = \"\\nRuns stored in DEFAULT_RUNS = \"+str(len(self.default_runs))\n print(s)\n\n s = \"\\nRuns stored in MOD_RUNS = \"+str(len(self.mod_runs))\n print(s)\n\n return \"\"","def test_config():\n args = Namespace(molecule=\"nucleotide\", verbose=False)\n config = core.Config.from_args(args)\n assert config.verbose is False\n assert config.molecule == 'nucleotide'\n assert config.extended_validation == 'none'\n\n args = Namespace(molecule=\"protein\", verbose=True)\n config = core.Config.from_args(args)\n assert config.verbose is True\n assert config.molecule == 'protein'","def config(ctx):\n return","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_flags():\n for key, value in vars(FLAGS).items():\n print(key + ' : ' + str(value))","def print_general_param(self, name=None, disp=True):\n\n if name is None:\n list = {}\n\n for name in self.params:\n list[name] = self.params[name].get_description()\n\n return self._print_params({'general': list}, disp)\n else:\n if name not in self.params:\n raise IndexError('%s is not a valid general parameter ' % name)\n\n return self._print_params({'general': {name: self.params[name].get_description()}}, disp)","def config_debug():\n config_str = request.args.get('config')\n config = pickle.loads(b64decode(config_str))\n return str(config)"],"string":"[\n \"def printConf(self):\\n print \\\"\\\"\\n for pname, pvalue in self.neededParams.items():\\n print pname, pvalue\\n for pname, pvalue in self.optionalParams.items():\\n print pname, pvalue\",\n \"def printSettings():\\n print \\\">>>\\\\n>>> SettingsTool: global variables:\\\"\\n for variable, value in globals().items():\\n if variable.count('__')>1: continue\\n print \\\">>> %-16s = %s\\\"%(variable,value)\\n print \\\">>>\\\"\",\n \"def print_configuration():\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"Initializing with the following configuration\\\")\\n configlog.info(\\\"Check constants.py to change any of the following\\\")\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"COMPANY_NAME: {}\\\".format(COMPANY_NAME))\\n configlog.info(\\\"ACTIVITY_TYPE_FILTER: {}\\\".format(ACTIVITY_TYPE_FILTER))\\n configlog.info(\\\"APPLY_ACTIVITY_FILTER: {}\\\".format(APPLY_ACTIVITY_FILTER))\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"Assuming an input dataset with the following features\\\")\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"BUDGET_COLUMN_NAME: {}\\\".format(BUDGET_COLUMN_NAME))\\n configlog.info(\\\"COMPANY_COLUMN_NAME: {}\\\".format(COMPANY_COLUMN_NAME))\\n configlog.info(\\\"ACTIVITY_COLUMN_NAME: {}\\\".format(ACTIVITY_COLUMN_NAME))\\n configlog.info(\\\"COUNTRY_COLUMN_NAME: {}\\\".format(COUNTRY_COLUMN_NAME))\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"Fallback data sources\\\")\\n configlog.info(\\\"-\\\" * 50)\\n configlog.info(\\\"DEFAULT_URL: {}\\\".format(DEFAULT_URL))\\n configlog.info(\\\"DEFAULT_LOCAL_DATA_PATH: {}\\\".format(DEFAULT_LOCAL_DATA_PATH))\\n configlog.info(\\\"-\\\" * 50)\",\n \"def print_params(env) -> None:\\n dict_pretty_print(env.config['parameters'])\",\n \"def printConfig():\\n # Why not log instead? Are we asking user to confirm settings?\\n pass # until implemented\",\n \"def print_params():\\n\\n help_out = convert_phil_to_text(master_phil, att_level=1)\\n txt_out = convert_phil_to_text(master_phil)\\n\\n return help_out, txt_out\",\n \"def magic_config(self,parameter_s=''):\\n \\n page('Current configuration structure:\\\\n'+\\n pformat(self.rc.dict()))\",\n \"def show_parameters(args):\\n\\n logging.basicConfig(format='%(message)s', level=args.logging)\\n\\n logging.info('\\\\n#{0}'.format('-'*60))\\n logging.info('BUILD CONFIG : {0}'.format(args.config))\\n logging.info('BUNDLE FILE : {0}'.format(args.bfile))\",\n \"def show_config(config, args):\\n pprint.pprint(config)\",\n \"def print_params(self):\\n\\n logger.info('SimulatedMaps has been initialised with the following attributes:')\\n for key in self.params.keys():\\n logger.info('{} = {}'.format(key, self.params[key]))\",\n \"def print_ofpt_get_config_request(msg):\\n pass\",\n \"def display_parameters(self):\\n ips = GAConfig[\\\"initial_population_size\\\"]\\n ps = GAConfig[\\\"population_size\\\"]\\n nomp = GAConfig[\\\"num_mating_pairs\\\"]\\n mf = GAConfig[\\\"base_mutation_factor\\\"]\\n ne = GAConfig[\\\"num_evolutions\\\"]\\n noc = GAConfig[\\\"num_categories\\\"]\\n nog = len(self.phones)\\n\\n display_string = \\\"\\\"\\\"\\n Genetic Algorithm Parameters\\n ----------------------------\\n Initial Population Size %s\\n Population Size %s\\n Number of Mating Pairs %s\\n Base Mutation Factor %s\\n Number of Evolutions %s\\n Number of Categories %s\\n Number of Genes %s\\n \\\"\\\"\\\" % (ips, ps, nomp, mf, ne, noc, nog)\\n\\n print(display_string)\",\n \"def print_config(self):\\n for key in self._config.keys():\\n print('[{0}] = {1}'.format(key, self._config[key]))\",\n \"def print_settings(config):\\n print(\\\"----------------------------------------\\\")\\n print(\\\"SETTINGS\\\")\\n print(\\\"----------------------------------------\\\")\\n for key, value in config:\\n print(\\\"%s=%s\\\" % (key, value))\\n print(\\\"----------------------------------------\\\")\",\n \"def test_print_config(self) -> None:\\n out = io.StringIO()\\n with contextlib.redirect_stdout(out):\\n self.config.print()\\n self.assertEqual(\\n out.getvalue().rstrip(),\\n \\\"{}: {}\\\\n{}\\\".format(\\\"q2\\\", \\\"abcdefghij\\\", \\\"^\\\".rjust(7)),\\n )\",\n \"def print_config(C):\\n print(\\\"Corpus Preprocessing would be done for these Configuations:\\\")\\n if(C.STEMMING == True):\\n print(\\\"Corpus tokens would be Stemmed\\\")\\n else:\\n print(\\\"NO STEMMING on corpus\\\")\\n if(C.LEMMATIZATION == True):\\n print(\\\"Corpus tokens would be Lemmatized\\\")\\n else:\\n print(\\\"NO LEMMATIZATION on corpus\\\")\\n print(\\\"Term Frequency list would be stored in \\\", C.TF_LIST)\\n print(\\\"Inverse Document Frequency would be stored in \\\", C.IDF_DICT)\\n print(\\\"Inverse Mapping would be stored in \\\", C.INVERSE_MAPPING)\\n print(\\\"Extracted Document title list would be stored in \\\", C.DOC_TITLE_LIST)\\n print(\\\"\\\")\",\n \"def config(ctx):\\n if not ctx.invoked_subcommand:\\n cfg = ctx.obj['cfg']\\n for section in cfg.sections():\\n print(\\\"[\\\", section, \\\"]\\\")\\n for option in cfg[section]:\\n print(option, \\\" = \\\", cfg[section][option])\",\n \"def handle_config():\\n print \\\"\\\"\\\"graph_title Title to appear at top of graph\\ngraph_vlabel Graph vertical label (unit)\\ngraph_args --base 1000 --lower-limit 0\\ngraph_category Category\\ngraph_info Some explanatory text about the graph\\nquantity1.label Brief label for quantity 'quantity1'\\nquantity1.draw LINE2\\nquantity1.info More descriptive explanatory text about quantity 'quantity1'\\nquantity1.warning 60\\nquantity1.critical 180\\n\\\"\\\"\\\"\\n return 0\",\n \"def print_vars(self):\\n COMPSsConfiguration.print_vars(self)\\n print(\\\"[INFO] - compss_modules: \\\" + str(self.compss_module))\\n print(\\\"[INFO] - remote_dir: \\\" + str(self.remote_working_dir))\\n print(\\\"[INFO] - queue: \\\" + str(self.queue))\\n print(\\\"[INFO] - qos: \\\" + str(self.qos))\\n print(\\\"[INFO] - batch: \\\" + str(self.batch))\",\n \"def show_parameters(self):\\n with np.printoptions(precision=3, suppress=True):\\n print('number of wind phase = {}'.format(self.ncomp))\\n print('galactic parameter = {}'.format(self.scaling_field))\\n print('reference height = {}'.format(self.z0))\\n for p in ['cool_params','hot_params','params','ref_params','scaling_params']:\\n params = getattr(self,p)\\n print(p)\\n for k,v in params.items():\\n print(' {} = {}'.format(k,v))\",\n \"def display_parameters(self):\\n\\n self.logging.debug(\\\"============\\\")\\n for attr in self.parm_list:\\n self.logging.debug(attr.label + \\\" (\\\" + attr.when + \\\")\\\" + \\\" = \\\" + str(attr.value))\\n self.logging.debug(\\\"============\\\")\",\n \"def configuration():\",\n \"def print_parameter(args, parser):\\n print(\\\"Default parameter\\\")\\n\\n for para in vars(args):\\n text = str(para) + \\\" : \\\"\\n print(text + str(parser.get_default(para)))\",\n \"def print_config(self):\\n for key in CONFIG_KEYS:\\n print('--- ' + key + ' ---')\\n print(CONFIG_KEYS[key])\",\n \"def print_cfg(self, out=stdout):\\n print(self.cmaboss_sim.str_cfg(), file=out)\",\n \"def print_defaults():\\n print 'area_bounds :', default_area_bounds\\n print 'area_bounds_format :', default_area_bounds_format\\n print 'area_bounds_range :', default_area_bounds_range\\n print 'years_bounds :', default_years_are_bounds\\n print 'dates_are_bounds :', default_dates_are_bounds\\n print 'init_date_str_format :', default_init_date_str_format\\n print 'member_name :', default_member_name\\n print 'period_name :', default_period_name\\n print 'initialistion_time_name :', default_initialistion_time_name\",\n \"def antenny_config_print_values(self):\\n return self.antenny_config.print_values()\",\n \"def print_config_option(args, run):\\n print_config(run)\\n print(\\\"-\\\" * 79)\",\n \"def do_config():\\n\\n tracking = get_tracking()\\n for unit in (\\\"ppm\\\", \\\"sec\\\"):\\n\\ttunit = unit\\n\\tif unit == \\\"sec\\\":\\n\\t tunit = \\\"seconds\\\"\\n\\tprint \\\"multigraph chrony_%s\\\" % unit\\n\\tprint \\\"graph_title NTP (Chrony) Statistics (%s)\\\" % unit\\n\\tprint \\\"graph_vlabel %s\\\" % unit\\n\\tprint \\\"graph_args --base 1000\\\"\\n\\tprint \\\"graph_category time\\\"\\n\\tprint \\\"graph_info NTP (Chrony) tracking statistics (the ones measured in %s)\\\" % tunit\\n\\tfor key in tracking[tunit]:\\n\\t item = tracking[tunit][key]\\n\\t print \\\"\\\"\\\"%s.label %s\\n%s.draw LINE2\\n%s.info %s\\\"\\\"\\\" % (key, item[\\\"label\\\"], key, key, item[\\\"label\\\"])\\n\\tprint\\n return 0\",\n \"def config():\",\n \"def config():\",\n \"def process_configuration(self):\\n print \\\"I \\\",self.I\",\n \"def __build_global_cfg(globalcfg):\\n cfglst = []\\n\\n # Set Global configuration\\n gbl_prefix = 'keylset global_config '\\n __append_line(cfglst, '#Generated from Cafe')\\n timestamp = time.strftime(\\\"%m-%d-%y %H:%M:%S\\\", time.localtime())\\n __append_line(cfglst, '#TimeStamp: ' + timestamp)\\n __append_line(cfglst, gbl_prefix + 'ChassisName {' + globalcfg['ChassisName'] + '}')\\n __append_line(cfglst, gbl_prefix + 'RandomSeed ' + str(random.randint(1, 999999999)))\\n __append_line(cfglst, \\\"\\\")\\n __append_line(cfglst, '#LogsAndResultsInfo Global Options')\\n # TODO: Remove hardcoded log directory\\n __append_line(cfglst, gbl_prefix + 'LogsDir C:/Users/Testmin/VeriWave/WaveApps/Results')\\n __append_line(cfglst, gbl_prefix + 'GeneratePdfReport True')\\n __append_line(cfglst, \\\"\\\")\\n __append_line(cfglst, '#Test Traffic Global Options')\\n __append_line(cfglst, gbl_prefix + 'Source {' + globalcfg['Source'] + '}')\\n __append_line(cfglst, gbl_prefix + 'Destination {' + globalcfg['Destination'] + '}')\\n __append_line(cfglst, gbl_prefix + 'Ports {' + globalcfg['Ports'] + '}')\\n # __append_line(cfglst, gbl_prefix + 'MappingOption 0')\\n __append_line(cfglst, gbl_prefix + 'PayloadData None')\\n # __append_line(cfglst, gbl_prefix + 'DestinationPort ' + globalcfg['DestinationPort'])\\n # __append_line(cfglst, gbl_prefix + 'SourcePort ' + globalcfg['SourcePort'])\\n #__append_line(cfglst, gbl_prefix + 'TestList {unicast_unidirectional_throughput}')\\n __append_line(cfglst, gbl_prefix + 'TestList {' + globalcfg['TestList'] + '}')\\n __append_line(cfglst, gbl_prefix + 'Direction {' + globalcfg['Direction'] + '}')\\n # Assumption there always be a WiFi group present\\n __append_line(cfglst, gbl_prefix + 'Channel {' + globalcfg['Channel'] + '}')\\n __append_line(cfglst, gbl_prefix + 'WirelessGroupCount ' + str(globalcfg['WirelessGroupCount']))\\n __append_line(cfglst, gbl_prefix + 'FlowType UDP')\\n __append_line(cfglst, gbl_prefix + 'ArpNumRetries 5')\\n __append_line(cfglst, gbl_prefix + 'ArpRate 100')\\n __append_line(cfglst, gbl_prefix + 'ArpTimeout 5')\\n __append_line(cfglst, gbl_prefix + 'NumTrials 1')\\n if 'SettleTime' in globalcfg:\\n __append_line(cfglst, gbl_prefix + 'SettleTime ' + globalcfg['SettleTime'])\\n else:\\n __append_line(cfglst, gbl_prefix + 'SettleTime 3')\\n if 'LossTolerance' in globalcfg:\\n __append_line(cfglst, gbl_prefix + 'LossTolerance ' + globalcfg['LossTolerance'])\\n if 'TrialDuration' in globalcfg:\\n __append_line(cfglst, gbl_prefix + 'TrialDuration ' + globalcfg['TrialDuration'])\\n __append_line(cfglst, gbl_prefix + 'TestDurationSec ' + globalcfg['TrialDuration'])\\n __append_line(cfglst, \\\"\\\")\\n\\n return cfglst\",\n \"def printParameter (a,b):\\n print(a)\\n print(b)\\n print(\\\"this is formating of {} and {}\\\".format(a,b))\",\n \"def print_params(self):\\n s = self._list_params()+\\\"\\\\n\\\"\\n if 'scale_params' in self.__dict__.keys():\\n s += self.scale_params._list_params()+\\\"\\\\n\\\"\\n if 'atmospheric_params' in self.__dict__.keys():\\n if self.atmospheric_params is not None:\\n s += self.atmospheric_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'atemperature_params' in self.__dict__.keys():\\n if self.atemperature_params is not None:\\n s += self.atemperature_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'oceanic_params' in self.__dict__.keys():\\n if self.oceanic_params is not None:\\n s += self.oceanic_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'ground_params' in self.__dict__.keys():\\n if self.ground_params is not None:\\n s += self.ground_params._list_params()+\\\"\\\\n\\\"\\n\\n if 'gotemperature_params' in self.__dict__.keys():\\n if self.gotemperature_params is not None:\\n s += self.gotemperature_params._list_params() + \\\"\\\\n\\\"\\n\\n print(\\\"Qgs v0.2.8 parameters summary\\\")\\n print(\\\"=============================\\\\n\\\")\\n print(s)\",\n \"def printInfo():\\n utils = CONFIG['utils']\\n mytime = utils.mytime()\\n logIt(\\\"Todays date: \\\" + mytime + \\\"\\\\n\\\")\\n logIt(\\\" Number is: \\\" + str(CONFIG['number']) + \\\"\\\\n\\\")\\n logIt(\\\" Host is: \\\" + str(CONFIG['host']) + \\\"\\\\n\\\")\\n logIt(\\\" Port is: \\\" + str(CONFIG['port']) + \\\"\\\\n\\\")\\n logIt(\\\" Log file is: \\\" + str(CONFIG['logfile']) + \\\"\\\\n\\\")\\n logIt(\\\" Stdout flag is: \\\" + str(CONFIG['stdout']) + \\\"\\\\n\\\")\\n logIt(\\\" Debug flag is: \\\" + str(CONFIG['debug']) + \\\"\\\\n\\\")\",\n \"def print_params(self):\\n print(self._list_params())\",\n \"def print_config(config, logger):\\n for k, v in config.items():\\n logger.info(\\\"{}:\\\\t{}\\\".format(k.ljust(15), v))\",\n \"def print_config(_run):\\n final_config = _run.config\\n config_mods = _run.config_modifications\\n print(_format_config(final_config, config_mods))\",\n \"def show_config(args):\\n args = args.__dict__\\n\\n log.warning('tomolog status start')\\n for section, name in zip(SECTIONS, NICE_NAMES):\\n entries = sorted((k for k in args.keys() if k.replace('_', '-') in SECTIONS[section]))\\n if entries:\\n for entry in entries:\\n value = args[entry] if args[entry] != None else \\\"-\\\"\\n log.info(\\\" {:<16} {}\\\".format(entry, value))\\n\\n log.warning('tomolog status end')\",\n \"def print_config_value(self, name, prefix='- ', separator=': '):\\r\\n\\r\\n value_out = 'None'\\r\\n if name in self.config_values and self.config_values[name] is not None:\\r\\n value_out = self.config_values[name]\\r\\n print(prefix + name + separator + value_out)\",\n \"def print_settings(self, title=None):\\n if title:\\n print(title)\\n print('Contents of imagenode.yaml:')\\n pprint.pprint(self.config)\\n print()\",\n \"def testcliparams(c, name=\\\"def\\\"):\\n print(name)\",\n \"def display_sim_parameters(self):\\n pprint.pprint(vars(self))\\n return\",\n \"def printMe(self):\\n tempDict = self.whoAreYou()\\n for key in tempDict.keys():\\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))\\n tempDict = self.getInitParams()\\n self.raiseADebug(' Initialization Parameters:')\\n for key in tempDict.keys():\\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))\\n tempDict = self.myCurrentSetting()\\n self.raiseADebug(' Current Setting:')\\n for key in tempDict.keys():\\n self.raiseADebug(' {0:15}: {1}'.format(key,str(tempDict[key])))\",\n \"def print_config_values(self, prefix='- '):\\r\\n print('Configuration values from ' + self.config_dir)\\r\\n self.print_config_value(self.CONFIG_NAME_USER, prefix=prefix)\\r\\n self.print_config_value(self.CONFIG_NAME_PATH, prefix=prefix)\\r\\n self.print_config_value(self.CONFIG_NAME_PROXY, prefix=prefix)\\r\\n self.print_config_value(self.CONFIG_NAME_COMPETITION, prefix=prefix)\",\n \"def print_usage():\\n print 'USAGE: %s [options]' % os.path.abspath(__file__)\\n print 'EXAMPLE1: %s # FOR DEFAULTS' % os.path.abspath(__file__)\\n print 'EXAMPLE2: %s 121f03=tweek hirap=towelie details=False # TWO SMALL SETS' % os.path.abspath(__file__)\\n print 'EXAMPLE3: %s 121f03=tweek details=True # ONE DETAILED SET' % os.path.abspath(__file__)\\n print 'EXAMPLE4: %s details=True # SHOWS MAX INFO' % os.path.abspath(__file__)\",\n \"def test():\\n conf = AppConf()\\n\\n for section in conf.sections():\\n print(section)\\n for option, value in conf.items(section):\\n print(\\\" {option:15}: {value}\\\".format(option=option, value=value))\",\n \"def test_dump_config(self):\\n config = easydms.config.Config()\\n print(config)\",\n \"def do_display_config(self, *arg):\\n try:\\n if self.pocs and self.pocs.config:\\n pprint(self.pocs.config)\\n else:\\n print_warning(\\\"No config file for POCS.\\\")\\n\\n except AttributeError:\\n print_warning(\\\"Please run `setup_pocs` before trying to run `display_config`\\\")\",\n \"def display(self):\\n print(\\\"{}, {}\\\".format(self.label, self.params))\",\n \"def print_variables(self):\\n\\n logging.debug(\\n \\\"The broker address \\\" + str(\\n self.broker_address) + \\\" transport \\\" + self.tTransport + \\\" the port is \\\" + str(\\n self.tPort))\",\n \"def view(self,\\n print_global_settings=True,\\n print_general_settings=True,\\n print_tmp_vals=False,\\n print_results=True,\\n **kws\\n ):\\n\\n print(self.name)\\n\\n if print_global_settings:\\n print(\\\"Global settings:\\\")\\n pprint.pprint(self.global_settings)\\n print()\\n\\n if print_general_settings:\\n print(\\\"General settings:\\\")\\n pprint.pprint(self.settings[self.name]['General'])\\n print()\\n\\n for i, x in enumerate(self.routine_template):\\n print(f\\\"Step {i}, {x[0].__name__} ({x[1]})\\\")\\n print(\\\"Settings:\\\")\\n pprint.pprint(x[2], indent=4)\\n\\n if print_tmp_vals:\\n try:\\n print(\\\"Temporary values:\\\")\\n pprint.pprint(x[3], indent=4)\\n except IndexError:\\n pass\\n print()\\n\\n if print_results:\\n print_step_results(self)\",\n \"def print_corr2_params():\\n treecorr.config.print_params(corr2_valid_params)\",\n \"def print_testvals(self):\\n print(self.use_planck)\",\n \"def log_environment_variables():\\n\\n LOGGER.info(f\\\"bucket: {BUCKET}\\\")\\n LOGGER.info(f\\\"config_s3_key: {CONFIG_S3_KEY}\\\")\\n LOGGER.info(f\\\"previously_valid_urls_s3_key: {PREVIOUSLY_VALID_URLS_S3_KEY}\\\")\\n LOGGER.info(f\\\"logging_level: {LOGGING_LEVEL}\\\")\\n LOGGER.info(f\\\"default_email_subject: {DEFAULT_EMAIL_SUBJECT}\\\")\\n LOGGER.info(f\\\"default_from_email: {DEFAULT_FROM_EMAIL}\\\")\\n LOGGER.info(f\\\"default_to_email: {DEFAULT_TO_EMAIL}\\\")\\n LOGGER.info(f\\\"default_url: {DEFAULT_URL}\\\")\\n LOGGER.info(f\\\"default_start_value: {DEFAULT_START_VALUE}\\\")\\n LOGGER.info(f\\\"default_look_ahead: {DEFAULT_LOOK_AHEAD}\\\")\\n LOGGER.info(f\\\"default_slide_window: {DEFAULT_SLIDE_WINDOW}\\\")\",\n \"def config( **kwargs ):\",\n \"def module_config_info():\\n\\n print(\\\"consumes\\\", CONSUMES)\\n module_config_template()\",\n \"def showconfig():\\n print(yaml.dump(CONFIG))\",\n \"def print_configs(opts, header=''):\\n if header:\\n print('\\\\n###############################################################\\\\n')\\n print('\\\\t########\\\\t {} \\\\t########\\\\n'.format(header))\\n print('###############################################################\\\\n')\\n\\n for field in opts._fields:\\n if len(field) < 8:\\n print('\\\\t{}\\\\t\\\\t\\\\t:\\\\t{}\\\\n'.format(field, getattr(opts, field)))\\n else:\\n print('\\\\t{}\\\\t\\\\t:\\\\t{}\\\\n'.format(field, getattr(opts, field)))\",\n \"def do_config(self, line: str):\\n if self._real_module is None:\\n print(\\\"'config' command depends on using a module. See 'use' for help.\\\")\\n return\\n\\n settings = self._real_module.params()\\n if line != '':\\n value = settings.get(line, None)\\n if value is not None:\\n print(value[\\\"Value\\\"])\\n else:\\n print(settings)\",\n \"def print_settings(args, clear=True):\\n s = \\\" # GPSeq analysis of FISH signals v%s\\\\n\\\" % version\\n\\n s += \\\"\\\"\\\"\\n --- INPUT =======\\n\\n FISH table : %s\\n Image folder : %s\\n Output folder : %s\\n\\n Mask folder : %s\\n Mask prefix : '%s'\\n\\n --- ANALYSIS ====\\n\\n Dilation : %d\\n Aspect (Z Y X) : %s\\n Distance type : %s\\nSkipped channels : %s\\n Pole fraction : %.3f\\n #bins : %d\\n\\n --- FLAGS =======\\n\\n 2D masks : '%s'\\n Labeled : %r\\n Compressed : %r\\n Dilate over Z : %r\\nUse dilation only\\nfor dot assignment : %r\\n\\n Plot all : %r\\nPlot compartments : %r\\n\\n --- ADVANCED ====\\n\\n Input regexp : %s\\n Delim : '%s'\\n Threads : %d\\n Debug mode : %r\\n \\\"\\\"\\\" % (\\n args.dotCoords,\\n args.imdir,\\n args.outdir,\\n args.mask_folder,\\n args.mask_prefix,\\n args.dilate,\\n str(args.aspect),\\n args.dist_type,\\n str(args.skip_channels),\\n args.pole,\\n args.nbins,\\n args.manual_2d_masks,\\n args.labeled,\\n args.compressed,\\n args.doZdilation,\\n args.dilate_for_assignment_only,\\n not args.noplot,\\n not args.no_compartment_plot,\\n args.inreg,\\n args.delim,\\n args.threads,\\n args.DEBUG_MODE,\\n )\\n\\n if clear:\\n print(\\\"\\\\033[H\\\\033[J%s\\\" % s)\\n else:\\n print(s)\\n return s\",\n \"def printing_vars(self):\\n print(\\\"Name is \\\", self.name)\",\n \"def config(self) -> NamedTuple:\",\n \"def print(self):\\n for attr in inspect.getmembers(self):\\n if not attr[0].startswith('_') and not inspect.ismethod(attr[1]):\\n if attr[0] not in ('lyapunov_hybrid_system'):\\n print(f\\\"{attr[0]}: {attr[1]}\\\")\\n if self.enable_wandb:\\n wandb.config.update({attr[0]: f\\\"{attr[1]}\\\"})\",\n \"def test_print_configs(self, print_config: MagicMock) -> None:\\n tape1 = TMTape(\\n tape=\\\"01010101\\\",\\n blank_symbol=\\\".\\\",\\n current_position=0,\\n )\\n tape2 = TMTape(\\n tape=\\\"x1010101\\\",\\n blank_symbol=\\\".\\\",\\n current_position=-1,\\n )\\n tape3 = TMTape(\\n tape=\\\"yx1010101\\\",\\n blank_symbol=\\\".\\\",\\n current_position=-2,\\n )\\n configs = [\\n TMConfiguration(\\\"q0\\\", tape1),\\n TMConfiguration(\\\"q1\\\", tape2),\\n TMConfiguration(\\\"q2\\\", tape3),\\n MTMConfiguration(\\\"q1\\\", (tape1, tape2, tape3)),\\n ]\\n out = io.StringIO()\\n with contextlib.redirect_stdout(out):\\n tmtools.print_configs(configs) # type: ignore\\n self.assertEqual(print_config.call_args_list, [call(), call(), call()])\",\n \"def print_all_params(self, disp=True):\\n descriptions = {'general': {}}\\n for name, param in self.params.items():\\n descriptions['general'][name] = param.get_description()\\n\\n for comp, comp_obj in self.components.items():\\n descriptions[comp] = {}\\n for name in comp_obj.get_params():\\n descriptions[comp][name] = comp_obj.get_param_description(name)\\n return self._print_params(descriptions, disp)\",\n \"def _dumpConfiguration(self):\\n print \\\"Writing configuration:\\\"\\n print \\\" - title = \\\" + self.title\\n print \\\" - executablePath = \\\" + self.exePath\\n print \\\" - configPath = \\\" + self.configPath\\n print \\\" - outputName = \\\" + self.outputName\\n print \\\" - branch = \\\" + self.branch\\n print \\\" - branchName = \\\" + self.branchName\\n print \\\" - buildid = \\\" + self.buildid\\n print \\\" - currentDate = \\\" + self.currentDate\\n print \\\" - testDate = \\\" + self.testDate\\n print \\\" - resultsServer = \\\" + self.resultsServer\\n print \\\" - resultsLink = \\\" + self.resultsLink\\n print \\\" - activeTests = \\\" + self.activeTests\\n if self.symbolsPath:\\n print \\\" - symbolsPath = \\\" + self.symbolsPath\",\n \"def load_standard_parameters(self):\\n paradic = {'x':'0',\\n 'y':'0',\\n 'n_oct':'8',\\n 'n_spo':'3',\\n 'sigma_min':'0.8',\\n 'delta_min':'0.5',\\n 'sigma_in':'0.5',\\n 'C_DoG':'0.015',\\n 'C_edge':'10',\\n 'n_bins':'36',\\n 'lambda_ori':'1.5',\\n 't':'0.8',\\n 'n_hist':'4',\\n 'n_ori':'8',\\n 'lambda_descr':'6',\\n 'flag_match':'1',\\n 'C_match':'0.6'}\\n self.cfg['param']['paradic'] = paradic\\n self.cfg.save()\",\n \"def print_conf(self, item):\\n\\t\\toutput = \\\"\\\"\\n\\t\\t## Header, to go on all files\\n\\t\\toutput += \\\"# Configuration file %s\\\\n\\\" % item['meta']['filename']\\n\\t\\toutput += \\\"# Edited by PyNag on %s\\\\n\\\" % time.ctime()\\n\\n\\t\\t## Some hostgroup information\\n\\t\\tif item['meta'].has_key('hostgroup_list'):\\n\\t\\t\\toutput += \\\"# Hostgroups: %s\\\\n\\\" % \\\",\\\".join(item['meta']['hostgroup_list'])\\n\\n\\t\\t## Some hostgroup information\\n\\t\\tif item['meta'].has_key('service_list'):\\n\\t\\t\\toutput += \\\"# Services: %s\\\\n\\\" % \\\",\\\".join(item['meta']['service_list'])\\n\\n\\t\\t## Some hostgroup information\\n\\t\\tif item['meta'].has_key('service_members'):\\n\\t\\t\\toutput += \\\"# Service Members: %s\\\\n\\\" % \\\",\\\".join(item['meta']['service_members'])\\n\\n\\t\\tif len(item['meta']['template_fields']) != 0:\\n\\t\\t\\toutput += \\\"# Values from templates:\\\\n\\\"\\n\\t\\tfor k in item['meta']['template_fields']:\\n\\t\\t\\toutput += \\\"#\\\\t %-30s %-30s\\\\n\\\" % (k, item[k])\\n\\t\\toutput += \\\"\\\\n\\\"\\n\\t\\toutput += \\\"define %s {\\\\n\\\" % item['meta']['object_type']\\n\\t\\tfor k, v in item.iteritems():\\n\\t\\t\\tif k != 'meta':\\n\\t\\t\\t\\tif k not in item['meta']['template_fields']:\\n\\t\\t\\t\\t\\toutput += \\\"\\\\t %-30s %-30s\\\\n\\\" % (k,v)\\n\\t\\t\\n\\t\\toutput += \\\"}\\\\n\\\\n\\\"\\n\\t\\treturn output\",\n \"def getDefaultParams():\\n defpar = [\\n # coordinate system\\n ['crd_sys', \\\"'sph'\\\", 'Coordinate system'],\\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\\n ['ny', '[10,30, 30, 10]',\\n 'Number of grid points in the second dimension'],\\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\\n 'Number of radial grid points'],\\n ['nz', '[361]', 'Number of grid points in the third dimension'],\\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\\n # star related\\n ['tstar', '[3900.0]', 'Temperature of star'],\\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\\n ['rstar', '[2.5*rs]', 'Radius of star'],\\n # gas density \\n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \\n ['ring_r', '[50*au]', 'location of gaussian ring'], \\n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \\n ['cutgdens', '1e-30', 'cut for density'], \\n ['Rt', '100*au', 'radius for scale height'], \\n ['Ht', '10*au', 'scale height'], \\n ['qheight', '1.25', 'height power-law'], \\n # gas species\\n ['gasspec_mol_name', \\\"['12co']\\\", 'name of molecule'],\\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\\n ['gasspec_mol_dbase_type', \\\"['leiden']\\\", ''],\\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\\n # dust density\\n # flat power-law parts\\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\\n # Lynden-Bell parts\\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \\n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \\n ['dLB_sig0', '[1e2]', 'surface density'], \\n # ring parts\\n ['dring_r', '[50*au]', 'location of gaussian ring'],\\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\\n ['cutddens', '1e-30', 'cut for dust density'],\\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \\n ['dHt', '[10*au]', 'scale height for each grain size'], \\n ['dqheight', '[1.25]', 'scale height power-law for dust'], \\n # temperature\\n ['T0mid', '50', 'mid plane temperature at Rt'],\\n ['T0atm', '50', 'atmosphere temperature at Rt'],\\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\\n ['qmid', '-0.5', 'midplane temperature exponent'],\\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\\n ['hdel', '2', 'temperature transition exponent '],\\n ['cuttemp', '10', 'temperature cut'], \\n # alignment\\n ['altype', \\\"'toroidal'\\\", 'alignment type']\\n ]\\n\\n return defpar\",\n \"def print_config(config_dic, logger):\\n for k, v in config_dic.items():\\n logger.info(\\\"{}:\\\\t{}\\\".format(k.ljust(15), v))\",\n \"def print_args():\\n for key, value in vars(ARGS).items():\\n print(key + ' : ' + str(value))\",\n \"def get_diameters():\\n return Global_Module.global_diameters\",\n \"def _debug_print(self, cfg, list_iterstore):\\n def __print_params(iterstore, edataset):\\n if (edataset not in iterstore): return\\n gen = iterstore[edataset]\\n if (gen is not None):\\n if (gen._params is not None):\\n print('{} : {}'.format(edataset, gen))\\n print(\\\"\\\\tIterator Parameters: (iter_param, iter_pp_param)\\\")\\n print(\\\"\\\\t-------------------------------------------------\\\")\\n for key, val in gen._params.items():\\n if (key.startswith('_')): continue\\n print('\\\\t{} : {}'.format(key, val))\\n \\n if (gen._pp_params is not None):\\n print(\\\"\\\\t-------------------------------------------------\\\")\\n for key, val in gen._pp_params.items():\\n if (key.startswith('_')): continue\\n print('\\\\t{} : {}'.format(key, val))\\n print(\\\"\\\")\\n\\n if (list_iterstore is None):\\n return\\n\\n print(\\\"\\\\nNNCfg\\\")\\n print(\\\"=====\\\")\\n for key, val in cfg.__dict__.items():\\n if (key.startswith('_')): continue\\n print('\\\\t{} : {}'.format(key, val))\\n\\n for i, iterstore in enumerate(list_iterstore):\\n print(\\\"\\\\nIterator Store:{}\\\".format(i))\\n print(\\\"=================\\\")\\n __print_params(iterstore, Dataset.TR)\\n __print_params(iterstore, Dataset.VAL)\\n __print_params(iterstore, Dataset.TE)\\n __print_params(iterstore, Dataset.TR_OUT)\\n __print_params(iterstore, Dataset.VAL_OUT)\\n __print_params(iterstore, Dataset.TE_OUT)\",\n \"def printme(parameters): # create a function called printme using def\\n print(parameters) # prints anything that is stored inside parameters\\n return\",\n \"def config(self) -> Dict[str, Any]:\",\n \"def pre_process_information(self):\\n self.logger.debug(\\n colorama.Fore.BLUE\\n + \\\"jsnapy.cfg file location used : %s\\\" % get_config_location(),\\n extra=self.log_detail,\\n )\\n self.logger.debug(\\n colorama.Fore.BLUE\\n + \\\"Configuration file location used : %s\\\"\\n % get_path(\\\"DEFAULT\\\", \\\"config_file_path\\\"),\\n extra=self.log_detail,\\n )\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def fullDebug():\\r\\n global CurrentState\\r\\n global CurrentInput\\r\\n global RESPONSEOPTIONS\\r\\n print(\\\"___________________________\\\")\\r\\n print(\\\"\\\\n*Current Input:\\\", CurrentInput)\\r\\n print(\\\"*Current State: \\\", CurrentState)\\r\\n print(\\\"\\\\n*Response Options: \\\", RESPONSEOPTIONS)\\r\\n print(\\\"___________________________\\\")\",\n \"def required_test_config_variables(cls) -> Tuple[str, ...]:\\n return (\\\"shell_cmd\\\", \\\"expect\\\", \\\"known_logline\\\")\",\n \"def PrintConfigs():\\n print '\\\\n\\\\n-----IO Box Inputs---------------------------------'\\n print 'Monitor Inputs: %s' %MonitorInputLst \\n print 'Assign Inputs to Alarm Type'\\n for ik in InputAssignment.keys():\\n print ' %s: %s' %(ik, InputAssignment[ik])\\n print '\\\\n\\\\n-----Emails----------------------------------------'\\n print 'MailHost(smtp) server: %s' %MailHost\\n print 'Send notification email to: '\\n cnt = 0\\n pstr = ' '\\n for m in MailList:\\n pstr += m\\n if cnt == 1:\\n pstr += '\\\\n '\\n cnt = 0\\n else:\\n cnt += 1\\n print pstr\\n print 'Emails sent from: %s' %FromEmail \\n print '\\\\n\\\\n-----Wave files------------------------------------'\\n print 'Play wave files with: %s' %WavCmd \\n print 'Play wave files %s times' %WavRepititions\\n print 'Wave file sounds for defined alarm types\\\\n' \\n for ak in AlarmSounds.keys():\\n print ' %s: %s' %(ak,AlarmSounds[ak])\\n print '\\\\n\\\\n-----Zip files-------------------------------------'\\n print 'Zip files with command %s' %ZipCmd \\n print '\\\\n\\\\n-----Camera information----------------------------'\\n print 'Directories'\\n for ck in camDirs.keys():\\n print ' %s: %s' %(ck, camDirs[ck])\\n print 'Images per cam'\\n for nk in NumCamImages.keys():\\n print ' %s: %s' %(nk, NumCamImages[nk])\\n print 'Camera image delay: %s' %IMAGE_DELAY\\n print '\\\\n\\\\n-----Remote commands-------------------------------'\\n for rk in RemoteCMDS.keys():\\n print ' %s: %s' %(rk, RemoteCMDS[rk])\\n print '\\\\n\\\\n-----Other-----------------------------------------'\\n print 'Sleep time between alarm/drive executions: %s' %ALARMSLEEP\\n print 'Quiet: %s' %QUIET\\n print '\\\\n\\\\n'\\n print 'Usage: HomeAutomation: -d = run -c = print configuration\\\\n\\\\n'\",\n \"def print_node_params(self, node=None, disp=True):\\n string = ''\\n\\n for comp in self.get_node_components(node):\\n comp = comp[len(node) + 1:]\\n string += self.print_comp_param(node, comp, disp=False)\\n\\n if disp:\\n print(string)\\n else:\\n return string\",\n \"def print_config(self, cfg, hide_password=True, history=False, module_id=None):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tcp = self.config_parser\\n\\t\\ts = ''\\n\\t\\tkeys1 = list(cfg.keys())\\n\\t\\tif keys1:\\n\\t\\t\\tkeys1.sort()\\n\\t\\tfor k in keys1:\\n\\t\\t\\tif module_id is not None and k != module_id:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tif isinstance(k, str) and isinstance(cfg[k], dict):\\n\\t\\t\\t\\ts += '\\\\n[' + k + ']\\\\n'\\n\\t\\t\\t\\tkeys2 = list(cfg[k].keys())\\n\\t\\t\\t\\tif keys2:\\n\\t\\t\\t\\t\\tkeys2.sort()\\n\\t\\t\\t\\tfor k1 in keys2:\\n\\t\\t\\t\\t\\tline = ''\\n\\t\\t\\t\\t\\tline += k1 + ':'\\n\\t\\t\\t\\t\\t# If we want to hide passwords, we do so using a sha512\\n\\t\\t\\t\\t\\t# done an aritrary number of times (27).\\n\\t\\t\\t\\t\\tif hide_password and (k1 == 'password' or k1 == 'passphrase'):\\n\\t\\t\\t\\t\\t\\tp = hashlib.sha512(cfg[k][k1]).hexdigest()\\n\\t\\t\\t\\t\\t\\ti = 27\\n\\t\\t\\t\\t\\t\\twhile i > 0:\\n\\t\\t\\t\\t\\t\\t\\ti -= 1\\n\\t\\t\\t\\t\\t\\t\\tp = hashlib.sha512(s).hexdigest()\\n\\t\\t\\t\\t\\t\\tline += p\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif type(cfg[k][k1] == bool):\\n\\t\\t\\t\\t\\t\\t\\tline += str(cfg[k][k1])\\n\\t\\t\\t\\t\\t\\telif type(cfg[k][k1] == str):\\n\\t\\t\\t\\t\\t\\t\\tline += cfg[k][k1]\\n\\t\\t\\t\\t\\tif history:\\n\\t\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\tline += (30-len(line)) * ' ' + ' # ' + cp.whereset(k, k1)\\n\\t\\t\\t\\t\\t\\texcept Exception:\\n\\t\\t\\t\\t\\t\\t\\t# Assume this is because it was never set by a config parser.\\n\\t\\t\\t\\t\\t\\t\\tline += (30-len(line)) * ' ' + ' # ' + \\\"defaults in code\\\"\\n\\t\\t\\t\\t\\ts += line + '\\\\n'\\n\\t\\treturn s\",\n \"def get_config(context):\\n conf_vars = ['disqus_developer', 'disqus_identifier', 'disqus_url', 'disqus_title']\\n \\n output = []\\n for item in conf_vars:\\n if item in context:\\n output.append('\\\\tvar %s = \\\"%s\\\";' % (item, context[item]))\\n return '\\\\n'.join(output)\",\n \"def main(config, debug):\\n config.debug = debug\\n if config.debug:\\n click.echo('Debug info...')\",\n \"def print_config(self):\\n for pod in self.pods:\\n for lb in pod.limbs:\\n print '%s limb %s ' % (pod.name, lb.name)\\n for br in lb.branches:\\n br.printInfo()\\n sys.stdout.flush()\",\n \"def config(self):\\n\\t\\tsys.stderr.write(\\\"Base class method called: config() This souldn't happen.\\\\n\\\")\",\n \"def __str__(self):\\n\\n print(\\\"\\\")\\n s = \\\"NAME : \\\"+self._name+\\\"\\\\n\\\\n\\\"\\n s += \\\"PARAMS :\\\"\\n print(s)\\n\\n for key, val in self.params.items():\\n l = (21-len(key))//7\\n print(\\\"{0}\\\".format(key)+\\\"\\\\t\\\"*l+\\\":\\\\t{0}\\\".format(val))\\n\\n s = \\\"\\\\nRuns stored in DEFAULT_RUNS = \\\"+str(len(self.default_runs))\\n print(s)\\n\\n s = \\\"\\\\nRuns stored in MOD_RUNS = \\\"+str(len(self.mod_runs))\\n print(s)\\n\\n return \\\"\\\"\",\n \"def test_config():\\n args = Namespace(molecule=\\\"nucleotide\\\", verbose=False)\\n config = core.Config.from_args(args)\\n assert config.verbose is False\\n assert config.molecule == 'nucleotide'\\n assert config.extended_validation == 'none'\\n\\n args = Namespace(molecule=\\\"protein\\\", verbose=True)\\n config = core.Config.from_args(args)\\n assert config.verbose is True\\n assert config.molecule == 'protein'\",\n \"def config(ctx):\\n return\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_flags():\\n for key, value in vars(FLAGS).items():\\n print(key + ' : ' + str(value))\",\n \"def print_general_param(self, name=None, disp=True):\\n\\n if name is None:\\n list = {}\\n\\n for name in self.params:\\n list[name] = self.params[name].get_description()\\n\\n return self._print_params({'general': list}, disp)\\n else:\\n if name not in self.params:\\n raise IndexError('%s is not a valid general parameter ' % name)\\n\\n return self._print_params({'general': {name: self.params[name].get_description()}}, disp)\",\n \"def config_debug():\\n config_str = request.args.get('config')\\n config = pickle.loads(b64decode(config_str))\\n return str(config)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7461699","0.7036818","0.70333016","0.6937575","0.6927378","0.6777318","0.6775346","0.6666382","0.6586468","0.6535474","0.64919525","0.6467023","0.6425723","0.64183","0.64038175","0.6391235","0.63494974","0.6276289","0.62646157","0.62633955","0.6179124","0.61627483","0.6141835","0.6130568","0.6120424","0.6089423","0.60846484","0.6070876","0.6053343","0.6051231","0.6051231","0.6041319","0.60117745","0.6009407","0.60014004","0.59950715","0.59823686","0.5976758","0.5970594","0.5964004","0.5957412","0.59453005","0.59443367","0.5927201","0.5920334","0.5915074","0.59115833","0.5907315","0.5899898","0.58948874","0.5892101","0.58686316","0.58659756","0.5857436","0.5847991","0.5801177","0.5800212","0.57964057","0.5791982","0.579088","0.57715964","0.5771544","0.57705426","0.5770033","0.5769178","0.5766081","0.57612175","0.5760129","0.57463664","0.5740054","0.57397205","0.5720551","0.572003","0.5714284","0.57139593","0.5710428","0.5707383","0.5702284","0.56851715","0.56851715","0.56851715","0.56851715","0.56845045","0.5683639","0.56781846","0.56653804","0.5657125","0.56546754","0.5652166","0.56371665","0.56371444","0.5632582","0.56301177","0.5629605","0.56102467","0.56102467","0.56102467","0.56102467","0.5609772","0.5604108"],"string":"[\n \"0.7461699\",\n \"0.7036818\",\n \"0.70333016\",\n \"0.6937575\",\n \"0.6927378\",\n \"0.6777318\",\n \"0.6775346\",\n \"0.6666382\",\n \"0.6586468\",\n \"0.6535474\",\n \"0.64919525\",\n \"0.6467023\",\n \"0.6425723\",\n \"0.64183\",\n \"0.64038175\",\n \"0.6391235\",\n \"0.63494974\",\n \"0.6276289\",\n \"0.62646157\",\n \"0.62633955\",\n \"0.6179124\",\n \"0.61627483\",\n \"0.6141835\",\n \"0.6130568\",\n \"0.6120424\",\n \"0.6089423\",\n \"0.60846484\",\n \"0.6070876\",\n \"0.6053343\",\n \"0.6051231\",\n \"0.6051231\",\n \"0.6041319\",\n \"0.60117745\",\n \"0.6009407\",\n \"0.60014004\",\n \"0.59950715\",\n \"0.59823686\",\n \"0.5976758\",\n \"0.5970594\",\n \"0.5964004\",\n \"0.5957412\",\n \"0.59453005\",\n \"0.59443367\",\n \"0.5927201\",\n \"0.5920334\",\n \"0.5915074\",\n \"0.59115833\",\n \"0.5907315\",\n \"0.5899898\",\n \"0.58948874\",\n \"0.5892101\",\n \"0.58686316\",\n \"0.58659756\",\n \"0.5857436\",\n \"0.5847991\",\n \"0.5801177\",\n \"0.5800212\",\n \"0.57964057\",\n \"0.5791982\",\n \"0.579088\",\n \"0.57715964\",\n \"0.5771544\",\n \"0.57705426\",\n \"0.5770033\",\n \"0.5769178\",\n \"0.5766081\",\n \"0.57612175\",\n \"0.5760129\",\n \"0.57463664\",\n \"0.5740054\",\n \"0.57397205\",\n \"0.5720551\",\n \"0.572003\",\n \"0.5714284\",\n \"0.57139593\",\n \"0.5710428\",\n \"0.5707383\",\n \"0.5702284\",\n \"0.56851715\",\n \"0.56851715\",\n \"0.56851715\",\n \"0.56851715\",\n \"0.56845045\",\n \"0.5683639\",\n \"0.56781846\",\n \"0.56653804\",\n \"0.5657125\",\n \"0.56546754\",\n \"0.5652166\",\n \"0.56371665\",\n \"0.56371444\",\n \"0.5632582\",\n \"0.56301177\",\n \"0.5629605\",\n \"0.56102467\",\n \"0.56102467\",\n \"0.56102467\",\n \"0.56102467\",\n \"0.5609772\",\n \"0.5604108\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6767941"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":89492,"cells":{"query":{"kind":"string","value":"Solve the discrete algebraic ricatti equation to compute the optimal feedback."},"document":{"kind":"string","value":"def sda_estimate(A, B, Q, R):\n X = sda(A, B, Q, R)\n K = np.linalg.inv(R + B.T @ X @ B) @ B.T @ X @ A\n return -K"},"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 evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def solve(self):\n\n if self.optimizer == 'pulp':\n for constraint in self.constraints:\n self.engine_model += constraint\n\n self.engine_model += self.objective\n status = self.engine_model.solve(PULP_CBC_CMD(msg=False))\n solution = (\n np.vectorize(self._var_sol)(self.variable_set)\n if status == LpStatusOptimal\n else np.array([])\n )\n\n else:\n for constraint in self.constraints:\n self.engine_model.addConstr(constraint)\n\n self.engine_model.setObjective(self.objective, self.sense)\n self.engine_model.optimize()\n solution = (\n np.vectorize(self._var_sol)(self.variable_set)\n if self.engine_model.status == GRB.OPTIMAL\n else np.array([])\n )\n\n return solution","def solve(self):\n start = timer()\n # encode into milp\n me = MILPEncoder(MILPSolver.prob,\n MILPSolver.params.logger.LOGFILE, \n MILPSolver.params.INTRA_DEP_CONSTRS,\n MILPSolver.params.INTER_DEP_CONSTRS)\n if MILPSolver.lp == True:\n gmodel = me.lp_encode()\n else:\n gmodel = me.encode()\n # Set gurobi parameters\n pgo = 1 if MILPSolver.params.PRINT_GUROBI_OUTPUT == True else 0\n gmodel.setParam('OUTPUT_FLAG', pgo)\n tl = MILPSolver.params.TIMEOUT\n if tl != -1 : gmodel.setParam('TIME_LIMIT', tl)\n if not MILPSolver.params.DEFAULT_CUTS: \n MILPSolver.disable_default_cuts(gmodel)\n gmodel._vars = gmodel.getVars()\n # set callback cuts \n MILPSolver.id_form = IdealFormulation(MILPSolver.prob,\n gmodel, \n MILPSolver.params.IDEAL_FREQ,\n MILPSolver.params.logger.LOGFILE)\n MILPSolver.dep_cuts = DepCuts(MILPSolver.prob,\n gmodel,\n MILPSolver.params.DEP_FREQ,\n MILPSolver.params.INTRA_DEP_CUTS,\n MILPSolver.params.INTER_DEP_CUTS,\n MILPSolver.sip_params,\n MILPSolver.params.logger.LOGFILE)\n # Optimise\n if MILPSolver.params.callback_enabled() and MILPSolver.lp == False:\n gmodel.optimize(MILPSolver._callback)\n else:\n gmodel.optimize()\n\n runtime = timer() - start\n cex = None \n if MILPSolver.status == SolveResult.BRANCH_THRESHOLD:\n result = SolveResult.BRANCH_THRESHOLD\n elif gmodel.status == GRB.OPTIMAL:\n cex_shape = MILPSolver.prob.spec.input_layer.input_shape\n cex = np.zeros(cex_shape)\n for i in itertools.product(*[range(j) for j in cex_shape]):\n cex[i] = MILPSolver.prob.spec.input_layer.out_vars[i].x\n result = SolveResult.UNSATISFIED\n elif gmodel.status == GRB.TIME_LIMIT:\n result = SolveResult.TIMEOUT\n elif gmodel.status == GRB.INTERRUPTED:\n result = SolveResult.INTERRUPTED\n elif gmodel.status == GRB.INFEASIBLE or gmodel.status == GRB.INF_OR_UNBD:\n result = SolveResult.SATISFIED\n else:\n result = SolveResult.UNKNOWN\n \n # MILPSolver.logger.info('Verification problem {} solved, '\n # 'LP: {}, '\n # 'time: {:.2f}, '\n # 'result: {}.'\n # .format(MILPSolver.prob.id,\n # MILPSolver.lp,\n # runtime,\n # result.value))\n \n return SolveReport(result, runtime, cex)","def _solve_implicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n l_and_u = (1, 1)\n ab = np.empty((3, self.n_x))\n # main diagonal\n ab[1] = 1 + 2.0 * coeff\n # upper and lower diagonals\n ab[0] = ab[2] = -coeff\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n ab[0][1] = 0 # upper diagonal\n ab[1][0] = 1 # main diagonal\n elif self.left_bc_type == \"NEUMANN\":\n ab[0][1] = 1 # upper diagonal\n ab[1][0] = -1 # main diagonal\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n ab[1][-1] = 1 # main diagonal\n ab[2][-2] = 0 # lower diagonal\n elif self.right_bc_type == \"NEUMANN\":\n ab[1][-1] = 1 # main diagonal\n ab[2][-2] = -1 # lower diagonal\n\n current_solution = initial_conditions\n solutions = []\n\n for t in self.t_grid:\n b = current_solution + self.tau * self.rhs(self.x_grid, t)\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n b[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n b[0] = self.h * self.left_bc(t)\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n b[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n b[-1] = self.h * self.right_bc(t)\n\n next_solution = solve_banded(l_and_u, ab, b)\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def g_solving_subproblem_of_ALR(self,vehicle_id):\r\n global_LB = -10000\r\n global_UB = 10000\r\n iteration_for_RSP = 20\r\n optimal_solution_for_RSP = None\r\n self.multiplier_v = 0.5\r\n\r\n # solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\r\n\r\n # obtain the variance\r\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB = 0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\r\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\r\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\r\n\r\n # step 3: update multipliers\r\n if variance- y != 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB - global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB","def _solve_explicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n current_solution = initial_conditions\n next_solution = np.empty_like(current_solution)\n solutions = []\n\n for t in self.t_grid:\n next_solution[1:-1] = (\n current_solution[1:-1]\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n next_solution[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n next_solution[0] = (\n 4 * next_solution[1]\n - next_solution[2]\n - 2 * self.h * self.left_bc(t)\n ) / 3.0\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n next_solution[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n next_solution[-1] = (\n 4 * next_solution[-2]\n - next_solution[-3]\n + 2 * self.h * self.right_bc(t)\n ) / 3.0\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n if is_wire(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n elif not is_cs(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n\n # Set up the linear algebraic equation Ax=b\n A = np.zeros((num, num))\n b = np.zeros(num)\n for row, element in lookup.items():\n if is_wire(element) and element is not self.ground:\n for two_sided in element.attached:\n if is_cs(two_sided):\n if two_sided.pos is element:\n b[row] += -1 * two_sided.current\n else:\n b[row] += two_sided.current\n else:\n if two_sided.pos is element:\n flow = 1\n else:\n flow = -1\n A[row, r_lookup[two_sided]] = flow\n elif is_vs(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n b[row] = element.voltage\n elif is_resistor(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n A[row, r_lookup[element]] = -1 * element.resistance\n\n b = b.reshape((num, 1))\n try:\n x = np.linalg.solve(A, b)\n except np.linalg.LinAlgError:\n raise CircuitError('Insufficient information to solve circuit')\n\n # Assign values to all circuit components\n for i in range(num):\n item = lookup[i]\n if is_wire(item):\n item.potential = x[i, 0]\n elif isinstance(item, DualSided):\n item.current = x[i, 0]\n\n # Mark circuit as solved\n self.been_solved = True","def solve(self):\n max_iter = 1000\n iter_count = 0\n yhat = self.predict()\n loss = self.cross_entropy(yhat)\n gradloss = self.cross_entropy_gradient(yhat)\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\n alpha = 1.0\n slope = la.norm(gradloss)**2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n while loss_new < loss + 1e-4 * alpha * slope:\n alpha = alpha / 2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n self.beta = beta_new\n loss = loss_new\n gradloss = self.cross_entropy_gradient(yhat)\n iter_count += 1","def solve(self):\n self.m.optimize()\n if self.m.status == GRB.OPTIMAL:\n self.solution = self.sol_as_mat()\n return self.solution","def solve(self):\n initial_fes = eades(self.graph, self.force_forward_edges)\n initial_fes_vec = self.edge_vector(initial_fes)\n\n # bounds for the objective\n lower_bound = 0\n upper_bound = np.sum(initial_fes_vec @ self.weights)\n\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\n\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\n\n for iteration in itertools.count(1):\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\n upper_bound, len(simple_cycles))\n\n # Formulate and solve the problem for this iteration:\n y = cp.Variable(self.m, boolean=True, name=\"y\")\n objective = cp.Minimize(cp.sum(y @ self.weights))\n\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\n problem = cp.Problem(objective, constraints)\n resolution = problem.solve(**self.solver_args)\n if problem.status != 'optimal':\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\n problem.solver_stats.solver_name)\n self.logger.debug(\n \"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\",\n len(constraints), resolution, problem.solution.status,\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\n current_fes = self.edges_for_vector(current_solution)\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\n len(current_fes))\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\n # from the heuristic\n lower_bound = max(lower_bound, objective.value)\n if lower_bound == upper_bound:\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\n break # y.value is the optimal solution\n\n if resolution > upper_bound:\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\n break\n\n Gi = self.graph.copy()\n Gi.remove_edges_from(current_fes)\n if nx.is_directed_acyclic_graph(Gi):\n self.logger.info('Graph is acyclic, optimal solution found')\n break # y.value is the optimal solution\n\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\n # determine additional simple cycles (= constraints)\n Fi = eades(Gi, self.force_forward_edges)\n yi = self.edge_vector(Fi) | current_solution\n zi = np.sum(yi @ self.weights)\n if zi < upper_bound:\n upper_bound = zi\n current_solution = yi\n simple_cycles |= set(induced_cycles(Gi, Fi))\n\n self.solution_vector = current_solution\n self.solution = self.edges_for_vector(current_solution)\n self.objective = objective.value\n self.iterations = iteration\n self.simple_cycles = simple_cycles\n return self.solution","def solve(self):\n \n # Check if cost is available for both estimators\n if not self.est0.cost_avail or not self.est1.cost_avail:\n self.comp_cost = False\n \n # Initial estimate from the input node\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\n else:\n z0, zvar0 = self.est0.est_init(return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0\n \n # Initialize other variables\n self.var_cost0 = 0\n self.var_cost1 = 0\n self.cost = 0\n self.s = np.zeros(self.shape1)\n \n for it in range(self.nit):\n \n # Forward transform to est1\n t0 = time.time()\n rvar1_new = self.A.var_dot(self.zvar0)\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\n self.var_axes1,rep=False)\n z1_mult = self.A.dot(self.z0)\n r1_new = z1_mult - rvar1_rep*self.s\n \n # Damping\n if it > 0: \n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\n else:\n self.r1 = r1_new\n self.rvar1 = rvar1_new\n\n # Estimator 1 \n if self.comp_cost: \n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \n if not self.map_est:\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\n self.shape1,self.var_axes1)\n else:\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \n cost1 = 0\n self.z1 = z1\n self.zvar1 = zvar1\n self.cost1 = cost1 \n con_new = np.mean(np.abs(z1-z1_mult)**2) \n \n # Reverse nonlinear transform to est 0\n self.s = (self.z1-self.r1)/rvar1_rep\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\n t1 = time.time()\n self.time_est1 = t1-t0\n \n # Reverse linear transform to est 0 \n rvar0_new = 1/self.A.var_dotH(self.sprec)\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\n self.var_axes0,rep=False)\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\n \n # Damping\n if it > 0:\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\n else:\n self.r0 = r0_new\n self.rvar0 = rvar0_new\n \n \n # Estimator 0\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\n if not self.map_est:\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\n self.shape0,self.var_axes0)\n \n else:\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0 \n\n \n # Compute total cost and constraint \n cost_new = self.cost0 + self.cost1 \n if not self.map_est:\n cost_new += self.cost_gauss()\n \n # Step size adaptation\n if (self.step_adapt) and (it > 0):\n if (con_new < self.con):\n self.step = np.minimum(1,self.step_inc*self.step)\n else:\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\n self.cost=cost_new\n self.con=con_new\n \n t2 = time.time()\n self.time_est0 = t2-t1\n self.time_iter = t2-t0\n \n # Print progress\n if self.prt_period > 0:\n if (it % self.prt_period == 0):\n if self.comp_cost:\n print(\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\".format(\\\n it, self.cost, self.con, self.step))\n else:\n print(\"it={0:4d} con={1:12.4e}\".format(\\\n it, self.con))\n \n # Save history\n self.save_hist()","def DirectSolve(self, y):\n if y >= -self.R:\n a1 = self.apath[y+1]\n if y == -2:\n a2 = 0\n else:\n a2 = self.apath[y+2] \n def constraints(a):\n c0 = (1+self.r)*a + self.b - a1\n c1 = (1+self.r)*a1 + self.b - a2\n return self.uc(c0,0)-self.beta*self.uc(c1,0)*(1+self.r)\n a, n = fsolve(constraints, a1), 0\n c = (1+self.r)*a + self.b - a1\n else:\n a1 = self.apath[y+1]\n a2 = self.apath[y+2]\n if y == -(self.R+1):\n n1 = 0\n c1 = (1+self.r)*a1 + self.b - a2\n else:\n n1 = self.npath[y+1]\n c1 = (1+self.r)*a1 + (1-self.tau)*self.w*n1 - a2\n def constraints((a0,n0)):\n c0 = (1+self.r)*a0 + (1-self.tau)*self.w*n0 - a1\n return self.uc(c0,n0) - self.beta*self.uc(c1,n1)*(1+self.r),\\\n (1-self.tau)*self.w*self.uc(c0,n0) + self.un(c0,n0)\n a, n = fsolve(constraints,(a1,n1))\n c = (1+self.r)*a + (1-self.tau)*self.w*n - a1\n return a, n, c","def optimize(self):\n prm = (self.b,self.c)\n d = self.d\n no = int(d*d)\n bounds = [(-1,1)]*no\n resG = differential_evolution(inpSc.entBias, bounds, args = prm, popsize = 40, disp = False)\n\n xOpt = resG.x\n xOpt = xOpt/(np.linalg.norm(xOpt))\n\n #Refine the global optimization by performing a second local optimizaiton\n x0 = xOpt\n\n res = minimize(inpSc.entBias, x0, args = prm, method='BFGS', options={'disp': False})\n xOpt = res.x\n xOpt = xOpt/(np.linalg.norm(xOpt))\n self.rhoOp = inpSc.getMat(xOpt, d)\n self.Q1 = -res.fun","def g_solving_subproblem_of_LR(self,vehicle_id):\r\n global_LB=-10000\r\n global_UB=10000\r\n iteration_for_RSP=20\r\n optimal_solution_for_RSP=None\r\n optimal_value_y=0\r\n self.multiplier_v=0.5\r\n\r\n #solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\r\n #obtain the variance\r\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB=0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\r\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\r\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\r\n optimal_value_y = y\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n\r\n\r\n # step 3: update multipliers\r\n if variance-y!= 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB-global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB","def iterations(self):\n i = 0\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n n = len(self.model.stateVector)\n self.answer = None\n \n while ((i < self.maxiter) \n and (stateVectorConv > self.stateVectorConvThreshold)\n ):\n \n F, K = self.model()\n \n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\n m = \"Iteration {0} failure of model.\"\n raise OptimalEstimationException(m.format(i))\n \n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n m = \"Iteration {0} failure in decomposition.\"\n raise OptimalEstimationException(m.format(i))\n \n statevectorOffset = (self.V.T * self.priorSinvh * \n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\n measurementOffset = (self.U.T * self.errSinvh * \n np.matrix(self.model.observation - F).T)\n \n newState = np.matrix((self.w * \n (measurementOffset.A1 + \n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\n newState = self.priorSh * self.V * newState\n newState = newState.A1 + self.model.prior\n \n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\n self.model.stateVector = newState\n\n if i == 0:\n \n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n \n print('cost Function for iteration {}:'.format(i), self.costFunction)\n\n i += 1\n \n F, K = self.model()\n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n raise OptimalEstimationException(\"Failure in decomposition.\")\n \n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \n self.V.T * self.priorSh)\n \n\n \n return i, stateVectorConv","def solve(self, Dn, Dm, c, b):\n m =self.m\n n =self.n\n kA =self.kA\n iA =self.iA\n A =self.A\n kAt=self.kAt\n iAt=self.iAt\n At =self.At\n kQ =self.kQ\n iQ =self.iQ\n Q =self.Q\n _max =self.max\n\n _pass=0\n consistent = True\n\n m2 = m+n\n\n # Replaced MALLOC & REALLOC with np.empty\n if self.y_k is None:\n self.y_k = np.empty(m)\n else:\n self.y_k.resize(m)\n if self.x_k is None:\n self.x_k = np.empty(n)\n else:\n self.x_k.resize(n)\n if self.r is None:\n self.r = np.empty(m)\n else:\n self.r.resize(m)\n if self.s is None:\n self.s = np.empty(n)\n else:\n self.s.resize(n)\n if self.z is None:\n self.z = np.empty(m2)\n else:\n self.z.resize(m2)\n if self.Qx is None:\n self.Qx = np.empty(n)\n else:\n self.Qx.resize(n)\n\n y_k = self.y_k\n x_k = self.x_k\n r = self.r\n s = self.s\n z = self.z\n Qx = self.Qx\n iperm = self.iperm\n\n maxbc = max(np.abs(b).max(), np.abs(c).max()) + 1\n maxrs = HUGE_VAL\n\n while True:\n\n if _pass == 0:\n for j in range(n):\n z[iperm[j]] = c[j]\n for i in range(m):\n z[iperm[n+i]] = b[i]\n else:\n for j in range(n):\n z[iperm[j]] = s[j]\n for i in range(m):\n z[iperm[n+i]] = r[i]\n\n consistent = self.rawsolve()\n\n if _pass == 0:\n for j in range(n):\n x_k[j] = z[iperm[j]]\n for i in range(m):\n y_k[i] = z[iperm[n+i]]\n else:\n for j in range(n):\n x_k[j] = x_k[j] + z[iperm[j]]\n for i in range(m):\n y_k[i] = y_k[i] + z[iperm[n+i]]\n\n smx(m, n, A, kA, iA, x_k,r)\n smx(n, m, At,kAt,iAt,y_k,s)\n smx(n, n, Q ,kQ ,iQ ,x_k,Qx)\n\n for j in range(n):\n s[j] = c[j] - (s[j] - Dn[j]*x_k[j] - _max*Qx[j])\n for i in range(m):\n r[i] = b[i] - (r[i] + Dm[i]*y_k[i])\n\n oldmaxrs = maxrs\n maxrs = max(np.abs(r).max(), np.abs(s).max())\n\n # --- for tuning purposes ---\n if (self.verbose>2 and _pass>0):\n print(\"refinement({:3d}): {:8.2e} {:8.2e} {:8.2e}\".format(\n _pass, np.abs(s).max(), np.abs(r).max(), maxrs/maxbc ))\n\n _pass += 1\n if maxrs > (1.0e-10*maxbc) and maxrs < (oldmaxrs/2):\n continue\n else:\n break\n\n if maxrs > oldmaxrs and _pass > 1:\n for j in range(n):\n x_k[j] = x_k[j] - z[iperm[j]]\n for i in range(m):\n y_k[i] = y_k[i] - z[iperm[n+i]]\n\n \t#----------------------------------------------------------\n \t#| overwrite input with output\n\n for j in range(n):\n c[j] = x_k[j]\n for i in range(m):\n b[i] = y_k[i]\n\n return consistent","def equations(self):\n k = 0\n ######################################################################\n # equations for fluid balance\n self.residual[k:k + self.num_nw_fluids * 2] = self.fluid_func()\n k += self.num_nw_fluids * 2\n\n ######################################################################\n # equations for mass flow balance\n self.residual[k:k + 2] = self.mass_flow_func()\n k += 2\n\n ######################################################################\n # equations for energy balance\n self.residual[k] = self.energy_func()\n k += 1\n\n ######################################################################\n # equations for specified heat transfer\n if self.Q.is_set:\n self.residual[k] = (\n self.inl[0].m.val_SI * (\n self.outl[0].h.val_SI - self.inl[0].h.val_SI) - self.Q.val)\n k += 1\n\n ######################################################################\n # equations for specified heat transfer coefficient\n if self.kA.is_set:\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\n self.residual[k] = self.kA_func()\n k += 1\n\n ######################################################################\n # equations for specified heat transfer coefficient characteristic\n if self.kA_char.is_set:\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\n self.residual[k] = self.kA_char_func()\n k += 1\n\n ######################################################################\n # equations for specified upper terminal temperature difference\n if self.ttd_u.is_set:\n self.residual[k] = self.ttd_u_func()\n k += 1\n\n ######################################################################\n # equations for specified lower terminal temperature difference\n if self.ttd_l.is_set:\n self.residual[k] = self.ttd_l_func()\n k += 1\n\n ######################################################################\n # equations for specified pressure ratio at hot side\n if self.pr1.is_set:\n self.residual[k] = (\n self.pr1.val * self.inl[0].p.val_SI - self.outl[0].p.val_SI)\n k += 1\n\n ######################################################################\n # equations for specified pressure ratio at cold side\n if self.pr2.is_set:\n self.residual[k] = (\n self.pr2.val * self.inl[1].p.val_SI - self.outl[1].p.val_SI)\n k += 1\n\n ######################################################################\n # equations for specified zeta at hot side\n if self.zeta1.is_set:\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\n self.residual[k] = self.zeta_func(\n zeta='zeta1', inconn=0, outconn=0)\n k += 1\n\n ######################################################################\n # equations for specified zeta at cold side\n if self.zeta2.is_set:\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\n self.residual[k] = self.zeta_func(\n zeta='zeta2', inconn=1, outconn=1)\n k += 1\n\n ######################################################################\n # additional equations\n self.additional_equations(k)","def optimize(self,max_iter=100):\n\n\n for itr in range(max_iter):\n opt_logs = self.opt.minimize(self.tot_neg_elbo,sum([expert.trainable_variables for expert in self.experts],())) \n print(self.neg_elbo)","def _compute_imprimitivity(self):\n m = floor(self._.d / 2)\n self._.antipodal = all(full_simplify(\n self._.b[i] - self._.c[self._.d - i]) == 0\n for i in range(self._.d) if i != m)\n self._.bipartite = all(a == 0 for a in self._.a)\n if self._.antipodal:\n try:\n self._.r = integralize(\n 1 + self._.b[m] / self._.c[self._.d - m])\n except TypeError:\n raise InfeasibleError(\"covering index not integral\")\n if self._.d >= 2:\n if self._.d == 2:\n b = [self._.b[0]/(self._.b[1]+1)]\n c = [Integer(1)]\n else:\n b = self._.b[:m]\n c = list(self._.c[1:m+1])\n if is_divisible(self._.d, 2):\n c[-1] *= self._.r\n scheme = self._get_class()(tuple(b), tuple(c))\n else:\n scheme = ASParameters(P=[[1]])\n self._.antipodal_subscheme = self.add_subscheme(scheme,\n self.ANTIPODAL)\n if self._.bipartite:\n if self._.d >= 2:\n b = tuple(self._.b[2*i]*self._.b[2*i+1]/self._.c[2]\n for i in range(m))\n c = tuple(self._.c[2*i+1]*self._.c[2*i+2]/self._.c[2]\n for i in range(m))\n scheme = self._get_class()(b, c)\n else:\n scheme = ASParameters(P=[[1]])\n self._.bipartite_subscheme = self.add_subscheme(scheme,\n self.BIPARTITE)","def solve(self):","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def _brute_force(self):\n if self.N > 9:\n #print(\"Input set is too big for brute force estimation.\")\n self.best_path = None\n else:\n #print(\"Number of permutations to check: {}\".format(math.factorial(self.N)))\n #init = \n A = self._P + np.finfo(np.float).eps\n A = (A + (1-A).T)/2\n for i in range(A.shape[0]):\n A[i,i] = np.finfo(np.float).eps\n init = (A>0.5).sum(axis=1).argsort()[::-1]\n #--- use log(p(Y=1\\mid s',s)) to shift multiplication to sum\n lP = np.log(A)\n for i in range(lP.shape[0]):\n lP[i,i] = 0\n #init_cost = 0\n ##--- lP[x:x+1] está MAL hay que sumar respecto a i+1 en z, no en lP.\n #for i in range(len(init)-1):\n # init_cost += lP[init[i],init[i+1]:].sum()\n z_star = []\n z_cost = -np.inf\n for z in permutations(range(self.N)):\n cost = 0\n for i in range(len(z)-1):\n cost += lP[z[i],z[i+1:]].sum()\n if cost > z_cost:\n z_cost = cost\n z_star = z\n self.best_path = np.array(z_star)","def _solver_dirty(X, R, coef_shared_, coef_specific_, Ls, alpha, beta,\n max_iter, tol, positive):\n n_tasks = len(X)\n n_samples, n_features = X[0].shape\n theta = coef_shared_ + coef_specific_\n alpha *= n_samples\n beta *= n_samples\n\n # dg = 1.\n for i in range(max_iter):\n w_max = 0.0\n d_w_max = 0.0\n for j in range(n_features):\n if Ls[j] == 0.:\n continue\n # compute residual\n grad = np.zeros(n_tasks)\n tmp1 = np.zeros(n_tasks)\n tmp2 = np.zeros(n_tasks)\n\n normtmp = 0.\n for t in range(n_tasks):\n for n in range(n_samples):\n grad[t] += X[t, n, j] * R[t, n]\n grad[t] /= Ls[j]\n tmp1[t] = grad[t] + coef_shared_[j, t]\n tmp2[t] = grad[t] + coef_specific_[j, t]\n\n normtmp += tmp1[t] ** 2\n\n normtmp = np.sqrt(normtmp)\n\n # l2 thresholding\n\n thresholdl2 = 0.\n if normtmp:\n thresholdl2 = max(1. - alpha / (Ls[j] * normtmp), 0.)\n tmp1 *= thresholdl2\n thresholdl1 = beta / Ls[j]\n tmp2 = np.sign(tmp2) * np.maximum(np.abs(tmp2) - thresholdl1, 0.)\n if positive:\n tmp2 = np.maximum(tmp2, 0.)\n tmp1 = np.maximum(tmp1, 0.)\n new_theta = tmp1 + tmp2\n if theta[j].any():\n for t in range(n_tasks):\n R[t] += X[t, :, j] * theta[j, t]\n\n d_w_j = np.abs(theta[j] - new_theta).max()\n d_w_max = max(d_w_max, d_w_j)\n w_max = max(w_max, np.abs(tmp1 + tmp2).max())\n coef_shared_[j] = tmp1\n coef_specific_[j] = tmp2\n theta[j] = new_theta\n\n if theta[j].any():\n for t in range(n_tasks):\n R[t] -= X[t, :, j] * theta[j, t]\n\n if (w_max == 0.0 or d_w_max / w_max < tol):\n break\n\n return coef_shared_, coef_specific_, R, i","def compute(self):\n\n self.setd = []\n self.satc = [False for cl in self.soft] # satisfied clauses\n self.solution = None\n self.bb_assumps = [] # backbone assumptions\n self.ss_assumps = [] # satisfied soft clause assumptions\n\n if self.oracle.solve():\n # hard part is satisfiable => there is a solution\n self._filter_satisfied(update_setd=True)\n self._compute()\n\n self.solution = list(map(lambda i: i + 1, filter(lambda i: not self.satc[i], range(len(self.soft)))))\n\n return self.solution","def cvxpy_solver(self, verbose=False):\n self.gamma = self._gamma_from_drawdown_control()\n\n objective = 0\n constr = []\n\n # weights variable depends on whether there is a risk-free asset in data\n if self.rf_included is True:\n # variable with shape h+1 predictions so first row\n # can be the known (non-variable) portfolio weight at time t\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets))\n else:\n # Set rf to zero in all preds and cov\n self.rets = np.insert(self.rets, self.n_assets, 0, axis=1)\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-2)\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-1) # Has to be done in two steps for cov due to dims\n self.start_weights = np.append(self.start_weights, 0)\n\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets+1))\n rf_zero_weights = np.zeros(shape=self.n_preds)\n constr += [weights[1:, -1] == 0] # Keep rf pos at zero since it non-present in this case\n\n\n # Loop through each row in the weights variable and construct the optimization problem\n # Note this loop is very cpu-light since no actual computations takes place inside it\n for t in range(1, weights.shape[0]):\n # sum problem objectives. Weights are shifted 1 period forward compared to self.rets\n # Concatenates objective and constraints in lists\n objective += self.single_period_objective_func(weights[t], weights[t-1], self.rets[t-1], self.cov[t-1])\n constr += self.single_period_constraints(weights[t]) # Concatenate constraints\n\n constr += [weights[0] == self.start_weights] # first weights are fixed at known current portfolio\n\n prob = cp.Problem(cp.Maximize(objective), constr) # Construct maximization problem\n prob.solve(solver=cp.ECOS, verbose=verbose)\n\n if self.rf_included is True:\n opt_var = weights.value\n else:\n opt_var = weights.value[:, :-1]\n\n if verbose is True:\n print(\"Shape of var: \", opt_var.shape)\n temp_df = pd.DataFrame(opt_var).round(3)\n temp_df['sum_weights'] = np.sum(opt_var, axis=1)\n print(temp_df)\n\n return opt_var[1:] # Discard first row which is not a variable.","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","def opt(self, demands: Demand) -> float:\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('multicommodity_flow_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the splitting ratios for each edge\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(self.num_edges):\n flow_variable_edges.append(\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Capacity constraint\n capacity_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint between 0 and edge capacity\n constraint_i = solver.Constraint(\n 0, self.graph.get_edge_data(*edge)['weight'],\n '(1,{},{})'.format(*edge))\n for j, commodity in enumerate(self.commodities):\n # Coefficient for jth flow over ith edge is scaled by flow width\n constraint_i.SetCoefficient(flow_variables[j][i],\n # cast because or-tools :'(\n float(demands[j]))\n capacity_constraints.append(constraint_i)\n\n # Conservation on transit nodes\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.num_nodes):\n if j != commodity[0] and j != commodity[1]:\n # Constraint must sum to zero\n constraint_j = solver.Constraint(0, 0,\n '(2,{},{})'.format(i, j))\n for k in list(sorted(self.graph.adj[j].keys())):\n # Ingress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\n # Egress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Conservation of flow at source node\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[0], edge_dest)]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[0])]],\n -1)\n conservation_source_constraints.append(constraint_i)\n\n # Conservation of flow at destination node\n conservation_dest_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[1])]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[1], edge_dest)]],\n -1)\n conservation_dest_constraints.append(constraint_i)\n\n ## OBJECTIVES\n # Implementation of the load-balancing example from Wikipedia\n # First we add more constraints so that we are minimising the maximum\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\n 'max_link_utilisation')\n min_of_max_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\n # i.e 'f_0 + f_1 + ... < max'\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\n '(5,{})'.format(i))\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\n for j, flow_variable in enumerate(flow_variables):\n constraint_i.SetCoefficient(flow_variable[i],\n demands[j] /\n self.graph.get_edge_data(*edge)[\n 'weight'])\n min_of_max_constraints.append(constraint_i)\n\n # Objective now is to minimise the maximum link utilisation\n objective = solver.Objective()\n objective.SetCoefficient(max_utilisation_variable, 1)\n objective.SetMinimization()\n solver.Solve()\n\n return objective.Value()","def solve_Q(ih, jh):\n # Build A and b\n\n # Solve for c via least squares.\n\n # Form C from c\n\n # Solve for Q and return it.\n return None","def _computeEquilibriumValue(self,cp,kdT,kdI,Cactiv0,Cinhib0,E0,X0,masks,observed=None,verbose=False):\n # We move from an array to a list of 2d-array for the competition over each template:\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 if verbose:\n print(\" input to python:\",X0,\" with cp: \",cp)\n for inpIdx in range(layer.shape[1]):\n # The first layer is a one to one non-linearity leading to an equation of the second order:\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\n x_eq = X0[inpIdx]\n else:\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0)\n if verbose:\n print(\"bOnA python\",bOnA)\n print(\"second part\",4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))\n x_eq = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))**0.5)\n # saving values\n layerEq[inpIdx] = x_eq\n olderX[layeridx] = layerEq\n\n else:\n for inpIdx in range(layer.shape[1]):\n\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]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),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]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n if verbose:\n print(\"numerateur: \",np.sum(CactivsOld*olderX[layeridx-1]), \" denominateur: \",np.sum(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n olderX[layeridx] = layerEq\n if verbose and layeridx==1:\n print(\"python second layer:\",layerEq)\n if verbose and layeridx==2:\n print(\"python third layer: \",layerEq)\n #Compute equilibrium for last layers:\n layerEq = np.zeros(masks[-1].shape[0])\n for outputIdx in range(masks[-1].shape[0]):\n\n CactivsOld = np.where(masks[-1][outputIdx,:]>0,Cactiv0[-1][outputIdx]/(1+self.k1M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\n CinhibsOld = np.where(masks[-1][outputIdx,:]<0,Cinhib0[-1][outputIdx]/(1+self.k3M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\n Inhib = np.sum(CinhibsOld*olderX[-1]/kdT[-1][outputIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[-1]/(kdI[-1][outputIdx]*cp+Inhib/cp))\n layerEq[outputIdx]=x_eq\n olderX = olderX + [layerEq]\n\n if observed is not None:\n try:\n assert len(observed)==2\n except:\n raise Exception(\"please provide a tuple of size two for observed indicating the value to use.\")\n return olderX[observed[0]][observed[1]]\n return olderX","def solve_VFI(self):\r\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \r\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\r\n tol = self.tol ; Niter = self.Niter ; R = self.R\r\n beta = self.beta ; Pi = self.Pi\r\n \r\n V0 = np.zeros((dimA,dimC,dimW))\r\n V1 = np.zeros((dimA,dimC,dimW))\r\n Pol = np.zeros((dimA,dimC,dimW))\r\n U = np.zeros((dimA,dimC,dimW))\r\n \r\n t0 = time()\r\n diff = 1 ; niter = 0\r\n \r\n while diff > tol:\r\n niter += 1\r\n # Value update step\r\n for ia in range(dimA):\r\n for ic in range(dimC):\r\n for iw in range(dimW):\r\n c = W[iw] + R*A[ia] - A\r\n x = C[ic]\r\n \r\n c[c < 0] = np.nan \r\n if x < 0:\r\n x = np.nan\r\n \r\n u = self.u(c,x) \r\n U[:,ic,iw] = u \r\n \r\n Objective = U + beta * V0 @ Pi.T\r\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\r\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\r\n \r\n # Evaluate distance between the value functions\r\n diff = np.max(np.max(np.abs(V1 - V0))) \r\n V0[:] = V1\r\n \r\n # Break the while loop if too many iterations\r\n #print(\"The current error is \"+str(diff))\r\n if niter > Niter:\r\n print('Ops, no convergence')\r\n break\r\n \r\n t1 = time()\r\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\r\n \r\n self.V1 = V1 ; self.Pol = Pol","def solve(num_wizards, num_constraints, wizards, constraints):\n print(\"starting time\")\n start = time.time()\n print(\"hello\")\n end = time.time()\n print(\"time taken\",end - start)\n random.shuffle(wizards)\n assignment = wizards\n loop_counter = 0\n temperature = 10.0\n while not numSat(constraints, assignment) == len(constraints):\n loop_counter += 1\n if loop_counter % 500 == 0:\n print(\"numSat\", numSat(constraints, assignment))\n print(\"loops\",loop_counter)\n print(\"time taken\", time.time()-start)\n a = random.sample([i for i in range(len(wizards))], 1)\n b = random.sample([i for i in range(len(wizards))], 1)\n new_assignment = swap(assignment, a[0], b[0])\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\n if delta < 0:\n print(\"delta negative\")\n assignment = new_assignment\n else: \n # print(\"sample greater than expo\")\n sample = random.uniform(0.0,1.0)\n expo = np.exp(-1*float(delta) / temperature)\n if sample < expo:\n # print(\"sample less than expo\")\n assignment = new_assignment\n temperature -= 0.2\n\n print(\"Solved BITCH! numSat:\", numSat(constraints, assignment))\n return assignment","def potentialSolver(self, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # solve potential\n for it in np.arange(1,max_it+1):\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n\n R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1])\n\n sum += R*R;\n\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n \n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def solve(self):\n\t\t# row and column to control the selected corner\n\t\tcurrent_positions = [0, 0]\n\t\tmax_row = self.result_index[self.__ROW_INDEX]-1\n\t\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\n\t\twhile self.matrix[max_row][max_col] != 0:\n\t\t\tcurrent_row = current_positions[self.__ROW_INDEX]\n\t\t\tcurrent_column = current_positions[self.__COLUMN_INDEX]\n\t\t\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\n\t\t\tactual_weight = self.matrix[current_row][current_column]\n\t\t\tactual_result_weight = multiplier_selected[1]\n\t\t\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\n\t\t\tself.matrix[max_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[current_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[max_row][current_column] -= actual_result_weight\n\t\t\tcurrent_positions[multiplier_selected[0]] += 1","def optimize(self):\n\n self.logger.info(\"Solving with Dynamic Slope Scaling Procedure in Julia :\")\n optimization_start = time.time()\n\n # 1. Preprocess for old network graph\n if self.old_network_graph is not None:\n\n # DSSP on old network\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\n try:\n self.check_infeasibility(self.old_network_graph, old_network_obj)\n except DHCOptimizerException as e:\n e.data = \"Invalid existing network: \" + e.data\n raise e\n\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\n\n if self.modify_old_network:\n\n # Add max capacity on old edges\n self.old_capacity = deepcopy(flows)\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\n for key in flows:\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\n\n # Add Imaginary edges\n for edge in self.old_capacity:\n if self.optimization_graph.has_edge(*edge):\n\n # add nodes\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\n # add edges\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\n\n # put cost\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n\n else:\n # if we don't modify the old network, we have to change the capacity of the supplies\n already_consummed = {}\n for edge in solution_old_graph.edges():\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\n for source in already_consummed:\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\n self.network_objective -= already_consummed[source]\n else:\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\n\n # Remove edges from old network\n edges_to_remove = set()\n for e in self.optimization_graph.edges():\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\n edges_to_remove.add(e)\n self.optimization_graph.remove_edges_from(edges_to_remove)\n\n # Remove isolated buildings of optimization graph\n isolated_to_remove = set()\n for e in self.old_network_graph.edges():\n if e[0] in self.old_network_graph.nodes() and \\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n isolated_to_remove.add(e)\n self.optimization_graph.remove_edges_from(isolated_to_remove)\n\n # Remove buildings from old network\n for n, data in self.old_network_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n self.optimization_graph.remove_node(n)\n\n # Re-link sources\n sources = set()\n for n, data in self.optimization_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n sources.add(n)\n source_graph = self.optimization_graph.subgraph(sources).copy()\n self.optimization_graph.remove_nodes_from(sources)\n gnx.remove_isolates(self.optimization_graph)\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\n\n # fill missing information\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\n for e in self.optimization_graph.edges(keys=True):\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\n\n\n\n # 2. Process the DSSP on optimization graph\n self.check_is_ready()\n self.check_infeasibility(self.optimization_graph, self.network_objective)\n\n if self.old_network_graph is not None and self.modify_old_network:\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\n else:\n old_buildings = set()\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\n\n # 3. Postprocess for old network graph\n if self.old_network_graph is not None:\n \n if self.modify_old_network:\n # Put the right supply capacity and cost\n for edge in self.old_capacity:\n if self.solution_graph.has_edge(edge[0],edge[1]):\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\n \n # Remove imaginary edges\n imaginary_nodes_to_remove = set()\n nodes_to_relabel = {}\n for edge in self.solution_graph.edges():\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\n if not self.solution_graph.has_edge(*real_edge):\n for i in range(2):\n nodes_to_relabel[edge[i]] = real_edge[i]\n else:\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\n imaginary_nodes_to_remove.add(edge[0])\n imaginary_nodes_to_remove.add(edge[1])\n elif str(edge[0]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[0])\n elif str(edge[1]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[1])\n\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\n for node in nodes_to_relabel.values():\n if self.solution_graph.has_edge(node, node):\n self.solution_graph.remove_edge(node, node)\n\n else:\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n\n return flows, obj_val","def sol_cost ( S, D, R ) :\n\tmask = array([0]* len(R))\n\tmask[R>0] = 1\n\tmaxerr = max(mask * abs(S - D))\n\tmeanerr = float(sum(mask * abs(S - D)))\n\tmeanerr /= sum(mask)\n\t\n\treturn (sum(R * (S - D)**2),maxerr,meanerr)","def CA_Algorithm(self, states, actions, rewards, next_states, terminals):\n states = states.reshape(-1, self.input_width)\n next_states = next_states.reshape(-1, self.input_width)\n update_rule = self.update_rule\n terminals = terminals.astype(np.float32)\n if (self.freeze_interval > 0 and\n self.update_counter % self.freeze_interval == 0):\n self.reset_q_hat()\n p_vals, next_p_vals = self.sess.run([self.p_vals, self.next_p_vals],{self.S: states, self.A: actions, self.R: rewards, self.S_: next_states, self.T: terminals})\n\n p_target = p_vals.copy()\n BestAct = np.argmax(np.sum(np.multiply(self.Z, next_p_vals),axis =2), axis = 1)\n terminals_false = np.ones_like(terminals)-terminals\n\n for batchIndex, r in enumerate(rewards):\n m = np.zeros(self.atoms)\n for j in range(self.atoms):\n Tau_z_j = np.clip(r + terminals_false[batchIndex][0]*self.discount * self.Z[j], self.Vmin, self.Vmax)\n b_j = float(Tau_z_j-self.Vmin)/self.delta_z\n l = math.floor(b_j)\n u = math.ceil(b_j)\n l_int = int(l)\n u_int = int(u)\n m[l_int] = m[l_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(u - b_j)\n m[u_int] = m[u_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(b_j - l)\n p_target[batchIndex,BestAct[batchIndex],:] = m\n\n _,loss = self.sess.run([self._train,self.loss], feed_dict={self.S: states, self.p_target: p_target})\n self.update_counter += 1\n return loss","def _cg_solve(self, x, data, iters, lambd, tol):\n b = np.zeros(\n (\n self.image_dim,\n self.image_dim\n ),\n self.DTYPE\n )\n Ax = np.zeros(\n (\n self.image_dim,\n self.image_dim\n ),\n self.DTYPE\n )\n\n b = self.operator_rhs(data)\n residual = b\n p = residual\n delta = np.linalg.norm(residual) ** 2 / np.linalg.norm(b) ** 2\n self.res.append(delta)\n print(\"Initial Residuum: \", delta)\n\n for i in range(iters):\n Ax = self.operator_lhs(p)\n Ax = Ax + lambd * p\n alpha = np.vdot(residual, residual)/(np.vdot(p, Ax))\n x[i + 1] = x[i] + alpha * p\n residual_new = residual - alpha * Ax\n delta = np.linalg.norm(residual_new) ** 2 / np.linalg.norm(b) ** 2\n self.res.append(delta)\n if delta < tol:\n print(\"\\nConverged after %i iterations to %1.3e.\" %\n (i+1, delta))\n x[0] = b\n return x[:i+1, ...]\n if not np.mod(i, 1):\n print(\"Residuum at iter %i : %1.3e\" % (i+1, delta), end='\\r')\n\n beta = (np.vdot(residual_new, residual_new) /\n np.vdot(residual, residual))\n p = residual_new + beta * p\n (residual, residual_new) = (residual_new, residual)\n x[0] = b\n return x","def rule(model, i, j):\n active = 1-self.task_spread[j]\n den = sum(triu[i, :])\n ind = model.timeslots\n # FIXME(cathywu) can/should be more precise with A,A2,A3 offsets\n total = sum(triu[i, k] * (\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\n k, j]) for k in ind)\n total /= den\n total *= active\n # CTu[i,j] = floor(total)\n return -1 + EPS, model.CTu[i, j] - total, EPS + self.slack_cont","def solve_cg_eps(self, params, r, sz, energy, aux):\n\n dp0_i, g2_i, itr, nsamples = aux\n\n jac = self.vmap_getder(params, r, sz, nsamples)\n #jac_T = conj_transpose(jac)\n\n f_i = jnp.real(-2 * psum(jnp.matmul(energy, jnp.conjugate(jac)), axis_name='p') / nsamples)\n g2_i = self.beta * g2_i + (1. - self.beta) * f_i**2\n g2h_i = jnp.sqrt(g2_i / (1. - self.beta**itr))\n\n# cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(v_i, jac_T), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\n cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(jnp.conjugate(jac), v_i), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\n\n dp_i, info = jax.scipy.sparse.linalg.cg(cg_mult, f_i, x0=dp0_i, tol=1e-5, atol=0.0, maxiter=200)\n return dp_i, g2_i","def fit(self):\n self._minuit_problem.migrad() # run optimizer\n self._status = 0 if self._minuit_problem.migrad_ok() else 1","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def run(self, C, p0 = None):\n global algorithm \n algorithm = AdaptiveMM(self.g, C, p0 = p0, lambda0 = 2000)\n solve()","def solve(self):\n is_valid = self.verify_sub_matrixes()\n \n if not is_valid:\n raise ValueError((\n \"El determinante es igual a cero \"\n \"el método no puede continuar\"\n ))\n \n (lower, upper) = self.doolittle_factorization()\n\n lower_solution_vector = lower.solve_matrix(matrix=None, vector=self.vector.vector)\n lower_solution_vector.print_vector()\n upper_solution_vector = upper.solve_matrix(\n matrix=None, vector=lower_solution_vector.vector)\n upper_solution_vector.print_vector()\n\n comprobation = self.matrix.comprobation(upper_solution_vector.vector)\n return comprobation","def equation(self):\n mat = np.zeros((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n rhs[0:self.nlayers - 1] = 0.0\n rhs[self.nlayers - 1] = self.Qc\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n head = e.potinflayers(self.xc, self.yc, self.layers) / self.aq.Tcol[self.layers, :]\n mat[0:self.nlayers - 1, ieq:ieq + e.nunknowns] = head[:-1] - head[1:]\n if e == self:\n for i in range(self.nlayers - 1):\n mat[i, ieq + i] -= self.resfac[i]\n mat[i, ieq + i + 1] += self.resfac[i + 1]\n mat[self.nlayers - 1, ieq:ieq + self.nlayers] = 1.0\n ieq += e.nunknowns\n else:\n head = e.potentiallayers(self.xc, self.yc, self.layers) / self.aq.T[self.layers]\n rhs[0:self.nlayers - 1] -= head[:-1] - head[1:]\n return mat, rhs","def evaluate_solution(self, chosen):\n self.candidate_counter += 1\n\n # evaluation function in abstract superclass\n \n solved_clauses = np.any(self.truth_clauses & np.array([chosen, ~chosen]), axis=(2, 1)) \n num_solved_clauses = np.sum(solved_clauses)\n # calculate evaluation with weight adaption heuristic\n evaluation = np.sum(solved_clauses * self.clause_weights)\n\n if self.candidate_counter == self.WEIGHT_ADAPTION_DURATION:\n # increase weights for unsatisfied clauses\n self.clause_weights += ~solved_clauses\n self.candidate_counter = 0\n\n return evaluation, num_solved_clauses","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fp_tn = tn + fp\n tp_fn = fn + tp\n tn_fn = tn + fn\n tp_fp = fp + tp\n nis = tn_fn * tn_fn + tp_fp * tp_fp\n njs = fp_tn * fp_tn + tp_fn * tp_fn\n sum_of_squares = tp * tp + tn * tn + fp * fp + fn * fn\n\n a = (tp * (tp - 1) + fp * (fp - 1) + tn * (tn - 1) + fn * (fn - 1)) / 2.\n b = (njs - sum_of_squares) / 2.\n c = (nis - sum_of_squares) / 2.\n d = (n * n + sum_of_squares - nis - njs) / 2.\n\n x1 = a - ((a + c) * (a + b) / (a + b + c + d))\n x2 = ((a + c) + (a + b)) / 2.\n x3 = ((a + c) * (a + b)) / (a + b + c + d)\n denominator = x2 - x3\n\n if denominator != 0:\n return x1 / denominator\n else:\n return 0","def SolveSCP(self):\n\n t0 = time()\n\n # Some predicates\n Lu_min = 0.\n niters_max = self._maxiters\n maxfracchange = self._maxfracchange\n\n # initialization, resetting ...\n self.reset_all() # including _u_naught(), first application\n scp_min = self.greedy()\n\n # re-initialization iteration; col fixing ignored for the moment\n niters = 0\n f_change = _largenumber\n while (f_change>maxfracchange) and (niters<niters_max):\n # re-initialize u\n if (np.mod(niters, 2)==0): \n self.reset_u(random=True)\n else:\n self.reset_u()\n u_tmp, Lu_tmp = self.subgradient() # find a near-optimal solution \n u, Lu = self.subgradient() # rerun subgradient to get a set of Lagrangian multipliers\n\n scp_all = np.zeros(self._subg_nsteps)\n for i in np.arange(self._subg_nsteps):\n #self.reset_s()\n self.s = np.copy(self.f)\n scp_all[i] = self.greedy(u=u[:,i])\n\n # check if the solution is gettting better\n imin_tmp = (np.where(scp_all==np.amin(scp_all)))[0]\n imin = imin_tmp[np.argmax(Lu[imin_tmp])]\n imax = np.argmax(Lu)\n if (np.mod(niters, 5)==0):\n print(\"This Best solution: UB={0}, LB={1}, UB1={2}, LB1={3}\".format(scp_all[imin], Lu[imin], scp_all[imax], Lu[imax]))\n if (niters==0) or ((scp_all[imin]<=scp_min) and ((Lu[imin]-Lu_min)>-(np.fabs(Lu_min)*self._LB_maxfracchange))):\n scp_min = scp_all[imin]\n u_min = np.copy(u[:,imin])\n Lu_min = Lu[imin]\n self.stepsize = _stepsize\n\n LB = Lu_min\n\n # final step, needs to get u_min back\n self.u = np.copy(u_min)\n self.s = np.copy(self.f)\n UB = self.greedy()\n\n # Which is better? absolute change or fractional change? \n # Both are fine, but cost should be normalized over the mean/median.\n GAP = (UB-LB)/np.fabs(UB)\n f_change = GAP\n if (np.mod(niters, 5)==0):\n print(\"Current Best Solution: UB={0}, LB={1}, change={2}% @ niters={3}\".format(UB,LB,f_change*100.,niters))\n niters = niters + 1\n if (niters == niters_max): \n #warnings.warn(\"Iteration reaches maximum = {0}\".format(niters))\n print(\"Iteration in re-initialization reaches maximum number = {0}\".format(niters))\n\n # Need to remove redundant columns\n # self.remove_redundant() # this itself is NP-hard ...\n\n print(\"Current Best Solution: UB={0}, LB={1}, change={2}% @ niters={3}\".format(UB,LB,f_change*100.,niters))\n print(\"Final Best solution: {0}\".format(UB))\n time_used = (time()-t0)/60.\n print(\"Took {0:.3f} minutes to reach current solution.\".format(time_used))\n\n return (UB,time_used)","def _compute_correction(self, initial_state, final_state, a, b, c, s):\r\n pertub = self.pertub\r\n pertub_s = pertub *10\r\n \r\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\r\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\r\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\r\n # no need to correct C, C is constrained by kappa_final\r\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\r\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\r\n\r\n d_state = np.zeros((3,1))\r\n d_pertub_state = np.zeros((3,3))\r\n Jacobian = np.zeros((3,3))\r\n for i in range(0, 3):\r\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\r\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\r\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\r\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\r\n \r\n d_state[i] = final_state[i] - pred_no_pertub[i]\r\n \r\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\r\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\r\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\r\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\r\n\r\n # inv_Jacobian = np.linalg.inv(Jacobian)\r\n inv_Jacobian = np.linalg.pinv(Jacobian)\r\n correction = np.dot(inv_Jacobian, d_state)\r\n # pdb.set_trace()\r\n return correction","def solve_model(self): \n \n t0 = time.time() #start the clock\n \n # a. benchmark case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(1)\n \n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(self.tau_benchmark) #set tax system\n \n #iii. benchmark equilibrium\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Benchmark Stationary Equilibrium\")\n print(\"-----------------------------------------\")\n print(f\"ss output = {self.Yss_b:.2f}\")\n print(f\"ss capital = {self.Kss_b:.2f}\")\n print(f\"ss tfp = {self.TFPss_b:.2f}\")\n print(f\"ss wage = {self.w_ss_b:.2f}\")\n print(f\"entry mass = {self.E_star_b:.3f}\")\n print(f\"avg. firm size = {self.average_firm_size_b:.2f}\")\n \n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\n \n if self.plott:\n #i. initialize\n employed = [4.99, 49.99]\n firm_size_by_employee = np.zeros(len(employed)+1)\n share_employment = np.zeros(len(employed)+1)\n \n \n #i. percentage of firms that employ employed\n \n for i_e in range(len(employed)):\n summ = np.sum(firm_size_by_employee)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\n firm_size_by_employee[i_e] = interpolate - summ\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\n \n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Size of Firms by Firm Size (Number of Employees)')\n plt.savefig('firm_size_rr08.pdf')\n plt.show()\n \n \n #ii. employment percentage by firm size\n for i_e in range(len(employed)):\n summ = np.sum(share_employment)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\n share_employment[i_e] = interpolate - summ\n share_employment[-1] = 1 - np.sum(share_employment)\n \n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Employment Share by Firm Size (Number of Employees)')\n plt.savefig('employment_by_firm_size_rr08.pdf')\n plt.show()\n \n #iii. productivity cdf and employment cdf\n plt.plot(self.grid_s, self.cdf_stationary_b)\n plt.plot(self.grid_s, self.cdf_emp_b)\n plt.title('Stationary CDF' )\n plt.xlabel('Productivity level')\n plt.ylabel('Cumulative Sum')\n plt.legend(['Firms by Productivity Level','Share of Employment'])\n plt.savefig('cdf_rr08.pdf')\n plt.show()\n \n \n \n #c. distortion case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(0)\n \n #ii. compute stationary economy for each tau\n \n for idx, tau in enumerate(self.tau_vector):\n \n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\n self.tau_s[idx] = self.find_subsidy_rate(tau)\n \n # set tax system with newly found tau_s and given tau\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv) #set tax system\n \n #v. distorted stationary equilibrium\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\n _, _ = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Distorted Stationary Equilibrium\")\n print(\"-----------------------------------------\\n\")\n if self.distortion_case == 1:\n print(\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\")\n print(\"(low productivity firms recieve subsidy, high productivity taxed)\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Positively Correlated with Firm Level Producitivity\")\n print(\"(high productivity firms recieve subsidy, low productivity taxed)\\n\")\n if self.policy_type == 1 :\n print(\"Tax Type: Tax on output\\n\")\n elif self.policy_type == 2 :\n print(\"Tax Type: Tax on capital\\n\")\n elif self.policy_type == 3 :\n print(\"Tax Type: Tax on labor\\n\")\n print(f\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\")\n print(f\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\")\n print(f\"fraction of firms excempt = {self.excempt_frac:.2f}\")\n print(\"-----------------------------------------\\n\")\n \n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\n [], \n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \"Tax = \"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\n \n\n t1 = time.time()\n print(f'\\nTotal Run Time: {t1-t0:.2f} seconds')","def solver(I, f, c, bc, Lx, Ly, nx, ny, dt, tstop,\n user_action=None, \n implementation={'ic': 'vec', # or 'scalar' or 'weave'\n 'inner': 'vec',\n 'bc': 'vec',\n 'storage': 'f77'},\n verbose=True):\n dx = Lx/float(nx)\n dy = Ly/float(ny)\n x = linspace(0, Lx, nx+1) # grid points in x dir\n y = linspace(0, Ly, ny+1) # grid points in y dir\n xv = x[:,newaxis] # for vectorized function evaluations\n yv = y[newaxis,:]\n\n if dt <= 0: # max time step?\n dt = (1/float(c))*(1/sqrt(1/dx**2 + 1/dy**2))\n Cx = c*dt/dx**2; Cy = c*dt/dy**2 # help variables\n\n up = zeros((nx+1,ny+1)) # solution array\n u = up.copy() # solution at t-dt\n\n # use scalar implementation mode if no info from user:\n if 'ic' not in implementation:\n implementation['ic'] = 'scalar'\n if 'bc' not in implementation:\n implementation['bc'] = 'scalar'\n if 'inner' not in implementation:\n implementation['inner'] = 'scalar'\n\n if 'weave' in implementation.itervalues() or \\\n 'f77' in implementation.itervalues():\n # we avoid callback to Python and require f, bc, and I to be\n # string formulas:\n print f, bc, I\n if not isinstance(f, StringFunction) or \\\n not isinstance(bc, StringFunction) or \\\n not isinstance(I, StringFunction):\n raise TypeError, \\\n 'with Weave or F77, f, bc, and I must be StringFunction'\n\n if 'f77' in implementation.itervalues():\n make_f77(f, bc, I) # build F77 module\n import f77\n # unified names with py versions:\n ic_f77 = f77.ic_f77\n bc_f77 = f77.bc_f77\n scheme_f77 = f77.scheme_f77\n \n # turn arrays to column major storage after the init. cond.\n\n # set initial condition:\n t0 = time.clock()\n t = 0.0\n print '***', implementation['ic']\n func = 'ic_'+implementation['ic']\n if func == 'ic_vec':\n u = eval(func)(u, I, xv, yv)\n elif func == 'ic_f77':\n u = eval(func)(u, x, y)\n else:\n u = eval(func)(u, I, x, y)\n t_ic = time.clock() - t0\n \n\n if implementation['inner'] == 'f77':\n # turn input arrays to Fortran storage for all arrays\n # that are input arrays in loop subroutine\n # (actually not necessary as up, u, and um are all fed\n # through the f77.loop routine and brought to column\n # major storage in turn - recall um=u, u=up, up=um)\n if implementation.get('storage', 'f77') == 'f77':\n up = asarray(up, order='Fortran')\n u = asarray(u, order='Fortran')\n\n if user_action is not None:\n user_action(u, xv, yv, t) # allow user to plot etc.\n\n t_inner = 0 # CPU time inner loops\n t_bc = 0 # CPU time boundary update\n \n while t <= tstop:\n t_old = t; t += dt\n if verbose:\n print 'solving (%s version) at t=%g' % \\\n (implementation['inner'], t)\n\n t0 = time.clock()\n # update all inner points:\n func = 'scheme_'+implementation['inner']\n if func == 'scheme_vec':\n up = eval(func)(up, u, um, f, xv, yv, t, Cx, Cy, dt2, t_old)\n elif func == 'scheme_f77':\n up = eval(func)(up, u, um, x, y, t, Cx, Cy, dt2, t_old)\n else:\n up = eval(func)(up, u, um, f, x, y, t, Cx, Cy, dt2, t_old)\n\n #id_u = id(u); id_um = id(um)\n #up,u,um = f77.loop(up, u, um, f_array, Cx, Cy, dt2)\n #print 'u changed:', id_u!=id(u),\n #print 'um changed:', id_um!=id(um),\n t_inner += time.clock() - t0\n\n t0 = time.clock()\n # insert boundary conditions:\n func = 'bc_'+implementation['bc']\n if func == 'bc_f77':\n up = eval(func)(up, x, y, t)\n else:\n up = eval(func)(up, bc, x, y, t)\n t_bc += time.clock() - t0\n \n if user_action is not None:\n user_action(up, xv, yv, t)\n # update data structures for next step:\n u, up = u, up\n\n # dt might be computed in this function\n return dt, t_ic, t_inner, t_bc","def alg(c):\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]","def get_sol(self):","def cost(comb,X_ica,X_real):\n X_ica_fit = np.zeros(X_ica.shape)\n for i in range(X_real.shape[0]):\n X_ica_fit[int(i)] = X_ica[int(comb[i])]\n\n return mean_squared_error(X_ica_fit, X_real)","def __solve_alternative_linear_problem(self, user):\n result = [0] * self.layout_slots\n de_rand_approach = \"greedy\"\n bins_per_category = []\n bins_cardinality = []\n for _ in range(len(self.categories)):\n bins_per_category.append([])\n bins_cardinality.append([])\n\n for cat in range(len(self.categories)):\n for _ in range(len(self.news_row_pivots) + 1):\n bins_per_category[cat].append([])\n bins_cardinality[cat].append([])\n for _ in range(len(self.news_column_pivots) + 1):\n bins_per_category[cat][-1].append([])\n bins_cardinality[cat][-1].append(0)\n\n for news in self.news_pool:\n category_index = self.categories.index(news.news_category)\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\n bins_per_category[category_index][x][y].append(news)\n bins_cardinality[category_index][x][y] += 1\n\n index = 0\n bin_samples = []\n for cat in range(len(self.categories)):\n for x in range(len(self.news_row_pivots) + 1):\n for y in range(len(self.news_column_pivots) + 1):\n if (y == 0) and (x != 0):\n continue\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\n index += 1\n try:\n selected_news = np.random.choice(bins_per_category[cat][x][y])\n self.sample_quality(selected_news, user, interest_decay=True)\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\n except ValueError:\n bin_samples += [0] * self.layout_slots\n\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\n\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\n slots_assegnation_probabilities = []\n slot_counter = 0\n tmp_slot_probabilities = []\n while slot_counter < self.layout_slots:\n i = slot_counter\n while i < len(linear_problem.x):\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\n i += self.layout_slots\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\n tmp_slot_probabilities.clear()\n slot_counter += 1\n\n slot_promenances = self.real_slot_promenances.copy()\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\n slots_nr = [s for s in range(0, self.layout_slots)]\n for i in range(self.layout_slots):\n if de_rand_approach == \"ordered\":\n k = i\n elif (de_rand_approach == \"greedy\") or (de_rand_approach == \"greedy_max\"):\n k = np.argmax(slot_promenances)\n slot_promenances[k] = 0\n elif de_rand_approach == \"randomized\":\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\n slot_promenances[k] = 0\n else:\n raise RuntimeError(\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \"\n \"'randomized' or 'greedy_max'.\")\n\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\n if de_rand_approach == \"greedy_max\":\n assigning_bin_index = np.argmax(target_slot_probabilities)\n cat_index = int(assigning_bin_index / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin_index)][0]\n y = self.bins_for_position[int(assigning_bin_index)][1]\n\n else:\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\n cat_index = int(assigning_bin / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin)][0]\n y = self.bins_for_position[int(assigning_bin)][1]\n\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\n\n return result","def _compute_results(self):\n self.Y_best = best_value(self.Y)\n self.x_opt = self.X[np.argmin(self.Y),:]\n self.fx_opt = np.min(self.Y)\n self.distance = self._compute_distance_betw_consecutive_x()","def main_function(self):\n self.ana_cont_probl = cont.AnalyticContinuationProblem(im_axis=self.input_data.mats,\n im_data=self.input_data.value.real,\n re_axis=self.realgrid.grid,\n kernel_mode='freq_bosonic')\n model = np.ones_like(self.realgrid.grid)\n model /= np.trapz(model, self.realgrid.grid)\n\n preblur, bw = self.get_preblur()\n\n sol = self.ana_cont_probl.solve(method='maxent_svd',\n optimizer='newton',\n alpha_determination='chi2kink',\n model=model,\n stdev=self.input_data.error,\n interactive=False, alpha_start=1e10, alpha_end=1e-3,\n preblur=preblur, blur_width=bw)\n\n inp_str = 'atom {}, orb {}, spin {}, blur {}: '.format(self.input_data.atom,\n self.input_data.orbital,\n self.input_data.spin,\n bw)\n all_chis = np.isfinite(np.array([s.chi2 for s in sol[1]]))\n res_str = 'alpha_opt={:3.2f}, chi2(alpha_opt)={:3.2f}, min(chi2)={:3.2f}'.format(\n sol[0].alpha, sol[0].chi2, np.amin(all_chis)\n )\n self.text_output.append(inp_str + res_str)\n alphas = [s.alpha for s in sol[1]]\n chis = [s.chi2 for s in sol[1]]\n\n self.output_data.update(self.realgrid.grid, sol[0].A_opt, self.input_data)\n\n fig, ax = plt.subplots(ncols=2, nrows=2, figsize=(11.75, 8.25)) # A4 paper size\n ax[0, 0].loglog(alphas, chis, marker='s', color='black')\n ax[0, 0].loglog(sol[0].alpha, sol[0].chi2, marker='*', color='red', markersize=15)\n ax[0, 0].set_xlabel(r'$\\alpha$')\n ax[0, 0].set_ylabel(r'$\\chi^2(\\alpha)$')\n\n ax[1, 0].plot(self.realgrid.grid, sol[0].A_opt)\n ax[1, 0].set_xlabel(r'$\\omega$')\n ax[1, 0].set_ylabel('spectrum')\n\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.real,\n color='blue', ls=':', marker='x', markersize=5,\n label='Re[data]')\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.imag,\n color='green', ls=':', marker='+', markersize=5,\n label='Im[data]')\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.real,\n ls='--', color='gray', label='Re[fit]')\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.imag,\n color='gray', label='Im[fit]')\n ax[0, 1].set_xlabel(r'$\\nu_n$')\n ax[0, 1].set_ylabel(self.input_data.data_type)\n ax[0, 1].legend()\n\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).real,\n ls='--', label='real part')\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).imag,\n label='imaginary part')\n ax[1, 1].set_xlabel(r'$\\nu_n$')\n ax[1, 1].set_ylabel('data $-$ fit')\n ax[1, 1].legend()\n plt.tight_layout()\n plt.show()","def rule(model, i, j):\n active = 1-self.task_spread[j]\n den = sum(tril[i, :])\n ind = model.timeslots\n total = sum(tril[i, k] * (\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\n k, j]) for k in ind)\n total /= den\n total *= active\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont","def potentialSolver2(self, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has dimensions:\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\n coverage = np.hstack(i for i in self.coverage_matrices)\n print coverage\n print coverage.shape \n \n #Diagonal matrix of the values of each target\n #(for the scenarios where we don't care about maximizing covered value,\n #target_values is just all ones, so this is just the identity matrix)\n V = np.diag(self.target_values)\n \n #If doing scenario where we want to fortify weakest link, only makes\n #sense if all targets are equal value:\n if self.objective_type == 'min_entries':\n V = np.eye(len(self.target_values))\n\n #Get the matrix of coverage values / expected value saved:\n C = np.dot(V,coverage)\n print 'V', V\n print 'coverage', coverage\n print 'C', C\n \n \n #Since not gauranteed to reach global optimum on any particular initialization,\n #run a few times and take the best result.\n #Just define \"best result\" as the result which had the most overall \n #\"converged\" x, combined over all tower kinds. \n# for j in xrange(self.N_random_starts_max):\n \n \n a = 2. #1.\n tau = 1e-4\n N = sum(i for i in self.N_tower_sites)\n w = np.zeros(N)\n ones = np.ones(N)\n p = 1. #the exponents power when doing he exponent method:\n \n for i in xrange(self.N_reweighting_iterations_max):\n #The concatenated vector of occupancies: Concatenated over all\n #of the kinds of towers.\n x = cvx.Variable(N)\n \n #Different objective functions depending on which optimization problem.\n #These are defined in the scenarios in the main function.\n if self.objective_type == 'min_entries':\n operation = cvx.min_entries\n elif self.objective_type == 'sum_entries':\n operation = cvx.sum_entries\n else:\n raise Exception('must specify valid objective_type')\n \n #Objective function includes penalty term for non-binary x values\n if self.penalty_type == 'reweighted_L1':\n #objective = cvx.Maximize(t - x.T*w)\n objective = cvx.Maximize(operation(C*x - x.T*w))\n\n\n #Main constraints on 0<=x<=1\n constraints = [0<=x, x<=1]\n \n \n #And then for each kind of tower, append the constraint that there\n #be exactly N_i towers, or <= quota (depending on constraint type)\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n print before_sum\n print before_sum + self.N_tower_sites[tk]\n if self.constraints__type == 'fixed_N_towers':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )==self.N_towers[tk])\n elif self.constraints__type == 'tower_quotas':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )<=self.budget__tower_quotas[tk])\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\n \n elif self.constraints__type == 'total_cost':\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \n \n \n \n\n\n \n \n print 'penalty_type', self.penalty_type\n print 'objective_type', self.objective_type\n print 'constraints__type', self.constraints__type\n print 'budget__tower_quotas', self.budget__tower_quotas\n print 'operation', operation\n print 'objective', objective\n print 'constraints', constraints\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\n x = np.array(x.value).flatten()\n print 'x', x\n w = a/(tau+np.abs(x))\n p += 1.\n plt.figure(figsize=(5,5))\n plt.plot(x,marker='o')\n plt.savefig('histrograms_{}.png'.format(i))\n print \n \n \n \n \n #From the solution x, get the coordinates of those tower sites where we\n #really do want to place a tower\n #use = np.isclose(x,1.)\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\n inds = np.argsort(y)\n s = y[inds]\n use = np.where(s>.5)[0]\n print inds\n print s\n print use \n if self.constraints__type == 'fixed_N_towers':\n if len(use) != self.N_towers[tk]:\n print 'Solution did not converge properly. Choosing the K best towers.'\n print self.N_towers[tk], len(use)\n # use = use[-self.N_towers[tk]:]\n use = inds[-self.N_towers[tk]:]\n elif self.constraints__type == 'tower_quotas':\n pass #Just use the towers thresholded at > .5\n print use\n \n \n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])","def fit(self):\n if self.cost_func.hessian:\n self._popt = ral_nlls.solve(self.initial_params,\n self.cost_func.eval_r,\n self.cost_func.jac_res,\n self.hes_eval,\n options=self._options,\n lower_bounds=self.param_ranges[0],\n upper_bounds=self.param_ranges[1])[0]\n else:\n self._popt = ral_nlls.solve(self.initial_params,\n self.cost_func.eval_r,\n self.cost_func.jac_res,\n options=self._options,\n lower_bounds=self.param_ranges[0],\n upper_bounds=self.param_ranges[1])[0]\n self._status = 0 if self._popt is not None else 1","def compute_cost(AL, Y):\n pass","def compute_cost(self, del_u : list, u : list):\n print(\"ym: \", self.ym, \"yn: \", self.yn)\n self.cost = 0.0\n\n self.ym = self.d_model.ym\n self.yn = self.d_model.yn\n\n # FIXME : this is supposed to be from N1 to N2\n self.cost+= (self.ym[0] - self.yn[0])\n angle_diff = (self.ym[1] - self.yn[1])\n if angle_diff > np.pi:\n angle_diff -= 2*np.pi\n if angle_diff < -np.pi:\n angle_diff += 2*np.pi\n self.cost += angle_diff\n\n for j in range(self.Nu):\n self.cost += (self.ym[j] - self.yn[j])**2\n\n for j in range(self.Nu):\n self.cost += self.lambd[j]*(del_u[j])**2\n\n for j in range(self.Nu):\n self.cost += self.s / (u[j] + self.r / 2.0 - self.b) + self.s / (self.r/2.0 + self.b - u[j]) - 4.0 / self.r\n\n return self.cost","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \n bc_surface, sigma):\n\n # temperatures are reported as a data frame, where each column is a step in time\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\n\n # extract the necessary parameters to determine the surface heat losses\n if bc_surface[0] == \"linear\":\n h = bc_surface[1] + bc_surface[2]\n hc = 0\n emissivity = 0\n elif bc_surface[0] == \"non-linear\":\n h = 0\n hc = bc_surface[1]\n emissivity = bc_surface[2]\n\n # initialize temperature arrays for present and future temperatures\n T = np.zeros_like(x_grid) + temp_initial\n Tn = np.zeros_like(x_grid)\n\n # iterate over each time step\n temperatures.iloc[:,0] = T\n for j, t in enumerate(t_grid[:-1]):\n \n # create tri-diagonal matrix A\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\n \n # create vector b\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \n emissivity = emissivity, sigma = sigma, j = j)\n \n # calculate value of future temperature\n Tn = np.linalg.solve(A,b)\n \n # update present temperature\n T = Tn.copy()\n \n # store temperature profile at this time in the data frame\n temperatures.iloc[:, j+1] = Tn\n \n return temperatures","def rwgraph_analyze2(input=(None)):\r\n\r\n\r\n #set up graph and degree distribution arrays\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n Nt=100\r\n M=20000\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n\r\n #set inital conditions and D\r\n y0=np.zeros(n,dtype=int)\r\n y0[j]=200\r\n D=1\r\n #define time for odi Int\r\n t=np.arange(Nt+1,dtype=int)\r\n #set up operators\r\n A = nx.adjacency_matrix(G)\r\n Q = A.toarray().sum(axis=1)\r\n L=np.diag(Q)-A.toarray()\r\n Q_inv=1/Q\r\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\r\n Ls_tran=np.transpose(Ls)\r\n\r\n #convert to sparse operators and include diffusion\r\n L_spar = scipy.sparse.csr_matrix(-D*L)\r\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\r\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\r\n A=nx.adjacency_matrix(G)\r\n L=-D*(scipy.sparse.diags(degree_arr)-A)\r\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\r\n\r\n #define operators\r\n def Lap(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\r\n def Lap_Ls(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\r\n def Lap_Ls_tran(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\r\n\r\n #solutions of different operators\r\n solL=scipy.integrate.odeint(Lap,y0,t)\r\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\r\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\r\n\r\n\r\n #finds eigen values and vectors and puts them into order\r\n def eigen(L):\r\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\r\n idx = eigen_values.argsort()[::-1]\r\n eigen_values = eigen_values[idx]\r\n eigen_vectors = eigen_vectors[:,idx]\r\n return eigen_values,eigen_vectors\r\n\r\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\r\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\r\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\r\n eigen_values_L,eigen_vectors_L=eigen(L)\r\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\r\n\r\n ### could have eigs here as didn't end up using all eigenvalues ####\r\n #eigen values graph\r\n n0=len(eigen_values_L)\r\n eig_nums=np.arange(n0)\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\"x\" ,label='L , D=0.36')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\"|\",label='LS , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\"+\" ,label='L , D=1')\r\n plt.legend(loc=\"lower left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.xlabel('eigen value number')\r\n plt.ylabel('eigenvalue')\r\n plt.title(\"Eigenvlaues of Laplacian Matrixs\")\r\n plt.show()\r\n\r\n print(\"4 biggest eigenvalues for each operater\")\r\n print('L=',eigen_values_L[0:4])\r\n print('Ls=',eigen_values_LS[0:4])\r\n print('Ls_tran=',eigen_values_LS_tran[0:4])\r\n #prints 4 biggest eigen values\r\n #counts node distrubtion by creating dictionary\r\n def result_count(sol,Nt,G):\r\n \"\"\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\"\"\"\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq\r\n\r\n #frequency count of solutions\r\n dict_freq=result_count(solL,Nt,G)\r\n dict_freq2=result_count(solLs,Nt,G)\r\n dict_freq3=result_count(solLs_tran,Nt,G)\r\n\r\n #random walk data\r\n X=rwgraph(G,j,20000,100)\r\n Listnodes7=[]\r\n for i in range(20000):\r\n Listnodes7.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,200,100)\r\n Listnodes8=[]\r\n for i in range(200):\r\n Listnodes8.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,50000,5000)\r\n Listnodes9=[]\r\n for i in range(50000):\r\n Listnodes9.append(G.degree(X[i,5000]))\r\n listfreq7=CountFrequency(Listnodes7)\r\n listfreq8=CountFrequency(Listnodes8)\r\n listfreq9=CountFrequency(Listnodes9)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n z2=[]\r\n z3=[]\r\n z1=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n z_deg1=[]\r\n for i in listfreq7:\r\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq8:\r\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n for i in listfreq8:\r\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\r\n z_deg1.append(i)\r\n #operator solutions compared to node degree frequency\r\n z4,z5,z6=[],[],[]\r\n z_deg4,z_deg5,z_deg6=[],[],[]\r\n for i in dict_freq:\r\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\r\n z_deg4.append(i)\r\n for i in dict_freq2:\r\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\r\n z_deg5.append(i)\r\n for i in dict_freq3:\r\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\r\n z_deg6.append(i)\r\n\r\n plt.figure(figsize=(15, 10))\r\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\r\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\r\n plt.scatter(z_deg4, z4,label='L, Nt=100')\r\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\r\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\r\n plt.ylim((-0.005,0.020))\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n\r\n #code to produce final graph\r\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\r\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\r\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\r\n tarray = np.linspace(0,5,Nt+1)\r\n plt.figure(figsize=(12, 6))\r\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\r\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\r\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\r\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\r\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\r\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\r\n plt.xlabel('time')\r\n plt.ylabel('representive frequency')\r\n plt.legend()\r\n plt.title(\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\")\r\n plt.show()\r\n return None #modify as needed\r","def solve(self):\n\n if self.degree > 2:\n return \"The polynomial degree is strictly greater than 2, I can't solve.\"\n \n elif self.degree == 0:\n \"\"\"a * X^0 = 0\"\"\" \n a = self.all_terms[0].coefficient\n if a != 0:\n return \"The eqution has no solution\"\n else:\n return \"Every real number is a solution\"\n\n elif self.degree == 1:\n \"\"\"a * X^1 + b * X^0 = 0\"\"\"\n a = self.all_terms[1].coefficient\n b = self.all_terms[0].coefficient\n return formula.linear(a, b)\n\n elif self.degree == 2:\n \"\"\"a * X^2 + b * X^1 + c * X^0 = 0\"\"\"\n a = self.all_terms[2].coefficient\n b = self.all_terms[1].coefficient\n c = self.all_terms[0].coefficient\n discriminant = (b ** 2) - (4 * a * c)\n two_a = 2 * a\n if discriminant == 0:\n return formula.linear(two_a, b)\n else:\n if discriminant > 0:\n return formula.quadratic(two_a, b, discriminant)\n else:\n return formula.quadratic(two_a, b, discriminant, simple=False)","def __call__(self, p, q, verbosity=1, warn=True):\n if self.exactly_zero: return 0.0 # shortcut for trivial case\n if self.weight == 0:\n return _np.sum(_np.abs(q - p)) / 2\n\n #Set parameter values\n self.P.value[:] = p[:]\n self.Q.value[:] = q[:]\n\n treg_factor_ok = False\n self.Treg_factor.value = self.initial_treg_factor\n while not treg_factor_ok:\n\n obj1 = self._obj(self.t_params)\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\n **default_cvxpy_args(self.solver))\n\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed: # sanity check\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\n\n self.warning_msg = None\n if failed:\n if self.solver == \"SCS\":\n #raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed:\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\n\n if eps > 1e-4:\n self.warning_msg = (\"ResidualTVD: Needed to increase eps to %g.\"\n \" The resulting ResidualTVD values are less precise.\") % eps\n if warn: print(self.warning_msg)\n break\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n\n #check that Treg_factor term doesn't dominate\n\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\n treg_factor_ok = True\n\n # ------------------------------------------------------------------\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\n # ------------------------------------------------------------------\n\n #resid_tvd = self._obj(self.T_params.value)\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\n # Treg_factor_ok = True\n #else:\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\n\n #obj2 = self._obj(self.T_params.value)\n #if obj2 < obj1:\n # Treg_factor_ok = True\n #else:\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\n # self.T_params.value[:] = self.t_params[:] #REVERT\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\n # self.Treg_factor.value = self.Treg_factor.value / 10\n # if self.Treg_factor.value > 1e-7:\n # print(\"REDUCING treg factor to: \", self.Treg_factor.value)\n # else:\n # Treg_factor_ok = True # give up!\n\n if self.Treg_factor.value != self.initial_treg_factor:\n if verbosity > 0: print(\"NOTE: Treg_factor was reduced to %g.\" % self.Treg_factor.value)\n #_warnings.warn((\"Initial Treg_factor (%g) was too large, and was reduced to %g.\"\n # \" Consider reducing the initial value to avoid repeating calculations.\")\n # % (self.initial_treg_factor, self.Treg_factor.value))\n\n obj2 = self._obj(self.T_params.value)\n if obj2 <= obj1:\n self.t_params[:] = self.T_params.value[:]\n else:\n print_revert_msg(\"ResidualTVD failed to reduce objective function (%g > %g)\", (obj2, obj1), verbosity)\n self.T_params.value[:] = self.t_params[:]\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\n\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def potentialSolver4(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def _cpEquilibriumFunc(self,cp,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n new_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\n for inpIdx in range(layer.shape[1]):\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\n #case where there is no polynomial equation\n new_input = X0[inpIdx]\n new_cp += 0\n else:\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*E0)\n # BE CAREFUL, HERE ONE SHOULD USE THE GREATER ROOT of the polynomial (only positive)\n new_input = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*E0))**0.5)\n # update for fixed point:\n new_cp += self.k1M[layeridx][inpIdx,inpIdx]*new_input*self.TA0[layeridx][inpIdx,inpIdx]/(1+self.k1M[layeridx][inpIdx,inpIdx]*new_input*E0/cp)\n layerEq[inpIdx] = new_input\n olderX[layeridx] = layerEq\n\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]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),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]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n # print(np.sum(CactivsOld*olderX[layeridx-1])/(kdI[layeridx-1][inpIdx,0]*cp+Inhib/cp))\n # print(x_eq)\n # assert np.sum(CactivsOld*olderX[layeridx-1])/(kdI[layeridx-1][inpIdx,0]*cp+Inhib/cp) == x_eq\n\n layerEq[inpIdx] = x_eq\n\n\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0)\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/(1+self.k1M[layeridx][:,inpIdx]*x_eq*self.E0/cp),np.where(layer[:,inpIdx]<0,Kinhibs*x_eq/(1+self.k3M[layeridx][:,inpIdx]*x_eq*self.E0/cp),0)))\n if layeridx>1:\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 new_cp += Inhib2/(E0*cp)*x_eq\n new_cp += firstComplex\n\n olderX[layeridx] = layerEq\n\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layer\n for outputsIdx in range(masks[-1].shape[0]):\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/(1+self.k1M[-1][outputsIdx]*olderX[-1]*self.E0/cp),0)\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/(1+self.k3M[-1][outputsIdx]*olderX[-1]*self.E0/cp),0)\n\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n new_cp += Inhib2/(E0*cp)*x_eq\n\n\n return cp - new_cp","def dual_problem(\n states: list[np.ndarray], probs: list[float] = None, dist_method=\"min-error\"\n) -> float:\n constraints = []\n meas = []\n\n dim_x, _ = states[0].shape\n\n y_var = cvxpy.Variable((dim_x, dim_x), hermitian=True)\n objective = cvxpy.Minimize(cvxpy.trace(cvxpy.real(y_var)))\n\n dim = int(np.log2(dim_x))\n dim_list = [2] * int(np.log2(dim_x))\n sys_list = list(range(1, dim, 2))\n # dim_list = [3, 3]\n\n if dist_method == \"min-error\":\n for i, _ in enumerate(states):\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\n constraints.append(\n cvxpy.real(y_var - probs[i] * states[i])\n >> partial_transpose(meas[i], sys=sys_list, dim=dim_list)\n )\n\n if dist_method == \"unambiguous\":\n for j, _ in enumerate(states):\n sum_val = 0\n for i, _ in enumerate(states):\n if i != j:\n sum_val += cvxpy.real(cvxpy.Variable()) * probs[i] * states[i]\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\n constraints.append(\n cvxpy.real(y_var - probs[j] * states[j] + sum_val)\n >> partial_transpose(meas[j], sys=sys_list, dim=dim_list)\n )\n\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\n constraints.append(\n cvxpy.real(y_var) >> partial_transpose(meas[-1], sys=sys_list, dim=dim_list)\n )\n\n problem = cvxpy.Problem(objective, constraints)\n sol_default = problem.solve()\n\n # print(np.around(y_var.value, decimals=3))\n\n return sol_default","def scoreCirc_PassiveFilter(circuit, gen, indi, makeRedundancyInMatrix):#TODO\n #Calculate density and uniquiness (as in makeNetlist)\n if makeRedundancyInMatrix == True:\n FullBigCircuitMatrix = deepcopy(fullRedundancyBigCircuitMatrix(circuit.BigCircuitMatrix))\n else:\n FullBigCircuitMatrix = deepcopy(circuit.BigCircuitMatrix)\n\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\n\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\t#(ones/(all/2))\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\n #print \"Kratkih stikov zunanjih povezav:\", OcSc\n \n results = None\n if OcSc > 1:\n score = 1e4*np.exp(OcSc)\n else:\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\n results = runme2.evaluatePassiveFilter_SUHAD(gen, indi)#TODO\n \n disfCount = 0\n\n gain = np.array(results['gain']['nominal'], dtype=float)\n if np.isnan(gain):\n disfCount = disfCount + 1\n g = 0\n else:\n g = abs(gain - 0) if gain < 0 else 0\n\n ripple = np.array(results['ripple']['nominal'], dtype=float)\n if np.isnan(ripple):\n disfCount = disfCount + 1\n r = 0 \n else:\n r = abs(ripple - 0.5)# if ripple > 0.5 else 0\n \n damping = np.array(results['damping']['nominal'], dtype=float)\n if np.isnan(damping):\n disfCount = disfCount + 1\n d = 0\n else:\n d = abs(40 - damping)# if damping < 60 else 0\n \n #THD = np.array(results['THD']['nominal'], dtype=float)\n #if np.isnan(THD):\n # disfCount = disfCount + 1\n # thd = 0\n #else:\n # thd = THD-1 if THD > 1 else 0\n \n score = 10*r + g + 10*d\n\n if disfCount > 0:\n score = np.exp(disfCount) * 1e3\n\n score = score + (IcNc*IcNc+1)# + abs(BW-bw)*1e2 + abs(CUTOFF-cutoff)*1e2 #add small punishment if not all nodes connected and bw and cutoff are off\n\n #print \"\\t\\t\\t\\t\\tG_\" + str(gen) + \"_I_\" + str(indi) + \" SCORE:\", score\n #cleanup current subcircuit\n filename = \"g_\" + str(gen) + \"_i_\" + str(indi) + \"_subckt.cir\"\n os.remove(filename)\n return score, matrixDensity, matrixQuaziID, results","def penalty_calc(self):\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\n\n # fiber attenuation,\n self.p_atten = self.alpha*self.length # column B\n\n # calculate bandwidth for RIN test (exclude transmitter)\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\n rin_bw = 1.0 / rin_inverse_bw\n\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\n k_rin = 0.7\n\n # v_rin,\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\n math.pow(10.0,0.1*self.rin)) # column AK\n\n # Prin,\n print('v_rin: ', self.v_rin)\n print('Q: ',self.Q)\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\n print(\"P_rin : \", self.p_rin)\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\n print(\"isi_center : \", self.isi_center)\n\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\n\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\n\n\n # calculate the \"cross\" penalty contribution, column S\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\n self.p_cross_center = ( # column S\n arg3\n - self.p_blw # cell T13\n - self.p_isi_center # column J\n - self.p_isi_dj_center # column L\n - self.p_mpn # column Q\n - self.p_reflection # column N\n - self.p_rin # column R\n - self.pmn*self.l_1) # cell G13\n print('p_isi_center: ', self.p_isi_center)\n\n # calculate the total power budget evaluated at the center of the eye\n self.p_total_center = ( # column T\n self.p_isi_center # column J\n + self.p_isi_dj_center # column L\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1) # cell G13\n # calculate the total power budget evaluated at the corner of the eye\n self.p_total_corners = (\n self.p_isi_center # column J\n + self.p_isi_corners # column K\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1 # cell G13\n + self.p_isi_dj_corners)# column M\n\n # receiver stressed sensitivity\n self.margin = ( self.p_budget\n - self.p_total_center) # column W\n\n self.rx_stressed_sensitivity = (\n self.tx_oma_min*self.l_1\n - self.chil\n - self.p_mpn\n - self.p_reflection\n - self.p_rin\n - 0.5*self.p_cross_center\n - self.pmn*self.l_1\n - self.margin[self.lnum//2]*self.l_1)\n\n\n # end of GbE10.penalty_calc\n #======================================================================+","def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\n\n # Raise('NotImplementedError: only adjusted the arguments.')\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\n #precompute the expensive operation:\n lin_penalties = 1/np.sqrt(2*eta_lin)\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\n #!!!!\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\n #!!!!\n u_prev = u_init + 1\n u = u_init\n count = 0\n obj_history = []\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\n start = time.time()\n \n u_prev = np.copy(u)\n w_0 = w_0_update(eta_0, u, T, alpha, B) \n w = w_update(u, H, gamma, D, C) \n w_lin = w_lin_update(u, L_lhs, L_rhs)\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\n #!!!!\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\n #!!!!\n count += 1 \n if count == 10:\n u_inf = np.copy(u)\n w_0_inf = w_0[:]\n w_inf = w[:]\n w_lin_inf = w_lin[:]\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\n \n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\n obj_history.append(cur_obj)\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\n relaxed_obj_history.append(cur_relaxed_obj) \n \n stop = time.time()\n duration = stop-start\n \n if count%1 == 0 and verbose: \n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\n print(' This iteration took: {}'.format(duration))\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history","def solve(self, regparam):\n self.regparam = regparam\n \n #Some counters for bookkeeping\n self.stepcounter = 0\n self.flipcounter = 0\n self.nochangecounter = 0\n \n #Cached results\n self.evals = np.multiply(self.svals, self.svals)\n self.newevals = 1. / (self.evals + self.regparam)\n newevalslamtilde = np.multiply(self.evals, self.newevals)\n self.D = np.sqrt(newevalslamtilde)\n #self.D = -newevalslamtilde\n \n self.VTY = self.svecs.T * self.Y\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\n \n #Using lists in order to avoid unnecessary matrix slicings\n self.DVTY_list = []\n self.YTVDDVTY_list = []\n self.classFitnessList = []\n for i in range(self.labelcount):\n DVTY_i = DVTY[:,i]\n self.DVTY_list.append(DVTY_i)\n YTVDDVTY_i = DVTY_i.T * DVTY_i\n self.YTVDDVTY_list.append(YTVDDVTY_i)\n fitness_i = self.size - DVTY_i.T * DVTY_i\n self.classFitnessList.append(fitness_i)\n \n self.Dsvecs_list = []\n self.svecsDDsvecs_list = []\n for i in range(self.size):\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\n self.Dsvecs_list.append(Dsvec)\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\n \n self.updateA()\n \n \n converged = False\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n while True:\n \n converged = self.roundRobin()\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n if converged: break\n \n if self.oneclass:\n self.Y = self.Y[:, 0]\n self.A = self.A[:, 0]\n self.results['predicted_clusters_for_training_data'] = self.Y\n self.predictor = self.svdad.createModel(self)","def potentialSolver5(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def eval_grads(self, data):\n drho = np.zeros_like(self.rhos)\n dW = np.zeros_like(self.W)\n da = np.zeros_like(self.a)\n dc = np.zeros_like(self.c)\n dba = np.zeros_like(self.bs['alpha'])\n dVa = np.zeros_like(self.Vs['alpha'])\n dbm = np.zeros_like(self.bs['mu'])\n dVm = np.zeros_like(self.Vs['mu'])\n dbs = np.zeros_like(self.bs['sigma'])\n dVs = np.zeros_like(self.Vs['sigma'])\n\n const = 0.5 * np.log(2. * np.pi)\n for i in range(self.Ndim - 1, -1, -1):\n a = self.rhos[i] * self.a[i]\n h = 0.5 * (a + np.abs(a)) # ReLU\n dlt = (data[:, i][:, None] - self.mus[i][None, :])\n dlt /= self.sigmas[i][None, :]\n dlt = np.mean(dlt, axis=0)\n phi = 0.5 * dlt ** 2. - np.log(self.sigmas[i]) - const\n pi = self.alphas[i] * phi\n pi /= np.mean(pi)\n dza = pi - self.alphas[i]\n dba[i] = dza\n dVa[i] = dza[None, :] * h[:, None]\n dzm = pi * dlt\n dzm *= self.slow_factor # apparently this is a `tight' component\n dbm[i] = dzm\n dVm[i] = dzm[None, :] * h[:, None]\n dzs = pi * (dlt ** 2. - 1)\n dbs[i] = dzs\n dVs[i] = dzs[None, :] * h[:, None]\n\n # dh has shape Nhidden x Ncomponents (?)\n dh = dza * dVa[i] + dzm * dVm[i] + dzs * dVs[i]\n dpsi = 1. * (dh > 0)\n\n # collapse to a scalar or vector of Nhidden?\n drho[i] = np.mean(dpsi)\n\n if i == 0:\n dc = da[i]\n else:\n da[i - 1] = da[i] + np.mean(dpsi * self.rhos[i], axis=1)\n dW[:, i] = np.mean(da[i - 1][:, None] * data[:, i][None, :],\n axis=1)\n self.a[i - 1] = self.a[i] - np.mean(data[:, i][None, :] *\n self.W[:, i][:, None],\n axis=1)\n\n return -drho, -dc, -dW, -dba, -dVa, -dbm, -dVm, -dbs, -dVs","def alternative_iterative_method(x0, n, gamma, b):\n # Parameters:\n MAX_ITER = 1000\n n2 = n**2\n\n # Creating NxN versions of vector for easier indexing during iteration\n b = b.copy().reshape(n, n)\n b_transposed = b.copy().T\n x0 = x0.copy().reshape(n, n)\n x0_transposed = x0.copy().T\n x1 = x0.copy()\n x1_transposed = x0_transposed.copy()\n\n # No need for M, N, only a smaller tridiagonal system:\n H = scipy.sparse.diags((-1, 2, -1), (-1, 0, 1), shape=(n, n), format=\"csr\")\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n, n), format=\"csr\")\n M1 = gammaI + H # Corresponds to both (gI + M) & (gI + N) in equations\n M2 = gammaI - H # Corresponds to both (gI - M) & (gI - N) in equations\n\n # Preallocating RHS of equations\n RHS7 = np.zeros((n, n), dtype=np.float64)\n RHS8 = np.zeros((n, n), dtype=np.float64)\n\n k = 0\n while k < MAX_ITER:\n for i in range(n): # Loading RHS values for Equation (7):\n RHS7[:, i] = scipy.sparse.csr_matrix.dot(M2, x0_transposed[i]) + b_transposed[i]\n for i in range(n): # Solving N independent tridig mat systems related to Eq(7):\n x1[i] = scipy.sparse.linalg.spsolve(M1, RHS7[i])\n RHS8[i] = scipy.sparse.csr_matrix.dot(M2, x1[i]) + b[i] # Loading RHS values for Equation (8):\n for i in range(n): # Solving N independent tridig mat systems related to Eq(8):\n x1_transposed[i] = scipy.sparse.linalg.spsolve(M1, RHS8[:, i])\n\n k += 1\n if np.allclose(x1_transposed, x0_transposed, rtol=1e-8):\n break\n x0_transposed = x1_transposed.copy()\n\n res = x1_transposed.T.reshape(n2)\n return res, k","def run(self):\n self.errList = []\n self.initialize()\n\n for i in range(self.maxiter):\n # update U\n for k in range(self.K):\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\n full_matrices=False)\n self.U[k] = q.T.dot(p.T)\n self.U[k] = self.U[k].real\n\n # calculate temporal variable y\n y = np.zeros([self.rank, self.L, self.K])\n for k in range(self.K):\n y[:, :, k] = self.U[k].T.dot(self.X[k])\n\n # get H, V, and temps by running a single iteration of CP_ALS\n if i == 0:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1, printitn=0)\n else:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1,\n init=[self.H, self.V, temps], printitn=0)\n self.H = cp.Us[0]\n self.V = cp.Us[1]\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\n\n # update S\n for k in range(self.K):\n self.S[:, :, k] = np.diag(temps[k, :])\n\n # checking the stop criteria\n # error = 0\n for k in range(self.K):\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\n\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\n self.errList.append(error)\n if (i + 1) % self.printitn == 0:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n elif error < self.tol:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n\n if error < self.tol:\n break\n else:\n self.sigma_old = self.sigma_new\n self.sigma_new = 0\n\n for k in range(self.K):\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)","def solve(self):\n\n # Open status display\n fmtstr, nsep = self.display_start()\n\n # Start solve timer\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Main optimisation iterations\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\n\n # Update record of X and Y from previous iteration\n self.on_iteration_start()\n\n # Compute backtracking\n if self.opt['Backtrack'] is not None and self.k >= 0:\n self.timer.stop('solve_wo_btrack')\n # Compute backtracking\n self.backtrack.update(self)\n self.timer.start('solve_wo_btrack')\n else:\n # Compute just proximal step\n self.xstep()\n # Update by combining previous iterates\n self.ystep()\n\n # Compute residuals and stopping thresholds\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n frcxd, adapt_tol = self.compute_residuals()\n self.timer.start('solve_wo_rsdl')\n\n # Compute and record other iteration statistics and\n # display iteration stats if Verbose option enabled\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n itst = self.iteration_stats(self.k, frcxd)\n self.itstat.append(itst)\n self.display_status(fmtstr, itst)\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Call callback function if defined\n if self.opt['Callback'] is not None:\n if self.opt['Callback'](self):\n break\n\n # Stop if residual-based stopping tolerances reached\n if not self.opt['FastSolve']:\n if frcxd < adapt_tol:\n break\n\n # Increment iteration count\n self.k += 1\n\n # Record solve time\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Print final separator string if Verbose option enabled\n self.display_end(nsep)\n\n return self.getmin()","def solve(self):\n pass","def solve(self):\n pass","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 compute_cost_matrix(self):\n\n if rank == 0:\n #do random sampling of a parameters\n if self.sampling == \"LHS\":\n lhs = Lhs(lhs_type=\"classic\", criterion=None)\n param_samples = lhs.generate(self.sample_space, self.niters)\n elif self.sampling == \"rsampling\":\n param_samples = self.sample_space.rvs(self.niters)\n elif self.sampling == \"Sobol\":\n sobol = Sobol()\n param_samples = sobol.generate(self.sample_space.dimensions, self.niters)\n \n # generate param samples split\n niters_rank0 = self.niters//size + self.niters % size\n niters_rank = self.niters//size\n count_scatter = [niters_rank0]\n count_scatter.extend((size-2)*[niters_rank])\n count_scatter = np.cumsum(count_scatter)\n\n param_samples_split = np.split(param_samples,count_scatter)\n else:\n param_samples_split = None\n \n #scatter parameter samples data\n param_samps = comm.scatter(param_samples_split,root=0)\n\n # initialize data\n param_samples_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\n param_samples_diff_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\n jac_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\n qoi_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\n\n \n\n # evaluate QoI at random sampling\n for sample in param_samps: \n qoi_sample, jac_sample = self.jac(sample).values()\n # store output\n for qoi_name in self.funcnames:\n if not (jac_sample[qoi_name] is None):\n param_samples_dict_rank[qoi_name].append(jac_sample[qoi_name])\n jac_dict_rank[qoi_name].append(jac_sample[qoi_name])\n qoi_dict_rank[qoi_name].append(qoi_sample[qoi_name])\n else:\n param_samples_diff_dict_rank[qoi_name].append(sample)\n\n # gather data\n param_samples = None\n param_samples_diff_int = None\n jac_dict = None\n qoi_dict= None\n\n param_samples_dict = comm.gather(param_samples_dict_rank, root=0)\n params_samples_diff_dict = comm.gather(param_samples_diff_dict_rank, root=0)\n jac_dict = comm.gather(jac_dict_rank, root=0)\n qoi_dict = comm.gather(qoi_dict_rank, root=0)\n\n # format gathered data\n if rank == 0:\n #flatten data\n param_samples_dict_flattened = {qoi_name:[] for qoi_name in self.funcnames}\n param_samples_diff_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\n jac_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\n qoi_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\n\n for cpurank in range(size):\n for qoi_name in self.funcnames:\n param_samples_dict_flattened[qoi_name].extend(param_samples_dict[cpurank][qoi_name]) \n param_samples_diff_dict_flattened[qoi_name].extend(params_samples_diff_dict[cpurank][qoi_name])\n jac_dict_flattened[qoi_name].extend(jac_dict[cpurank][qoi_name])\n qoi_dict_flattened[qoi_name].extend(qoi_dict[cpurank][qoi_name])\n\n #compute outer product\n jac_outer_dict = {qoi_name: [] for qoi_name in self.funcnames}\n nfuncs_dict = {qoi_name: 0 for qoi_name in self.funcnames}\n\n for qoi_name in self.funcnames:\n for i in range(len(jac_dict_flattened[qoi_name])):\n jac_sample = jac_dict_flattened[qoi_name][i]\n jac_outer_dict[qoi_name].append(np.outer(jac_sample,jac_sample))\n nfuncs_dict[qoi_name] += 1\n\n # compute cost matrix and norm convergence\n cost_matrix_dict = {}\n cost_matrix_cumul_dict = {}\n norm_convergence_dict = {}\n\n for qoi_name in self.funcnames:\n cost_cumsum = np.cumsum(jac_outer_dict[qoi_name],axis=0)/np.arange(1,nfuncs_dict[qoi_name]+1)[:,None,None]\n cost_matrix_cumul_dict[qoi_name] = cost_cumsum\n cost_matrix_dict[qoi_name] = cost_cumsum[-1,:,:]\n norm_convergence_dict[qoi_name] = np.linalg.norm(cost_cumsum,ord='fro',axis=(1,2))\n\n # compute variance matrix\n variance_matrix_dict = {}\n for qoi_name in self.funcnames:\n variance_mat = np.sum((jac_outer_dict[qoi_name]-cost_matrix_dict[qoi_name])**2/(nfuncs_dict[qoi_name]-1),axis=0) \n variance_matrix_dict[qoi_name] = variance_mat\n\n param_results = {\"PARAM_SAMPLES\": param_samples_dict_flattened,\n \"DIFFICULT_PARAM_SAMPLES\": param_samples_diff_dict_flattened}\n\n fun_results = {\"NUMBER_OF_FUNCTION_SUCCESS\": nfuncs_dict,\n \"NORM_OF_SEQ_OF_CUMUL_SUMS\": norm_convergence_dict,\n \"SEQ_OF_CUMUL_SUMS\": cost_matrix_cumul_dict, \n \"VARIANCE_OF_ENTRIES\": variance_matrix_dict,\n \"FINAL_COST_MATRIX\":cost_matrix_dict}\n\n return {'PARAMETER_RESULTS': param_results, 'FUNCTION_RESULTS': fun_results}","def solve(self):\r\n while not self.done():\r\n self.no_open_cells()\r\n self.all_cells_are_mines()\r\n self.no_mines()\r\n if not self.done():\r\n self.obvious_cells()\r\n if not self.done():\r\n made_progress = self.safe_neighbour_difference()\r\n if made_progress:\r\n continue\r\n if not self.done():\r\n made_progress = self.adjacent_combinations()\r\n if made_progress:\r\n continue\r\n return","def evaluate(self):\n #fac o lista cu toate perechile si vad daca se repeta vreuna (pana acum)\n nr=0\n \n pairs = []\n for i in range(0,self.__size):\n for j in range(0, self.__size):\n if self.__solution[i] != [] and self.__solution[i+self.__size] != [] : #sa am de unde face perechea\n p=[]\n p.append(self.__solution[i][j])\n p.append(self.__solution[i+self.__size][j])\n pairs.append(p)\n for p in pairs:\n if pairs.count(p) == 1:\n nr += 1\n\n return self.__size*self.__size - nr + 1 # pun acel +1 ca sa nu fie 0 niciodata -> ca sa nu am probleme la impartire\n # la 0 mai incolo\n #return nr","def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\n # process and activate input settings\n sigint_callback = kwds.pop('sigint_callback', None)\n settings = self._process_inputs(kwds)\n disp = settings['disp'] if 'disp' in settings else False\n echo = settings['callback'] if 'callback' in settings else None\n# for key in settings:\n# exec \"%s = settings['%s']\" % (key,key)\n if disp in ['verbose', 'all']: verbose = True\n else: verbose = False\n #-------------------------------------------------------------\n\n from python_map import python_map\n if self._map != python_map:\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\n from mystic.monitors import Null\n evalmon = Null()\n else: evalmon = self._evalmon\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\n\n # set up signal handler\n #self._EARLYEXIT = False\n self._generateHandler(sigint_callback) \n\n # activate signal_handler\n #import threading as thread\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\n import signal\n if self._handle_sigint:\n signal.signal(signal.SIGINT,self.signal_handler)\n\n # register termination function\n if termination is not None: self.SetTermination(termination)\n\n # get the nested solver instance\n solver = self._AbstractEnsembleSolver__get_solver_instance()\n #-------------------------------------------------------------\n\n # generate starting points\n initial_values = self._InitialPoints()\n\n # run optimizer for each grid point\n from copy import deepcopy as _copy\n op = [_copy(solver) for i in range(len(initial_values))]\n #cf = [cost for i in range(len(initial_values))]\n vb = [verbose for i in range(len(initial_values))]\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\n at = self.id if self.id else 0 # start at self.id\n id = range(at,at+len(initial_values))\n\n # generate the local_optimize function\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\n from copy import deepcopy as _copy\n from mystic.tools import isNull\n solver.id = rank\n solver.SetInitialPoints(x0)\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\n solver.SetStrictRanges(min=solver._strictMin, \\\n max=solver._strictMax) # or lower,upper ?\n solver.Solve(cost, disp=disp, callback=callback)\n sm = solver._stepmon\n em = solver._evalmon\n if isNull(sm): sm = ([],[],[],[])\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\n if isNull(em): em = ([],[],[],[])\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\n return solver, sm, em\n\n # map:: solver = local_optimize(solver, x0, id, verbose)\n results = self._map(local_optimize, op, initial_values, id, \\\n vb, cb, **self._mapconfig)\n\n # save initial state\n self._AbstractSolver__save_state()\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\n # reconnect monitors; save all solvers\n from mystic.monitors import Monitor\n while results: #XXX: option to not save allSolvers? skip this and _copy\n _solver, _stepmon, _evalmon = results.pop()\n sm = Monitor()\n sm._x,sm._y,sm._id,sm._info = _stepmon\n _solver._stepmon.extend(sm)\n del sm\n em = Monitor()\n em._x,em._y,em._id,em._info = _evalmon\n _solver._evalmon.extend(em)\n del em\n self._allSolvers[len(results)] = _solver\n del results, _solver, _stepmon, _evalmon\n #XXX: END HACK\n\n # get the results with the lowest energy\n self._bestSolver = self._allSolvers[0]\n bestpath = self._bestSolver._stepmon\n besteval = self._bestSolver._evalmon\n self._total_evals = self._bestSolver.evaluations\n for solver in self._allSolvers[1:]:\n self._total_evals += solver.evaluations # add func evals\n if solver.bestEnergy < self._bestSolver.bestEnergy:\n self._bestSolver = solver\n bestpath = solver._stepmon\n besteval = solver._evalmon\n\n # return results to internals\n self.population = self._bestSolver.population #XXX: pointer? copy?\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\n self.bestEnergy = self._bestSolver.bestEnergy\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\n self._maxiter = self._bestSolver._maxiter\n self._maxfun = self._bestSolver._maxfun\n\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\n self._stepmon = bestpath #XXX: pointer? copy?\n self._evalmon = besteval #XXX: pointer? copy?\n self.energy_history = None\n self.solution_history = None\n #from mystic.tools import isNull\n #if isNull(bestpath):\n # self._stepmon = bestpath\n #else:\n # for i in range(len(bestpath.y)):\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\n # #XXX: could apply callback here, or in exec'd code\n #if isNull(besteval):\n # self._evalmon = besteval\n #else:\n # for i in range(len(besteval.y)):\n # self._evalmon(besteval.x[i], besteval.y[i])\n #-------------------------------------------------------------\n\n # restore default handler for signal interrupts\n if self._handle_sigint:\n signal.signal(signal.SIGINT,signal.default_int_handler)\n\n # log any termination messages\n msg = self.Terminated(disp=disp, info=True)\n if msg: self._stepmon.info('STOP(\"%s\")' % msg)\n # save final state\n self._AbstractSolver__save_state(force=True)\n return","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\n auto_param_obj_history = []\n auto_param_relaxed_obj_history = []\n \n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\n eta = np.array([eta_0/len(H)]*len(H))*0.9\n eta_lin = np.ones(L_lhs.shape[0])*0.01\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Feasibility')\n count = 0\n num_violated = -1\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n count += 1\n num_violated_prev = np.copy(num_violated)\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\n \n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\n eta[cnstr['Relaxed'] == False] *= eta_step\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n # eta_lin *= eta_step\n \n if num_violated == num_violated_prev:\n print('Increase enforcement')\n if num_violated_lin > 0:\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n #eta_lin *= eta_step\n if num_violated_oar > 0:\n eta[cnstr['Relaxed'] == False] *= eta_step\n # eta_0 *= eta_step*2\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Optimality')\n count = 0\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\n count += 1\n print('Opt Iter', count)\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\n u_prev = np.copy(u)\n eta_0 *= eta_step_tumor\n print('Current eta_0:', eta_0)\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n \n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\n print('No improvement, increase enforcement')\n eta_step_tumor *= 0.1\n eta_0 *= eta_step_tumor\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # break\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\n \n print('Finding the correct solution:')\n u = u_prev\n eta_0 = eta_0/eta_step_tumor\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\n print(\"OBJJJJJ:\", obj_u_opt_N_fixed(u, T, alpha, B))\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history","def solve_assignments(self):\n # build valuations vector \n c = -1 * self.valuations.flatten()\n\n # empty G and h, no inequality constraints\n G = np.zeros((1, self.n**2))\n h = np.zeros((1))\n\n # build A and b, enforces unique room-agent matching\n A = np.zeros((2 * self.n, self.n**2))\n b = np.ones((2 * self.n))\n for i in range(self.n):\n # exactly one room per agent\n A[i, i * self.n + np.arange(self.n)] = 1.0 \n # exactyly one agent per room\n A[self.n + i, (self.n) * np.arange(self.n) + i] = 1.0\n\n B = set(range(self.n**2))\n status, x = ilp(c=matrix(c, tc='d'), G=matrix(G, tc='d'), \n h=matrix(h, tc='d'), A=matrix(A, tc='d'), \n b=matrix(b, tc='d'), B=B)\n\n # get assignments\n x = np.argmax(np.array(x).reshape(self.n, self.n), axis=1)\n self.assignments = x \n\n return self.assignments","def optimize(self):\n # Loop through every WD and WS individually\n wd_array = self.fi_subset.floris.flow_field.wind_directions\n ws_array = self.fi_subset.floris.flow_field.wind_speeds\n for nwsi, ws in enumerate(ws_array):\n\n self.fi_subset.reinitialize(wind_speeds=[ws])\n\n for nwdi, wd in enumerate(wd_array):\n # Find turbines to optimize\n turbs_to_opt = self._turbs_to_opt_subset[nwdi, nwsi, :]\n if not any(turbs_to_opt):\n continue # Nothing to do here: no turbines to optimize\n\n # Extract current optimization problem variables (normalized)\n yaw_lb = self._minimum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\n yaw_ub = self._maximum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\n bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)]\n x0 = self._x0_subset_norm[nwdi, nwsi, turbs_to_opt]\n\n J0 = self._farm_power_baseline_subset[nwdi, nwsi]\n yaw_template = self._yaw_angles_template_subset[nwdi, nwsi, :]\n turbine_weights = self._turbine_weights_subset[nwdi, nwsi, :]\n yaw_template = np.tile(yaw_template, (1, 1, 1))\n turbine_weights = np.tile(turbine_weights, (1, 1, 1))\n\n # Define cost function\n def cost(x):\n x_full = np.array(yaw_template, copy=True)\n x_full[0, 0, turbs_to_opt] = x * self._normalization_length\n return (\n - 1.0 * self._calculate_farm_power(\n yaw_angles=x_full,\n wd_array=[wd],\n turbine_weights=turbine_weights\n )[0, 0] / J0\n )\n\n # Perform optimization\n residual_plant = minimize(\n fun=cost,\n x0=x0,\n bounds=bnds,\n method=self.opt_method,\n options=self.opt_options,\n )\n\n # Undo normalization/masks and save results to self\n self._farm_power_opt_subset[nwdi, nwsi] = -residual_plant.fun * J0\n self._yaw_angles_opt_subset[nwdi, nwsi, turbs_to_opt] = (\n residual_plant.x * self._normalization_length\n )\n\n # Finalize optimization, i.e., retrieve full solutions\n df_opt = self._finalize()\n return df_opt","def add_objective(self): \n \n if \"CSS\" in self.algorithm:\n \n if self.num_hidden == 0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n else:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.add_css_approximation(data_term)\n \n if \"CD\" in self.algorithm and self.num_hidden ==0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n normalizer_term = self.compute_energy(self.x_gibbs, \n self.batch_size)\n \n normalizer_term = -T.mean(normalizer_term)\n \n if \"CD\" in self.algorithm and self.num_hidden > 0:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\n \n normalizer_term = -T.mean(normalizer_term)\n \n # cost is negative log likelihood \n self.cost = T.mean(data_term) + normalizer_term","def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\n\n # def Q_gen(I, R):\n # w = I * I * R\n # return w\n\n # def Q_rad_in(I_sun, A_s, a_s):\n # w = I_sun * D * a_s\n # return w\n\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\n # w = htcoeff * A_s * (T_line - T_amb)\n # return w\n\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\n # return w\n\n def reynolds(V, D, v, Mair=1.103):\n r = V * D / v\n return r\n\n def nusselt(Re, Pr):\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\n c = (Re / 282000) ** (5.0/8.0)\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\n return n\n\n def air_prop(T_amb):\n # temp v k Pr\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\n [250, 11.44e-6, 22.3e-3, 0.720],\n [300, 15.89e-6, 26.3e-3, 0.707],\n [350, 20.92e-6, 30.0e-3, 0.700],\n [400, 26.41e-6, 33.8e-3, 0.690],\n [450, 32.39e-6, 37.3e-3, 0.686],\n [500, 38.79e-6, 40.7e-3, 0.684],\n [550, 45.57e-6, 43.9e-3, 0.683],\n [600, 52.69e-6, 46.9e-3, 0.685]])\n\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\n 0, air_prop[:,1:])\n return v, k, Pr\n\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\n if 273 <= T_line <= 323:\n R = ((R_lo + \n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\n *(T_line - T_range[0]))/N_cond)\n elif T_line > 323:\n R = ((R_mid + \n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\n *(T_line - T_range[1]))/N_cond)\n else:\n R = R_lo\n print('Out of bounds')\n return R\n\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\n temp_factor = 1\n wind_factor = 1\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\n\n T_amb = T_amb*temp_factor\n V = V*wind_factor\n\n v, k, Pr = air_prop(T_amb)\n Re = reynolds(V, D, v)\n htcoeff = nusselt(Re, Pr) * k / D\n\n def T_line(T_init):\n \n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\n print R\n\n C4 = e_s * sigma * D * math.pi\n C3 = 0.0\n C2 = 0.0\n C1 = htcoeff * D * math.pi\n C0 = - ( I ** 2 * R\n + I_sun * a_s * D\n + htcoeff * D * math.pi * T_amb\n + e_s * D * math.pi * sigma * (T_amb ** 4))\n\n return np.roots([C4, C3, C2, C1, C0])\n\n T_c = T_amb\n \n for i in range(n_iter):\n T_arr = T_line(T_c)\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\n print T_c\n\n return T_c","def run(self):\n\n # Initializing required variables for the algorithm\n start = time.time()\n i = 0\n w = self.w\n k = 99.99\n\n #Running the algorithm till tolerance is reached\n while k > self.tolerance: \n\n i = i + 1\n\n if self.verbose:\n print(\"Iteration \" + str(i),end=\"\\r\")\n\n # Following is a gradient descent algorithm\n # You can find the update step at the following\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\n t_0 = w.T.dot(w)\n t_1 = self.x.T.dot(self.x).dot(w)\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\n w_new[-1] = -1\n l = len(self.x[0]) - 1 \n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \n\n #tolerance is checked against the root mean square of change in weights\n k = np.dot(np.transpose(w - w_new),(w - w_new))\n\n #Updating the weights \n w = w_new\n\n if self.verbose:\n print(\"Tolerance Reached\")\n timetaken = round(time.time() - start, 3)\n print(\"Ran for \" + str(timetaken) + \" seconds\" + \" in \" + str(i) + \" iterations.\")\n\n return w_new, y_plt","def solve(self):\n\n # Set up display header if verbose operation enabled\n if self.opt['Verbose']:\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\n ' ResG '\n print(hdr)\n print('-' * len(hdr))\n\n # Main iteration loop\n for n in range(self.opt['MaxMainIter']):\n\n # At start of 2nd iteration, set the numbers of inner\n # iterations for the X and G solvers from the options\n # object for the outer solver\n if n == 1:\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\n\n # Run the configured number of iterations of the X (CSC)\n # solver and assign the result to X\n self.X = self.slvX.solve()\n\n # Compute the sum of the subpixel shifts of X\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\n axis=-1)\n\n # Set the convolution kernel in the deconvolution solver\n # to the sum of the subpixel shifts of X\n self.slvG.setG(Xhs)\n # Run the configured number of iterations of the G\n # (deconvolution) solver and crop the result to obtain the\n # updated g\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\n\n # Construct a new dictionary for the X (CSC) solver from\n # the updated psf g\n self.D, self.dn = self.getD(self.g)\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\n\n # Display iteration statistics if verbose operation enabled\n if self.opt['Verbose']:\n itsX = self.slvX.getitstat()\n itsG = self.slvG.getitstat()\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\n print(fmt % tpl)\n\n # Return the (normalised) psf estimate g\n return self.g / np.linalg.norm(self.g)","def fConnectivityModel(RD,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha):\n#\n# 1. Initialisations:\n# \t-------------------\n\tFSwEnd = 0\n\tFSwInt = 0\n\tFSwMax = 200\n\tFSwErr = 0.0001\n\tSwOld = 1\n\tSwNew = 1\n\tSwInc = 0\n\tTiny=0.000000001\n\tBig=1000000000000\n\tTout=0 # Defines output of fRCrim\n#\n# 2. Calculate Observed Conductivity:\n#-----------------------------------\n\tif(RD<=0):\n\t\tCt=Big\n\telse:\n\t\tCt=1/RD\n#\n# 2. Interative Loop:\n#--------------------\t\t\n\tSwOld=0.50 # Initialises Effective Water Saturation\n\twhile(FSwEnd==0):\n\t\tCm=fRCrim(SwOld,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout)\n\t\tr=Ct-Cm\n\t\ts=(Cm-fRCrim((SwOld-Tiny),Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout))/Tiny # dCm/dSw\n\t\tif(s==0): \n\t\t\tFSwEnd=1\n\t\t\ts=Tiny\n\t\tSwInc=(r/s)\n\t\tSwNew=SwOld+SwInc\n\t\tFSwInt=FSwInt+1\n\t\tif(FSwInt>3):\t\n\t\t\tif (FSwInt>=FSwMax):\n\t\t\t\tFSwEnd=1\n\t\t\tif (abs(SwOld-SwNew)<FSwErr):\n\t\t\t\tFSwEnd=1\n\t\tSwOld=SwNew\n\t\tSwOld=ImposeLimits(SwOld,Tiny,1)\n\t#\t\t\n\treturn SwOld","def clfqp(self,x,p):\n alp = self.alp_opt\n nu = self.nu_opt\n dt = self.dt\n n = self.n\n I = np.identity(n)\n M = self.ncm(x,p)\n nu = np.size(self.h_or_g(x,p),1)\n u = cp.Variable((nu,1))\n e = np.reshape(x,(n,1))\n fx = np.reshape(self.dynamicsf(x,p),(n,1))\n gx = self.h_or_g(x,p)\n dMdt = (nu*I-M)/dt\n constraints = [2*e.T@(fx+gx@u)+e.T@dMdt@e <= -2*alp*e.T@M@e]\n prob = cp.Problem(cp.Minimize(cp.sum_squares(u)),constraints)\n prob.solve()\n u = u.value\n u = np.ravel(u)\n return u","def solve_ilp(self):\n\n ilp_solution = pylp.Solution()\n self.ilp_solver.set_constraints(self.constraints)\n message = self.ilp_solver.solve(ilp_solution)\n print(\"ILP solved with minimal value \" + str(ilp_solution.get_value()) + \" and status \" + message)\n\n solution = lil_matrix(self.graph.shape)\n for i in range(self.num_variables):\n print(\"value of var \" + str(i) + \" is \" + str(ilp_solution.get_vector()[i]))\n if ilp_solution.get_vector()[i] < 0.5:\n continue\n (u,v) = self.var_to_edge[i]\n solution[u,v] = self.graph[u,v] - self.min_cost + 1\n\n return solution","def solve(m):\n\t\n #with the assumption that at least one terminal state is given:\n if(len(m)==2 or len(m)==1): return [1,1]\n \n #Normalizing the in. matrix and identifying the trans./abs. states:\n m = normalizeProbabilityMatrix(m)\n t = getTransientStates(m)\n a = getAbsorbingStates(m)\n\t\n if len(a) >0:\n print( str(len(a)) + \" absorbing state\" + (\"\" if len(a)<=1 else \"s\" ))\n else:\n print(\"No absorbing state detected\")\n return\n \n #Getting the matrices Q and R as in the canonical form:\n Q = getQ(m,t)\n R = getR(m,t,a)\n I = getIdentity(len(Q))\n I_Q = subtractMatrices(I, Q)\n \n #Getting the fundamental matrix\n N = invertMatrix(I_Q)\n F = multiplyMatrices(N,R)\n \n #packing the result with a common denominator:\n gcd = getGCD(F[0]).denominator\n res=[]\n sum = 0\n for r in F[0]:\n val = int(r.numerator*(gcd/r.denominator))\n sum+=val\n res.append(val)\n res.append(sum) \n return res"],"string":"[\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def solve(self):\\n\\n if self.optimizer == 'pulp':\\n for constraint in self.constraints:\\n self.engine_model += constraint\\n\\n self.engine_model += self.objective\\n status = self.engine_model.solve(PULP_CBC_CMD(msg=False))\\n solution = (\\n np.vectorize(self._var_sol)(self.variable_set)\\n if status == LpStatusOptimal\\n else np.array([])\\n )\\n\\n else:\\n for constraint in self.constraints:\\n self.engine_model.addConstr(constraint)\\n\\n self.engine_model.setObjective(self.objective, self.sense)\\n self.engine_model.optimize()\\n solution = (\\n np.vectorize(self._var_sol)(self.variable_set)\\n if self.engine_model.status == GRB.OPTIMAL\\n else np.array([])\\n )\\n\\n return solution\",\n \"def solve(self):\\n start = timer()\\n # encode into milp\\n me = MILPEncoder(MILPSolver.prob,\\n MILPSolver.params.logger.LOGFILE, \\n MILPSolver.params.INTRA_DEP_CONSTRS,\\n MILPSolver.params.INTER_DEP_CONSTRS)\\n if MILPSolver.lp == True:\\n gmodel = me.lp_encode()\\n else:\\n gmodel = me.encode()\\n # Set gurobi parameters\\n pgo = 1 if MILPSolver.params.PRINT_GUROBI_OUTPUT == True else 0\\n gmodel.setParam('OUTPUT_FLAG', pgo)\\n tl = MILPSolver.params.TIMEOUT\\n if tl != -1 : gmodel.setParam('TIME_LIMIT', tl)\\n if not MILPSolver.params.DEFAULT_CUTS: \\n MILPSolver.disable_default_cuts(gmodel)\\n gmodel._vars = gmodel.getVars()\\n # set callback cuts \\n MILPSolver.id_form = IdealFormulation(MILPSolver.prob,\\n gmodel, \\n MILPSolver.params.IDEAL_FREQ,\\n MILPSolver.params.logger.LOGFILE)\\n MILPSolver.dep_cuts = DepCuts(MILPSolver.prob,\\n gmodel,\\n MILPSolver.params.DEP_FREQ,\\n MILPSolver.params.INTRA_DEP_CUTS,\\n MILPSolver.params.INTER_DEP_CUTS,\\n MILPSolver.sip_params,\\n MILPSolver.params.logger.LOGFILE)\\n # Optimise\\n if MILPSolver.params.callback_enabled() and MILPSolver.lp == False:\\n gmodel.optimize(MILPSolver._callback)\\n else:\\n gmodel.optimize()\\n\\n runtime = timer() - start\\n cex = None \\n if MILPSolver.status == SolveResult.BRANCH_THRESHOLD:\\n result = SolveResult.BRANCH_THRESHOLD\\n elif gmodel.status == GRB.OPTIMAL:\\n cex_shape = MILPSolver.prob.spec.input_layer.input_shape\\n cex = np.zeros(cex_shape)\\n for i in itertools.product(*[range(j) for j in cex_shape]):\\n cex[i] = MILPSolver.prob.spec.input_layer.out_vars[i].x\\n result = SolveResult.UNSATISFIED\\n elif gmodel.status == GRB.TIME_LIMIT:\\n result = SolveResult.TIMEOUT\\n elif gmodel.status == GRB.INTERRUPTED:\\n result = SolveResult.INTERRUPTED\\n elif gmodel.status == GRB.INFEASIBLE or gmodel.status == GRB.INF_OR_UNBD:\\n result = SolveResult.SATISFIED\\n else:\\n result = SolveResult.UNKNOWN\\n \\n # MILPSolver.logger.info('Verification problem {} solved, '\\n # 'LP: {}, '\\n # 'time: {:.2f}, '\\n # 'result: {}.'\\n # .format(MILPSolver.prob.id,\\n # MILPSolver.lp,\\n # runtime,\\n # result.value))\\n \\n return SolveReport(result, runtime, cex)\",\n \"def _solve_implicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n l_and_u = (1, 1)\\n ab = np.empty((3, self.n_x))\\n # main diagonal\\n ab[1] = 1 + 2.0 * coeff\\n # upper and lower diagonals\\n ab[0] = ab[2] = -coeff\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n ab[0][1] = 0 # upper diagonal\\n ab[1][0] = 1 # main diagonal\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n ab[0][1] = 1 # upper diagonal\\n ab[1][0] = -1 # main diagonal\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n ab[1][-1] = 1 # main diagonal\\n ab[2][-2] = 0 # lower diagonal\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n ab[1][-1] = 1 # main diagonal\\n ab[2][-2] = -1 # lower diagonal\\n\\n current_solution = initial_conditions\\n solutions = []\\n\\n for t in self.t_grid:\\n b = current_solution + self.tau * self.rhs(self.x_grid, t)\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n b[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n b[0] = self.h * self.left_bc(t)\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n b[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n b[-1] = self.h * self.right_bc(t)\\n\\n next_solution = solve_banded(l_and_u, ab, b)\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def g_solving_subproblem_of_ALR(self,vehicle_id):\\r\\n global_LB = -10000\\r\\n global_UB = 10000\\r\\n iteration_for_RSP = 20\\r\\n optimal_solution_for_RSP = None\\r\\n self.multiplier_v = 0.5\\r\\n\\r\\n # solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\\r\\n\\r\\n # obtain the variance\\r\\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB = 0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\\r\\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\\r\\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance- y != 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB - global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def solve(self):\\n\\n # Assign variables to each quantity being solved.\\n r_lookup, lookup, num = {}, {}, 0\\n for element in self.elements:\\n if is_wire(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n elif not is_cs(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n\\n # Set up the linear algebraic equation Ax=b\\n A = np.zeros((num, num))\\n b = np.zeros(num)\\n for row, element in lookup.items():\\n if is_wire(element) and element is not self.ground:\\n for two_sided in element.attached:\\n if is_cs(two_sided):\\n if two_sided.pos is element:\\n b[row] += -1 * two_sided.current\\n else:\\n b[row] += two_sided.current\\n else:\\n if two_sided.pos is element:\\n flow = 1\\n else:\\n flow = -1\\n A[row, r_lookup[two_sided]] = flow\\n elif is_vs(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n b[row] = element.voltage\\n elif is_resistor(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n A[row, r_lookup[element]] = -1 * element.resistance\\n\\n b = b.reshape((num, 1))\\n try:\\n x = np.linalg.solve(A, b)\\n except np.linalg.LinAlgError:\\n raise CircuitError('Insufficient information to solve circuit')\\n\\n # Assign values to all circuit components\\n for i in range(num):\\n item = lookup[i]\\n if is_wire(item):\\n item.potential = x[i, 0]\\n elif isinstance(item, DualSided):\\n item.current = x[i, 0]\\n\\n # Mark circuit as solved\\n self.been_solved = True\",\n \"def solve(self):\\n max_iter = 1000\\n iter_count = 0\\n yhat = self.predict()\\n loss = self.cross_entropy(yhat)\\n gradloss = self.cross_entropy_gradient(yhat)\\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\\n alpha = 1.0\\n slope = la.norm(gradloss)**2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n while loss_new < loss + 1e-4 * alpha * slope:\\n alpha = alpha / 2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n self.beta = beta_new\\n loss = loss_new\\n gradloss = self.cross_entropy_gradient(yhat)\\n iter_count += 1\",\n \"def solve(self):\\n self.m.optimize()\\n if self.m.status == GRB.OPTIMAL:\\n self.solution = self.sol_as_mat()\\n return self.solution\",\n \"def solve(self):\\n initial_fes = eades(self.graph, self.force_forward_edges)\\n initial_fes_vec = self.edge_vector(initial_fes)\\n\\n # bounds for the objective\\n lower_bound = 0\\n upper_bound = np.sum(initial_fes_vec @ self.weights)\\n\\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\\n\\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\\n\\n for iteration in itertools.count(1):\\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\\n upper_bound, len(simple_cycles))\\n\\n # Formulate and solve the problem for this iteration:\\n y = cp.Variable(self.m, boolean=True, name=\\\"y\\\")\\n objective = cp.Minimize(cp.sum(y @ self.weights))\\n\\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\\n problem = cp.Problem(objective, constraints)\\n resolution = problem.solve(**self.solver_args)\\n if problem.status != 'optimal':\\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\\n problem.solver_stats.solver_name)\\n self.logger.debug(\\n \\\"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\\\",\\n len(constraints), resolution, problem.solution.status,\\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\\n current_fes = self.edges_for_vector(current_solution)\\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\\n len(current_fes))\\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\\n # from the heuristic\\n lower_bound = max(lower_bound, objective.value)\\n if lower_bound == upper_bound:\\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\\n break # y.value is the optimal solution\\n\\n if resolution > upper_bound:\\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\\n break\\n\\n Gi = self.graph.copy()\\n Gi.remove_edges_from(current_fes)\\n if nx.is_directed_acyclic_graph(Gi):\\n self.logger.info('Graph is acyclic, optimal solution found')\\n break # y.value is the optimal solution\\n\\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\\n # determine additional simple cycles (= constraints)\\n Fi = eades(Gi, self.force_forward_edges)\\n yi = self.edge_vector(Fi) | current_solution\\n zi = np.sum(yi @ self.weights)\\n if zi < upper_bound:\\n upper_bound = zi\\n current_solution = yi\\n simple_cycles |= set(induced_cycles(Gi, Fi))\\n\\n self.solution_vector = current_solution\\n self.solution = self.edges_for_vector(current_solution)\\n self.objective = objective.value\\n self.iterations = iteration\\n self.simple_cycles = simple_cycles\\n return self.solution\",\n \"def solve(self):\\n \\n # Check if cost is available for both estimators\\n if not self.est0.cost_avail or not self.est1.cost_avail:\\n self.comp_cost = False\\n \\n # Initial estimate from the input node\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\\n else:\\n z0, zvar0 = self.est0.est_init(return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0\\n \\n # Initialize other variables\\n self.var_cost0 = 0\\n self.var_cost1 = 0\\n self.cost = 0\\n self.s = np.zeros(self.shape1)\\n \\n for it in range(self.nit):\\n \\n # Forward transform to est1\\n t0 = time.time()\\n rvar1_new = self.A.var_dot(self.zvar0)\\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\\\\n self.var_axes1,rep=False)\\n z1_mult = self.A.dot(self.z0)\\n r1_new = z1_mult - rvar1_rep*self.s\\n \\n # Damping\\n if it > 0: \\n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\\n else:\\n self.r1 = r1_new\\n self.rvar1 = rvar1_new\\n\\n # Estimator 1 \\n if self.comp_cost: \\n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \\n if not self.map_est:\\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\\\\n self.shape1,self.var_axes1)\\n else:\\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \\n cost1 = 0\\n self.z1 = z1\\n self.zvar1 = zvar1\\n self.cost1 = cost1 \\n con_new = np.mean(np.abs(z1-z1_mult)**2) \\n \\n # Reverse nonlinear transform to est 0\\n self.s = (self.z1-self.r1)/rvar1_rep\\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\\n t1 = time.time()\\n self.time_est1 = t1-t0\\n \\n # Reverse linear transform to est 0 \\n rvar0_new = 1/self.A.var_dotH(self.sprec)\\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\\\\n self.var_axes0,rep=False)\\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\\n \\n # Damping\\n if it > 0:\\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\\n else:\\n self.r0 = r0_new\\n self.rvar0 = rvar0_new\\n \\n \\n # Estimator 0\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\\n if not self.map_est:\\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\\\\n self.shape0,self.var_axes0)\\n \\n else:\\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0 \\n\\n \\n # Compute total cost and constraint \\n cost_new = self.cost0 + self.cost1 \\n if not self.map_est:\\n cost_new += self.cost_gauss()\\n \\n # Step size adaptation\\n if (self.step_adapt) and (it > 0):\\n if (con_new < self.con):\\n self.step = np.minimum(1,self.step_inc*self.step)\\n else:\\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\\n self.cost=cost_new\\n self.con=con_new\\n \\n t2 = time.time()\\n self.time_est0 = t2-t1\\n self.time_iter = t2-t0\\n \\n # Print progress\\n if self.prt_period > 0:\\n if (it % self.prt_period == 0):\\n if self.comp_cost:\\n print(\\\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\\\".format(\\\\\\n it, self.cost, self.con, self.step))\\n else:\\n print(\\\"it={0:4d} con={1:12.4e}\\\".format(\\\\\\n it, self.con))\\n \\n # Save history\\n self.save_hist()\",\n \"def DirectSolve(self, y):\\n if y >= -self.R:\\n a1 = self.apath[y+1]\\n if y == -2:\\n a2 = 0\\n else:\\n a2 = self.apath[y+2] \\n def constraints(a):\\n c0 = (1+self.r)*a + self.b - a1\\n c1 = (1+self.r)*a1 + self.b - a2\\n return self.uc(c0,0)-self.beta*self.uc(c1,0)*(1+self.r)\\n a, n = fsolve(constraints, a1), 0\\n c = (1+self.r)*a + self.b - a1\\n else:\\n a1 = self.apath[y+1]\\n a2 = self.apath[y+2]\\n if y == -(self.R+1):\\n n1 = 0\\n c1 = (1+self.r)*a1 + self.b - a2\\n else:\\n n1 = self.npath[y+1]\\n c1 = (1+self.r)*a1 + (1-self.tau)*self.w*n1 - a2\\n def constraints((a0,n0)):\\n c0 = (1+self.r)*a0 + (1-self.tau)*self.w*n0 - a1\\n return self.uc(c0,n0) - self.beta*self.uc(c1,n1)*(1+self.r),\\\\\\n (1-self.tau)*self.w*self.uc(c0,n0) + self.un(c0,n0)\\n a, n = fsolve(constraints,(a1,n1))\\n c = (1+self.r)*a + (1-self.tau)*self.w*n - a1\\n return a, n, c\",\n \"def optimize(self):\\n prm = (self.b,self.c)\\n d = self.d\\n no = int(d*d)\\n bounds = [(-1,1)]*no\\n resG = differential_evolution(inpSc.entBias, bounds, args = prm, popsize = 40, disp = False)\\n\\n xOpt = resG.x\\n xOpt = xOpt/(np.linalg.norm(xOpt))\\n\\n #Refine the global optimization by performing a second local optimizaiton\\n x0 = xOpt\\n\\n res = minimize(inpSc.entBias, x0, args = prm, method='BFGS', options={'disp': False})\\n xOpt = res.x\\n xOpt = xOpt/(np.linalg.norm(xOpt))\\n self.rhoOp = inpSc.getMat(xOpt, d)\\n self.Q1 = -res.fun\",\n \"def g_solving_subproblem_of_LR(self,vehicle_id):\\r\\n global_LB=-10000\\r\\n global_UB=10000\\r\\n iteration_for_RSP=20\\r\\n optimal_solution_for_RSP=None\\r\\n optimal_value_y=0\\r\\n self.multiplier_v=0.5\\r\\n\\r\\n #solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\\r\\n #obtain the variance\\r\\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB=0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\\r\\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\\r\\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\\r\\n optimal_value_y = y\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance-y!= 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB-global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\",\n \"def iterations(self):\\n i = 0\\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n n = len(self.model.stateVector)\\n self.answer = None\\n \\n while ((i < self.maxiter) \\n and (stateVectorConv > self.stateVectorConvThreshold)\\n ):\\n \\n F, K = self.model()\\n \\n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\\n m = \\\"Iteration {0} failure of model.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n m = \\\"Iteration {0} failure in decomposition.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n statevectorOffset = (self.V.T * self.priorSinvh * \\n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\\n measurementOffset = (self.U.T * self.errSinvh * \\n np.matrix(self.model.observation - F).T)\\n \\n newState = np.matrix((self.w * \\n (measurementOffset.A1 + \\n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\\n newState = self.priorSh * self.V * newState\\n newState = newState.A1 + self.model.prior\\n \\n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \\n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\\n self.model.stateVector = newState\\n\\n if i == 0:\\n \\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n \\n print('cost Function for iteration {}:'.format(i), self.costFunction)\\n\\n i += 1\\n \\n F, K = self.model()\\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n raise OptimalEstimationException(\\\"Failure in decomposition.\\\")\\n \\n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \\n self.V.T * self.priorSh)\\n \\n\\n \\n return i, stateVectorConv\",\n \"def solve(self, Dn, Dm, c, b):\\n m =self.m\\n n =self.n\\n kA =self.kA\\n iA =self.iA\\n A =self.A\\n kAt=self.kAt\\n iAt=self.iAt\\n At =self.At\\n kQ =self.kQ\\n iQ =self.iQ\\n Q =self.Q\\n _max =self.max\\n\\n _pass=0\\n consistent = True\\n\\n m2 = m+n\\n\\n # Replaced MALLOC & REALLOC with np.empty\\n if self.y_k is None:\\n self.y_k = np.empty(m)\\n else:\\n self.y_k.resize(m)\\n if self.x_k is None:\\n self.x_k = np.empty(n)\\n else:\\n self.x_k.resize(n)\\n if self.r is None:\\n self.r = np.empty(m)\\n else:\\n self.r.resize(m)\\n if self.s is None:\\n self.s = np.empty(n)\\n else:\\n self.s.resize(n)\\n if self.z is None:\\n self.z = np.empty(m2)\\n else:\\n self.z.resize(m2)\\n if self.Qx is None:\\n self.Qx = np.empty(n)\\n else:\\n self.Qx.resize(n)\\n\\n y_k = self.y_k\\n x_k = self.x_k\\n r = self.r\\n s = self.s\\n z = self.z\\n Qx = self.Qx\\n iperm = self.iperm\\n\\n maxbc = max(np.abs(b).max(), np.abs(c).max()) + 1\\n maxrs = HUGE_VAL\\n\\n while True:\\n\\n if _pass == 0:\\n for j in range(n):\\n z[iperm[j]] = c[j]\\n for i in range(m):\\n z[iperm[n+i]] = b[i]\\n else:\\n for j in range(n):\\n z[iperm[j]] = s[j]\\n for i in range(m):\\n z[iperm[n+i]] = r[i]\\n\\n consistent = self.rawsolve()\\n\\n if _pass == 0:\\n for j in range(n):\\n x_k[j] = z[iperm[j]]\\n for i in range(m):\\n y_k[i] = z[iperm[n+i]]\\n else:\\n for j in range(n):\\n x_k[j] = x_k[j] + z[iperm[j]]\\n for i in range(m):\\n y_k[i] = y_k[i] + z[iperm[n+i]]\\n\\n smx(m, n, A, kA, iA, x_k,r)\\n smx(n, m, At,kAt,iAt,y_k,s)\\n smx(n, n, Q ,kQ ,iQ ,x_k,Qx)\\n\\n for j in range(n):\\n s[j] = c[j] - (s[j] - Dn[j]*x_k[j] - _max*Qx[j])\\n for i in range(m):\\n r[i] = b[i] - (r[i] + Dm[i]*y_k[i])\\n\\n oldmaxrs = maxrs\\n maxrs = max(np.abs(r).max(), np.abs(s).max())\\n\\n # --- for tuning purposes ---\\n if (self.verbose>2 and _pass>0):\\n print(\\\"refinement({:3d}): {:8.2e} {:8.2e} {:8.2e}\\\".format(\\n _pass, np.abs(s).max(), np.abs(r).max(), maxrs/maxbc ))\\n\\n _pass += 1\\n if maxrs > (1.0e-10*maxbc) and maxrs < (oldmaxrs/2):\\n continue\\n else:\\n break\\n\\n if maxrs > oldmaxrs and _pass > 1:\\n for j in range(n):\\n x_k[j] = x_k[j] - z[iperm[j]]\\n for i in range(m):\\n y_k[i] = y_k[i] - z[iperm[n+i]]\\n\\n \\t#----------------------------------------------------------\\n \\t#| overwrite input with output\\n\\n for j in range(n):\\n c[j] = x_k[j]\\n for i in range(m):\\n b[i] = y_k[i]\\n\\n return consistent\",\n \"def equations(self):\\n k = 0\\n ######################################################################\\n # equations for fluid balance\\n self.residual[k:k + self.num_nw_fluids * 2] = self.fluid_func()\\n k += self.num_nw_fluids * 2\\n\\n ######################################################################\\n # equations for mass flow balance\\n self.residual[k:k + 2] = self.mass_flow_func()\\n k += 2\\n\\n ######################################################################\\n # equations for energy balance\\n self.residual[k] = self.energy_func()\\n k += 1\\n\\n ######################################################################\\n # equations for specified heat transfer\\n if self.Q.is_set:\\n self.residual[k] = (\\n self.inl[0].m.val_SI * (\\n self.outl[0].h.val_SI - self.inl[0].h.val_SI) - self.Q.val)\\n k += 1\\n\\n ######################################################################\\n # equations for specified heat transfer coefficient\\n if self.kA.is_set:\\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\\n self.residual[k] = self.kA_func()\\n k += 1\\n\\n ######################################################################\\n # equations for specified heat transfer coefficient characteristic\\n if self.kA_char.is_set:\\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\\n self.residual[k] = self.kA_char_func()\\n k += 1\\n\\n ######################################################################\\n # equations for specified upper terminal temperature difference\\n if self.ttd_u.is_set:\\n self.residual[k] = self.ttd_u_func()\\n k += 1\\n\\n ######################################################################\\n # equations for specified lower terminal temperature difference\\n if self.ttd_l.is_set:\\n self.residual[k] = self.ttd_l_func()\\n k += 1\\n\\n ######################################################################\\n # equations for specified pressure ratio at hot side\\n if self.pr1.is_set:\\n self.residual[k] = (\\n self.pr1.val * self.inl[0].p.val_SI - self.outl[0].p.val_SI)\\n k += 1\\n\\n ######################################################################\\n # equations for specified pressure ratio at cold side\\n if self.pr2.is_set:\\n self.residual[k] = (\\n self.pr2.val * self.inl[1].p.val_SI - self.outl[1].p.val_SI)\\n k += 1\\n\\n ######################################################################\\n # equations for specified zeta at hot side\\n if self.zeta1.is_set:\\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\\n self.residual[k] = self.zeta_func(\\n zeta='zeta1', inconn=0, outconn=0)\\n k += 1\\n\\n ######################################################################\\n # equations for specified zeta at cold side\\n if self.zeta2.is_set:\\n if np.absolute(self.residual[k]) > err ** 2 or self.it % 4 == 0:\\n self.residual[k] = self.zeta_func(\\n zeta='zeta2', inconn=1, outconn=1)\\n k += 1\\n\\n ######################################################################\\n # additional equations\\n self.additional_equations(k)\",\n \"def optimize(self,max_iter=100):\\n\\n\\n for itr in range(max_iter):\\n opt_logs = self.opt.minimize(self.tot_neg_elbo,sum([expert.trainable_variables for expert in self.experts],())) \\n print(self.neg_elbo)\",\n \"def _compute_imprimitivity(self):\\n m = floor(self._.d / 2)\\n self._.antipodal = all(full_simplify(\\n self._.b[i] - self._.c[self._.d - i]) == 0\\n for i in range(self._.d) if i != m)\\n self._.bipartite = all(a == 0 for a in self._.a)\\n if self._.antipodal:\\n try:\\n self._.r = integralize(\\n 1 + self._.b[m] / self._.c[self._.d - m])\\n except TypeError:\\n raise InfeasibleError(\\\"covering index not integral\\\")\\n if self._.d >= 2:\\n if self._.d == 2:\\n b = [self._.b[0]/(self._.b[1]+1)]\\n c = [Integer(1)]\\n else:\\n b = self._.b[:m]\\n c = list(self._.c[1:m+1])\\n if is_divisible(self._.d, 2):\\n c[-1] *= self._.r\\n scheme = self._get_class()(tuple(b), tuple(c))\\n else:\\n scheme = ASParameters(P=[[1]])\\n self._.antipodal_subscheme = self.add_subscheme(scheme,\\n self.ANTIPODAL)\\n if self._.bipartite:\\n if self._.d >= 2:\\n b = tuple(self._.b[2*i]*self._.b[2*i+1]/self._.c[2]\\n for i in range(m))\\n c = tuple(self._.c[2*i+1]*self._.c[2*i+2]/self._.c[2]\\n for i in range(m))\\n scheme = self._get_class()(b, c)\\n else:\\n scheme = ASParameters(P=[[1]])\\n self._.bipartite_subscheme = self.add_subscheme(scheme,\\n self.BIPARTITE)\",\n \"def solve(self):\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def _brute_force(self):\\n if self.N > 9:\\n #print(\\\"Input set is too big for brute force estimation.\\\")\\n self.best_path = None\\n else:\\n #print(\\\"Number of permutations to check: {}\\\".format(math.factorial(self.N)))\\n #init = \\n A = self._P + np.finfo(np.float).eps\\n A = (A + (1-A).T)/2\\n for i in range(A.shape[0]):\\n A[i,i] = np.finfo(np.float).eps\\n init = (A>0.5).sum(axis=1).argsort()[::-1]\\n #--- use log(p(Y=1\\\\mid s',s)) to shift multiplication to sum\\n lP = np.log(A)\\n for i in range(lP.shape[0]):\\n lP[i,i] = 0\\n #init_cost = 0\\n ##--- lP[x:x+1] está MAL hay que sumar respecto a i+1 en z, no en lP.\\n #for i in range(len(init)-1):\\n # init_cost += lP[init[i],init[i+1]:].sum()\\n z_star = []\\n z_cost = -np.inf\\n for z in permutations(range(self.N)):\\n cost = 0\\n for i in range(len(z)-1):\\n cost += lP[z[i],z[i+1:]].sum()\\n if cost > z_cost:\\n z_cost = cost\\n z_star = z\\n self.best_path = np.array(z_star)\",\n \"def _solver_dirty(X, R, coef_shared_, coef_specific_, Ls, alpha, beta,\\n max_iter, tol, positive):\\n n_tasks = len(X)\\n n_samples, n_features = X[0].shape\\n theta = coef_shared_ + coef_specific_\\n alpha *= n_samples\\n beta *= n_samples\\n\\n # dg = 1.\\n for i in range(max_iter):\\n w_max = 0.0\\n d_w_max = 0.0\\n for j in range(n_features):\\n if Ls[j] == 0.:\\n continue\\n # compute residual\\n grad = np.zeros(n_tasks)\\n tmp1 = np.zeros(n_tasks)\\n tmp2 = np.zeros(n_tasks)\\n\\n normtmp = 0.\\n for t in range(n_tasks):\\n for n in range(n_samples):\\n grad[t] += X[t, n, j] * R[t, n]\\n grad[t] /= Ls[j]\\n tmp1[t] = grad[t] + coef_shared_[j, t]\\n tmp2[t] = grad[t] + coef_specific_[j, t]\\n\\n normtmp += tmp1[t] ** 2\\n\\n normtmp = np.sqrt(normtmp)\\n\\n # l2 thresholding\\n\\n thresholdl2 = 0.\\n if normtmp:\\n thresholdl2 = max(1. - alpha / (Ls[j] * normtmp), 0.)\\n tmp1 *= thresholdl2\\n thresholdl1 = beta / Ls[j]\\n tmp2 = np.sign(tmp2) * np.maximum(np.abs(tmp2) - thresholdl1, 0.)\\n if positive:\\n tmp2 = np.maximum(tmp2, 0.)\\n tmp1 = np.maximum(tmp1, 0.)\\n new_theta = tmp1 + tmp2\\n if theta[j].any():\\n for t in range(n_tasks):\\n R[t] += X[t, :, j] * theta[j, t]\\n\\n d_w_j = np.abs(theta[j] - new_theta).max()\\n d_w_max = max(d_w_max, d_w_j)\\n w_max = max(w_max, np.abs(tmp1 + tmp2).max())\\n coef_shared_[j] = tmp1\\n coef_specific_[j] = tmp2\\n theta[j] = new_theta\\n\\n if theta[j].any():\\n for t in range(n_tasks):\\n R[t] -= X[t, :, j] * theta[j, t]\\n\\n if (w_max == 0.0 or d_w_max / w_max < tol):\\n break\\n\\n return coef_shared_, coef_specific_, R, i\",\n \"def compute(self):\\n\\n self.setd = []\\n self.satc = [False for cl in self.soft] # satisfied clauses\\n self.solution = None\\n self.bb_assumps = [] # backbone assumptions\\n self.ss_assumps = [] # satisfied soft clause assumptions\\n\\n if self.oracle.solve():\\n # hard part is satisfiable => there is a solution\\n self._filter_satisfied(update_setd=True)\\n self._compute()\\n\\n self.solution = list(map(lambda i: i + 1, filter(lambda i: not self.satc[i], range(len(self.soft)))))\\n\\n return self.solution\",\n \"def cvxpy_solver(self, verbose=False):\\n self.gamma = self._gamma_from_drawdown_control()\\n\\n objective = 0\\n constr = []\\n\\n # weights variable depends on whether there is a risk-free asset in data\\n if self.rf_included is True:\\n # variable with shape h+1 predictions so first row\\n # can be the known (non-variable) portfolio weight at time t\\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets))\\n else:\\n # Set rf to zero in all preds and cov\\n self.rets = np.insert(self.rets, self.n_assets, 0, axis=1)\\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-2)\\n self.cov = np.insert(self.cov, self.n_assets, 0, axis=-1) # Has to be done in two steps for cov due to dims\\n self.start_weights = np.append(self.start_weights, 0)\\n\\n weights = cp.Variable(shape=(self.n_preds + 1, self.n_assets+1))\\n rf_zero_weights = np.zeros(shape=self.n_preds)\\n constr += [weights[1:, -1] == 0] # Keep rf pos at zero since it non-present in this case\\n\\n\\n # Loop through each row in the weights variable and construct the optimization problem\\n # Note this loop is very cpu-light since no actual computations takes place inside it\\n for t in range(1, weights.shape[0]):\\n # sum problem objectives. Weights are shifted 1 period forward compared to self.rets\\n # Concatenates objective and constraints in lists\\n objective += self.single_period_objective_func(weights[t], weights[t-1], self.rets[t-1], self.cov[t-1])\\n constr += self.single_period_constraints(weights[t]) # Concatenate constraints\\n\\n constr += [weights[0] == self.start_weights] # first weights are fixed at known current portfolio\\n\\n prob = cp.Problem(cp.Maximize(objective), constr) # Construct maximization problem\\n prob.solve(solver=cp.ECOS, verbose=verbose)\\n\\n if self.rf_included is True:\\n opt_var = weights.value\\n else:\\n opt_var = weights.value[:, :-1]\\n\\n if verbose is True:\\n print(\\\"Shape of var: \\\", opt_var.shape)\\n temp_df = pd.DataFrame(opt_var).round(3)\\n temp_df['sum_weights'] = np.sum(opt_var, axis=1)\\n print(temp_df)\\n\\n return opt_var[1:] # Discard first row which is not a variable.\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\n \"def opt(self, demands: Demand) -> float:\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('multicommodity_flow_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the splitting ratios for each edge\\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(self.num_edges):\\n flow_variable_edges.append(\\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Capacity constraint\\n capacity_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint between 0 and edge capacity\\n constraint_i = solver.Constraint(\\n 0, self.graph.get_edge_data(*edge)['weight'],\\n '(1,{},{})'.format(*edge))\\n for j, commodity in enumerate(self.commodities):\\n # Coefficient for jth flow over ith edge is scaled by flow width\\n constraint_i.SetCoefficient(flow_variables[j][i],\\n # cast because or-tools :'(\\n float(demands[j]))\\n capacity_constraints.append(constraint_i)\\n\\n # Conservation on transit nodes\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.num_nodes):\\n if j != commodity[0] and j != commodity[1]:\\n # Constraint must sum to zero\\n constraint_j = solver.Constraint(0, 0,\\n '(2,{},{})'.format(i, j))\\n for k in list(sorted(self.graph.adj[j].keys())):\\n # Ingress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\\n # Egress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Conservation of flow at source node\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[0], edge_dest)]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[0])]],\\n -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Conservation of flow at destination node\\n conservation_dest_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[1])]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[1], edge_dest)]],\\n -1)\\n conservation_dest_constraints.append(constraint_i)\\n\\n ## OBJECTIVES\\n # Implementation of the load-balancing example from Wikipedia\\n # First we add more constraints so that we are minimising the maximum\\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\\n 'max_link_utilisation')\\n min_of_max_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\\n # i.e 'f_0 + f_1 + ... < max'\\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\\n '(5,{})'.format(i))\\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\\n for j, flow_variable in enumerate(flow_variables):\\n constraint_i.SetCoefficient(flow_variable[i],\\n demands[j] /\\n self.graph.get_edge_data(*edge)[\\n 'weight'])\\n min_of_max_constraints.append(constraint_i)\\n\\n # Objective now is to minimise the maximum link utilisation\\n objective = solver.Objective()\\n objective.SetCoefficient(max_utilisation_variable, 1)\\n objective.SetMinimization()\\n solver.Solve()\\n\\n return objective.Value()\",\n \"def solve_Q(ih, jh):\\n # Build A and b\\n\\n # Solve for c via least squares.\\n\\n # Form C from c\\n\\n # Solve for Q and return it.\\n return None\",\n \"def _computeEquilibriumValue(self,cp,kdT,kdI,Cactiv0,Cinhib0,E0,X0,masks,observed=None,verbose=False):\\n # We move from an array to a list of 2d-array for the competition over each template:\\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 if verbose:\\n print(\\\" input to python:\\\",X0,\\\" with cp: \\\",cp)\\n for inpIdx in range(layer.shape[1]):\\n # The first layer is a one to one non-linearity leading to an equation of the second order:\\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\\n x_eq = X0[inpIdx]\\n else:\\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0)\\n if verbose:\\n print(\\\"bOnA python\\\",bOnA)\\n print(\\\"second part\\\",4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))\\n x_eq = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))**0.5)\\n # saving values\\n layerEq[inpIdx] = x_eq\\n olderX[layeridx] = layerEq\\n\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\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]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),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]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n if verbose:\\n print(\\\"numerateur: \\\",np.sum(CactivsOld*olderX[layeridx-1]), \\\" denominateur: \\\",np.sum(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n olderX[layeridx] = layerEq\\n if verbose and layeridx==1:\\n print(\\\"python second layer:\\\",layerEq)\\n if verbose and layeridx==2:\\n print(\\\"python third layer: \\\",layerEq)\\n #Compute equilibrium for last layers:\\n layerEq = np.zeros(masks[-1].shape[0])\\n for outputIdx in range(masks[-1].shape[0]):\\n\\n CactivsOld = np.where(masks[-1][outputIdx,:]>0,Cactiv0[-1][outputIdx]/(1+self.k1M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\\n CinhibsOld = np.where(masks[-1][outputIdx,:]<0,Cinhib0[-1][outputIdx]/(1+self.k3M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\\n Inhib = np.sum(CinhibsOld*olderX[-1]/kdT[-1][outputIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[-1]/(kdI[-1][outputIdx]*cp+Inhib/cp))\\n layerEq[outputIdx]=x_eq\\n olderX = olderX + [layerEq]\\n\\n if observed is not None:\\n try:\\n assert len(observed)==2\\n except:\\n raise Exception(\\\"please provide a tuple of size two for observed indicating the value to use.\\\")\\n return olderX[observed[0]][observed[1]]\\n return olderX\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n print(\\\"starting time\\\")\\n start = time.time()\\n print(\\\"hello\\\")\\n end = time.time()\\n print(\\\"time taken\\\",end - start)\\n random.shuffle(wizards)\\n assignment = wizards\\n loop_counter = 0\\n temperature = 10.0\\n while not numSat(constraints, assignment) == len(constraints):\\n loop_counter += 1\\n if loop_counter % 500 == 0:\\n print(\\\"numSat\\\", numSat(constraints, assignment))\\n print(\\\"loops\\\",loop_counter)\\n print(\\\"time taken\\\", time.time()-start)\\n a = random.sample([i for i in range(len(wizards))], 1)\\n b = random.sample([i for i in range(len(wizards))], 1)\\n new_assignment = swap(assignment, a[0], b[0])\\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\\n if delta < 0:\\n print(\\\"delta negative\\\")\\n assignment = new_assignment\\n else: \\n # print(\\\"sample greater than expo\\\")\\n sample = random.uniform(0.0,1.0)\\n expo = np.exp(-1*float(delta) / temperature)\\n if sample < expo:\\n # print(\\\"sample less than expo\\\")\\n assignment = new_assignment\\n temperature -= 0.2\\n\\n print(\\\"Solved BITCH! numSat:\\\", numSat(constraints, assignment))\\n return assignment\",\n \"def potentialSolver(self, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n\\n R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1])\\n\\n sum += R*R;\\n\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n \\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def solve(self):\\n\\t\\t# row and column to control the selected corner\\n\\t\\tcurrent_positions = [0, 0]\\n\\t\\tmax_row = self.result_index[self.__ROW_INDEX]-1\\n\\t\\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\\n\\t\\twhile self.matrix[max_row][max_col] != 0:\\n\\t\\t\\tcurrent_row = current_positions[self.__ROW_INDEX]\\n\\t\\t\\tcurrent_column = current_positions[self.__COLUMN_INDEX]\\n\\t\\t\\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\\n\\t\\t\\tactual_weight = self.matrix[current_row][current_column]\\n\\t\\t\\tactual_result_weight = multiplier_selected[1]\\n\\t\\t\\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\\n\\t\\t\\tself.matrix[max_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[current_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[max_row][current_column] -= actual_result_weight\\n\\t\\t\\tcurrent_positions[multiplier_selected[0]] += 1\",\n \"def optimize(self):\\n\\n self.logger.info(\\\"Solving with Dynamic Slope Scaling Procedure in Julia :\\\")\\n optimization_start = time.time()\\n\\n # 1. Preprocess for old network graph\\n if self.old_network_graph is not None:\\n\\n # DSSP on old network\\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\\n try:\\n self.check_infeasibility(self.old_network_graph, old_network_obj)\\n except DHCOptimizerException as e:\\n e.data = \\\"Invalid existing network: \\\" + e.data\\n raise e\\n\\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\\n\\n if self.modify_old_network:\\n\\n # Add max capacity on old edges\\n self.old_capacity = deepcopy(flows)\\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\\n for key in flows:\\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\\n\\n # Add Imaginary edges\\n for edge in self.old_capacity:\\n if self.optimization_graph.has_edge(*edge):\\n\\n # add nodes\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\\n # add edges\\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\\n\\n # put cost\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n\\n else:\\n # if we don't modify the old network, we have to change the capacity of the supplies\\n already_consummed = {}\\n for edge in solution_old_graph.edges():\\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\\\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\\n for source in already_consummed:\\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\\n self.network_objective -= already_consummed[source]\\n else:\\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\\n\\n # Remove edges from old network\\n edges_to_remove = set()\\n for e in self.optimization_graph.edges():\\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\\n edges_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(edges_to_remove)\\n\\n # Remove isolated buildings of optimization graph\\n isolated_to_remove = set()\\n for e in self.old_network_graph.edges():\\n if e[0] in self.old_network_graph.nodes() and \\\\\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n isolated_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(isolated_to_remove)\\n\\n # Remove buildings from old network\\n for n, data in self.old_network_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n self.optimization_graph.remove_node(n)\\n\\n # Re-link sources\\n sources = set()\\n for n, data in self.optimization_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n sources.add(n)\\n source_graph = self.optimization_graph.subgraph(sources).copy()\\n self.optimization_graph.remove_nodes_from(sources)\\n gnx.remove_isolates(self.optimization_graph)\\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\\n\\n # fill missing information\\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\\n for e in self.optimization_graph.edges(keys=True):\\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\\\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\\n\\n\\n\\n # 2. Process the DSSP on optimization graph\\n self.check_is_ready()\\n self.check_infeasibility(self.optimization_graph, self.network_objective)\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\\n else:\\n old_buildings = set()\\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\\n\\n # 3. Postprocess for old network graph\\n if self.old_network_graph is not None:\\n \\n if self.modify_old_network:\\n # Put the right supply capacity and cost\\n for edge in self.old_capacity:\\n if self.solution_graph.has_edge(edge[0],edge[1]):\\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\\n \\n # Remove imaginary edges\\n imaginary_nodes_to_remove = set()\\n nodes_to_relabel = {}\\n for edge in self.solution_graph.edges():\\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\\n if not self.solution_graph.has_edge(*real_edge):\\n for i in range(2):\\n nodes_to_relabel[edge[i]] = real_edge[i]\\n else:\\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\\\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\\n imaginary_nodes_to_remove.add(edge[0])\\n imaginary_nodes_to_remove.add(edge[1])\\n elif str(edge[0]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[0])\\n elif str(edge[1]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[1])\\n\\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\\n for node in nodes_to_relabel.values():\\n if self.solution_graph.has_edge(node, node):\\n self.solution_graph.remove_edge(node, node)\\n\\n else:\\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n\\n return flows, obj_val\",\n \"def sol_cost ( S, D, R ) :\\n\\tmask = array([0]* len(R))\\n\\tmask[R>0] = 1\\n\\tmaxerr = max(mask * abs(S - D))\\n\\tmeanerr = float(sum(mask * abs(S - D)))\\n\\tmeanerr /= sum(mask)\\n\\t\\n\\treturn (sum(R * (S - D)**2),maxerr,meanerr)\",\n \"def CA_Algorithm(self, states, actions, rewards, next_states, terminals):\\n states = states.reshape(-1, self.input_width)\\n next_states = next_states.reshape(-1, self.input_width)\\n update_rule = self.update_rule\\n terminals = terminals.astype(np.float32)\\n if (self.freeze_interval > 0 and\\n self.update_counter % self.freeze_interval == 0):\\n self.reset_q_hat()\\n p_vals, next_p_vals = self.sess.run([self.p_vals, self.next_p_vals],{self.S: states, self.A: actions, self.R: rewards, self.S_: next_states, self.T: terminals})\\n\\n p_target = p_vals.copy()\\n BestAct = np.argmax(np.sum(np.multiply(self.Z, next_p_vals),axis =2), axis = 1)\\n terminals_false = np.ones_like(terminals)-terminals\\n\\n for batchIndex, r in enumerate(rewards):\\n m = np.zeros(self.atoms)\\n for j in range(self.atoms):\\n Tau_z_j = np.clip(r + terminals_false[batchIndex][0]*self.discount * self.Z[j], self.Vmin, self.Vmax)\\n b_j = float(Tau_z_j-self.Vmin)/self.delta_z\\n l = math.floor(b_j)\\n u = math.ceil(b_j)\\n l_int = int(l)\\n u_int = int(u)\\n m[l_int] = m[l_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(u - b_j)\\n m[u_int] = m[u_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(b_j - l)\\n p_target[batchIndex,BestAct[batchIndex],:] = m\\n\\n _,loss = self.sess.run([self._train,self.loss], feed_dict={self.S: states, self.p_target: p_target})\\n self.update_counter += 1\\n return loss\",\n \"def _cg_solve(self, x, data, iters, lambd, tol):\\n b = np.zeros(\\n (\\n self.image_dim,\\n self.image_dim\\n ),\\n self.DTYPE\\n )\\n Ax = np.zeros(\\n (\\n self.image_dim,\\n self.image_dim\\n ),\\n self.DTYPE\\n )\\n\\n b = self.operator_rhs(data)\\n residual = b\\n p = residual\\n delta = np.linalg.norm(residual) ** 2 / np.linalg.norm(b) ** 2\\n self.res.append(delta)\\n print(\\\"Initial Residuum: \\\", delta)\\n\\n for i in range(iters):\\n Ax = self.operator_lhs(p)\\n Ax = Ax + lambd * p\\n alpha = np.vdot(residual, residual)/(np.vdot(p, Ax))\\n x[i + 1] = x[i] + alpha * p\\n residual_new = residual - alpha * Ax\\n delta = np.linalg.norm(residual_new) ** 2 / np.linalg.norm(b) ** 2\\n self.res.append(delta)\\n if delta < tol:\\n print(\\\"\\\\nConverged after %i iterations to %1.3e.\\\" %\\n (i+1, delta))\\n x[0] = b\\n return x[:i+1, ...]\\n if not np.mod(i, 1):\\n print(\\\"Residuum at iter %i : %1.3e\\\" % (i+1, delta), end='\\\\r')\\n\\n beta = (np.vdot(residual_new, residual_new) /\\n np.vdot(residual, residual))\\n p = residual_new + beta * p\\n (residual, residual_new) = (residual_new, residual)\\n x[0] = b\\n return x\",\n \"def rule(model, i, j):\\n active = 1-self.task_spread[j]\\n den = sum(triu[i, :])\\n ind = model.timeslots\\n # FIXME(cathywu) can/should be more precise with A,A2,A3 offsets\\n total = sum(triu[i, k] * (\\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\\n k, j]) for k in ind)\\n total /= den\\n total *= active\\n # CTu[i,j] = floor(total)\\n return -1 + EPS, model.CTu[i, j] - total, EPS + self.slack_cont\",\n \"def solve_cg_eps(self, params, r, sz, energy, aux):\\n\\n dp0_i, g2_i, itr, nsamples = aux\\n\\n jac = self.vmap_getder(params, r, sz, nsamples)\\n #jac_T = conj_transpose(jac)\\n\\n f_i = jnp.real(-2 * psum(jnp.matmul(energy, jnp.conjugate(jac)), axis_name='p') / nsamples)\\n g2_i = self.beta * g2_i + (1. - self.beta) * f_i**2\\n g2h_i = jnp.sqrt(g2_i / (1. - self.beta**itr))\\n\\n# cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(v_i, jac_T), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\\n cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(jnp.conjugate(jac), v_i), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\\n\\n dp_i, info = jax.scipy.sparse.linalg.cg(cg_mult, f_i, x0=dp0_i, tol=1e-5, atol=0.0, maxiter=200)\\n return dp_i, g2_i\",\n \"def fit(self):\\n self._minuit_problem.migrad() # run optimizer\\n self._status = 0 if self._minuit_problem.migrad_ok() else 1\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def run(self, C, p0 = None):\\n global algorithm \\n algorithm = AdaptiveMM(self.g, C, p0 = p0, lambda0 = 2000)\\n solve()\",\n \"def solve(self):\\n is_valid = self.verify_sub_matrixes()\\n \\n if not is_valid:\\n raise ValueError((\\n \\\"El determinante es igual a cero \\\"\\n \\\"el método no puede continuar\\\"\\n ))\\n \\n (lower, upper) = self.doolittle_factorization()\\n\\n lower_solution_vector = lower.solve_matrix(matrix=None, vector=self.vector.vector)\\n lower_solution_vector.print_vector()\\n upper_solution_vector = upper.solve_matrix(\\n matrix=None, vector=lower_solution_vector.vector)\\n upper_solution_vector.print_vector()\\n\\n comprobation = self.matrix.comprobation(upper_solution_vector.vector)\\n return comprobation\",\n \"def equation(self):\\n mat = np.zeros((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n rhs[0:self.nlayers - 1] = 0.0\\n rhs[self.nlayers - 1] = self.Qc\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n head = e.potinflayers(self.xc, self.yc, self.layers) / self.aq.Tcol[self.layers, :]\\n mat[0:self.nlayers - 1, ieq:ieq + e.nunknowns] = head[:-1] - head[1:]\\n if e == self:\\n for i in range(self.nlayers - 1):\\n mat[i, ieq + i] -= self.resfac[i]\\n mat[i, ieq + i + 1] += self.resfac[i + 1]\\n mat[self.nlayers - 1, ieq:ieq + self.nlayers] = 1.0\\n ieq += e.nunknowns\\n else:\\n head = e.potentiallayers(self.xc, self.yc, self.layers) / self.aq.T[self.layers]\\n rhs[0:self.nlayers - 1] -= head[:-1] - head[1:]\\n return mat, rhs\",\n \"def evaluate_solution(self, chosen):\\n self.candidate_counter += 1\\n\\n # evaluation function in abstract superclass\\n \\n solved_clauses = np.any(self.truth_clauses & np.array([chosen, ~chosen]), axis=(2, 1)) \\n num_solved_clauses = np.sum(solved_clauses)\\n # calculate evaluation with weight adaption heuristic\\n evaluation = np.sum(solved_clauses * self.clause_weights)\\n\\n if self.candidate_counter == self.WEIGHT_ADAPTION_DURATION:\\n # increase weights for unsatisfied clauses\\n self.clause_weights += ~solved_clauses\\n self.candidate_counter = 0\\n\\n return evaluation, num_solved_clauses\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fp_tn = tn + fp\\n tp_fn = fn + tp\\n tn_fn = tn + fn\\n tp_fp = fp + tp\\n nis = tn_fn * tn_fn + tp_fp * tp_fp\\n njs = fp_tn * fp_tn + tp_fn * tp_fn\\n sum_of_squares = tp * tp + tn * tn + fp * fp + fn * fn\\n\\n a = (tp * (tp - 1) + fp * (fp - 1) + tn * (tn - 1) + fn * (fn - 1)) / 2.\\n b = (njs - sum_of_squares) / 2.\\n c = (nis - sum_of_squares) / 2.\\n d = (n * n + sum_of_squares - nis - njs) / 2.\\n\\n x1 = a - ((a + c) * (a + b) / (a + b + c + d))\\n x2 = ((a + c) + (a + b)) / 2.\\n x3 = ((a + c) * (a + b)) / (a + b + c + d)\\n denominator = x2 - x3\\n\\n if denominator != 0:\\n return x1 / denominator\\n else:\\n return 0\",\n \"def SolveSCP(self):\\n\\n t0 = time()\\n\\n # Some predicates\\n Lu_min = 0.\\n niters_max = self._maxiters\\n maxfracchange = self._maxfracchange\\n\\n # initialization, resetting ...\\n self.reset_all() # including _u_naught(), first application\\n scp_min = self.greedy()\\n\\n # re-initialization iteration; col fixing ignored for the moment\\n niters = 0\\n f_change = _largenumber\\n while (f_change>maxfracchange) and (niters<niters_max):\\n # re-initialize u\\n if (np.mod(niters, 2)==0): \\n self.reset_u(random=True)\\n else:\\n self.reset_u()\\n u_tmp, Lu_tmp = self.subgradient() # find a near-optimal solution \\n u, Lu = self.subgradient() # rerun subgradient to get a set of Lagrangian multipliers\\n\\n scp_all = np.zeros(self._subg_nsteps)\\n for i in np.arange(self._subg_nsteps):\\n #self.reset_s()\\n self.s = np.copy(self.f)\\n scp_all[i] = self.greedy(u=u[:,i])\\n\\n # check if the solution is gettting better\\n imin_tmp = (np.where(scp_all==np.amin(scp_all)))[0]\\n imin = imin_tmp[np.argmax(Lu[imin_tmp])]\\n imax = np.argmax(Lu)\\n if (np.mod(niters, 5)==0):\\n print(\\\"This Best solution: UB={0}, LB={1}, UB1={2}, LB1={3}\\\".format(scp_all[imin], Lu[imin], scp_all[imax], Lu[imax]))\\n if (niters==0) or ((scp_all[imin]<=scp_min) and ((Lu[imin]-Lu_min)>-(np.fabs(Lu_min)*self._LB_maxfracchange))):\\n scp_min = scp_all[imin]\\n u_min = np.copy(u[:,imin])\\n Lu_min = Lu[imin]\\n self.stepsize = _stepsize\\n\\n LB = Lu_min\\n\\n # final step, needs to get u_min back\\n self.u = np.copy(u_min)\\n self.s = np.copy(self.f)\\n UB = self.greedy()\\n\\n # Which is better? absolute change or fractional change? \\n # Both are fine, but cost should be normalized over the mean/median.\\n GAP = (UB-LB)/np.fabs(UB)\\n f_change = GAP\\n if (np.mod(niters, 5)==0):\\n print(\\\"Current Best Solution: UB={0}, LB={1}, change={2}% @ niters={3}\\\".format(UB,LB,f_change*100.,niters))\\n niters = niters + 1\\n if (niters == niters_max): \\n #warnings.warn(\\\"Iteration reaches maximum = {0}\\\".format(niters))\\n print(\\\"Iteration in re-initialization reaches maximum number = {0}\\\".format(niters))\\n\\n # Need to remove redundant columns\\n # self.remove_redundant() # this itself is NP-hard ...\\n\\n print(\\\"Current Best Solution: UB={0}, LB={1}, change={2}% @ niters={3}\\\".format(UB,LB,f_change*100.,niters))\\n print(\\\"Final Best solution: {0}\\\".format(UB))\\n time_used = (time()-t0)/60.\\n print(\\\"Took {0:.3f} minutes to reach current solution.\\\".format(time_used))\\n\\n return (UB,time_used)\",\n \"def _compute_correction(self, initial_state, final_state, a, b, c, s):\\r\\n pertub = self.pertub\\r\\n pertub_s = pertub *10\\r\\n \\r\\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\\r\\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\\r\\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\\r\\n # no need to correct C, C is constrained by kappa_final\\r\\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\\r\\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\\r\\n\\r\\n d_state = np.zeros((3,1))\\r\\n d_pertub_state = np.zeros((3,3))\\r\\n Jacobian = np.zeros((3,3))\\r\\n for i in range(0, 3):\\r\\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\\r\\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\\r\\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\\r\\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\\r\\n \\r\\n d_state[i] = final_state[i] - pred_no_pertub[i]\\r\\n \\r\\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\\r\\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\\r\\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\\r\\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\\r\\n\\r\\n # inv_Jacobian = np.linalg.inv(Jacobian)\\r\\n inv_Jacobian = np.linalg.pinv(Jacobian)\\r\\n correction = np.dot(inv_Jacobian, d_state)\\r\\n # pdb.set_trace()\\r\\n return correction\",\n \"def solve_model(self): \\n \\n t0 = time.time() #start the clock\\n \\n # a. benchmark case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(1)\\n \\n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(self.tau_benchmark) #set tax system\\n \\n #iii. benchmark equilibrium\\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\\\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Benchmark Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\")\\n print(f\\\"ss output = {self.Yss_b:.2f}\\\")\\n print(f\\\"ss capital = {self.Kss_b:.2f}\\\")\\n print(f\\\"ss tfp = {self.TFPss_b:.2f}\\\")\\n print(f\\\"ss wage = {self.w_ss_b:.2f}\\\")\\n print(f\\\"entry mass = {self.E_star_b:.3f}\\\")\\n print(f\\\"avg. firm size = {self.average_firm_size_b:.2f}\\\")\\n \\n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\\n \\n if self.plott:\\n #i. initialize\\n employed = [4.99, 49.99]\\n firm_size_by_employee = np.zeros(len(employed)+1)\\n share_employment = np.zeros(len(employed)+1)\\n \\n \\n #i. percentage of firms that employ employed\\n \\n for i_e in range(len(employed)):\\n summ = np.sum(firm_size_by_employee)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\\n firm_size_by_employee[i_e] = interpolate - summ\\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\\n \\n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Size of Firms by Firm Size (Number of Employees)')\\n plt.savefig('firm_size_rr08.pdf')\\n plt.show()\\n \\n \\n #ii. employment percentage by firm size\\n for i_e in range(len(employed)):\\n summ = np.sum(share_employment)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\\n share_employment[i_e] = interpolate - summ\\n share_employment[-1] = 1 - np.sum(share_employment)\\n \\n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Employment Share by Firm Size (Number of Employees)')\\n plt.savefig('employment_by_firm_size_rr08.pdf')\\n plt.show()\\n \\n #iii. productivity cdf and employment cdf\\n plt.plot(self.grid_s, self.cdf_stationary_b)\\n plt.plot(self.grid_s, self.cdf_emp_b)\\n plt.title('Stationary CDF' )\\n plt.xlabel('Productivity level')\\n plt.ylabel('Cumulative Sum')\\n plt.legend(['Firms by Productivity Level','Share of Employment'])\\n plt.savefig('cdf_rr08.pdf')\\n plt.show()\\n \\n \\n \\n #c. distortion case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(0)\\n \\n #ii. compute stationary economy for each tau\\n \\n for idx, tau in enumerate(self.tau_vector):\\n \\n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\\n self.tau_s[idx] = self.find_subsidy_rate(tau)\\n \\n # set tax system with newly found tau_s and given tau\\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv) #set tax system\\n \\n #v. distorted stationary equilibrium\\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\\\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\\\\n _, _ = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Distorted Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n if self.distortion_case == 1:\\n print(\\\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(low productivity firms recieve subsidy, high productivity taxed)\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Positively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(high productivity firms recieve subsidy, low productivity taxed)\\\\n\\\")\\n if self.policy_type == 1 :\\n print(\\\"Tax Type: Tax on output\\\\n\\\")\\n elif self.policy_type == 2 :\\n print(\\\"Tax Type: Tax on capital\\\\n\\\")\\n elif self.policy_type == 3 :\\n print(\\\"Tax Type: Tax on labor\\\\n\\\")\\n print(f\\\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\\\")\\n print(f\\\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\\\")\\n print(f\\\"fraction of firms excempt = {self.excempt_frac:.2f}\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n \\n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \\n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\\n [], \\n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \\n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \\n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \\n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \\\"Tax = \\\"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\\n \\n\\n t1 = time.time()\\n print(f'\\\\nTotal Run Time: {t1-t0:.2f} seconds')\",\n \"def solver(I, f, c, bc, Lx, Ly, nx, ny, dt, tstop,\\n user_action=None, \\n implementation={'ic': 'vec', # or 'scalar' or 'weave'\\n 'inner': 'vec',\\n 'bc': 'vec',\\n 'storage': 'f77'},\\n verbose=True):\\n dx = Lx/float(nx)\\n dy = Ly/float(ny)\\n x = linspace(0, Lx, nx+1) # grid points in x dir\\n y = linspace(0, Ly, ny+1) # grid points in y dir\\n xv = x[:,newaxis] # for vectorized function evaluations\\n yv = y[newaxis,:]\\n\\n if dt <= 0: # max time step?\\n dt = (1/float(c))*(1/sqrt(1/dx**2 + 1/dy**2))\\n Cx = c*dt/dx**2; Cy = c*dt/dy**2 # help variables\\n\\n up = zeros((nx+1,ny+1)) # solution array\\n u = up.copy() # solution at t-dt\\n\\n # use scalar implementation mode if no info from user:\\n if 'ic' not in implementation:\\n implementation['ic'] = 'scalar'\\n if 'bc' not in implementation:\\n implementation['bc'] = 'scalar'\\n if 'inner' not in implementation:\\n implementation['inner'] = 'scalar'\\n\\n if 'weave' in implementation.itervalues() or \\\\\\n 'f77' in implementation.itervalues():\\n # we avoid callback to Python and require f, bc, and I to be\\n # string formulas:\\n print f, bc, I\\n if not isinstance(f, StringFunction) or \\\\\\n not isinstance(bc, StringFunction) or \\\\\\n not isinstance(I, StringFunction):\\n raise TypeError, \\\\\\n 'with Weave or F77, f, bc, and I must be StringFunction'\\n\\n if 'f77' in implementation.itervalues():\\n make_f77(f, bc, I) # build F77 module\\n import f77\\n # unified names with py versions:\\n ic_f77 = f77.ic_f77\\n bc_f77 = f77.bc_f77\\n scheme_f77 = f77.scheme_f77\\n \\n # turn arrays to column major storage after the init. cond.\\n\\n # set initial condition:\\n t0 = time.clock()\\n t = 0.0\\n print '***', implementation['ic']\\n func = 'ic_'+implementation['ic']\\n if func == 'ic_vec':\\n u = eval(func)(u, I, xv, yv)\\n elif func == 'ic_f77':\\n u = eval(func)(u, x, y)\\n else:\\n u = eval(func)(u, I, x, y)\\n t_ic = time.clock() - t0\\n \\n\\n if implementation['inner'] == 'f77':\\n # turn input arrays to Fortran storage for all arrays\\n # that are input arrays in loop subroutine\\n # (actually not necessary as up, u, and um are all fed\\n # through the f77.loop routine and brought to column\\n # major storage in turn - recall um=u, u=up, up=um)\\n if implementation.get('storage', 'f77') == 'f77':\\n up = asarray(up, order='Fortran')\\n u = asarray(u, order='Fortran')\\n\\n if user_action is not None:\\n user_action(u, xv, yv, t) # allow user to plot etc.\\n\\n t_inner = 0 # CPU time inner loops\\n t_bc = 0 # CPU time boundary update\\n \\n while t <= tstop:\\n t_old = t; t += dt\\n if verbose:\\n print 'solving (%s version) at t=%g' % \\\\\\n (implementation['inner'], t)\\n\\n t0 = time.clock()\\n # update all inner points:\\n func = 'scheme_'+implementation['inner']\\n if func == 'scheme_vec':\\n up = eval(func)(up, u, um, f, xv, yv, t, Cx, Cy, dt2, t_old)\\n elif func == 'scheme_f77':\\n up = eval(func)(up, u, um, x, y, t, Cx, Cy, dt2, t_old)\\n else:\\n up = eval(func)(up, u, um, f, x, y, t, Cx, Cy, dt2, t_old)\\n\\n #id_u = id(u); id_um = id(um)\\n #up,u,um = f77.loop(up, u, um, f_array, Cx, Cy, dt2)\\n #print 'u changed:', id_u!=id(u),\\n #print 'um changed:', id_um!=id(um),\\n t_inner += time.clock() - t0\\n\\n t0 = time.clock()\\n # insert boundary conditions:\\n func = 'bc_'+implementation['bc']\\n if func == 'bc_f77':\\n up = eval(func)(up, x, y, t)\\n else:\\n up = eval(func)(up, bc, x, y, t)\\n t_bc += time.clock() - t0\\n \\n if user_action is not None:\\n user_action(up, xv, yv, t)\\n # update data structures for next step:\\n u, up = u, up\\n\\n # dt might be computed in this function\\n return dt, t_ic, t_inner, t_bc\",\n \"def alg(c):\\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]\",\n \"def get_sol(self):\",\n \"def cost(comb,X_ica,X_real):\\n X_ica_fit = np.zeros(X_ica.shape)\\n for i in range(X_real.shape[0]):\\n X_ica_fit[int(i)] = X_ica[int(comb[i])]\\n\\n return mean_squared_error(X_ica_fit, X_real)\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def _compute_results(self):\\n self.Y_best = best_value(self.Y)\\n self.x_opt = self.X[np.argmin(self.Y),:]\\n self.fx_opt = np.min(self.Y)\\n self.distance = self._compute_distance_betw_consecutive_x()\",\n \"def main_function(self):\\n self.ana_cont_probl = cont.AnalyticContinuationProblem(im_axis=self.input_data.mats,\\n im_data=self.input_data.value.real,\\n re_axis=self.realgrid.grid,\\n kernel_mode='freq_bosonic')\\n model = np.ones_like(self.realgrid.grid)\\n model /= np.trapz(model, self.realgrid.grid)\\n\\n preblur, bw = self.get_preblur()\\n\\n sol = self.ana_cont_probl.solve(method='maxent_svd',\\n optimizer='newton',\\n alpha_determination='chi2kink',\\n model=model,\\n stdev=self.input_data.error,\\n interactive=False, alpha_start=1e10, alpha_end=1e-3,\\n preblur=preblur, blur_width=bw)\\n\\n inp_str = 'atom {}, orb {}, spin {}, blur {}: '.format(self.input_data.atom,\\n self.input_data.orbital,\\n self.input_data.spin,\\n bw)\\n all_chis = np.isfinite(np.array([s.chi2 for s in sol[1]]))\\n res_str = 'alpha_opt={:3.2f}, chi2(alpha_opt)={:3.2f}, min(chi2)={:3.2f}'.format(\\n sol[0].alpha, sol[0].chi2, np.amin(all_chis)\\n )\\n self.text_output.append(inp_str + res_str)\\n alphas = [s.alpha for s in sol[1]]\\n chis = [s.chi2 for s in sol[1]]\\n\\n self.output_data.update(self.realgrid.grid, sol[0].A_opt, self.input_data)\\n\\n fig, ax = plt.subplots(ncols=2, nrows=2, figsize=(11.75, 8.25)) # A4 paper size\\n ax[0, 0].loglog(alphas, chis, marker='s', color='black')\\n ax[0, 0].loglog(sol[0].alpha, sol[0].chi2, marker='*', color='red', markersize=15)\\n ax[0, 0].set_xlabel(r'$\\\\alpha$')\\n ax[0, 0].set_ylabel(r'$\\\\chi^2(\\\\alpha)$')\\n\\n ax[1, 0].plot(self.realgrid.grid, sol[0].A_opt)\\n ax[1, 0].set_xlabel(r'$\\\\omega$')\\n ax[1, 0].set_ylabel('spectrum')\\n\\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.real,\\n color='blue', ls=':', marker='x', markersize=5,\\n label='Re[data]')\\n ax[0, 1].plot(self.input_data.mats, self.input_data.value.imag,\\n color='green', ls=':', marker='+', markersize=5,\\n label='Im[data]')\\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.real,\\n ls='--', color='gray', label='Re[fit]')\\n ax[0, 1].plot(self.input_data.mats, sol[0].backtransform.imag,\\n color='gray', label='Im[fit]')\\n ax[0, 1].set_xlabel(r'$\\\\nu_n$')\\n ax[0, 1].set_ylabel(self.input_data.data_type)\\n ax[0, 1].legend()\\n\\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).real,\\n ls='--', label='real part')\\n ax[1, 1].plot(self.input_data.mats, (self.input_data.value - sol[0].backtransform).imag,\\n label='imaginary part')\\n ax[1, 1].set_xlabel(r'$\\\\nu_n$')\\n ax[1, 1].set_ylabel('data $-$ fit')\\n ax[1, 1].legend()\\n plt.tight_layout()\\n plt.show()\",\n \"def rule(model, i, j):\\n active = 1-self.task_spread[j]\\n den = sum(tril[i, :])\\n ind = model.timeslots\\n total = sum(tril[i, k] * (\\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\\n k, j]) for k in ind)\\n total /= den\\n total *= active\\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont\",\n \"def potentialSolver2(self, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def solve_environment(self):\\n \\n #The first problem formulation\\n #K kinds of towers\\n #See more details about problem formulation in the writeup \\n \\n #Get a full matrix of the concatenated coverage matrices for \\n #each tower type. THis new matrix has dimensions:\\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\\n coverage = np.hstack(i for i in self.coverage_matrices)\\n print coverage\\n print coverage.shape \\n \\n #Diagonal matrix of the values of each target\\n #(for the scenarios where we don't care about maximizing covered value,\\n #target_values is just all ones, so this is just the identity matrix)\\n V = np.diag(self.target_values)\\n \\n #If doing scenario where we want to fortify weakest link, only makes\\n #sense if all targets are equal value:\\n if self.objective_type == 'min_entries':\\n V = np.eye(len(self.target_values))\\n\\n #Get the matrix of coverage values / expected value saved:\\n C = np.dot(V,coverage)\\n print 'V', V\\n print 'coverage', coverage\\n print 'C', C\\n \\n \\n #Since not gauranteed to reach global optimum on any particular initialization,\\n #run a few times and take the best result.\\n #Just define \\\"best result\\\" as the result which had the most overall \\n #\\\"converged\\\" x, combined over all tower kinds. \\n# for j in xrange(self.N_random_starts_max):\\n \\n \\n a = 2. #1.\\n tau = 1e-4\\n N = sum(i for i in self.N_tower_sites)\\n w = np.zeros(N)\\n ones = np.ones(N)\\n p = 1. #the exponents power when doing he exponent method:\\n \\n for i in xrange(self.N_reweighting_iterations_max):\\n #The concatenated vector of occupancies: Concatenated over all\\n #of the kinds of towers.\\n x = cvx.Variable(N)\\n \\n #Different objective functions depending on which optimization problem.\\n #These are defined in the scenarios in the main function.\\n if self.objective_type == 'min_entries':\\n operation = cvx.min_entries\\n elif self.objective_type == 'sum_entries':\\n operation = cvx.sum_entries\\n else:\\n raise Exception('must specify valid objective_type')\\n \\n #Objective function includes penalty term for non-binary x values\\n if self.penalty_type == 'reweighted_L1':\\n #objective = cvx.Maximize(t - x.T*w)\\n objective = cvx.Maximize(operation(C*x - x.T*w))\\n\\n\\n #Main constraints on 0<=x<=1\\n constraints = [0<=x, x<=1]\\n \\n \\n #And then for each kind of tower, append the constraint that there\\n #be exactly N_i towers, or <= quota (depending on constraint type)\\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n print before_sum\\n print before_sum + self.N_tower_sites[tk]\\n if self.constraints__type == 'fixed_N_towers':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )==self.N_towers[tk])\\n elif self.constraints__type == 'tower_quotas':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )<=self.budget__tower_quotas[tk])\\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\\n \\n elif self.constraints__type == 'total_cost':\\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \\n \\n \\n \\n\\n\\n \\n \\n print 'penalty_type', self.penalty_type\\n print 'objective_type', self.objective_type\\n print 'constraints__type', self.constraints__type\\n print 'budget__tower_quotas', self.budget__tower_quotas\\n print 'operation', operation\\n print 'objective', objective\\n print 'constraints', constraints\\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\\n x = np.array(x.value).flatten()\\n print 'x', x\\n w = a/(tau+np.abs(x))\\n p += 1.\\n plt.figure(figsize=(5,5))\\n plt.plot(x,marker='o')\\n plt.savefig('histrograms_{}.png'.format(i))\\n print \\n \\n \\n \\n \\n #From the solution x, get the coordinates of those tower sites where we\\n #really do want to place a tower\\n #use = np.isclose(x,1.)\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\\n inds = np.argsort(y)\\n s = y[inds]\\n use = np.where(s>.5)[0]\\n print inds\\n print s\\n print use \\n if self.constraints__type == 'fixed_N_towers':\\n if len(use) != self.N_towers[tk]:\\n print 'Solution did not converge properly. Choosing the K best towers.'\\n print self.N_towers[tk], len(use)\\n # use = use[-self.N_towers[tk]:]\\n use = inds[-self.N_towers[tk]:]\\n elif self.constraints__type == 'tower_quotas':\\n pass #Just use the towers thresholded at > .5\\n print use\\n \\n \\n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])\",\n \"def fit(self):\\n if self.cost_func.hessian:\\n self._popt = ral_nlls.solve(self.initial_params,\\n self.cost_func.eval_r,\\n self.cost_func.jac_res,\\n self.hes_eval,\\n options=self._options,\\n lower_bounds=self.param_ranges[0],\\n upper_bounds=self.param_ranges[1])[0]\\n else:\\n self._popt = ral_nlls.solve(self.initial_params,\\n self.cost_func.eval_r,\\n self.cost_func.jac_res,\\n options=self._options,\\n lower_bounds=self.param_ranges[0],\\n upper_bounds=self.param_ranges[1])[0]\\n self._status = 0 if self._popt is not None else 1\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def compute_cost(self, del_u : list, u : list):\\n print(\\\"ym: \\\", self.ym, \\\"yn: \\\", self.yn)\\n self.cost = 0.0\\n\\n self.ym = self.d_model.ym\\n self.yn = self.d_model.yn\\n\\n # FIXME : this is supposed to be from N1 to N2\\n self.cost+= (self.ym[0] - self.yn[0])\\n angle_diff = (self.ym[1] - self.yn[1])\\n if angle_diff > np.pi:\\n angle_diff -= 2*np.pi\\n if angle_diff < -np.pi:\\n angle_diff += 2*np.pi\\n self.cost += angle_diff\\n\\n for j in range(self.Nu):\\n self.cost += (self.ym[j] - self.yn[j])**2\\n\\n for j in range(self.Nu):\\n self.cost += self.lambd[j]*(del_u[j])**2\\n\\n for j in range(self.Nu):\\n self.cost += self.s / (u[j] + self.r / 2.0 - self.b) + self.s / (self.r/2.0 + self.b - u[j]) - 4.0 / self.r\\n\\n return self.cost\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \\n bc_surface, sigma):\\n\\n # temperatures are reported as a data frame, where each column is a step in time\\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\\n\\n # extract the necessary parameters to determine the surface heat losses\\n if bc_surface[0] == \\\"linear\\\":\\n h = bc_surface[1] + bc_surface[2]\\n hc = 0\\n emissivity = 0\\n elif bc_surface[0] == \\\"non-linear\\\":\\n h = 0\\n hc = bc_surface[1]\\n emissivity = bc_surface[2]\\n\\n # initialize temperature arrays for present and future temperatures\\n T = np.zeros_like(x_grid) + temp_initial\\n Tn = np.zeros_like(x_grid)\\n\\n # iterate over each time step\\n temperatures.iloc[:,0] = T\\n for j, t in enumerate(t_grid[:-1]):\\n \\n # create tri-diagonal matrix A\\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\\n \\n # create vector b\\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \\n emissivity = emissivity, sigma = sigma, j = j)\\n \\n # calculate value of future temperature\\n Tn = np.linalg.solve(A,b)\\n \\n # update present temperature\\n T = Tn.copy()\\n \\n # store temperature profile at this time in the data frame\\n temperatures.iloc[:, j+1] = Tn\\n \\n return temperatures\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def solve(self):\\n\\n if self.degree > 2:\\n return \\\"The polynomial degree is strictly greater than 2, I can't solve.\\\"\\n \\n elif self.degree == 0:\\n \\\"\\\"\\\"a * X^0 = 0\\\"\\\"\\\" \\n a = self.all_terms[0].coefficient\\n if a != 0:\\n return \\\"The eqution has no solution\\\"\\n else:\\n return \\\"Every real number is a solution\\\"\\n\\n elif self.degree == 1:\\n \\\"\\\"\\\"a * X^1 + b * X^0 = 0\\\"\\\"\\\"\\n a = self.all_terms[1].coefficient\\n b = self.all_terms[0].coefficient\\n return formula.linear(a, b)\\n\\n elif self.degree == 2:\\n \\\"\\\"\\\"a * X^2 + b * X^1 + c * X^0 = 0\\\"\\\"\\\"\\n a = self.all_terms[2].coefficient\\n b = self.all_terms[1].coefficient\\n c = self.all_terms[0].coefficient\\n discriminant = (b ** 2) - (4 * a * c)\\n two_a = 2 * a\\n if discriminant == 0:\\n return formula.linear(two_a, b)\\n else:\\n if discriminant > 0:\\n return formula.quadratic(two_a, b, discriminant)\\n else:\\n return formula.quadratic(two_a, b, discriminant, simple=False)\",\n \"def __call__(self, p, q, verbosity=1, warn=True):\\n if self.exactly_zero: return 0.0 # shortcut for trivial case\\n if self.weight == 0:\\n return _np.sum(_np.abs(q - p)) / 2\\n\\n #Set parameter values\\n self.P.value[:] = p[:]\\n self.Q.value[:] = q[:]\\n\\n treg_factor_ok = False\\n self.Treg_factor.value = self.initial_treg_factor\\n while not treg_factor_ok:\\n\\n obj1 = self._obj(self.t_params)\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\\n **default_cvxpy_args(self.solver))\\n\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed: # sanity check\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\\n\\n self.warning_msg = None\\n if failed:\\n if self.solver == \\\"SCS\\\":\\n #raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed:\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\\n\\n if eps > 1e-4:\\n self.warning_msg = (\\\"ResidualTVD: Needed to increase eps to %g.\\\"\\n \\\" The resulting ResidualTVD values are less precise.\\\") % eps\\n if warn: print(self.warning_msg)\\n break\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n\\n #check that Treg_factor term doesn't dominate\\n\\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\\n treg_factor_ok = True\\n\\n # ------------------------------------------------------------------\\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\\n # ------------------------------------------------------------------\\n\\n #resid_tvd = self._obj(self.T_params.value)\\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\\n # Treg_factor_ok = True\\n #else:\\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\\n\\n #obj2 = self._obj(self.T_params.value)\\n #if obj2 < obj1:\\n # Treg_factor_ok = True\\n #else:\\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\\n # self.T_params.value[:] = self.t_params[:] #REVERT\\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\\n # self.Treg_factor.value = self.Treg_factor.value / 10\\n # if self.Treg_factor.value > 1e-7:\\n # print(\\\"REDUCING treg factor to: \\\", self.Treg_factor.value)\\n # else:\\n # Treg_factor_ok = True # give up!\\n\\n if self.Treg_factor.value != self.initial_treg_factor:\\n if verbosity > 0: print(\\\"NOTE: Treg_factor was reduced to %g.\\\" % self.Treg_factor.value)\\n #_warnings.warn((\\\"Initial Treg_factor (%g) was too large, and was reduced to %g.\\\"\\n # \\\" Consider reducing the initial value to avoid repeating calculations.\\\")\\n # % (self.initial_treg_factor, self.Treg_factor.value))\\n\\n obj2 = self._obj(self.T_params.value)\\n if obj2 <= obj1:\\n self.t_params[:] = self.T_params.value[:]\\n else:\\n print_revert_msg(\\\"ResidualTVD failed to reduce objective function (%g > %g)\\\", (obj2, obj1), verbosity)\\n self.T_params.value[:] = self.t_params[:]\\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\\n\\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def potentialSolver4(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def _cpEquilibriumFunc(self,cp,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n new_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\\n for inpIdx in range(layer.shape[1]):\\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\\n #case where there is no polynomial equation\\n new_input = X0[inpIdx]\\n new_cp += 0\\n else:\\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*E0)\\n # BE CAREFUL, HERE ONE SHOULD USE THE GREATER ROOT of the polynomial (only positive)\\n new_input = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*E0))**0.5)\\n # update for fixed point:\\n new_cp += self.k1M[layeridx][inpIdx,inpIdx]*new_input*self.TA0[layeridx][inpIdx,inpIdx]/(1+self.k1M[layeridx][inpIdx,inpIdx]*new_input*E0/cp)\\n layerEq[inpIdx] = new_input\\n olderX[layeridx] = layerEq\\n\\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]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),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]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n # print(np.sum(CactivsOld*olderX[layeridx-1])/(kdI[layeridx-1][inpIdx,0]*cp+Inhib/cp))\\n # print(x_eq)\\n # assert np.sum(CactivsOld*olderX[layeridx-1])/(kdI[layeridx-1][inpIdx,0]*cp+Inhib/cp) == x_eq\\n\\n layerEq[inpIdx] = x_eq\\n\\n\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0)\\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/(1+self.k1M[layeridx][:,inpIdx]*x_eq*self.E0/cp),np.where(layer[:,inpIdx]<0,Kinhibs*x_eq/(1+self.k3M[layeridx][:,inpIdx]*x_eq*self.E0/cp),0)))\\n if layeridx>1:\\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 new_cp += Inhib2/(E0*cp)*x_eq\\n new_cp += firstComplex\\n\\n olderX[layeridx] = layerEq\\n\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layer\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/(1+self.k1M[-1][outputsIdx]*olderX[-1]*self.E0/cp),0)\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/(1+self.k3M[-1][outputsIdx]*olderX[-1]*self.E0/cp),0)\\n\\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n new_cp += Inhib2/(E0*cp)*x_eq\\n\\n\\n return cp - new_cp\",\n \"def dual_problem(\\n states: list[np.ndarray], probs: list[float] = None, dist_method=\\\"min-error\\\"\\n) -> float:\\n constraints = []\\n meas = []\\n\\n dim_x, _ = states[0].shape\\n\\n y_var = cvxpy.Variable((dim_x, dim_x), hermitian=True)\\n objective = cvxpy.Minimize(cvxpy.trace(cvxpy.real(y_var)))\\n\\n dim = int(np.log2(dim_x))\\n dim_list = [2] * int(np.log2(dim_x))\\n sys_list = list(range(1, dim, 2))\\n # dim_list = [3, 3]\\n\\n if dist_method == \\\"min-error\\\":\\n for i, _ in enumerate(states):\\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\\n constraints.append(\\n cvxpy.real(y_var - probs[i] * states[i])\\n >> partial_transpose(meas[i], sys=sys_list, dim=dim_list)\\n )\\n\\n if dist_method == \\\"unambiguous\\\":\\n for j, _ in enumerate(states):\\n sum_val = 0\\n for i, _ in enumerate(states):\\n if i != j:\\n sum_val += cvxpy.real(cvxpy.Variable()) * probs[i] * states[i]\\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\\n constraints.append(\\n cvxpy.real(y_var - probs[j] * states[j] + sum_val)\\n >> partial_transpose(meas[j], sys=sys_list, dim=dim_list)\\n )\\n\\n meas.append(cvxpy.Variable((dim_x, dim_x), PSD=True))\\n constraints.append(\\n cvxpy.real(y_var) >> partial_transpose(meas[-1], sys=sys_list, dim=dim_list)\\n )\\n\\n problem = cvxpy.Problem(objective, constraints)\\n sol_default = problem.solve()\\n\\n # print(np.around(y_var.value, decimals=3))\\n\\n return sol_default\",\n \"def scoreCirc_PassiveFilter(circuit, gen, indi, makeRedundancyInMatrix):#TODO\\n #Calculate density and uniquiness (as in makeNetlist)\\n if makeRedundancyInMatrix == True:\\n FullBigCircuitMatrix = deepcopy(fullRedundancyBigCircuitMatrix(circuit.BigCircuitMatrix))\\n else:\\n FullBigCircuitMatrix = deepcopy(circuit.BigCircuitMatrix)\\n\\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\\n\\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\\t#(ones/(all/2))\\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\\n #print \\\"Kratkih stikov zunanjih povezav:\\\", OcSc\\n \\n results = None\\n if OcSc > 1:\\n score = 1e4*np.exp(OcSc)\\n else:\\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\\n results = runme2.evaluatePassiveFilter_SUHAD(gen, indi)#TODO\\n \\n disfCount = 0\\n\\n gain = np.array(results['gain']['nominal'], dtype=float)\\n if np.isnan(gain):\\n disfCount = disfCount + 1\\n g = 0\\n else:\\n g = abs(gain - 0) if gain < 0 else 0\\n\\n ripple = np.array(results['ripple']['nominal'], dtype=float)\\n if np.isnan(ripple):\\n disfCount = disfCount + 1\\n r = 0 \\n else:\\n r = abs(ripple - 0.5)# if ripple > 0.5 else 0\\n \\n damping = np.array(results['damping']['nominal'], dtype=float)\\n if np.isnan(damping):\\n disfCount = disfCount + 1\\n d = 0\\n else:\\n d = abs(40 - damping)# if damping < 60 else 0\\n \\n #THD = np.array(results['THD']['nominal'], dtype=float)\\n #if np.isnan(THD):\\n # disfCount = disfCount + 1\\n # thd = 0\\n #else:\\n # thd = THD-1 if THD > 1 else 0\\n \\n score = 10*r + g + 10*d\\n\\n if disfCount > 0:\\n score = np.exp(disfCount) * 1e3\\n\\n score = score + (IcNc*IcNc+1)# + abs(BW-bw)*1e2 + abs(CUTOFF-cutoff)*1e2 #add small punishment if not all nodes connected and bw and cutoff are off\\n\\n #print \\\"\\\\t\\\\t\\\\t\\\\t\\\\tG_\\\" + str(gen) + \\\"_I_\\\" + str(indi) + \\\" SCORE:\\\", score\\n #cleanup current subcircuit\\n filename = \\\"g_\\\" + str(gen) + \\\"_i_\\\" + str(indi) + \\\"_subckt.cir\\\"\\n os.remove(filename)\\n return score, matrixDensity, matrixQuaziID, results\",\n \"def penalty_calc(self):\\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\\n\\n # fiber attenuation,\\n self.p_atten = self.alpha*self.length # column B\\n\\n # calculate bandwidth for RIN test (exclude transmitter)\\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\\n rin_bw = 1.0 / rin_inverse_bw\\n\\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\\n k_rin = 0.7\\n\\n # v_rin,\\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\\n math.pow(10.0,0.1*self.rin)) # column AK\\n\\n # Prin,\\n print('v_rin: ', self.v_rin)\\n print('Q: ',self.Q)\\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\\n print(\\\"P_rin : \\\", self.p_rin)\\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\\n print(\\\"isi_center : \\\", self.isi_center)\\n\\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\\n\\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\\n\\n\\n # calculate the \\\"cross\\\" penalty contribution, column S\\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\\n self.p_cross_center = ( # column S\\n arg3\\n - self.p_blw # cell T13\\n - self.p_isi_center # column J\\n - self.p_isi_dj_center # column L\\n - self.p_mpn # column Q\\n - self.p_reflection # column N\\n - self.p_rin # column R\\n - self.pmn*self.l_1) # cell G13\\n print('p_isi_center: ', self.p_isi_center)\\n\\n # calculate the total power budget evaluated at the center of the eye\\n self.p_total_center = ( # column T\\n self.p_isi_center # column J\\n + self.p_isi_dj_center # column L\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1) # cell G13\\n # calculate the total power budget evaluated at the corner of the eye\\n self.p_total_corners = (\\n self.p_isi_center # column J\\n + self.p_isi_corners # column K\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1 # cell G13\\n + self.p_isi_dj_corners)# column M\\n\\n # receiver stressed sensitivity\\n self.margin = ( self.p_budget\\n - self.p_total_center) # column W\\n\\n self.rx_stressed_sensitivity = (\\n self.tx_oma_min*self.l_1\\n - self.chil\\n - self.p_mpn\\n - self.p_reflection\\n - self.p_rin\\n - 0.5*self.p_cross_center\\n - self.pmn*self.l_1\\n - self.margin[self.lnum//2]*self.l_1)\\n\\n\\n # end of GbE10.penalty_calc\\n #======================================================================+\",\n \"def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\\n\\n # Raise('NotImplementedError: only adjusted the arguments.')\\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\\n #precompute the expensive operation:\\n lin_penalties = 1/np.sqrt(2*eta_lin)\\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\\n #!!!!\\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\\n #!!!!\\n u_prev = u_init + 1\\n u = u_init\\n count = 0\\n obj_history = []\\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\\n start = time.time()\\n \\n u_prev = np.copy(u)\\n w_0 = w_0_update(eta_0, u, T, alpha, B) \\n w = w_update(u, H, gamma, D, C) \\n w_lin = w_lin_update(u, L_lhs, L_rhs)\\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\\n #!!!!\\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\\n #!!!!\\n count += 1 \\n if count == 10:\\n u_inf = np.copy(u)\\n w_0_inf = w_0[:]\\n w_inf = w[:]\\n w_lin_inf = w_lin[:]\\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\\n \\n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\\n obj_history.append(cur_obj)\\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\\n relaxed_obj_history.append(cur_relaxed_obj) \\n \\n stop = time.time()\\n duration = stop-start\\n \\n if count%1 == 0 and verbose: \\n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\\n print(' This iteration took: {}'.format(duration))\\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def potentialSolver5(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def eval_grads(self, data):\\n drho = np.zeros_like(self.rhos)\\n dW = np.zeros_like(self.W)\\n da = np.zeros_like(self.a)\\n dc = np.zeros_like(self.c)\\n dba = np.zeros_like(self.bs['alpha'])\\n dVa = np.zeros_like(self.Vs['alpha'])\\n dbm = np.zeros_like(self.bs['mu'])\\n dVm = np.zeros_like(self.Vs['mu'])\\n dbs = np.zeros_like(self.bs['sigma'])\\n dVs = np.zeros_like(self.Vs['sigma'])\\n\\n const = 0.5 * np.log(2. * np.pi)\\n for i in range(self.Ndim - 1, -1, -1):\\n a = self.rhos[i] * self.a[i]\\n h = 0.5 * (a + np.abs(a)) # ReLU\\n dlt = (data[:, i][:, None] - self.mus[i][None, :])\\n dlt /= self.sigmas[i][None, :]\\n dlt = np.mean(dlt, axis=0)\\n phi = 0.5 * dlt ** 2. - np.log(self.sigmas[i]) - const\\n pi = self.alphas[i] * phi\\n pi /= np.mean(pi)\\n dza = pi - self.alphas[i]\\n dba[i] = dza\\n dVa[i] = dza[None, :] * h[:, None]\\n dzm = pi * dlt\\n dzm *= self.slow_factor # apparently this is a `tight' component\\n dbm[i] = dzm\\n dVm[i] = dzm[None, :] * h[:, None]\\n dzs = pi * (dlt ** 2. - 1)\\n dbs[i] = dzs\\n dVs[i] = dzs[None, :] * h[:, None]\\n\\n # dh has shape Nhidden x Ncomponents (?)\\n dh = dza * dVa[i] + dzm * dVm[i] + dzs * dVs[i]\\n dpsi = 1. * (dh > 0)\\n\\n # collapse to a scalar or vector of Nhidden?\\n drho[i] = np.mean(dpsi)\\n\\n if i == 0:\\n dc = da[i]\\n else:\\n da[i - 1] = da[i] + np.mean(dpsi * self.rhos[i], axis=1)\\n dW[:, i] = np.mean(da[i - 1][:, None] * data[:, i][None, :],\\n axis=1)\\n self.a[i - 1] = self.a[i] - np.mean(data[:, i][None, :] *\\n self.W[:, i][:, None],\\n axis=1)\\n\\n return -drho, -dc, -dW, -dba, -dVa, -dbm, -dVm, -dbs, -dVs\",\n \"def alternative_iterative_method(x0, n, gamma, b):\\n # Parameters:\\n MAX_ITER = 1000\\n n2 = n**2\\n\\n # Creating NxN versions of vector for easier indexing during iteration\\n b = b.copy().reshape(n, n)\\n b_transposed = b.copy().T\\n x0 = x0.copy().reshape(n, n)\\n x0_transposed = x0.copy().T\\n x1 = x0.copy()\\n x1_transposed = x0_transposed.copy()\\n\\n # No need for M, N, only a smaller tridiagonal system:\\n H = scipy.sparse.diags((-1, 2, -1), (-1, 0, 1), shape=(n, n), format=\\\"csr\\\")\\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n, n), format=\\\"csr\\\")\\n M1 = gammaI + H # Corresponds to both (gI + M) & (gI + N) in equations\\n M2 = gammaI - H # Corresponds to both (gI - M) & (gI - N) in equations\\n\\n # Preallocating RHS of equations\\n RHS7 = np.zeros((n, n), dtype=np.float64)\\n RHS8 = np.zeros((n, n), dtype=np.float64)\\n\\n k = 0\\n while k < MAX_ITER:\\n for i in range(n): # Loading RHS values for Equation (7):\\n RHS7[:, i] = scipy.sparse.csr_matrix.dot(M2, x0_transposed[i]) + b_transposed[i]\\n for i in range(n): # Solving N independent tridig mat systems related to Eq(7):\\n x1[i] = scipy.sparse.linalg.spsolve(M1, RHS7[i])\\n RHS8[i] = scipy.sparse.csr_matrix.dot(M2, x1[i]) + b[i] # Loading RHS values for Equation (8):\\n for i in range(n): # Solving N independent tridig mat systems related to Eq(8):\\n x1_transposed[i] = scipy.sparse.linalg.spsolve(M1, RHS8[:, i])\\n\\n k += 1\\n if np.allclose(x1_transposed, x0_transposed, rtol=1e-8):\\n break\\n x0_transposed = x1_transposed.copy()\\n\\n res = x1_transposed.T.reshape(n2)\\n return res, k\",\n \"def run(self):\\n self.errList = []\\n self.initialize()\\n\\n for i in range(self.maxiter):\\n # update U\\n for k in range(self.K):\\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\\n full_matrices=False)\\n self.U[k] = q.T.dot(p.T)\\n self.U[k] = self.U[k].real\\n\\n # calculate temporal variable y\\n y = np.zeros([self.rank, self.L, self.K])\\n for k in range(self.K):\\n y[:, :, k] = self.U[k].T.dot(self.X[k])\\n\\n # get H, V, and temps by running a single iteration of CP_ALS\\n if i == 0:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1, printitn=0)\\n else:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1,\\n init=[self.H, self.V, temps], printitn=0)\\n self.H = cp.Us[0]\\n self.V = cp.Us[1]\\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\\n\\n # update S\\n for k in range(self.K):\\n self.S[:, :, k] = np.diag(temps[k, :])\\n\\n # checking the stop criteria\\n # error = 0\\n for k in range(self.K):\\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\\n\\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\\n self.errList.append(error)\\n if (i + 1) % self.printitn == 0:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n elif error < self.tol:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n\\n if error < self.tol:\\n break\\n else:\\n self.sigma_old = self.sigma_new\\n self.sigma_new = 0\\n\\n for k in range(self.K):\\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\",\n \"def solve(self):\\n\\n # Open status display\\n fmtstr, nsep = self.display_start()\\n\\n # Start solve timer\\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Main optimisation iterations\\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\\n\\n # Update record of X and Y from previous iteration\\n self.on_iteration_start()\\n\\n # Compute backtracking\\n if self.opt['Backtrack'] is not None and self.k >= 0:\\n self.timer.stop('solve_wo_btrack')\\n # Compute backtracking\\n self.backtrack.update(self)\\n self.timer.start('solve_wo_btrack')\\n else:\\n # Compute just proximal step\\n self.xstep()\\n # Update by combining previous iterates\\n self.ystep()\\n\\n # Compute residuals and stopping thresholds\\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n frcxd, adapt_tol = self.compute_residuals()\\n self.timer.start('solve_wo_rsdl')\\n\\n # Compute and record other iteration statistics and\\n # display iteration stats if Verbose option enabled\\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n itst = self.iteration_stats(self.k, frcxd)\\n self.itstat.append(itst)\\n self.display_status(fmtstr, itst)\\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Call callback function if defined\\n if self.opt['Callback'] is not None:\\n if self.opt['Callback'](self):\\n break\\n\\n # Stop if residual-based stopping tolerances reached\\n if not self.opt['FastSolve']:\\n if frcxd < adapt_tol:\\n break\\n\\n # Increment iteration count\\n self.k += 1\\n\\n # Record solve time\\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Print final separator string if Verbose option enabled\\n self.display_end(nsep)\\n\\n return self.getmin()\",\n \"def solve(self):\\n pass\",\n \"def solve(self):\\n pass\",\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 compute_cost_matrix(self):\\n\\n if rank == 0:\\n #do random sampling of a parameters\\n if self.sampling == \\\"LHS\\\":\\n lhs = Lhs(lhs_type=\\\"classic\\\", criterion=None)\\n param_samples = lhs.generate(self.sample_space, self.niters)\\n elif self.sampling == \\\"rsampling\\\":\\n param_samples = self.sample_space.rvs(self.niters)\\n elif self.sampling == \\\"Sobol\\\":\\n sobol = Sobol()\\n param_samples = sobol.generate(self.sample_space.dimensions, self.niters)\\n \\n # generate param samples split\\n niters_rank0 = self.niters//size + self.niters % size\\n niters_rank = self.niters//size\\n count_scatter = [niters_rank0]\\n count_scatter.extend((size-2)*[niters_rank])\\n count_scatter = np.cumsum(count_scatter)\\n\\n param_samples_split = np.split(param_samples,count_scatter)\\n else:\\n param_samples_split = None\\n \\n #scatter parameter samples data\\n param_samps = comm.scatter(param_samples_split,root=0)\\n\\n # initialize data\\n param_samples_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\\n param_samples_diff_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\\n jac_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\\n qoi_dict_rank = {qoi_name:[] for qoi_name in self.funcnames}\\n\\n \\n\\n # evaluate QoI at random sampling\\n for sample in param_samps: \\n qoi_sample, jac_sample = self.jac(sample).values()\\n # store output\\n for qoi_name in self.funcnames:\\n if not (jac_sample[qoi_name] is None):\\n param_samples_dict_rank[qoi_name].append(jac_sample[qoi_name])\\n jac_dict_rank[qoi_name].append(jac_sample[qoi_name])\\n qoi_dict_rank[qoi_name].append(qoi_sample[qoi_name])\\n else:\\n param_samples_diff_dict_rank[qoi_name].append(sample)\\n\\n # gather data\\n param_samples = None\\n param_samples_diff_int = None\\n jac_dict = None\\n qoi_dict= None\\n\\n param_samples_dict = comm.gather(param_samples_dict_rank, root=0)\\n params_samples_diff_dict = comm.gather(param_samples_diff_dict_rank, root=0)\\n jac_dict = comm.gather(jac_dict_rank, root=0)\\n qoi_dict = comm.gather(qoi_dict_rank, root=0)\\n\\n # format gathered data\\n if rank == 0:\\n #flatten data\\n param_samples_dict_flattened = {qoi_name:[] for qoi_name in self.funcnames}\\n param_samples_diff_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\\n jac_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\\n qoi_dict_flattened = {qoi_name: [] for qoi_name in self.funcnames}\\n\\n for cpurank in range(size):\\n for qoi_name in self.funcnames:\\n param_samples_dict_flattened[qoi_name].extend(param_samples_dict[cpurank][qoi_name]) \\n param_samples_diff_dict_flattened[qoi_name].extend(params_samples_diff_dict[cpurank][qoi_name])\\n jac_dict_flattened[qoi_name].extend(jac_dict[cpurank][qoi_name])\\n qoi_dict_flattened[qoi_name].extend(qoi_dict[cpurank][qoi_name])\\n\\n #compute outer product\\n jac_outer_dict = {qoi_name: [] for qoi_name in self.funcnames}\\n nfuncs_dict = {qoi_name: 0 for qoi_name in self.funcnames}\\n\\n for qoi_name in self.funcnames:\\n for i in range(len(jac_dict_flattened[qoi_name])):\\n jac_sample = jac_dict_flattened[qoi_name][i]\\n jac_outer_dict[qoi_name].append(np.outer(jac_sample,jac_sample))\\n nfuncs_dict[qoi_name] += 1\\n\\n # compute cost matrix and norm convergence\\n cost_matrix_dict = {}\\n cost_matrix_cumul_dict = {}\\n norm_convergence_dict = {}\\n\\n for qoi_name in self.funcnames:\\n cost_cumsum = np.cumsum(jac_outer_dict[qoi_name],axis=0)/np.arange(1,nfuncs_dict[qoi_name]+1)[:,None,None]\\n cost_matrix_cumul_dict[qoi_name] = cost_cumsum\\n cost_matrix_dict[qoi_name] = cost_cumsum[-1,:,:]\\n norm_convergence_dict[qoi_name] = np.linalg.norm(cost_cumsum,ord='fro',axis=(1,2))\\n\\n # compute variance matrix\\n variance_matrix_dict = {}\\n for qoi_name in self.funcnames:\\n variance_mat = np.sum((jac_outer_dict[qoi_name]-cost_matrix_dict[qoi_name])**2/(nfuncs_dict[qoi_name]-1),axis=0) \\n variance_matrix_dict[qoi_name] = variance_mat\\n\\n param_results = {\\\"PARAM_SAMPLES\\\": param_samples_dict_flattened,\\n \\\"DIFFICULT_PARAM_SAMPLES\\\": param_samples_diff_dict_flattened}\\n\\n fun_results = {\\\"NUMBER_OF_FUNCTION_SUCCESS\\\": nfuncs_dict,\\n \\\"NORM_OF_SEQ_OF_CUMUL_SUMS\\\": norm_convergence_dict,\\n \\\"SEQ_OF_CUMUL_SUMS\\\": cost_matrix_cumul_dict, \\n \\\"VARIANCE_OF_ENTRIES\\\": variance_matrix_dict,\\n \\\"FINAL_COST_MATRIX\\\":cost_matrix_dict}\\n\\n return {'PARAMETER_RESULTS': param_results, 'FUNCTION_RESULTS': fun_results}\",\n \"def solve(self):\\r\\n while not self.done():\\r\\n self.no_open_cells()\\r\\n self.all_cells_are_mines()\\r\\n self.no_mines()\\r\\n if not self.done():\\r\\n self.obvious_cells()\\r\\n if not self.done():\\r\\n made_progress = self.safe_neighbour_difference()\\r\\n if made_progress:\\r\\n continue\\r\\n if not self.done():\\r\\n made_progress = self.adjacent_combinations()\\r\\n if made_progress:\\r\\n continue\\r\\n return\",\n \"def evaluate(self):\\n #fac o lista cu toate perechile si vad daca se repeta vreuna (pana acum)\\n nr=0\\n \\n pairs = []\\n for i in range(0,self.__size):\\n for j in range(0, self.__size):\\n if self.__solution[i] != [] and self.__solution[i+self.__size] != [] : #sa am de unde face perechea\\n p=[]\\n p.append(self.__solution[i][j])\\n p.append(self.__solution[i+self.__size][j])\\n pairs.append(p)\\n for p in pairs:\\n if pairs.count(p) == 1:\\n nr += 1\\n\\n return self.__size*self.__size - nr + 1 # pun acel +1 ca sa nu fie 0 niciodata -> ca sa nu am probleme la impartire\\n # la 0 mai incolo\\n #return nr\",\n \"def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\\n # process and activate input settings\\n sigint_callback = kwds.pop('sigint_callback', None)\\n settings = self._process_inputs(kwds)\\n disp = settings['disp'] if 'disp' in settings else False\\n echo = settings['callback'] if 'callback' in settings else None\\n# for key in settings:\\n# exec \\\"%s = settings['%s']\\\" % (key,key)\\n if disp in ['verbose', 'all']: verbose = True\\n else: verbose = False\\n #-------------------------------------------------------------\\n\\n from python_map import python_map\\n if self._map != python_map:\\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\\n from mystic.monitors import Null\\n evalmon = Null()\\n else: evalmon = self._evalmon\\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\\n\\n # set up signal handler\\n #self._EARLYEXIT = False\\n self._generateHandler(sigint_callback) \\n\\n # activate signal_handler\\n #import threading as thread\\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\\n import signal\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,self.signal_handler)\\n\\n # register termination function\\n if termination is not None: self.SetTermination(termination)\\n\\n # get the nested solver instance\\n solver = self._AbstractEnsembleSolver__get_solver_instance()\\n #-------------------------------------------------------------\\n\\n # generate starting points\\n initial_values = self._InitialPoints()\\n\\n # run optimizer for each grid point\\n from copy import deepcopy as _copy\\n op = [_copy(solver) for i in range(len(initial_values))]\\n #cf = [cost for i in range(len(initial_values))]\\n vb = [verbose for i in range(len(initial_values))]\\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\\n at = self.id if self.id else 0 # start at self.id\\n id = range(at,at+len(initial_values))\\n\\n # generate the local_optimize function\\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\\n from copy import deepcopy as _copy\\n from mystic.tools import isNull\\n solver.id = rank\\n solver.SetInitialPoints(x0)\\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\\n solver.SetStrictRanges(min=solver._strictMin, \\\\\\n max=solver._strictMax) # or lower,upper ?\\n solver.Solve(cost, disp=disp, callback=callback)\\n sm = solver._stepmon\\n em = solver._evalmon\\n if isNull(sm): sm = ([],[],[],[])\\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\\n if isNull(em): em = ([],[],[],[])\\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\\n return solver, sm, em\\n\\n # map:: solver = local_optimize(solver, x0, id, verbose)\\n results = self._map(local_optimize, op, initial_values, id, \\\\\\n vb, cb, **self._mapconfig)\\n\\n # save initial state\\n self._AbstractSolver__save_state()\\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\\n # reconnect monitors; save all solvers\\n from mystic.monitors import Monitor\\n while results: #XXX: option to not save allSolvers? skip this and _copy\\n _solver, _stepmon, _evalmon = results.pop()\\n sm = Monitor()\\n sm._x,sm._y,sm._id,sm._info = _stepmon\\n _solver._stepmon.extend(sm)\\n del sm\\n em = Monitor()\\n em._x,em._y,em._id,em._info = _evalmon\\n _solver._evalmon.extend(em)\\n del em\\n self._allSolvers[len(results)] = _solver\\n del results, _solver, _stepmon, _evalmon\\n #XXX: END HACK\\n\\n # get the results with the lowest energy\\n self._bestSolver = self._allSolvers[0]\\n bestpath = self._bestSolver._stepmon\\n besteval = self._bestSolver._evalmon\\n self._total_evals = self._bestSolver.evaluations\\n for solver in self._allSolvers[1:]:\\n self._total_evals += solver.evaluations # add func evals\\n if solver.bestEnergy < self._bestSolver.bestEnergy:\\n self._bestSolver = solver\\n bestpath = solver._stepmon\\n besteval = solver._evalmon\\n\\n # return results to internals\\n self.population = self._bestSolver.population #XXX: pointer? copy?\\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\\n self.bestEnergy = self._bestSolver.bestEnergy\\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\\n self._maxiter = self._bestSolver._maxiter\\n self._maxfun = self._bestSolver._maxfun\\n\\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\\n self._stepmon = bestpath #XXX: pointer? copy?\\n self._evalmon = besteval #XXX: pointer? copy?\\n self.energy_history = None\\n self.solution_history = None\\n #from mystic.tools import isNull\\n #if isNull(bestpath):\\n # self._stepmon = bestpath\\n #else:\\n # for i in range(len(bestpath.y)):\\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\\n # #XXX: could apply callback here, or in exec'd code\\n #if isNull(besteval):\\n # self._evalmon = besteval\\n #else:\\n # for i in range(len(besteval.y)):\\n # self._evalmon(besteval.x[i], besteval.y[i])\\n #-------------------------------------------------------------\\n\\n # restore default handler for signal interrupts\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,signal.default_int_handler)\\n\\n # log any termination messages\\n msg = self.Terminated(disp=disp, info=True)\\n if msg: self._stepmon.info('STOP(\\\"%s\\\")' % msg)\\n # save final state\\n self._AbstractSolver__save_state(force=True)\\n return\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\\n auto_param_obj_history = []\\n auto_param_relaxed_obj_history = []\\n \\n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\\n eta = np.array([eta_0/len(H)]*len(H))*0.9\\n eta_lin = np.ones(L_lhs.shape[0])*0.01\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Feasibility')\\n count = 0\\n num_violated = -1\\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n count += 1\\n num_violated_prev = np.copy(num_violated)\\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\\n \\n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n # eta_lin *= eta_step\\n \\n if num_violated == num_violated_prev:\\n print('Increase enforcement')\\n if num_violated_lin > 0:\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n #eta_lin *= eta_step\\n if num_violated_oar > 0:\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n # eta_0 *= eta_step*2\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Optimality')\\n count = 0\\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\\n count += 1\\n print('Opt Iter', count)\\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\\n u_prev = np.copy(u)\\n eta_0 *= eta_step_tumor\\n print('Current eta_0:', eta_0)\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n \\n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\\n print('No improvement, increase enforcement')\\n eta_step_tumor *= 0.1\\n eta_0 *= eta_step_tumor\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # break\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\\n \\n print('Finding the correct solution:')\\n u = u_prev\\n eta_0 = eta_0/eta_step_tumor\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\\n print(\\\"OBJJJJJ:\\\", obj_u_opt_N_fixed(u, T, alpha, B))\\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history\",\n \"def solve_assignments(self):\\n # build valuations vector \\n c = -1 * self.valuations.flatten()\\n\\n # empty G and h, no inequality constraints\\n G = np.zeros((1, self.n**2))\\n h = np.zeros((1))\\n\\n # build A and b, enforces unique room-agent matching\\n A = np.zeros((2 * self.n, self.n**2))\\n b = np.ones((2 * self.n))\\n for i in range(self.n):\\n # exactly one room per agent\\n A[i, i * self.n + np.arange(self.n)] = 1.0 \\n # exactyly one agent per room\\n A[self.n + i, (self.n) * np.arange(self.n) + i] = 1.0\\n\\n B = set(range(self.n**2))\\n status, x = ilp(c=matrix(c, tc='d'), G=matrix(G, tc='d'), \\n h=matrix(h, tc='d'), A=matrix(A, tc='d'), \\n b=matrix(b, tc='d'), B=B)\\n\\n # get assignments\\n x = np.argmax(np.array(x).reshape(self.n, self.n), axis=1)\\n self.assignments = x \\n\\n return self.assignments\",\n \"def optimize(self):\\n # Loop through every WD and WS individually\\n wd_array = self.fi_subset.floris.flow_field.wind_directions\\n ws_array = self.fi_subset.floris.flow_field.wind_speeds\\n for nwsi, ws in enumerate(ws_array):\\n\\n self.fi_subset.reinitialize(wind_speeds=[ws])\\n\\n for nwdi, wd in enumerate(wd_array):\\n # Find turbines to optimize\\n turbs_to_opt = self._turbs_to_opt_subset[nwdi, nwsi, :]\\n if not any(turbs_to_opt):\\n continue # Nothing to do here: no turbines to optimize\\n\\n # Extract current optimization problem variables (normalized)\\n yaw_lb = self._minimum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\\n yaw_ub = self._maximum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\\n bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)]\\n x0 = self._x0_subset_norm[nwdi, nwsi, turbs_to_opt]\\n\\n J0 = self._farm_power_baseline_subset[nwdi, nwsi]\\n yaw_template = self._yaw_angles_template_subset[nwdi, nwsi, :]\\n turbine_weights = self._turbine_weights_subset[nwdi, nwsi, :]\\n yaw_template = np.tile(yaw_template, (1, 1, 1))\\n turbine_weights = np.tile(turbine_weights, (1, 1, 1))\\n\\n # Define cost function\\n def cost(x):\\n x_full = np.array(yaw_template, copy=True)\\n x_full[0, 0, turbs_to_opt] = x * self._normalization_length\\n return (\\n - 1.0 * self._calculate_farm_power(\\n yaw_angles=x_full,\\n wd_array=[wd],\\n turbine_weights=turbine_weights\\n )[0, 0] / J0\\n )\\n\\n # Perform optimization\\n residual_plant = minimize(\\n fun=cost,\\n x0=x0,\\n bounds=bnds,\\n method=self.opt_method,\\n options=self.opt_options,\\n )\\n\\n # Undo normalization/masks and save results to self\\n self._farm_power_opt_subset[nwdi, nwsi] = -residual_plant.fun * J0\\n self._yaw_angles_opt_subset[nwdi, nwsi, turbs_to_opt] = (\\n residual_plant.x * self._normalization_length\\n )\\n\\n # Finalize optimization, i.e., retrieve full solutions\\n df_opt = self._finalize()\\n return df_opt\",\n \"def add_objective(self): \\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n if self.num_hidden == 0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n else:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.add_css_approximation(data_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden ==0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n normalizer_term = self.compute_energy(self.x_gibbs, \\n self.batch_size)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden > 0:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n # cost is negative log likelihood \\n self.cost = T.mean(data_term) + normalizer_term\",\n \"def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\\n\\n # def Q_gen(I, R):\\n # w = I * I * R\\n # return w\\n\\n # def Q_rad_in(I_sun, A_s, a_s):\\n # w = I_sun * D * a_s\\n # return w\\n\\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\\n # w = htcoeff * A_s * (T_line - T_amb)\\n # return w\\n\\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\\n # return w\\n\\n def reynolds(V, D, v, Mair=1.103):\\n r = V * D / v\\n return r\\n\\n def nusselt(Re, Pr):\\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\\n c = (Re / 282000) ** (5.0/8.0)\\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\\n return n\\n\\n def air_prop(T_amb):\\n # temp v k Pr\\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\\n [250, 11.44e-6, 22.3e-3, 0.720],\\n [300, 15.89e-6, 26.3e-3, 0.707],\\n [350, 20.92e-6, 30.0e-3, 0.700],\\n [400, 26.41e-6, 33.8e-3, 0.690],\\n [450, 32.39e-6, 37.3e-3, 0.686],\\n [500, 38.79e-6, 40.7e-3, 0.684],\\n [550, 45.57e-6, 43.9e-3, 0.683],\\n [600, 52.69e-6, 46.9e-3, 0.685]])\\n\\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\\n 0, air_prop[:,1:])\\n return v, k, Pr\\n\\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\\n if 273 <= T_line <= 323:\\n R = ((R_lo + \\n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\\n *(T_line - T_range[0]))/N_cond)\\n elif T_line > 323:\\n R = ((R_mid + \\n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\\n *(T_line - T_range[1]))/N_cond)\\n else:\\n R = R_lo\\n print('Out of bounds')\\n return R\\n\\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\\n temp_factor = 1\\n wind_factor = 1\\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\\n\\n T_amb = T_amb*temp_factor\\n V = V*wind_factor\\n\\n v, k, Pr = air_prop(T_amb)\\n Re = reynolds(V, D, v)\\n htcoeff = nusselt(Re, Pr) * k / D\\n\\n def T_line(T_init):\\n \\n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\\n print R\\n\\n C4 = e_s * sigma * D * math.pi\\n C3 = 0.0\\n C2 = 0.0\\n C1 = htcoeff * D * math.pi\\n C0 = - ( I ** 2 * R\\n + I_sun * a_s * D\\n + htcoeff * D * math.pi * T_amb\\n + e_s * D * math.pi * sigma * (T_amb ** 4))\\n\\n return np.roots([C4, C3, C2, C1, C0])\\n\\n T_c = T_amb\\n \\n for i in range(n_iter):\\n T_arr = T_line(T_c)\\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\\n print T_c\\n\\n return T_c\",\n \"def run(self):\\n\\n # Initializing required variables for the algorithm\\n start = time.time()\\n i = 0\\n w = self.w\\n k = 99.99\\n\\n #Running the algorithm till tolerance is reached\\n while k > self.tolerance: \\n\\n i = i + 1\\n\\n if self.verbose:\\n print(\\\"Iteration \\\" + str(i),end=\\\"\\\\r\\\")\\n\\n # Following is a gradient descent algorithm\\n # You can find the update step at the following\\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\\n t_0 = w.T.dot(w)\\n t_1 = self.x.T.dot(self.x).dot(w)\\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\\n w_new[-1] = -1\\n l = len(self.x[0]) - 1 \\n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \\n\\n #tolerance is checked against the root mean square of change in weights\\n k = np.dot(np.transpose(w - w_new),(w - w_new))\\n\\n #Updating the weights \\n w = w_new\\n\\n if self.verbose:\\n print(\\\"Tolerance Reached\\\")\\n timetaken = round(time.time() - start, 3)\\n print(\\\"Ran for \\\" + str(timetaken) + \\\" seconds\\\" + \\\" in \\\" + str(i) + \\\" iterations.\\\")\\n\\n return w_new, y_plt\",\n \"def solve(self):\\n\\n # Set up display header if verbose operation enabled\\n if self.opt['Verbose']:\\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\\\\n ' ResG '\\n print(hdr)\\n print('-' * len(hdr))\\n\\n # Main iteration loop\\n for n in range(self.opt['MaxMainIter']):\\n\\n # At start of 2nd iteration, set the numbers of inner\\n # iterations for the X and G solvers from the options\\n # object for the outer solver\\n if n == 1:\\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\\n\\n # Run the configured number of iterations of the X (CSC)\\n # solver and assign the result to X\\n self.X = self.slvX.solve()\\n\\n # Compute the sum of the subpixel shifts of X\\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\\n axis=-1)\\n\\n # Set the convolution kernel in the deconvolution solver\\n # to the sum of the subpixel shifts of X\\n self.slvG.setG(Xhs)\\n # Run the configured number of iterations of the G\\n # (deconvolution) solver and crop the result to obtain the\\n # updated g\\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\\n\\n # Construct a new dictionary for the X (CSC) solver from\\n # the updated psf g\\n self.D, self.dn = self.getD(self.g)\\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\\n\\n # Display iteration statistics if verbose operation enabled\\n if self.opt['Verbose']:\\n itsX = self.slvX.getitstat()\\n itsG = self.slvG.getitstat()\\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\\n print(fmt % tpl)\\n\\n # Return the (normalised) psf estimate g\\n return self.g / np.linalg.norm(self.g)\",\n \"def fConnectivityModel(RD,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha):\\n#\\n# 1. Initialisations:\\n# \\t-------------------\\n\\tFSwEnd = 0\\n\\tFSwInt = 0\\n\\tFSwMax = 200\\n\\tFSwErr = 0.0001\\n\\tSwOld = 1\\n\\tSwNew = 1\\n\\tSwInc = 0\\n\\tTiny=0.000000001\\n\\tBig=1000000000000\\n\\tTout=0 # Defines output of fRCrim\\n#\\n# 2. Calculate Observed Conductivity:\\n#-----------------------------------\\n\\tif(RD<=0):\\n\\t\\tCt=Big\\n\\telse:\\n\\t\\tCt=1/RD\\n#\\n# 2. Interative Loop:\\n#--------------------\\t\\t\\n\\tSwOld=0.50 # Initialises Effective Water Saturation\\n\\twhile(FSwEnd==0):\\n\\t\\tCm=fRCrim(SwOld,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout)\\n\\t\\tr=Ct-Cm\\n\\t\\ts=(Cm-fRCrim((SwOld-Tiny),Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout))/Tiny # dCm/dSw\\n\\t\\tif(s==0): \\n\\t\\t\\tFSwEnd=1\\n\\t\\t\\ts=Tiny\\n\\t\\tSwInc=(r/s)\\n\\t\\tSwNew=SwOld+SwInc\\n\\t\\tFSwInt=FSwInt+1\\n\\t\\tif(FSwInt>3):\\t\\n\\t\\t\\tif (FSwInt>=FSwMax):\\n\\t\\t\\t\\tFSwEnd=1\\n\\t\\t\\tif (abs(SwOld-SwNew)<FSwErr):\\n\\t\\t\\t\\tFSwEnd=1\\n\\t\\tSwOld=SwNew\\n\\t\\tSwOld=ImposeLimits(SwOld,Tiny,1)\\n\\t#\\t\\t\\n\\treturn SwOld\",\n \"def clfqp(self,x,p):\\n alp = self.alp_opt\\n nu = self.nu_opt\\n dt = self.dt\\n n = self.n\\n I = np.identity(n)\\n M = self.ncm(x,p)\\n nu = np.size(self.h_or_g(x,p),1)\\n u = cp.Variable((nu,1))\\n e = np.reshape(x,(n,1))\\n fx = np.reshape(self.dynamicsf(x,p),(n,1))\\n gx = self.h_or_g(x,p)\\n dMdt = (nu*I-M)/dt\\n constraints = [2*e.T@(fx+gx@u)+e.T@dMdt@e <= -2*alp*e.T@M@e]\\n prob = cp.Problem(cp.Minimize(cp.sum_squares(u)),constraints)\\n prob.solve()\\n u = u.value\\n u = np.ravel(u)\\n return u\",\n \"def solve_ilp(self):\\n\\n ilp_solution = pylp.Solution()\\n self.ilp_solver.set_constraints(self.constraints)\\n message = self.ilp_solver.solve(ilp_solution)\\n print(\\\"ILP solved with minimal value \\\" + str(ilp_solution.get_value()) + \\\" and status \\\" + message)\\n\\n solution = lil_matrix(self.graph.shape)\\n for i in range(self.num_variables):\\n print(\\\"value of var \\\" + str(i) + \\\" is \\\" + str(ilp_solution.get_vector()[i]))\\n if ilp_solution.get_vector()[i] < 0.5:\\n continue\\n (u,v) = self.var_to_edge[i]\\n solution[u,v] = self.graph[u,v] - self.min_cost + 1\\n\\n return solution\",\n \"def solve(m):\\n\\t\\n #with the assumption that at least one terminal state is given:\\n if(len(m)==2 or len(m)==1): return [1,1]\\n \\n #Normalizing the in. matrix and identifying the trans./abs. states:\\n m = normalizeProbabilityMatrix(m)\\n t = getTransientStates(m)\\n a = getAbsorbingStates(m)\\n\\t\\n if len(a) >0:\\n print( str(len(a)) + \\\" absorbing state\\\" + (\\\"\\\" if len(a)<=1 else \\\"s\\\" ))\\n else:\\n print(\\\"No absorbing state detected\\\")\\n return\\n \\n #Getting the matrices Q and R as in the canonical form:\\n Q = getQ(m,t)\\n R = getR(m,t,a)\\n I = getIdentity(len(Q))\\n I_Q = subtractMatrices(I, Q)\\n \\n #Getting the fundamental matrix\\n N = invertMatrix(I_Q)\\n F = multiplyMatrices(N,R)\\n \\n #packing the result with a common denominator:\\n gcd = getGCD(F[0]).denominator\\n res=[]\\n sum = 0\\n for r in F[0]:\\n val = int(r.numerator*(gcd/r.denominator))\\n sum+=val\\n res.append(val)\\n res.append(sum) \\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61143297","0.6101354","0.6066659","0.6060728","0.603991","0.6005973","0.59834266","0.5945585","0.5919671","0.5912027","0.5907284","0.586913","0.58657324","0.58402","0.5801388","0.57696843","0.5769187","0.5742733","0.5734056","0.5726234","0.56925076","0.5679997","0.5677399","0.56641775","0.5659747","0.56370115","0.56269246","0.5619074","0.56186235","0.55972487","0.5595499","0.5590937","0.55896693","0.55895114","0.5585419","0.5579666","0.55743223","0.5564102","0.554866","0.5545898","0.55050296","0.55032647","0.5491114","0.5488708","0.54792607","0.54782665","0.54664296","0.5459431","0.5458461","0.54582644","0.54555756","0.5448088","0.5446932","0.54438686","0.54352176","0.5428677","0.5417326","0.54121363","0.539963","0.53949684","0.53870344","0.53863156","0.5378805","0.5375443","0.5375443","0.53727317","0.5370824","0.53702736","0.536966","0.5367211","0.5366623","0.5358586","0.53484094","0.5346793","0.5344907","0.5334957","0.53286326","0.53209764","0.5320759","0.5317501","0.5313893","0.531088","0.530912","0.530912","0.53055793","0.53033113","0.5302393","0.52990484","0.52988327","0.529878","0.5298749","0.52960086","0.5294381","0.5293867","0.5293386","0.5290525","0.52860427","0.52801824","0.5277073","0.5275806","0.5274929"],"string":"[\n \"0.61143297\",\n \"0.6101354\",\n \"0.6066659\",\n \"0.6060728\",\n \"0.603991\",\n \"0.6005973\",\n \"0.59834266\",\n \"0.5945585\",\n \"0.5919671\",\n \"0.5912027\",\n \"0.5907284\",\n \"0.586913\",\n \"0.58657324\",\n \"0.58402\",\n \"0.5801388\",\n \"0.57696843\",\n \"0.5769187\",\n \"0.5742733\",\n \"0.5734056\",\n \"0.5726234\",\n \"0.56925076\",\n \"0.5679997\",\n \"0.5677399\",\n \"0.56641775\",\n \"0.5659747\",\n \"0.56370115\",\n \"0.56269246\",\n \"0.5619074\",\n \"0.56186235\",\n \"0.55972487\",\n \"0.5595499\",\n \"0.5590937\",\n \"0.55896693\",\n \"0.55895114\",\n \"0.5585419\",\n \"0.5579666\",\n \"0.55743223\",\n \"0.5564102\",\n \"0.554866\",\n \"0.5545898\",\n \"0.55050296\",\n \"0.55032647\",\n \"0.5491114\",\n \"0.5488708\",\n \"0.54792607\",\n \"0.54782665\",\n \"0.54664296\",\n \"0.5459431\",\n \"0.5458461\",\n \"0.54582644\",\n \"0.54555756\",\n \"0.5448088\",\n \"0.5446932\",\n \"0.54438686\",\n \"0.54352176\",\n \"0.5428677\",\n \"0.5417326\",\n \"0.54121363\",\n \"0.539963\",\n \"0.53949684\",\n \"0.53870344\",\n \"0.53863156\",\n \"0.5378805\",\n \"0.5375443\",\n \"0.5375443\",\n \"0.53727317\",\n \"0.5370824\",\n \"0.53702736\",\n \"0.536966\",\n \"0.5367211\",\n \"0.5366623\",\n \"0.5358586\",\n \"0.53484094\",\n \"0.5346793\",\n \"0.5344907\",\n \"0.5334957\",\n \"0.53286326\",\n \"0.53209764\",\n \"0.5320759\",\n \"0.5317501\",\n \"0.5313893\",\n \"0.531088\",\n \"0.530912\",\n \"0.530912\",\n \"0.53055793\",\n \"0.53033113\",\n \"0.5302393\",\n \"0.52990484\",\n \"0.52988327\",\n \"0.529878\",\n \"0.5298749\",\n \"0.52960086\",\n \"0.5294381\",\n \"0.5293867\",\n \"0.5293386\",\n \"0.5290525\",\n \"0.52860427\",\n \"0.52801824\",\n \"0.5277073\",\n \"0.5275806\",\n \"0.5274929\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89493,"cells":{"query":{"kind":"string","value":"Solve A^T P A P + Q = 0"},"document":{"kind":"string","value":"def solve_discrete_lyapunov(A, Q, method=None):\n\n # newer versions of scipy solve A P A^T - P + Q = 0,\n # while older ones solve A^T P A - P + Q = 0. I do not\n # remember exactly which version of scipy made the change.\n\n # I am going to assume you have the newer version installed.\n # If the assertion below fails, please add an if statement\n # that branches on your version.\n\n P = scipy.linalg.solve_discrete_lyapunov(A.T, Q, method)\n\n assert np.allclose(A.T.dot(P).dot(A) - P, -Q)\n\n return P"},"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 solve(P, Q):\n L = cho_factor(P)\n return cho_solve(L, Q)","def sol_p(t, p0, s0, u0, alpha, beta, gamma, eta, delta):\n u = sol_u(t, u0, alpha, beta)\n s = sol_s(t, s0, u0, alpha, beta, gamma)\n exp_gt = np.exp(-delta * t)\n p = p0 * exp_gt + eta / (delta - gamma) * (\n s - s0 * exp_gt - beta / (delta - beta) * (u - u0 * exp_gt - alpha / delta * (1 - exp_gt))\n )\n return p, s, u","def regular(P):\n try:\n dim = P.shape[0]\n q = (P - np.eye(dim))\n ones = np.ones(dim)\n q = np.c_[q, ones]\n QTQ = np.dot(q, q.T)\n bQT = np.ones(dim)\n answer = np.linalg.solve(QTQ, bQT)\n if np.all(answer > 0):\n return answer\n else:\n return None\n except Exception as e:\n return None","def regular(P):\n try:\n cols = P.shape[0]\n ans = np.ones((1, cols))\n # eq = np.matmul(ans, P)\n # s = np.array(np.arange(1, cols + 1))\n eq = np.vstack([P.T - np.identity(cols), ans])\n # va, vec = np.linalg .eig(P)\n results = np.zeros((cols, 1))\n results = np.vstack([results, np.array([1])])\n statetionary = np.linalg.solve(eq.T.dot(eq), eq.T.dot(results)).T\n # print(statetionary)\n # print(np.argwhere(statetionary < 0))\n if len(np.argwhere(statetionary < 0)) > 0:\n return None\n return statetionary\n except Exception as e:\n return None","def l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # z >= 0 \n \n c = matrix(n*[0.0] + m*[1.0])\n h = matrix([q, -q])\n\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \n if trans == 'N':\n # y := alpha * [P, -I; -P, -I] * x + beta*y\n u = P*x[:n]\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\n\n else:\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\n\n\n def Fkkt(W): \n\n # Returns a function f(x, y, z) that solves\n #\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\n #\n # On entry bx, bz are stored in x, z.\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\n # returned instead of z). \n\n d1, d2 = W['d'][:m], W['d'][m:]\n D = 4*(d1**2 + d2**2)**-1\n A = P.T * spdiag(D) * P\n lapack.potrf(A)\n\n def f(x, y, z):\n\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \n + mul( .5*D, z[:m]-z[m:] ) )\n lapack.potrs(A, x)\n\n u = P*x[:n]\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\n\n z[:m] = div(u-x[n:]-z[:m], d1)\n z[m:] = div(-u-x[n:]-z[m:], d2)\n\n return f\n\n\n # Initial primal and dual points from least-squares solution.\n\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\n uls = +q\n lapack.gels(+P, uls)\n rls = P*uls[:n] - q \n\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \n s0 = +h\n Fi(x0, s0, alpha=-1, beta=1) \n\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \n # if rls is nonzero and w = 0 otherwise.\n if max(abs(rls)) > 1e-10: \n w = .9/max(abs(rls)) * rls\n else: \n w = matrix(0.0, (m,1))\n z0 = matrix([.5*(1+w), .5*(1-w)])\n\n dims = {'l': 2*m, 'q': [], 's': []}\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\n return sol['x'][:n]","def quadprog_solve_qp(P, q, G=None, h=None, A=None, b=None):\n #qp_G = .5 * (P + P.T) # make sure P is symmetric\n qp_G = P\n qp_a = -q\n if A is not None:\n qp_C = -np.vstack([A, G]).T\n qp_b = -np.hstack([b, h])\n meq = A.shape[0]\n else: # no equality constraint\n qp_C = -G.T\n qp_b = -h\n meq = 0\n return quadprog.solve_qp(qp_G, qp_a, qp_C, qp_b, meq)[0]","def f(t,x,p,q):\n return p[1] + q[0]*x","def solve(self, state, times):","def algorithm_1_1(p, c, t, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\n t[j + k] - t[j]) * q[j + 1]\n return q[0]","def Y(t, p, q):\n \n if t <= 0:\n return float('inf')\n \n if q == 1:\n return (t**(p+1) - 1) / (p * (p+1)) - np.log(t) / q + (p - 1) / p * (t-1)\n else:\n return (t**(p+1) - 1) / (p * (p+1)) + (t**(1-q) - 1) / (q*(q-1)) + (p - q) / (p * q) * (t-1)","def solve_Q(ih, jh):\n # Build A and b\n\n # Solve for c via least squares.\n\n # Form C from c\n\n # Solve for Q and return it.\n return None","def solve(self):","def Yp(t, p, q):\n \n return (t**p - 1) / p + (1-t**(-q)) / q","def confirm_Alex_fast(p, q, r):\n if p*q*r < 0:\n return False\n if q*r + p*r + p*q -1 == 0:\n return True\n else:\n return False","def Problem3(n):\n A = Problem2(n)\n b = np.vstack(np.random.random(n))\n return A,sl.spsolve(A,b),b","def PQa(P_0, Q_0, D):\n A_i_2 = B_i_1 = 0\n A_i_1 = B_i_2 = 1\n\n G_i_2 = -P_0\n G_i_1 = Q_0\n\n P_i = P_0\n Q_i = Q_0\n\n while True:\n\n a_i = floor((P_i + sqrt(D))/Q_i)\n A_i = a_i*A_i_1 + A_i_2\n B_i = a_i*B_i_1 + B_i_2\n G_i = a_i*G_i_1 + G_i_2\n\n yield P_i, Q_i, a_i, A_i, B_i, G_i\n\n A_i_1, A_i_2 = A_i, A_i_1\n B_i_1, B_i_2 = B_i, B_i_1\n G_i_1, G_i_2 = G_i, G_i_1\n\n P_i = a_i*Q_i - P_i\n Q_i = (D - P_i**2)/Q_i","def _solve_subproblem(\n self, x_eval: Tensor, x_neg: Tensor, X_pos: Tensor,\n cache_book: dict\n ) -> Tensor:\n\n # Q = A @ A.t()\n A, b, Q = self._qp_params(\n x_eval, x_neg, X_pos, cache_book\n )\n lamda = self._qp_solver(Q, b)\n\n return -A.t() @ lamda","def ea_from_q(p, q):\n return p * q / (0.622 + 0.378 * q)","def _solve(self, H, T):\n P = pinv(H)\n Beta = np.dot(P, T)\n return Beta","def _solve(self, mu=None):\n pass","def algorithm_4_9(p, tau, t):\n m = len(t) - (p + 1)\n n = len(tau) - (p + 1)\n\n a = np.zeros(shape=(m, n))\n t = np.array(t, dtype=np.float64)\n tau = np.array(tau, dtype=np.float64)\n\n for i in range(m):\n mu = index(t[i], tau)\n b = 1\n for k in range(1, p + 1):\n tau1 = tau[mu - k + 1:mu + 1]\n tau2 = tau[mu + 1:mu + k + 1]\n omega = (t[i + k] - tau1) / (tau2 - tau1)\n b = np.append((1 - omega) * b, 0) + np.insert((omega * b), 0, 0)\n\n a[i, mu - p:mu + 1] = b\n return a","def qaoa(H, n_qubits, p):\n params=get_params(H,n_qubits,p)\n return cost_function(H, n_qubits, p, params)","def exactsolution(x, t, u):\n if 0 <= (x - u*t) and (x - u*t) <= 0.2:\n temp = 1 - (10 * (x - u*t) -1)**2\n else:\n temp = 0\n return temp","def q_from_ea(ea, p):\n return 0.622 * ea / (p - 0.378 * ea)","def __call__(self, p, q, verbosity=1, warn=True):\n if self.exactly_zero: return 0.0 # shortcut for trivial case\n if self.weight == 0:\n return _np.sum(_np.abs(q - p)) / 2\n\n #Set parameter values\n self.P.value[:] = p[:]\n self.Q.value[:] = q[:]\n\n treg_factor_ok = False\n self.Treg_factor.value = self.initial_treg_factor\n while not treg_factor_ok:\n\n obj1 = self._obj(self.t_params)\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\n **default_cvxpy_args(self.solver))\n\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed: # sanity check\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\n\n self.warning_msg = None\n if failed:\n if self.solver == \"SCS\":\n #raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed:\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\n\n if eps > 1e-4:\n self.warning_msg = (\"ResidualTVD: Needed to increase eps to %g.\"\n \" The resulting ResidualTVD values are less precise.\") % eps\n if warn: print(self.warning_msg)\n break\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n\n #check that Treg_factor term doesn't dominate\n\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\n treg_factor_ok = True\n\n # ------------------------------------------------------------------\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\n # ------------------------------------------------------------------\n\n #resid_tvd = self._obj(self.T_params.value)\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\n # Treg_factor_ok = True\n #else:\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\n\n #obj2 = self._obj(self.T_params.value)\n #if obj2 < obj1:\n # Treg_factor_ok = True\n #else:\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\n # self.T_params.value[:] = self.t_params[:] #REVERT\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\n # self.Treg_factor.value = self.Treg_factor.value / 10\n # if self.Treg_factor.value > 1e-7:\n # print(\"REDUCING treg factor to: \", self.Treg_factor.value)\n # else:\n # Treg_factor_ok = True # give up!\n\n if self.Treg_factor.value != self.initial_treg_factor:\n if verbosity > 0: print(\"NOTE: Treg_factor was reduced to %g.\" % self.Treg_factor.value)\n #_warnings.warn((\"Initial Treg_factor (%g) was too large, and was reduced to %g.\"\n # \" Consider reducing the initial value to avoid repeating calculations.\")\n # % (self.initial_treg_factor, self.Treg_factor.value))\n\n obj2 = self._obj(self.T_params.value)\n if obj2 <= obj1:\n self.t_params[:] = self.T_params.value[:]\n else:\n print_revert_msg(\"ResidualTVD failed to reduce objective function (%g > %g)\", (obj2, obj1), verbosity)\n self.T_params.value[:] = self.t_params[:]\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\n\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization","def ptrans(Xn):\n p = intgrate.quad(lambda q: q**(Xn + 1) * (1-q)**(2-Xn-1), 0, 1)\n prob = 2.0 * p[0]\n return prob","def qsolve(self, options=''):\n for x in self._rhs:\n if x != 0:\n raise NotImplementedError, \"qsolve is currently only implemented for homogeneous systems (i.e., with rhs=0)\"\n out, err = self.call_4ti2('qsolve', options=options)\n qhom = ExtremalRays(self._read_file('qhom'), self)\n qfree = self._read_file('qfree')\n return (qhom, qfree)","def cost(P, Q):\n Q = np.where(Q != 0, Q, 1e-12)\n P = np.where(P != 0, P, 1e-12)\n Div = P / Q\n C = np.sum(P * np.log(Div))\n return C","def _solve_explicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n current_solution = initial_conditions\n next_solution = np.empty_like(current_solution)\n solutions = []\n\n for t in self.t_grid:\n next_solution[1:-1] = (\n current_solution[1:-1]\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n next_solution[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n next_solution[0] = (\n 4 * next_solution[1]\n - next_solution[2]\n - 2 * self.h * self.left_bc(t)\n ) / 3.0\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n next_solution[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n next_solution[-1] = (\n 4 * next_solution[-2]\n - next_solution[-3]\n + 2 * self.h * self.right_bc(t)\n ) / 3.0\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def solve(m):\n\t\n #with the assumption that at least one terminal state is given:\n if(len(m)==2 or len(m)==1): return [1,1]\n \n #Normalizing the in. matrix and identifying the trans./abs. states:\n m = normalizeProbabilityMatrix(m)\n t = getTransientStates(m)\n a = getAbsorbingStates(m)\n\t\n if len(a) >0:\n print( str(len(a)) + \" absorbing state\" + (\"\" if len(a)<=1 else \"s\" ))\n else:\n print(\"No absorbing state detected\")\n return\n \n #Getting the matrices Q and R as in the canonical form:\n Q = getQ(m,t)\n R = getR(m,t,a)\n I = getIdentity(len(Q))\n I_Q = subtractMatrices(I, Q)\n \n #Getting the fundamental matrix\n N = invertMatrix(I_Q)\n F = multiplyMatrices(N,R)\n \n #packing the result with a common denominator:\n gcd = getGCD(F[0]).denominator\n res=[]\n sum = 0\n for r in F[0]:\n val = int(r.numerator*(gcd/r.denominator))\n sum+=val\n res.append(val)\n res.append(sum) \n return res","def solve(self, time_points):\n self.t = np.asarray(time_points)\n n = self.t.size\n if self.neq == 1: # scalar ODEs\n self.u = np.zeros(n)\n else: # systems of ODEs\n self.u = np.zeros((n, self.neq))\n\n # Assume self.t[0] corresponds to self.U0\n self.u[0] = self.U0\n\n # Time loop\n for k in range(n - 1):\n self.k = k\n self.u[k + 1] = self.advance()\n return self.u, self.t","def pe_solver(Aij, Bij, pi):\n # =========================================================================\n # Calculating the pressure at row i + 1\n # =========================================================================\n return np.dot(np.linalg.inv(Aij), np.dot(Bij, pi))","def qp(self, eta_u, eta_v):\n z = 1\n v = np.array(eta_u)\n n_features = v.shape[0]\n u = np.sort(v)[::-1]\n cssv = np.cumsum(u) - z\n ind = np.arange(n_features) + 1\n cond = u - cssv / ind > 0\n rho = ind[cond][-1]\n theta = cssv[cond][-1] / float(rho)\n uu = np.maximum(v - theta, 0)\n vv = np.array(())\n return uu, vv","def test_solve_quadratic(self):\n iden1 = Identity()\n iden2 = Identity()\n iden3 = Identity()\n iden1.x.fixed = False\n iden2.x.fixed = False\n iden3.x.fixed = False\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\n prob = LeastSquaresProblem([term1, term2, term3])\n prob.solve()\n self.assertAlmostEqual(prob.objective, 0)\n self.assertAlmostEqual(iden1.x.val, 1)\n self.assertAlmostEqual(iden2.x.val, 2)\n self.assertAlmostEqual(iden3.x.val, 3)","def rawsolve(self,):\n m = self.m\n n = self.n\n z = self.z\n mark = self.mark\n kAAt = self.kAAt\n iAAt = self.iAAt\n AAt = self.AAt\n diag = self.diag\n consistent = True\n eps = 0.0\n m2 = m+n\n\n if self.ndep:\n eps = self.epssol * np.abs(z).max()\n\n #/*------------------------------------------------------+\n #| |\n #| -1 |\n #| z <- L z |\n #| */\n\n for i in range(m2):\n if mark[i]:\n beta = z[i]\n for k in range(kAAt[i], kAAt[i+1]):\n row = iAAt[k]\n z[row] -= AAt[k]*beta\n elif abs(z[i]) > eps:\n consistent = False\n else:\n z[i] = 0.0\n\n #/*------------------------------------------------------+\n #| |\n #| -1 |\n #| z <- D z |\n #| */\n\n for i in range(m2-1, -1, -1):\n if mark[i]:\n z[i] = z[i]/diag[i]\n elif abs(z[i]) > eps:\n consistent = False\n else:\n z[i] = 0.0\n\n #/*------------------------------------------------------+\n #| |\n #| t -1 |\n #| z <- (L ) z |\n #| */\n\n for i in range(m2-1, -1, -1):\n if mark[i]:\n beta = z[i]\n for k in range(kAAt[i], kAAt[i+1]):\n beta -= AAt[k]*z[iAAt[k]]\n z[i] = beta\n elif abs(z[i]) > eps:\n consistent = False\n else:\n z[i] = 0.0\n\n return consistent","def resultant(P, Q):\n return np.linalg.det(P.sylvester(Q))","def phase_equilibrium_calculation(s, p, g_x_func, Z_0, k=None, P=None, T=None, \n tol=1e-9, Print_Results=False, Plot_Results=False):\n # Calculate first minimizer\n from tgo import tgo\n if True: # Print time\n import timeit\n A = timeit.time.time()\n \n s.update_state(s, p, P=P, T=T, X = Z_0, Force_Update=True) \n s = dual_equal(s, p, g_x_func, Z_0 , tol=tol)\n X_I = s.m['Z_eq']\n Lambda_d = s.m['Lambda_d']\n \n # Find phase of eq. point I\n s.update_state(s, p, X = X_I, Force_Update=True) \n s.m['Phase eq. I'] = g_x_func(s, p).m['g_mix']['ph min']\n\n # Calculate second minimizer\n Bounds = []\n for i in range(len(Z_0)):\n if Z_0[i] <= X_I[i]:\n Bounds.append((1e-6, Z_0[i]))\n if Z_0[i] > X_I[i]:\n Bounds.append((Z_0[i], 0.99999))\n\n # Calculate second point from redifined gobal func. \n Args = (g_x_func, Lambda_d, X_I, s, p, ['All'])\n print Bounds\n X_II = tgo(eq_sol, Bounds, args=Args, n=100, k_t = 5)\n \n # Find phase of eq. point II\n s.update_state(s, p, X = X_II, Force_Update=True) \n s.m['Phase eq. II'] = g_x_func(s, p).m['g_mix']['ph min']\n \n \n if True: \n B = timeit.time.time()\n print 'Total calculation time = {}'.format(B - A)\n \n if Print_Results:\n print 'EQUILIBRIUM SOLUTIONS I: {} (phase = {})'.format(X_I, \n s.m['Phase eq. I'])\n print ' II: {} (phase = {})'.format(X_II, \n s.m['Phase eq. II']) \n \n if Plot_Results:\n Z_0 = s.m['Z_eq']\n\n # Gibbs mix func with Tie lines\n from scipy import linspace\n print 'Feeding Lamda_d = {} to ep. func.'.format(s.m['Lambda_d'])\n print [[X_II, X_I]]\n if p.m['n'] == 2: # Plot binary tie lines\n plot.plot_g_mix(s, p, g_x_func, Tie =[[X_II, X_I]], x_r=1000)\n \n if p.m['n'] == 3: # Plot ternary tie lines\n s.update_state(s, p, P=P, T=T, X = X_I, Force_Update=True) \n G_P = g_x_func(s, p).m['g_mix']['t']\n print G_P\n Tie = [[G_P,# -0.3247905329, # G_P # TODO\n X_I[0], # x_1\n s.m['Lambda_d'][0], # lambda_1\n X_I[1], # x_2\n s.m['Lambda_d'][1]] # lambda_2\n ] \n s.m['Lambda_d']\n plot.plot_g_mix(s, p, g_x_func, Tie = Tie, x_r=100)\n \n # Error func\n s.m['Lambda_d'] = Lambda_d \n s.m['Z_eq'] = X_I\n X_r = linspace(1e-5, 0.9999, 1000) \n plot.plot_ep(eq_sol, X_r, s, p, args=Args)\n\n # Save returns in state dictionary.\n s.m['X_I'] = X_I\n s.m['X_II'] = X_II\n \n return s","def clfqp(self,x,p):\n alp = self.alp_opt\n nu = self.nu_opt\n dt = self.dt\n n = self.n\n I = np.identity(n)\n M = self.ncm(x,p)\n nu = np.size(self.h_or_g(x,p),1)\n u = cp.Variable((nu,1))\n e = np.reshape(x,(n,1))\n fx = np.reshape(self.dynamicsf(x,p),(n,1))\n gx = self.h_or_g(x,p)\n dMdt = (nu*I-M)/dt\n constraints = [2*e.T@(fx+gx@u)+e.T@dMdt@e <= -2*alp*e.T@M@e]\n prob = cp.Problem(cp.Minimize(cp.sum_squares(u)),constraints)\n prob.solve()\n u = u.value\n u = np.ravel(u)\n return u","def solution(n,p):\n \n a=pow(n, (p - 1) // 2, p)\n if(a==1):\n return True\n else :\n return False","def _solve(self) -> CasADiArrayType:\n\n # Setup solver\n self.m = osqp.OSQP()\n self.m.setup(**self._setup_input)\n\n # Warm start optimization\n if self.use_warm_start:\n self.m.warm_start(x=self.x0.toarray().flatten())\n\n # Solve problem\n self._solution = self.m.solve()\n\n return self._solution.x","def solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\n\n print(\"Solving random problems with solver %s\\n\" % solver)\n\n # Define statistics to record\n std_solve_time = np.zeros(len(n_vec))\n avg_solve_time = np.zeros(len(n_vec))\n min_solve_time = np.zeros(len(n_vec))\n max_solve_time = np.zeros(len(n_vec))\n\n n_prob = len(n_vec)\n\n # Store also OSQP time\n if solver == 'miosqp':\n # Add OSQP solve times statistics\n avg_osqp_solve_time = np.zeros(len(n_vec))\n\n # reset random seed\n np.random.seed(seed)\n\n for i in range(n_prob):\n\n # Get dimensions\n n = n_vec[i]\n m = m_vec[i]\n p = p_vec[i]\n\n print(\"problem n = %i, m = %i, p = %i\" % (n, m, p))\n\n # Define vector of cpu times\n solve_time_temp = np.zeros(repeat)\n\n # Store also OSQP time\n if solver == 'miosqp':\n osqp_solve_time_temp = np.zeros(repeat)\n\n for j in tqdm(range(repeat)):\n # for j in range(repeat):\n\n # Generate random vector of indeces\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\n\n # Generate random Matrices\n Pt = spa.random(n, n, density=dns_level)\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\n q = sp.randn(n)\n A = spa.random(m, n, density=dns_level)\n u = 2 + sp.rand(m)\n l = -2 + sp.rand(m)\n\n # Enforce [0, 1] bounds on variables\n i_l = np.zeros(p)\n i_u = np.ones(p)\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\n\n if solver == 'gurobi':\n # Solve with gurobi\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\n verbose=False, Threads=1)\n if res_gurobi.status != 'optimal':\n import ipdb\n ipdb.set_trace()\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\n\n elif solver == 'miosqp':\n # Define problem settings\n miosqp_settings = {\n # integer feasibility tolerance\n 'eps_int_feas': 1e-03,\n # maximum number of iterations\n 'max_iter_bb': 1000,\n # tree exploration rule\n # [0] depth first\n # [1] two-phase: depth first until first incumbent and then best bound\n 'tree_explor_rule': 1,\n # branching rule\n # [0] max fractional part\n 'branching_rule': 0,\n 'verbose': False,\n 'print_interval': 1}\n\n osqp_settings = {'eps_abs': 1e-03,\n 'eps_rel': 1e-03,\n 'eps_prim_inf': 1e-04,\n 'verbose': False}\n\n model = miosqp.MIOSQP()\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\n miosqp_settings,\n osqp_settings)\n res_miosqp = model.solve()\n\n # DEBUG (check if solutions match)\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\n # import ipdb; ipdb.set_trace()\n#\n # import ipdb; ipdb.set_trace()\n\n if res_miosqp.status != miosqp.MI_SOLVED:\n import ipdb\n ipdb.set_trace()\n \n # Solution time \n solve_time_temp[j] = 1e3 * res_miosqp.run_time\n\n # Store OSQP time in percentage\n if solver == 'miosqp':\n osqp_solve_time_temp[j] = \\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\n\n # Get time statistics\n std_solve_time[i] = np.std(solve_time_temp)\n avg_solve_time[i] = np.mean(solve_time_temp)\n max_solve_time[i] = np.max(solve_time_temp)\n min_solve_time[i] = np.min(solve_time_temp)\n\n # Store also OSQP time\n if solver == 'miosqp':\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\n\n # Create pandas dataframe for the results\n df_dict = {'n': n_vec,\n 'm': m_vec,\n 'p': p_vec,\n 't_min': min_solve_time,\n 't_max': max_solve_time,\n 't_avg': avg_solve_time,\n 't_std': std_solve_time}\n\n # Store also OSQP time\n if solver == 'miosqp':\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\n\n timings = pd.DataFrame(df_dict)\n\n return timings","def qtrans(m,V):\n T = s.Symbol(\"T\")\n return (((2 * s.pi * m * k * T) / (h**2))**(3/2)) * V","def solucaoEspacoPontoX(arq,t,x):\n \n parametros = open(arq,'r')\n lista = []\n for linha in parametros:\n valores = linha.split()\n lista.append( valores[1] )\n Ks = float(lista[0]) # Conductibilidade na fase solida\n Kl = float(lista[1]) # Conductibilidade na fase liquida\n Tf = float(lista[2]) # temperatura de mudanca de fase\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\n L = float(lista[5]) # calor latente\n cs = float(lista[6]) # calor especifico na zona solida\n cl = float(lista[7]) # calor especifico na zona liquida\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\n p = float(lista[9]) # pho = massa especifica\n parametros.close()\n \n lam = 0.5064 # chute inicial\n xx = x\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\n frente = X_espaco(lamb,Ks,t)\n if (frente > xx):\n T = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\n elif (frente < xx):\n T = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\n else:\n T = Tf\n return T","def yule_q(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = a + b + c + d\n\n if n == 0:\n return np.nan\n elif p1 == n:\n # c and d are zero\n return _div(a - b, p1)\n elif p2 == n:\n # b and d are zero\n return _div(a - c, p2)\n elif q1 == n:\n # a and b are zero\n return _div(d - c, q1)\n elif q2 == n:\n # a and c are zero\n return _div(d - b, q2)\n\n return _div(self.covar(), a * d + b * c)","def test_q(self):\n assert np.allclose(self.stepper.q, self.ODE.exact(self.stepper.t), rtol=1e-3, atol=1e-5)","def solve(self):\n\n if self.optimizer == 'pulp':\n for constraint in self.constraints:\n self.engine_model += constraint\n\n self.engine_model += self.objective\n status = self.engine_model.solve(PULP_CBC_CMD(msg=False))\n solution = (\n np.vectorize(self._var_sol)(self.variable_set)\n if status == LpStatusOptimal\n else np.array([])\n )\n\n else:\n for constraint in self.constraints:\n self.engine_model.addConstr(constraint)\n\n self.engine_model.setObjective(self.objective, self.sense)\n self.engine_model.optimize()\n solution = (\n np.vectorize(self._var_sol)(self.variable_set)\n if self.engine_model.status == GRB.OPTIMAL\n else np.array([])\n )\n\n return solution","def cost_function(H, n_qubits, p, params):\n ini_state=plus_state(n_qubits)\n for i in range(p):\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state","def busca_vector(A, a, p):\n \n Sq = busca_base(A, a, q)\n dim = np.shape(Sq)[1] # calcula la dimension del espacio Sq\n nrow = np.shape(A)[0] # numero de filas de A\n \n C0 = power(A-a*np.identity(nrow), q-1) # C0 = (A-aI)^{p-1} \n C1 = np.dot(C0, A-a*np.identity(nrow)) # C1 = (A-aI)^{p}\n \n for k in range(dim):\n if np.allclose(np.dot(B1,Sq[:,k]), 0.0) and not np.allclose(np.dot(B0,Sq[:,k]), 0.0):\n return Sq[:,k]","def Lq(self):\n if not self.isVaild():\n pass\n temp = ((self.r()**self.C)*self.Rho()) / \\\n (math.factorial(self.C)*((1 - self.Rho())**2))\n return temp*self.P0()","def solucaoEspacoX(arq,t,x):\n \n parametros = open(arq,'r')\n lista = []\n for linha in parametros:\n valores = linha.split()\n lista.append( valores[1] )\n Ks = float(lista[0]) # Conductibilidade na fase solida\n Kl = float(lista[1]) # Conductibilidade na fase liquida\n Tf = float(lista[2]) # temperatura de mudanca de fase\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\n L = float(lista[5]) # calor latente\n cs = float(lista[6]) # calor especifico na zona solida\n cl = float(lista[7]) # calor especifico na zona liquida\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\n p = float(lista[9]) # pho = massa especifica\n parametros.close()\n \n lam = 0.5064 # chute inicial \n n = len(x) # tamanho da malha\n T = np.zeros(n) # temperaturas\n\n T[0] = Tw\n for i in range(1,n):\n xx = x[i]\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\n frente = X_espaco(lamb,Ks,t)\n if (frente > xx):\n T[i] = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\n elif (frente < xx):\n T[i] = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\n else:\n T[i] = Tf\n lam = lamb\n return T","def closed_toda_3(x):\n q, p = extract_q_p(x)\n x = q[:,0,0,0]\n y = q[:,0,1,0]\n V = tf.exp(-2.*y) + tf.exp(y - tf.sqrt(3.)*x) + tf.exp(y + tf.sqrt(3.)*x)\n return tf.reduce_sum(tf.square(p), axis=2) + V","def get_sol(self):","def algorithm_1_2(p, c, x):\n\n q = np.array(c, dtype=np.float64)\n\n for k in range(1, p + 1):\n for j in range(0, p - k + 1):\n q[j] = (1 - x) * q[j] + x * q[j + 1]\n return q[0]","def solve(self):\n ...","def actualSolve(self, lp):\n\t\traise NotImplementedError","def solve(self):\n pass","def solve(self):\n pass","def anl_solution(self):\r\n\r\n m = float(self.mass) / self.nu_m\r\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\r\n / float(self.size_tick * self.size_tick)\r\n print 'qE=', qe\r\n c = self.light_vel\r\n for i in range(0, len(self.obs.obt_g)):\r\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\r\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\r\n * c)) ** 2) - 1.0)\r\n self.xa_track.append(x)\r\n p = qe * self.t[i]\r\n self.pa.append(p)\r\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\r\n jv = self.t[i] * qe / (m * c)\r\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\r\n self.va.append(v)\r\n print 'Analytical solution of the differential equation of motion'","def p(e, t):\n return b * e ** 2","def solve(self, d, t, x0 = None, **kwargs):\n if x0 == None:\n x0 = np.array([0., d])\n #x0 = np.array([self.Om*self.A0/np.sqrt(self.Q**2*(1-self.Om**2)**2 + self.Om**2), d])\n sol = solve_ivp(self.get_ode(d), (t[0], t[-1]), x0, t_eval = t, vectorized = True, **kwargs)\n\n return sol","def construct_Q(self, N, r, t0, tf):\n q = np.zeros((N, N))\n for i in xrange(N): \n for l in xrange(N):\n if i>= r and l>=r: \n q[i,l] = 2*self.prodoftwoterms(i,l,r)*(tf**(i+l-2*r+1) - t0**(i+l-2*r+1))/(i+l-2*r+1)\n return q","def P_i(self, alpha, Q, X_data):\n X_lin_comb = np.dot(alpha, X_data)\n Pi = Q * np.exp(X_lin_comb - X_lin_comb.max(initial=0))\n Pi = Pi / Pi.sum()\n return Pi","def actualSolve(self, lp):\n\t\tif lp.isMIP() and self.mip: return self.solve_CBC(lp)\n\t\telse: return self.solve_CLP(lp)","def prob3():\n # Define the nonlinear system, its Jacobian, and the initial guess.\n def f(X):\n x,y,z = X\n return np.array([ -x + y + z,\n 1 + x**3 -y**2 + z**3,\n -2 -x**2 + y**2 + z**2 ])\n def jacobian(X):\n x,y,z = X\n return np.array([ [ -1, 1, 1 ],\n [3*x**2, -2*y, 3*z**2],\n [ -2*x, 2*y, 2*z ] ])\n x0 = np.array([0,0,0])\n\n # Calculate the solution, check that it is a root, and return it.\n sol = opt.root(f, x0, jac=jacobian, method='hybr')\n assert np.allclose(np.zeros_like(sol.x), f(sol.x)), \"FAILURE\"\n return sol.x","def algorithm_2_21(p, t, x):\n\n t = np.array(t, dtype=np.float64)\n b = 1\n mu = index(x, t)\n\n for k in range(1, p + 1):\n t1 = t[mu - k + 1:mu + 1]\n t2 = t[mu + 1:mu + k + 1]\n omega = np.divide(\n (x - t1), (t2 - t1), out=np.zeros_like(t1), where=((t2 - t1) != 0))\n b = np.append((1 - omega) * b, 0) + np.insert((omega * b), 0, 0)\n\n return b","def qi(self, tl, psi_l):\n\t try: \n\t ans = .622*esat(tl)/P_ATM*exp(psi_l*1000000.*VW/R/tl)\n\t except OverflowError:\n\t ans = 0.\n\t return ans","def deterministic_solve(LEP):\n # solve state equation\n SE = LEP.SE(LEP.u, LEP.phi_n[0], LEP.v_u, LEP.g)\n solve(lhs(SE) == rhs(SE), LEP.u_n, bcs=LEP.bcSE, solver_parameters={\"linear_solver\": \"umfpack\", \"preconditioner\": \"default\"}, form_compiler_parameters=None)\n\n # solve adjoint equation\n LEP.p_n.assign(LEP.u_n) # p_n = u_n\n\n # solve gradient equation\n GE = LEP.GE(LEP.phi, LEP.phi_n, LEP.v_phi, LEP.p_n, LEP.u_n, LEP.tau[0], LEP.gamma)\n solve(lhs(GE) == rhs(GE), LEP.phi_next, bcs=None, solver_parameters={\"linear_solver\": \"umfpack\", \"preconditioner\": \"default\"}, form_compiler_parameters=None)\n\n LEP.project_phi()\n\n print(\"Phi_n as Vector:\", LEP.phi_next.vector()[:])\n print(\"Länge von Phi:\", len(LEP.phi_next.vector()[:]))\n\n J_eps = LEP.J_eps(LEP.u_n, LEP.phi_n[0])\n\n return J_eps","def Qfun(Phieq,Phi,Phibar,taurad):\n #note Q is different from Perez-Becker and Showman by a factor of g (for consistency with Phi vs H)\n Q=(1/taurad)*(Phieq-(Phi+Phibar))\n\n return Q","def solve(self):\n \n raise NotImplementedError(\"not implemented!\")","def a_q(self, phi, ci, tl):\n\t return (self.j(phi, tl)*(ci - self.gamma(tl)))/(4.*(ci + 2.*self.gamma(tl)))","def Q_i(params):\n Q = params['Q'].value\n Qe = Q_e(params)\n return (Q ** -1 - np.real(Qe ** -1)) ** -1","def sepinsky_formula(q=1, A=1):\n return vec_pick_formula(q, A)","def PDE_RHS_FKPP(t,y,q,x,description=None):\n \n \n D_mat = create_Uxx_mat(x)\n\n return (q[0]*D_mat.dot(y) + \n q[1]*y*(1-y))","def model(a, t, D, m):\n xprime = a[1] # x' = v\n vprime = -D*a[0]/m # v' = -D*x/m\n return [xprime, vprime]","def calc_pA_info_gain(pA, qo_pi, qs_pi):\n\n n_steps = len(qo_pi)\n \n num_modalities = len(pA)\n wA = utils.obj_array(num_modalities)\n for modality, pA_m in enumerate(pA):\n wA[modality] = spm_wnorm(pA[modality])\n\n pA_infogain = 0\n \n for modality in range(num_modalities):\n wA_modality = wA[modality] * (pA[modality] > 0).astype(\"float\")\n for t in range(n_steps):\n pA_infogain -= qo_pi[t][modality].dot(spm_dot(wA_modality, qs_pi[t])[:, np.newaxis])\n\n return pA_infogain","def _solve(self) -> CasADiArrayType:\n solver_input = {\"x0\": self.x0, \"p\": self.p}\n if self.opt_type in CONSTRAINED_OPT:\n solver_input[\"lbg\"] = self._lbg\n solver_input[\"ubg\"] = self._ubg\n self._solution = self._solver(**solver_input)\n self._stats = self._solver.stats()\n self._stats[\"solution\"] = self._solution\n return self._solution[\"x\"]","def project_curve(q):\n n,T = q.shape\n if n==2:\n dt = 0.35\n if n==3:\n dt = 0.2\n epsilon = 1e-6\n\n iter = 1\n res = ones(n)\n J = zeros((n,n))\n\n s = linspace(0,1,T)\n\n qnew = q.copy()\n qnew = qnew / sqrt(innerprod_q2(qnew,qnew))\n\n qnorm = zeros(T)\n G = zeros(n)\n C = zeros(300)\n while (norm(res) > epsilon):\n if iter > 300:\n break\n\n # Jacobian\n for i in range(0,n):\n for j in range(0,n):\n J[i,j] = 3 * trapz(qnew[i,:]*qnew[j,:],s)\n \n J += eye(n)\n\n for i in range(0,T):\n qnorm[i] = norm(qnew[:,i])\n \n # Compute the residue\n for i in range(0,n):\n G[i] = trapz(qnew[i,:]*qnorm,s)\n \n res = -G\n\n if (norm(res) < epsilon):\n break\n\n x = solve(J,res)\n C[iter] = norm(res)\n\n delG = Basis_Normal_A(qnew)\n temp = zeros((n,T))\n for i in range(0,n):\n temp += x[i]*delG[i]*dt\n \n qnew += temp\n iter += 1\n \n qnew = qnew/sqrt(innerprod_q2(qnew,qnew))\n\n return qnew","def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \n tol=1e-2):\n from numpy import array, zeros_like, zeros\n from scipy.optimize import minimize\n from tgo import tgo\n \n def x_lim(X): # limiting function used in TGO\n import numpy\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\n \n if k == None:\n k = p.m['Valid phases']\n \n # Initialize\n Z_0 = array(Z_0)\n LBD = - 1e300 # -inf\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \n \n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\n UBD = g_x_func(s, p).m['g_mix']['t'] \n Lambda_d = zeros_like(Z_0)\n\n # X bounds used in UBD optimization\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\n zeros(shape=(p.m['n']-1)) # Lower bound\n ] \n for i in range(p.m['n']-1): \n Sigma_ind = 0.0 # Sum of independent components excluding i\n # (lever rule) \n for j in range(p.m['n']-1):\n if j != i:\n Sigma_ind += Z_0[j]\n\n X_bounds[0][i] = 1.0 - Sigma_ind \n \n # Construct physical bounds x \\in [0, 1] for all independent components\n # (used in differential_evolution)\n Bounds = []\n for i in range(p.m['n'] - 1):\n #Bounds.append((0, 1))\n Bounds.append((1e-5, 0.99999))\n \n # Construct composition container from X_d for all phases. (REMOVED)\n X_d = Z_0\n\n\n #%% Normal calculation of daul problem if Z_0 is unstable.\n while abs(UBD - LBD) >= tol:\n # Solve UBD\n # Update system to new composition.\n # (Comp. invariant in UBD)\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\n k))['x']\n \n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\n \n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\n\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\n g_func=x_lim,\n n = 100,\n skip=2)\n # Solve LBD \n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \n X_d = X_sol\n # End\n \n\n if False: # Print results optional\n print 'Final UBD = {}'.format(UBD)\n print 'Final LBD = {}'.format(LBD)\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\n print 'Final Z_eq = {}'.format(X_d)\n print 'Final Lambda_d = {}'.format(Lambda_d)\n \n # Returns\n s.m['Z_eq'] = X_d\n s.m['Lambda_d'] = Lambda_d\n return s","def __init__ (self, p, q):\n self.n = p * q\n self.n_sq = self.n * self.n\n self.g = self.n + 1","def qp(self, eta_u, eta_v):\n\n c1, c2, c12 = eta_u[0], eta_u[1], eta_v[0]\n\n flip_sign = False\n if c12 < 0:\n flip_sign = True\n c1, c2, c12 = c1 + c12, 1 - c2, -c12\n\n if c1 > c2 + c12:\n u = [c1, c2 + c12]\n elif c2 > c1 + c12:\n u = [c1 + c12, c2]\n else:\n uu = (c1 + c2 + c12) / 2\n u = [uu, uu]\n\n u = np.clip(np.array(u), 0, 1)\n v = np.atleast_1d(np.min(u))\n\n if flip_sign:\n u[1] = 1 - u[1]\n v[0] = u[0] - v[0]\n\n return u, v","def _solve(self) -> CasADiArrayType:\n self._solution = cvxopt.solvers.qp(**self._solver_input)\n return self._solution[\"x\"]","def analyticSol (x):\n\treturn x*(1-x);","def __init__ (self, p, q):\n self.lamb = (p-1) * (q-1)\n self.mu = modinv(self.lamb, (p * q))","def solution(data):\n lines = preprocess(data)\n solver = Code(lines)\n return solver.solve()","def inv(P):\n L = cho_factor(P)\n return cho_solve(L, np.eye(P.shape[0]))","def analytical_integral_rppd(p, q, r, a, b, c):\n if p < 0:\n return 0.0\n elif q < 0:\n return 0.0\n elif r < 0.0:\n return 0.0\n else:\n return (\n a ** (p + 1)\n * b ** (q + 1)\n * c ** (r + 1)\n * ((-1) ** p + 1)\n * ((-1) ** q + 1)\n * ((-1) ** r + 1)\n / ((p + 1) * (q + 1) * (r + 1))\n )","def solver_parachute(T, dt, v0, tp, Cd, rho, A, m):\n \n # Mesh initialization\n v = []; v.append(v0); t=[]; t.append(0);\n x = []; x.append(3000.)\n \n def X(t):\n return -9.81\n def Y(t):\n return Cd*rho*A/(2.*m)\n \n # Simulate the same way as solver() untill time tp\n while t[-1]<=tp:\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Y))\n x.append(x[-1] + dt*v[-1])\n t.append(t[-1] + dt)\n \n # Z is the same as the function Y, but with different values\n def Z(t):\n return 1.8*1.0*44./(2.*m)\n \n # Continue the simulation untill the skydiver hits the ground\n while x[-1] > 0:\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Z))\n x.append(x[-1] + dt*v[-1])\n t.append(t[-1] + dt)\n return v, t, x","def func_exact_sol(x, case):\n TB, TA, L, q, k = get_valdict(case, 'TB,TA,L,q,k')\n return ((TB-TA)/L + (q/(2*k)*(L-x)))*x + TA","def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n if is_wire(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n elif not is_cs(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n\n # Set up the linear algebraic equation Ax=b\n A = np.zeros((num, num))\n b = np.zeros(num)\n for row, element in lookup.items():\n if is_wire(element) and element is not self.ground:\n for two_sided in element.attached:\n if is_cs(two_sided):\n if two_sided.pos is element:\n b[row] += -1 * two_sided.current\n else:\n b[row] += two_sided.current\n else:\n if two_sided.pos is element:\n flow = 1\n else:\n flow = -1\n A[row, r_lookup[two_sided]] = flow\n elif is_vs(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n b[row] = element.voltage\n elif is_resistor(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n A[row, r_lookup[element]] = -1 * element.resistance\n\n b = b.reshape((num, 1))\n try:\n x = np.linalg.solve(A, b)\n except np.linalg.LinAlgError:\n raise CircuitError('Insufficient information to solve circuit')\n\n # Assign values to all circuit components\n for i in range(num):\n item = lookup[i]\n if is_wire(item):\n item.potential = x[i, 0]\n elif isinstance(item, DualSided):\n item.current = x[i, 0]\n\n # Mark circuit as solved\n self.been_solved = True","def solve(self, solver):\n solver.solve()","def obtain_Q(self):\n \n #create the initial triangular matrix as a copy of the m x n - matrix A\n \n v_list = Householder.vector(self)\n n_v = len(v_list) # number of vectors, not equal to number of columns in R\n q_m = len(v_list[0]) # longest vector, should determine the shape of Q\n \n H_list = []\n for i in list(range(n_v)):\n \n gamma = ((np.linalg.norm(v_list[i]))**2)/2\n vvtrans = v_list[i] * np.transpose(v_list[i])\n H = np.identity((q_m-i)) - (vvtrans/gamma)\n \n print(H.shape)\n\n m_H, n_H = H.shape\n if m_H < q_m:\n I = np.identity(q_m)\n x = y = i\n I [ x:x+H.shape[0], y:y+H.shape[1]] = H\n H = I\n H_list.append(H)\n \n # The transpose of Q is the result of the dot product H(n-1)...H1 \n \n len_H = len(H_list)\n\n H_temp = H_list[-1]\n \n for i in np.arange(len_H-1,0,-1):\n \n H_temp = np.matmul(H_temp, H_list[i-1])\n \n Q = np.transpose(H_temp)\n \n return(Q)","def padeIIi(z, f_z, p_order, q_order):\n\n if len(z) != len(f_z):\n raise ValueError(\"z, f_z should be the same length.\")\n \n #################\n # Equation (2.25)\n \n dim = max(p_order, q_order) + 1\n # z_ij\n index_range = np.arange(dim)\n I,J = np.meshgrid(index_range, index_range)\n exponent = I+J\n z_ij = np.sum(z ** exponent[:,:,None], axis=2)\n \n # Now f_ij, and f^(2)_ij\n f_ij = np.sum(f_z * z ** exponent[:,:,None], axis=2)\n f2_ij = np.sum(f_z**2 * z ** exponent[:,:,None], axis=2)\n \n # Finally, we get to (2.24), which we cast in matrix form to solve:\n # M * poly = F\n # Where poly = [p coeffs, q coeffs]\n \n M = np.concatenate(\n (\n np.concatenate(\n (f_ij[1:q_order+1, 0:p_order+1] , -f2_ij[1:q_order+1, 1:q_order+1]),\n axis=1,\n ),\n np.concatenate(\n ( z_ij[0:p_order+1, 0:p_order+1] , -f_ij[0:p_order+1, 1:q_order+1]),\n axis=1\n )\n ))\n \n F = np.concatenate((f2_ij[1:q_order+1, 0], f_ij[0:p_order+1, 0]))\n \n poly, residuals, rank, s = np.linalg.lstsq(M, F, rcond=0)\n \n P = poly[0:p_order+1][::-1]\n Q = np.concatenate(([1], poly[-(q_order):]))[::-1]\n \n return (P,Q)","def xBounds2cvxoptMatrix(p):\n\n #TODO: is reshape/flatten required in newest numpy versions?\n indLB, indUB, indEQ = \\\n where(isfinite(p.lb) & ~(p.lb == p.ub))[0], \\\n where(isfinite(p.ub) & ~(p.lb == p.ub))[0], \\\n where(p.lb == p.ub)[0] \n \n initLenB = Len(p.b)\n initLenBeq = Len(p.beq)\n nLB, nUB, nEQ = Len(indLB), Len(indUB), Len(indEQ)\n\n if nLB>0 or nUB>0:\n A, b = copy(p.A), copy(p.b)\n p.A = zeros([Len(p.b) + nLB+nUB, p.n])\n p.b = zeros(Len(p.b) + nLB+nUB)\n p.b[:Len(b)] = b.flatten() # sometimes flatten is needed when called before runProbSolver(), from tests\n p.A[:Len(b)] = A\n for i in range(len(indLB)):\n p.A[initLenB+i, indLB[i]] = -1\n p.b[initLenB+i] = -p.lb[indLB[i]]\n for i in range(len(indUB)):\n p.A[initLenB+len(indLB)+i, indUB[i]] = 1\n p.b[initLenB+len(indLB)+i] = p.ub[indUB[i]]\n\n if nEQ>0:\n Aeq, beq = copy(p.Aeq), copy(p.beq)\n p.Aeq = zeros([Len(p.beq) + nEQ, p.n])\n p.beq = zeros(Len(p.beq) + nEQ)\n p.beq[:Len(beq)] = beq\n p.Aeq[:Len(beq)] = Aeq\n for i in range(len(indEQ)):\n p.Aeq[initLenBeq+i, indEQ[i]] = 1\n p.beq[initLenBeq+i] = p.lb[indEQ[i]] # = p.ub[indEQ[i]], because they are the same\n\n p.lb = -inf*ones(p.n)\n p.ub = inf*ones(p.n)","def solve(self):\n \n # Definition of the parameters\n Q_pc = self.parameters.getParam(\"Q_pc\")\n V_c = self.parameters.getParam(\"V_c\")\n V_p = self.parameters.getParam(\"V_p\")\n CL = self.parameters.getParam(\"CL\")\n initial_conditions = [\n self.parameters.getParam(\"q_c0\"),\n self.parameters.getParam(\"q_p0\"),\n ]\n t_eval = np.linspace(0, self.timespan, self.nsteps)\n\n # Definition of the model ODEs\n def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\n \"\"\"Defines the differential equations for the PK IV model.\n\n Parameters:\n :param t: time (h)\n :param y: list of the state variables of the ODEs system, in the\n form [q_c, q_p]\n :param Q_pc: transition rate between central and peripheral\n compartments (mL/h)\n :param V_c: volume of central compartment (mL)\n :param V_p: volume of peripheral compartment (mL)\n :param CL: clearance/elimination rate from the central\n compartment (mL/h)\n\n The parameters (except for t and y) are extracted from the\n Parameter class, using getParam method.\n\n Returns list containing the differential equations, in the form:\n [dqc_dt, dqp_dt]\n \"\"\"\n q_c, q_p = y\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\n dqp_dt = transfer\n return [dqc_dt, dqp_dt]\n\n # Solving the model\n sol = scipy.integrate.solve_ivp(\n fun=lambda t, y: pk_iv_model(t, y, Q_pc, V_c, V_p, CL),\n t_span=[t_eval[0], t_eval[-1]],\n y0=initial_conditions,\n t_eval=t_eval,\n )\n\n # Feeding the solution line by line to solution class\n t = sol.t\n y = sol.y\n N = t.shape[0]\n columnNames = [\"t\", \"dose\", \"q_c\", \"q_p\"]\n self.solution.begin(columnNames, N)\n for i in range(N):\n arr = np.zeros((len(columnNames), 1))\n arr[0] = t[i]\n arr[1] = self.dosefunction(t[i])\n arr[2:, 0] = y[:, i]\n self.solution.report(arr)","def solucaoEspaco(arq,t,n,xf):\n \n parametros = open(arq,'r')\n lista = []\n for linha in parametros:\n valores = linha.split()\n lista.append( valores[1] )\n Ks = float(lista[0]) # Conductibilidade na fase solida\n Kl = float(lista[1]) # Conductibilidade na fase liquida\n Tf = float(lista[2]) # temperatura de mudanca de fase\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\n L = float(lista[5]) # calor latente\n cs = float(lista[6]) # calor especifico na zona solida\n cl = float(lista[7]) # calor especifico na zona liquida\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\n p = float(lista[9]) # pho = massa especifica\n parametros.close() \n\n lam = 0.5064 # chute inicial \n T = np.zeros(n+1) # temperaturas\n x = np.linspace(0.0,xf,n+1) # espaco\n\n T[0] = Tw\n for i in range(1,n+1):\n xx = x[i]\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\n frente = X_espaco(lamb,Ks,t)\n if (frente > xx):\n T[i] = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\n elif (frente < xx):\n T[i] = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\n else:\n T[i] = Tf\n lam = lamb\n return x,T","def REINFORCEMENT(self, p, tau):\n tau = np.array(tau)\n T = len(tau)\n A = tau[:, 1]\n R = tau[:, 2]\n\n prob = p\n estG = self.estG(R, self.gamma, T)\n\n for t in range(T):\n prob += self.alpha * self.gamma**t * estG[t] * self.gradient(prob, A[t]) \n\n return prob","def ppca(Y, Q, iterations=100):\r\n from numpy.ma import dot as madot\r\n N, D = Y.shape\r\n # Initialise W randomly\r\n W = np.random.randn(D, Q) * 1e-3\r\n Y = np.ma.masked_invalid(Y, copy=0)\r\n mu = Y.mean(0)\r\n Ycentered = Y - mu\r\n try:\r\n for _ in range(iterations):\r\n exp_x = np.asarray_chkfinite(np.linalg.solve(W.T.dot(W), madot(W.T, Ycentered.T))).T\r\n W = np.asarray_chkfinite(np.linalg.solve(exp_x.T.dot(exp_x), madot(exp_x.T, Ycentered))).T\r\n except np.linalg.linalg.LinAlgError:\r\n #\"converged\"\r\n pass\r\n return np.asarray_chkfinite(exp_x), np.asarray_chkfinite(W)","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def qaoa_step(state, H, n_qubits, params):\n B=B_operator(n_qubits)\n state=lasp.expm_multiply(1j*params[0]*H, state)\n return lasp.expm_multiply(-1j*params[1]*B,state)","def ap(self, P):\n if P.divides(self.conductor()):\n if (P*P).divides(self.conductor()):\n # It is 0, because the reduction is additive.\n return ZZ(0)\n else:\n # TODO: It is +1 or -1, but I do not yet know how to\n # compute which without using the L-function.\n return '?'\n else:\n return self._S.hecke_matrix(P)[0,0]"],"string":"[\n \"def solve(P, Q):\\n L = cho_factor(P)\\n return cho_solve(L, Q)\",\n \"def sol_p(t, p0, s0, u0, alpha, beta, gamma, eta, delta):\\n u = sol_u(t, u0, alpha, beta)\\n s = sol_s(t, s0, u0, alpha, beta, gamma)\\n exp_gt = np.exp(-delta * t)\\n p = p0 * exp_gt + eta / (delta - gamma) * (\\n s - s0 * exp_gt - beta / (delta - beta) * (u - u0 * exp_gt - alpha / delta * (1 - exp_gt))\\n )\\n return p, s, u\",\n \"def regular(P):\\n try:\\n dim = P.shape[0]\\n q = (P - np.eye(dim))\\n ones = np.ones(dim)\\n q = np.c_[q, ones]\\n QTQ = np.dot(q, q.T)\\n bQT = np.ones(dim)\\n answer = np.linalg.solve(QTQ, bQT)\\n if np.all(answer > 0):\\n return answer\\n else:\\n return None\\n except Exception as e:\\n return None\",\n \"def regular(P):\\n try:\\n cols = P.shape[0]\\n ans = np.ones((1, cols))\\n # eq = np.matmul(ans, P)\\n # s = np.array(np.arange(1, cols + 1))\\n eq = np.vstack([P.T - np.identity(cols), ans])\\n # va, vec = np.linalg .eig(P)\\n results = np.zeros((cols, 1))\\n results = np.vstack([results, np.array([1])])\\n statetionary = np.linalg.solve(eq.T.dot(eq), eq.T.dot(results)).T\\n # print(statetionary)\\n # print(np.argwhere(statetionary < 0))\\n if len(np.argwhere(statetionary < 0)) > 0:\\n return None\\n return statetionary\\n except Exception as e:\\n return None\",\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def quadprog_solve_qp(P, q, G=None, h=None, A=None, b=None):\\n #qp_G = .5 * (P + P.T) # make sure P is symmetric\\n qp_G = P\\n qp_a = -q\\n if A is not None:\\n qp_C = -np.vstack([A, G]).T\\n qp_b = -np.hstack([b, h])\\n meq = A.shape[0]\\n else: # no equality constraint\\n qp_C = -G.T\\n qp_b = -h\\n meq = 0\\n return quadprog.solve_qp(qp_G, qp_a, qp_C, qp_b, meq)[0]\",\n \"def f(t,x,p,q):\\n return p[1] + q[0]*x\",\n \"def solve(self, state, times):\",\n \"def algorithm_1_1(p, c, t, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (t[j + k] - x) / (t[j + k] - t[j]) * q[j] + (x - t[j]) / (\\n t[j + k] - t[j]) * q[j + 1]\\n return q[0]\",\n \"def Y(t, p, q):\\n \\n if t <= 0:\\n return float('inf')\\n \\n if q == 1:\\n return (t**(p+1) - 1) / (p * (p+1)) - np.log(t) / q + (p - 1) / p * (t-1)\\n else:\\n return (t**(p+1) - 1) / (p * (p+1)) + (t**(1-q) - 1) / (q*(q-1)) + (p - q) / (p * q) * (t-1)\",\n \"def solve_Q(ih, jh):\\n # Build A and b\\n\\n # Solve for c via least squares.\\n\\n # Form C from c\\n\\n # Solve for Q and return it.\\n return None\",\n \"def solve(self):\",\n \"def Yp(t, p, q):\\n \\n return (t**p - 1) / p + (1-t**(-q)) / q\",\n \"def confirm_Alex_fast(p, q, r):\\n if p*q*r < 0:\\n return False\\n if q*r + p*r + p*q -1 == 0:\\n return True\\n else:\\n return False\",\n \"def Problem3(n):\\n A = Problem2(n)\\n b = np.vstack(np.random.random(n))\\n return A,sl.spsolve(A,b),b\",\n \"def PQa(P_0, Q_0, D):\\n A_i_2 = B_i_1 = 0\\n A_i_1 = B_i_2 = 1\\n\\n G_i_2 = -P_0\\n G_i_1 = Q_0\\n\\n P_i = P_0\\n Q_i = Q_0\\n\\n while True:\\n\\n a_i = floor((P_i + sqrt(D))/Q_i)\\n A_i = a_i*A_i_1 + A_i_2\\n B_i = a_i*B_i_1 + B_i_2\\n G_i = a_i*G_i_1 + G_i_2\\n\\n yield P_i, Q_i, a_i, A_i, B_i, G_i\\n\\n A_i_1, A_i_2 = A_i, A_i_1\\n B_i_1, B_i_2 = B_i, B_i_1\\n G_i_1, G_i_2 = G_i, G_i_1\\n\\n P_i = a_i*Q_i - P_i\\n Q_i = (D - P_i**2)/Q_i\",\n \"def _solve_subproblem(\\n self, x_eval: Tensor, x_neg: Tensor, X_pos: Tensor,\\n cache_book: dict\\n ) -> Tensor:\\n\\n # Q = A @ A.t()\\n A, b, Q = self._qp_params(\\n x_eval, x_neg, X_pos, cache_book\\n )\\n lamda = self._qp_solver(Q, b)\\n\\n return -A.t() @ lamda\",\n \"def ea_from_q(p, q):\\n return p * q / (0.622 + 0.378 * q)\",\n \"def _solve(self, H, T):\\n P = pinv(H)\\n Beta = np.dot(P, T)\\n return Beta\",\n \"def _solve(self, mu=None):\\n pass\",\n \"def algorithm_4_9(p, tau, t):\\n m = len(t) - (p + 1)\\n n = len(tau) - (p + 1)\\n\\n a = np.zeros(shape=(m, n))\\n t = np.array(t, dtype=np.float64)\\n tau = np.array(tau, dtype=np.float64)\\n\\n for i in range(m):\\n mu = index(t[i], tau)\\n b = 1\\n for k in range(1, p + 1):\\n tau1 = tau[mu - k + 1:mu + 1]\\n tau2 = tau[mu + 1:mu + k + 1]\\n omega = (t[i + k] - tau1) / (tau2 - tau1)\\n b = np.append((1 - omega) * b, 0) + np.insert((omega * b), 0, 0)\\n\\n a[i, mu - p:mu + 1] = b\\n return a\",\n \"def qaoa(H, n_qubits, p):\\n params=get_params(H,n_qubits,p)\\n return cost_function(H, n_qubits, p, params)\",\n \"def exactsolution(x, t, u):\\n if 0 <= (x - u*t) and (x - u*t) <= 0.2:\\n temp = 1 - (10 * (x - u*t) -1)**2\\n else:\\n temp = 0\\n return temp\",\n \"def q_from_ea(ea, p):\\n return 0.622 * ea / (p - 0.378 * ea)\",\n \"def __call__(self, p, q, verbosity=1, warn=True):\\n if self.exactly_zero: return 0.0 # shortcut for trivial case\\n if self.weight == 0:\\n return _np.sum(_np.abs(q - p)) / 2\\n\\n #Set parameter values\\n self.P.value[:] = p[:]\\n self.Q.value[:] = q[:]\\n\\n treg_factor_ok = False\\n self.Treg_factor.value = self.initial_treg_factor\\n while not treg_factor_ok:\\n\\n obj1 = self._obj(self.t_params)\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\\n **default_cvxpy_args(self.solver))\\n\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed: # sanity check\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\\n\\n self.warning_msg = None\\n if failed:\\n if self.solver == \\\"SCS\\\":\\n #raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed:\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\\n\\n if eps > 1e-4:\\n self.warning_msg = (\\\"ResidualTVD: Needed to increase eps to %g.\\\"\\n \\\" The resulting ResidualTVD values are less precise.\\\") % eps\\n if warn: print(self.warning_msg)\\n break\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n\\n #check that Treg_factor term doesn't dominate\\n\\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\\n treg_factor_ok = True\\n\\n # ------------------------------------------------------------------\\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\\n # ------------------------------------------------------------------\\n\\n #resid_tvd = self._obj(self.T_params.value)\\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\\n # Treg_factor_ok = True\\n #else:\\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\\n\\n #obj2 = self._obj(self.T_params.value)\\n #if obj2 < obj1:\\n # Treg_factor_ok = True\\n #else:\\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\\n # self.T_params.value[:] = self.t_params[:] #REVERT\\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\\n # self.Treg_factor.value = self.Treg_factor.value / 10\\n # if self.Treg_factor.value > 1e-7:\\n # print(\\\"REDUCING treg factor to: \\\", self.Treg_factor.value)\\n # else:\\n # Treg_factor_ok = True # give up!\\n\\n if self.Treg_factor.value != self.initial_treg_factor:\\n if verbosity > 0: print(\\\"NOTE: Treg_factor was reduced to %g.\\\" % self.Treg_factor.value)\\n #_warnings.warn((\\\"Initial Treg_factor (%g) was too large, and was reduced to %g.\\\"\\n # \\\" Consider reducing the initial value to avoid repeating calculations.\\\")\\n # % (self.initial_treg_factor, self.Treg_factor.value))\\n\\n obj2 = self._obj(self.T_params.value)\\n if obj2 <= obj1:\\n self.t_params[:] = self.T_params.value[:]\\n else:\\n print_revert_msg(\\\"ResidualTVD failed to reduce objective function (%g > %g)\\\", (obj2, obj1), verbosity)\\n self.T_params.value[:] = self.t_params[:]\\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\\n\\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization\",\n \"def ptrans(Xn):\\n p = intgrate.quad(lambda q: q**(Xn + 1) * (1-q)**(2-Xn-1), 0, 1)\\n prob = 2.0 * p[0]\\n return prob\",\n \"def qsolve(self, options=''):\\n for x in self._rhs:\\n if x != 0:\\n raise NotImplementedError, \\\"qsolve is currently only implemented for homogeneous systems (i.e., with rhs=0)\\\"\\n out, err = self.call_4ti2('qsolve', options=options)\\n qhom = ExtremalRays(self._read_file('qhom'), self)\\n qfree = self._read_file('qfree')\\n return (qhom, qfree)\",\n \"def cost(P, Q):\\n Q = np.where(Q != 0, Q, 1e-12)\\n P = np.where(P != 0, P, 1e-12)\\n Div = P / Q\\n C = np.sum(P * np.log(Div))\\n return C\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def solve(m):\\n\\t\\n #with the assumption that at least one terminal state is given:\\n if(len(m)==2 or len(m)==1): return [1,1]\\n \\n #Normalizing the in. matrix and identifying the trans./abs. states:\\n m = normalizeProbabilityMatrix(m)\\n t = getTransientStates(m)\\n a = getAbsorbingStates(m)\\n\\t\\n if len(a) >0:\\n print( str(len(a)) + \\\" absorbing state\\\" + (\\\"\\\" if len(a)<=1 else \\\"s\\\" ))\\n else:\\n print(\\\"No absorbing state detected\\\")\\n return\\n \\n #Getting the matrices Q and R as in the canonical form:\\n Q = getQ(m,t)\\n R = getR(m,t,a)\\n I = getIdentity(len(Q))\\n I_Q = subtractMatrices(I, Q)\\n \\n #Getting the fundamental matrix\\n N = invertMatrix(I_Q)\\n F = multiplyMatrices(N,R)\\n \\n #packing the result with a common denominator:\\n gcd = getGCD(F[0]).denominator\\n res=[]\\n sum = 0\\n for r in F[0]:\\n val = int(r.numerator*(gcd/r.denominator))\\n sum+=val\\n res.append(val)\\n res.append(sum) \\n return res\",\n \"def solve(self, time_points):\\n self.t = np.asarray(time_points)\\n n = self.t.size\\n if self.neq == 1: # scalar ODEs\\n self.u = np.zeros(n)\\n else: # systems of ODEs\\n self.u = np.zeros((n, self.neq))\\n\\n # Assume self.t[0] corresponds to self.U0\\n self.u[0] = self.U0\\n\\n # Time loop\\n for k in range(n - 1):\\n self.k = k\\n self.u[k + 1] = self.advance()\\n return self.u, self.t\",\n \"def pe_solver(Aij, Bij, pi):\\n # =========================================================================\\n # Calculating the pressure at row i + 1\\n # =========================================================================\\n return np.dot(np.linalg.inv(Aij), np.dot(Bij, pi))\",\n \"def qp(self, eta_u, eta_v):\\n z = 1\\n v = np.array(eta_u)\\n n_features = v.shape[0]\\n u = np.sort(v)[::-1]\\n cssv = np.cumsum(u) - z\\n ind = np.arange(n_features) + 1\\n cond = u - cssv / ind > 0\\n rho = ind[cond][-1]\\n theta = cssv[cond][-1] / float(rho)\\n uu = np.maximum(v - theta, 0)\\n vv = np.array(())\\n return uu, vv\",\n \"def test_solve_quadratic(self):\\n iden1 = Identity()\\n iden2 = Identity()\\n iden3 = Identity()\\n iden1.x.fixed = False\\n iden2.x.fixed = False\\n iden3.x.fixed = False\\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\\n prob = LeastSquaresProblem([term1, term2, term3])\\n prob.solve()\\n self.assertAlmostEqual(prob.objective, 0)\\n self.assertAlmostEqual(iden1.x.val, 1)\\n self.assertAlmostEqual(iden2.x.val, 2)\\n self.assertAlmostEqual(iden3.x.val, 3)\",\n \"def rawsolve(self,):\\n m = self.m\\n n = self.n\\n z = self.z\\n mark = self.mark\\n kAAt = self.kAAt\\n iAAt = self.iAAt\\n AAt = self.AAt\\n diag = self.diag\\n consistent = True\\n eps = 0.0\\n m2 = m+n\\n\\n if self.ndep:\\n eps = self.epssol * np.abs(z).max()\\n\\n #/*------------------------------------------------------+\\n #| |\\n #| -1 |\\n #| z <- L z |\\n #| */\\n\\n for i in range(m2):\\n if mark[i]:\\n beta = z[i]\\n for k in range(kAAt[i], kAAt[i+1]):\\n row = iAAt[k]\\n z[row] -= AAt[k]*beta\\n elif abs(z[i]) > eps:\\n consistent = False\\n else:\\n z[i] = 0.0\\n\\n #/*------------------------------------------------------+\\n #| |\\n #| -1 |\\n #| z <- D z |\\n #| */\\n\\n for i in range(m2-1, -1, -1):\\n if mark[i]:\\n z[i] = z[i]/diag[i]\\n elif abs(z[i]) > eps:\\n consistent = False\\n else:\\n z[i] = 0.0\\n\\n #/*------------------------------------------------------+\\n #| |\\n #| t -1 |\\n #| z <- (L ) z |\\n #| */\\n\\n for i in range(m2-1, -1, -1):\\n if mark[i]:\\n beta = z[i]\\n for k in range(kAAt[i], kAAt[i+1]):\\n beta -= AAt[k]*z[iAAt[k]]\\n z[i] = beta\\n elif abs(z[i]) > eps:\\n consistent = False\\n else:\\n z[i] = 0.0\\n\\n return consistent\",\n \"def resultant(P, Q):\\n return np.linalg.det(P.sylvester(Q))\",\n \"def phase_equilibrium_calculation(s, p, g_x_func, Z_0, k=None, P=None, T=None, \\n tol=1e-9, Print_Results=False, Plot_Results=False):\\n # Calculate first minimizer\\n from tgo import tgo\\n if True: # Print time\\n import timeit\\n A = timeit.time.time()\\n \\n s.update_state(s, p, P=P, T=T, X = Z_0, Force_Update=True) \\n s = dual_equal(s, p, g_x_func, Z_0 , tol=tol)\\n X_I = s.m['Z_eq']\\n Lambda_d = s.m['Lambda_d']\\n \\n # Find phase of eq. point I\\n s.update_state(s, p, X = X_I, Force_Update=True) \\n s.m['Phase eq. I'] = g_x_func(s, p).m['g_mix']['ph min']\\n\\n # Calculate second minimizer\\n Bounds = []\\n for i in range(len(Z_0)):\\n if Z_0[i] <= X_I[i]:\\n Bounds.append((1e-6, Z_0[i]))\\n if Z_0[i] > X_I[i]:\\n Bounds.append((Z_0[i], 0.99999))\\n\\n # Calculate second point from redifined gobal func. \\n Args = (g_x_func, Lambda_d, X_I, s, p, ['All'])\\n print Bounds\\n X_II = tgo(eq_sol, Bounds, args=Args, n=100, k_t = 5)\\n \\n # Find phase of eq. point II\\n s.update_state(s, p, X = X_II, Force_Update=True) \\n s.m['Phase eq. II'] = g_x_func(s, p).m['g_mix']['ph min']\\n \\n \\n if True: \\n B = timeit.time.time()\\n print 'Total calculation time = {}'.format(B - A)\\n \\n if Print_Results:\\n print 'EQUILIBRIUM SOLUTIONS I: {} (phase = {})'.format(X_I, \\n s.m['Phase eq. I'])\\n print ' II: {} (phase = {})'.format(X_II, \\n s.m['Phase eq. II']) \\n \\n if Plot_Results:\\n Z_0 = s.m['Z_eq']\\n\\n # Gibbs mix func with Tie lines\\n from scipy import linspace\\n print 'Feeding Lamda_d = {} to ep. func.'.format(s.m['Lambda_d'])\\n print [[X_II, X_I]]\\n if p.m['n'] == 2: # Plot binary tie lines\\n plot.plot_g_mix(s, p, g_x_func, Tie =[[X_II, X_I]], x_r=1000)\\n \\n if p.m['n'] == 3: # Plot ternary tie lines\\n s.update_state(s, p, P=P, T=T, X = X_I, Force_Update=True) \\n G_P = g_x_func(s, p).m['g_mix']['t']\\n print G_P\\n Tie = [[G_P,# -0.3247905329, # G_P # TODO\\n X_I[0], # x_1\\n s.m['Lambda_d'][0], # lambda_1\\n X_I[1], # x_2\\n s.m['Lambda_d'][1]] # lambda_2\\n ] \\n s.m['Lambda_d']\\n plot.plot_g_mix(s, p, g_x_func, Tie = Tie, x_r=100)\\n \\n # Error func\\n s.m['Lambda_d'] = Lambda_d \\n s.m['Z_eq'] = X_I\\n X_r = linspace(1e-5, 0.9999, 1000) \\n plot.plot_ep(eq_sol, X_r, s, p, args=Args)\\n\\n # Save returns in state dictionary.\\n s.m['X_I'] = X_I\\n s.m['X_II'] = X_II\\n \\n return s\",\n \"def clfqp(self,x,p):\\n alp = self.alp_opt\\n nu = self.nu_opt\\n dt = self.dt\\n n = self.n\\n I = np.identity(n)\\n M = self.ncm(x,p)\\n nu = np.size(self.h_or_g(x,p),1)\\n u = cp.Variable((nu,1))\\n e = np.reshape(x,(n,1))\\n fx = np.reshape(self.dynamicsf(x,p),(n,1))\\n gx = self.h_or_g(x,p)\\n dMdt = (nu*I-M)/dt\\n constraints = [2*e.T@(fx+gx@u)+e.T@dMdt@e <= -2*alp*e.T@M@e]\\n prob = cp.Problem(cp.Minimize(cp.sum_squares(u)),constraints)\\n prob.solve()\\n u = u.value\\n u = np.ravel(u)\\n return u\",\n \"def solution(n,p):\\n \\n a=pow(n, (p - 1) // 2, p)\\n if(a==1):\\n return True\\n else :\\n return False\",\n \"def _solve(self) -> CasADiArrayType:\\n\\n # Setup solver\\n self.m = osqp.OSQP()\\n self.m.setup(**self._setup_input)\\n\\n # Warm start optimization\\n if self.use_warm_start:\\n self.m.warm_start(x=self.x0.toarray().flatten())\\n\\n # Solve problem\\n self._solution = self.m.solve()\\n\\n return self._solution.x\",\n \"def solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\\n\\n print(\\\"Solving random problems with solver %s\\\\n\\\" % solver)\\n\\n # Define statistics to record\\n std_solve_time = np.zeros(len(n_vec))\\n avg_solve_time = np.zeros(len(n_vec))\\n min_solve_time = np.zeros(len(n_vec))\\n max_solve_time = np.zeros(len(n_vec))\\n\\n n_prob = len(n_vec)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n # Add OSQP solve times statistics\\n avg_osqp_solve_time = np.zeros(len(n_vec))\\n\\n # reset random seed\\n np.random.seed(seed)\\n\\n for i in range(n_prob):\\n\\n # Get dimensions\\n n = n_vec[i]\\n m = m_vec[i]\\n p = p_vec[i]\\n\\n print(\\\"problem n = %i, m = %i, p = %i\\\" % (n, m, p))\\n\\n # Define vector of cpu times\\n solve_time_temp = np.zeros(repeat)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n osqp_solve_time_temp = np.zeros(repeat)\\n\\n for j in tqdm(range(repeat)):\\n # for j in range(repeat):\\n\\n # Generate random vector of indeces\\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\\n\\n # Generate random Matrices\\n Pt = spa.random(n, n, density=dns_level)\\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\\n q = sp.randn(n)\\n A = spa.random(m, n, density=dns_level)\\n u = 2 + sp.rand(m)\\n l = -2 + sp.rand(m)\\n\\n # Enforce [0, 1] bounds on variables\\n i_l = np.zeros(p)\\n i_u = np.ones(p)\\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\\n\\n if solver == 'gurobi':\\n # Solve with gurobi\\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\\n verbose=False, Threads=1)\\n if res_gurobi.status != 'optimal':\\n import ipdb\\n ipdb.set_trace()\\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\\n\\n elif solver == 'miosqp':\\n # Define problem settings\\n miosqp_settings = {\\n # integer feasibility tolerance\\n 'eps_int_feas': 1e-03,\\n # maximum number of iterations\\n 'max_iter_bb': 1000,\\n # tree exploration rule\\n # [0] depth first\\n # [1] two-phase: depth first until first incumbent and then best bound\\n 'tree_explor_rule': 1,\\n # branching rule\\n # [0] max fractional part\\n 'branching_rule': 0,\\n 'verbose': False,\\n 'print_interval': 1}\\n\\n osqp_settings = {'eps_abs': 1e-03,\\n 'eps_rel': 1e-03,\\n 'eps_prim_inf': 1e-04,\\n 'verbose': False}\\n\\n model = miosqp.MIOSQP()\\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\\n miosqp_settings,\\n osqp_settings)\\n res_miosqp = model.solve()\\n\\n # DEBUG (check if solutions match)\\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\\n # import ipdb; ipdb.set_trace()\\n#\\n # import ipdb; ipdb.set_trace()\\n\\n if res_miosqp.status != miosqp.MI_SOLVED:\\n import ipdb\\n ipdb.set_trace()\\n \\n # Solution time \\n solve_time_temp[j] = 1e3 * res_miosqp.run_time\\n\\n # Store OSQP time in percentage\\n if solver == 'miosqp':\\n osqp_solve_time_temp[j] = \\\\\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\\n\\n # Get time statistics\\n std_solve_time[i] = np.std(solve_time_temp)\\n avg_solve_time[i] = np.mean(solve_time_temp)\\n max_solve_time[i] = np.max(solve_time_temp)\\n min_solve_time[i] = np.min(solve_time_temp)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\\n\\n # Create pandas dataframe for the results\\n df_dict = {'n': n_vec,\\n 'm': m_vec,\\n 'p': p_vec,\\n 't_min': min_solve_time,\\n 't_max': max_solve_time,\\n 't_avg': avg_solve_time,\\n 't_std': std_solve_time}\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\\n\\n timings = pd.DataFrame(df_dict)\\n\\n return timings\",\n \"def qtrans(m,V):\\n T = s.Symbol(\\\"T\\\")\\n return (((2 * s.pi * m * k * T) / (h**2))**(3/2)) * V\",\n \"def solucaoEspacoPontoX(arq,t,x):\\n \\n parametros = open(arq,'r')\\n lista = []\\n for linha in parametros:\\n valores = linha.split()\\n lista.append( valores[1] )\\n Ks = float(lista[0]) # Conductibilidade na fase solida\\n Kl = float(lista[1]) # Conductibilidade na fase liquida\\n Tf = float(lista[2]) # temperatura de mudanca de fase\\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\\n L = float(lista[5]) # calor latente\\n cs = float(lista[6]) # calor especifico na zona solida\\n cl = float(lista[7]) # calor especifico na zona liquida\\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\\n p = float(lista[9]) # pho = massa especifica\\n parametros.close()\\n \\n lam = 0.5064 # chute inicial\\n xx = x\\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\\n frente = X_espaco(lamb,Ks,t)\\n if (frente > xx):\\n T = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\\n elif (frente < xx):\\n T = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\\n else:\\n T = Tf\\n return T\",\n \"def yule_q(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = a + b + c + d\\n\\n if n == 0:\\n return np.nan\\n elif p1 == n:\\n # c and d are zero\\n return _div(a - b, p1)\\n elif p2 == n:\\n # b and d are zero\\n return _div(a - c, p2)\\n elif q1 == n:\\n # a and b are zero\\n return _div(d - c, q1)\\n elif q2 == n:\\n # a and c are zero\\n return _div(d - b, q2)\\n\\n return _div(self.covar(), a * d + b * c)\",\n \"def test_q(self):\\n assert np.allclose(self.stepper.q, self.ODE.exact(self.stepper.t), rtol=1e-3, atol=1e-5)\",\n \"def solve(self):\\n\\n if self.optimizer == 'pulp':\\n for constraint in self.constraints:\\n self.engine_model += constraint\\n\\n self.engine_model += self.objective\\n status = self.engine_model.solve(PULP_CBC_CMD(msg=False))\\n solution = (\\n np.vectorize(self._var_sol)(self.variable_set)\\n if status == LpStatusOptimal\\n else np.array([])\\n )\\n\\n else:\\n for constraint in self.constraints:\\n self.engine_model.addConstr(constraint)\\n\\n self.engine_model.setObjective(self.objective, self.sense)\\n self.engine_model.optimize()\\n solution = (\\n np.vectorize(self._var_sol)(self.variable_set)\\n if self.engine_model.status == GRB.OPTIMAL\\n else np.array([])\\n )\\n\\n return solution\",\n \"def cost_function(H, n_qubits, p, params):\\n ini_state=plus_state(n_qubits)\\n for i in range(p):\\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state\",\n \"def busca_vector(A, a, p):\\n \\n Sq = busca_base(A, a, q)\\n dim = np.shape(Sq)[1] # calcula la dimension del espacio Sq\\n nrow = np.shape(A)[0] # numero de filas de A\\n \\n C0 = power(A-a*np.identity(nrow), q-1) # C0 = (A-aI)^{p-1} \\n C1 = np.dot(C0, A-a*np.identity(nrow)) # C1 = (A-aI)^{p}\\n \\n for k in range(dim):\\n if np.allclose(np.dot(B1,Sq[:,k]), 0.0) and not np.allclose(np.dot(B0,Sq[:,k]), 0.0):\\n return Sq[:,k]\",\n \"def Lq(self):\\n if not self.isVaild():\\n pass\\n temp = ((self.r()**self.C)*self.Rho()) / \\\\\\n (math.factorial(self.C)*((1 - self.Rho())**2))\\n return temp*self.P0()\",\n \"def solucaoEspacoX(arq,t,x):\\n \\n parametros = open(arq,'r')\\n lista = []\\n for linha in parametros:\\n valores = linha.split()\\n lista.append( valores[1] )\\n Ks = float(lista[0]) # Conductibilidade na fase solida\\n Kl = float(lista[1]) # Conductibilidade na fase liquida\\n Tf = float(lista[2]) # temperatura de mudanca de fase\\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\\n L = float(lista[5]) # calor latente\\n cs = float(lista[6]) # calor especifico na zona solida\\n cl = float(lista[7]) # calor especifico na zona liquida\\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\\n p = float(lista[9]) # pho = massa especifica\\n parametros.close()\\n \\n lam = 0.5064 # chute inicial \\n n = len(x) # tamanho da malha\\n T = np.zeros(n) # temperaturas\\n\\n T[0] = Tw\\n for i in range(1,n):\\n xx = x[i]\\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\\n frente = X_espaco(lamb,Ks,t)\\n if (frente > xx):\\n T[i] = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\\n elif (frente < xx):\\n T[i] = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\\n else:\\n T[i] = Tf\\n lam = lamb\\n return T\",\n \"def closed_toda_3(x):\\n q, p = extract_q_p(x)\\n x = q[:,0,0,0]\\n y = q[:,0,1,0]\\n V = tf.exp(-2.*y) + tf.exp(y - tf.sqrt(3.)*x) + tf.exp(y + tf.sqrt(3.)*x)\\n return tf.reduce_sum(tf.square(p), axis=2) + V\",\n \"def get_sol(self):\",\n \"def algorithm_1_2(p, c, x):\\n\\n q = np.array(c, dtype=np.float64)\\n\\n for k in range(1, p + 1):\\n for j in range(0, p - k + 1):\\n q[j] = (1 - x) * q[j] + x * q[j + 1]\\n return q[0]\",\n \"def solve(self):\\n ...\",\n \"def actualSolve(self, lp):\\n\\t\\traise NotImplementedError\",\n \"def solve(self):\\n pass\",\n \"def solve(self):\\n pass\",\n \"def anl_solution(self):\\r\\n\\r\\n m = float(self.mass) / self.nu_m\\r\\n qe = 1 / self.nu_m * (self.nu_t * self.nu_t / self.nu_x) * 1.0 \\\\\\r\\n / float(self.size_tick * self.size_tick)\\r\\n print 'qE=', qe\\r\\n c = self.light_vel\\r\\n for i in range(0, len(self.obs.obt_g)):\\r\\n ddt = float(self.obs.obt[i] - self.obs.obt[i - 1])\\r\\n x = m * c ** 2 / qe * (math.sqrt(1.0 + (qe * self.t[i] / (m\\r\\n * c)) ** 2) - 1.0)\\r\\n self.xa_track.append(x)\\r\\n p = qe * self.t[i]\\r\\n self.pa.append(p)\\r\\n v = p / math.sqrt(m ** 2 + (p / c) ** 2)\\r\\n jv = self.t[i] * qe / (m * c)\\r\\n v = math.sqrt(jv * jv / (1 + jv * jv)) * c\\r\\n self.va.append(v)\\r\\n print 'Analytical solution of the differential equation of motion'\",\n \"def p(e, t):\\n return b * e ** 2\",\n \"def solve(self, d, t, x0 = None, **kwargs):\\n if x0 == None:\\n x0 = np.array([0., d])\\n #x0 = np.array([self.Om*self.A0/np.sqrt(self.Q**2*(1-self.Om**2)**2 + self.Om**2), d])\\n sol = solve_ivp(self.get_ode(d), (t[0], t[-1]), x0, t_eval = t, vectorized = True, **kwargs)\\n\\n return sol\",\n \"def construct_Q(self, N, r, t0, tf):\\n q = np.zeros((N, N))\\n for i in xrange(N): \\n for l in xrange(N):\\n if i>= r and l>=r: \\n q[i,l] = 2*self.prodoftwoterms(i,l,r)*(tf**(i+l-2*r+1) - t0**(i+l-2*r+1))/(i+l-2*r+1)\\n return q\",\n \"def P_i(self, alpha, Q, X_data):\\n X_lin_comb = np.dot(alpha, X_data)\\n Pi = Q * np.exp(X_lin_comb - X_lin_comb.max(initial=0))\\n Pi = Pi / Pi.sum()\\n return Pi\",\n \"def actualSolve(self, lp):\\n\\t\\tif lp.isMIP() and self.mip: return self.solve_CBC(lp)\\n\\t\\telse: return self.solve_CLP(lp)\",\n \"def prob3():\\n # Define the nonlinear system, its Jacobian, and the initial guess.\\n def f(X):\\n x,y,z = X\\n return np.array([ -x + y + z,\\n 1 + x**3 -y**2 + z**3,\\n -2 -x**2 + y**2 + z**2 ])\\n def jacobian(X):\\n x,y,z = X\\n return np.array([ [ -1, 1, 1 ],\\n [3*x**2, -2*y, 3*z**2],\\n [ -2*x, 2*y, 2*z ] ])\\n x0 = np.array([0,0,0])\\n\\n # Calculate the solution, check that it is a root, and return it.\\n sol = opt.root(f, x0, jac=jacobian, method='hybr')\\n assert np.allclose(np.zeros_like(sol.x), f(sol.x)), \\\"FAILURE\\\"\\n return sol.x\",\n \"def algorithm_2_21(p, t, x):\\n\\n t = np.array(t, dtype=np.float64)\\n b = 1\\n mu = index(x, t)\\n\\n for k in range(1, p + 1):\\n t1 = t[mu - k + 1:mu + 1]\\n t2 = t[mu + 1:mu + k + 1]\\n omega = np.divide(\\n (x - t1), (t2 - t1), out=np.zeros_like(t1), where=((t2 - t1) != 0))\\n b = np.append((1 - omega) * b, 0) + np.insert((omega * b), 0, 0)\\n\\n return b\",\n \"def qi(self, tl, psi_l):\\n\\t try: \\n\\t ans = .622*esat(tl)/P_ATM*exp(psi_l*1000000.*VW/R/tl)\\n\\t except OverflowError:\\n\\t ans = 0.\\n\\t return ans\",\n \"def deterministic_solve(LEP):\\n # solve state equation\\n SE = LEP.SE(LEP.u, LEP.phi_n[0], LEP.v_u, LEP.g)\\n solve(lhs(SE) == rhs(SE), LEP.u_n, bcs=LEP.bcSE, solver_parameters={\\\"linear_solver\\\": \\\"umfpack\\\", \\\"preconditioner\\\": \\\"default\\\"}, form_compiler_parameters=None)\\n\\n # solve adjoint equation\\n LEP.p_n.assign(LEP.u_n) # p_n = u_n\\n\\n # solve gradient equation\\n GE = LEP.GE(LEP.phi, LEP.phi_n, LEP.v_phi, LEP.p_n, LEP.u_n, LEP.tau[0], LEP.gamma)\\n solve(lhs(GE) == rhs(GE), LEP.phi_next, bcs=None, solver_parameters={\\\"linear_solver\\\": \\\"umfpack\\\", \\\"preconditioner\\\": \\\"default\\\"}, form_compiler_parameters=None)\\n\\n LEP.project_phi()\\n\\n print(\\\"Phi_n as Vector:\\\", LEP.phi_next.vector()[:])\\n print(\\\"Länge von Phi:\\\", len(LEP.phi_next.vector()[:]))\\n\\n J_eps = LEP.J_eps(LEP.u_n, LEP.phi_n[0])\\n\\n return J_eps\",\n \"def Qfun(Phieq,Phi,Phibar,taurad):\\n #note Q is different from Perez-Becker and Showman by a factor of g (for consistency with Phi vs H)\\n Q=(1/taurad)*(Phieq-(Phi+Phibar))\\n\\n return Q\",\n \"def solve(self):\\n \\n raise NotImplementedError(\\\"not implemented!\\\")\",\n \"def a_q(self, phi, ci, tl):\\n\\t return (self.j(phi, tl)*(ci - self.gamma(tl)))/(4.*(ci + 2.*self.gamma(tl)))\",\n \"def Q_i(params):\\n Q = params['Q'].value\\n Qe = Q_e(params)\\n return (Q ** -1 - np.real(Qe ** -1)) ** -1\",\n \"def sepinsky_formula(q=1, A=1):\\n return vec_pick_formula(q, A)\",\n \"def PDE_RHS_FKPP(t,y,q,x,description=None):\\n \\n \\n D_mat = create_Uxx_mat(x)\\n\\n return (q[0]*D_mat.dot(y) + \\n q[1]*y*(1-y))\",\n \"def model(a, t, D, m):\\n xprime = a[1] # x' = v\\n vprime = -D*a[0]/m # v' = -D*x/m\\n return [xprime, vprime]\",\n \"def calc_pA_info_gain(pA, qo_pi, qs_pi):\\n\\n n_steps = len(qo_pi)\\n \\n num_modalities = len(pA)\\n wA = utils.obj_array(num_modalities)\\n for modality, pA_m in enumerate(pA):\\n wA[modality] = spm_wnorm(pA[modality])\\n\\n pA_infogain = 0\\n \\n for modality in range(num_modalities):\\n wA_modality = wA[modality] * (pA[modality] > 0).astype(\\\"float\\\")\\n for t in range(n_steps):\\n pA_infogain -= qo_pi[t][modality].dot(spm_dot(wA_modality, qs_pi[t])[:, np.newaxis])\\n\\n return pA_infogain\",\n \"def _solve(self) -> CasADiArrayType:\\n solver_input = {\\\"x0\\\": self.x0, \\\"p\\\": self.p}\\n if self.opt_type in CONSTRAINED_OPT:\\n solver_input[\\\"lbg\\\"] = self._lbg\\n solver_input[\\\"ubg\\\"] = self._ubg\\n self._solution = self._solver(**solver_input)\\n self._stats = self._solver.stats()\\n self._stats[\\\"solution\\\"] = self._solution\\n return self._solution[\\\"x\\\"]\",\n \"def project_curve(q):\\n n,T = q.shape\\n if n==2:\\n dt = 0.35\\n if n==3:\\n dt = 0.2\\n epsilon = 1e-6\\n\\n iter = 1\\n res = ones(n)\\n J = zeros((n,n))\\n\\n s = linspace(0,1,T)\\n\\n qnew = q.copy()\\n qnew = qnew / sqrt(innerprod_q2(qnew,qnew))\\n\\n qnorm = zeros(T)\\n G = zeros(n)\\n C = zeros(300)\\n while (norm(res) > epsilon):\\n if iter > 300:\\n break\\n\\n # Jacobian\\n for i in range(0,n):\\n for j in range(0,n):\\n J[i,j] = 3 * trapz(qnew[i,:]*qnew[j,:],s)\\n \\n J += eye(n)\\n\\n for i in range(0,T):\\n qnorm[i] = norm(qnew[:,i])\\n \\n # Compute the residue\\n for i in range(0,n):\\n G[i] = trapz(qnew[i,:]*qnorm,s)\\n \\n res = -G\\n\\n if (norm(res) < epsilon):\\n break\\n\\n x = solve(J,res)\\n C[iter] = norm(res)\\n\\n delG = Basis_Normal_A(qnew)\\n temp = zeros((n,T))\\n for i in range(0,n):\\n temp += x[i]*delG[i]*dt\\n \\n qnew += temp\\n iter += 1\\n \\n qnew = qnew/sqrt(innerprod_q2(qnew,qnew))\\n\\n return qnew\",\n \"def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \\n tol=1e-2):\\n from numpy import array, zeros_like, zeros\\n from scipy.optimize import minimize\\n from tgo import tgo\\n \\n def x_lim(X): # limiting function used in TGO\\n import numpy\\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\\n \\n if k == None:\\n k = p.m['Valid phases']\\n \\n # Initialize\\n Z_0 = array(Z_0)\\n LBD = - 1e300 # -inf\\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \\n \\n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\\n UBD = g_x_func(s, p).m['g_mix']['t'] \\n Lambda_d = zeros_like(Z_0)\\n\\n # X bounds used in UBD optimization\\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\\n zeros(shape=(p.m['n']-1)) # Lower bound\\n ] \\n for i in range(p.m['n']-1): \\n Sigma_ind = 0.0 # Sum of independent components excluding i\\n # (lever rule) \\n for j in range(p.m['n']-1):\\n if j != i:\\n Sigma_ind += Z_0[j]\\n\\n X_bounds[0][i] = 1.0 - Sigma_ind \\n \\n # Construct physical bounds x \\\\in [0, 1] for all independent components\\n # (used in differential_evolution)\\n Bounds = []\\n for i in range(p.m['n'] - 1):\\n #Bounds.append((0, 1))\\n Bounds.append((1e-5, 0.99999))\\n \\n # Construct composition container from X_d for all phases. (REMOVED)\\n X_d = Z_0\\n\\n\\n #%% Normal calculation of daul problem if Z_0 is unstable.\\n while abs(UBD - LBD) >= tol:\\n # Solve UBD\\n # Update system to new composition.\\n # (Comp. invariant in UBD)\\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \\n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \\n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\\n k))['x']\\n \\n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\\n \\n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\\n\\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\\n g_func=x_lim,\\n n = 100,\\n skip=2)\\n # Solve LBD \\n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \\n X_d = X_sol\\n # End\\n \\n\\n if False: # Print results optional\\n print 'Final UBD = {}'.format(UBD)\\n print 'Final LBD = {}'.format(LBD)\\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\\n print 'Final Z_eq = {}'.format(X_d)\\n print 'Final Lambda_d = {}'.format(Lambda_d)\\n \\n # Returns\\n s.m['Z_eq'] = X_d\\n s.m['Lambda_d'] = Lambda_d\\n return s\",\n \"def __init__ (self, p, q):\\n self.n = p * q\\n self.n_sq = self.n * self.n\\n self.g = self.n + 1\",\n \"def qp(self, eta_u, eta_v):\\n\\n c1, c2, c12 = eta_u[0], eta_u[1], eta_v[0]\\n\\n flip_sign = False\\n if c12 < 0:\\n flip_sign = True\\n c1, c2, c12 = c1 + c12, 1 - c2, -c12\\n\\n if c1 > c2 + c12:\\n u = [c1, c2 + c12]\\n elif c2 > c1 + c12:\\n u = [c1 + c12, c2]\\n else:\\n uu = (c1 + c2 + c12) / 2\\n u = [uu, uu]\\n\\n u = np.clip(np.array(u), 0, 1)\\n v = np.atleast_1d(np.min(u))\\n\\n if flip_sign:\\n u[1] = 1 - u[1]\\n v[0] = u[0] - v[0]\\n\\n return u, v\",\n \"def _solve(self) -> CasADiArrayType:\\n self._solution = cvxopt.solvers.qp(**self._solver_input)\\n return self._solution[\\\"x\\\"]\",\n \"def analyticSol (x):\\n\\treturn x*(1-x);\",\n \"def __init__ (self, p, q):\\n self.lamb = (p-1) * (q-1)\\n self.mu = modinv(self.lamb, (p * q))\",\n \"def solution(data):\\n lines = preprocess(data)\\n solver = Code(lines)\\n return solver.solve()\",\n \"def inv(P):\\n L = cho_factor(P)\\n return cho_solve(L, np.eye(P.shape[0]))\",\n \"def analytical_integral_rppd(p, q, r, a, b, c):\\n if p < 0:\\n return 0.0\\n elif q < 0:\\n return 0.0\\n elif r < 0.0:\\n return 0.0\\n else:\\n return (\\n a ** (p + 1)\\n * b ** (q + 1)\\n * c ** (r + 1)\\n * ((-1) ** p + 1)\\n * ((-1) ** q + 1)\\n * ((-1) ** r + 1)\\n / ((p + 1) * (q + 1) * (r + 1))\\n )\",\n \"def solver_parachute(T, dt, v0, tp, Cd, rho, A, m):\\n \\n # Mesh initialization\\n v = []; v.append(v0); t=[]; t.append(0);\\n x = []; x.append(3000.)\\n \\n def X(t):\\n return -9.81\\n def Y(t):\\n return Cd*rho*A/(2.*m)\\n \\n # Simulate the same way as solver() untill time tp\\n while t[-1]<=tp:\\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Y))\\n x.append(x[-1] + dt*v[-1])\\n t.append(t[-1] + dt)\\n \\n # Z is the same as the function Y, but with different values\\n def Z(t):\\n return 1.8*1.0*44./(2.*m)\\n \\n # Continue the simulation untill the skydiver hits the ground\\n while x[-1] > 0:\\n v.append(skydiving_iterate(v[-1], t[-1], dt, X, Z))\\n x.append(x[-1] + dt*v[-1])\\n t.append(t[-1] + dt)\\n return v, t, x\",\n \"def func_exact_sol(x, case):\\n TB, TA, L, q, k = get_valdict(case, 'TB,TA,L,q,k')\\n return ((TB-TA)/L + (q/(2*k)*(L-x)))*x + TA\",\n \"def solve(self):\\n\\n # Assign variables to each quantity being solved.\\n r_lookup, lookup, num = {}, {}, 0\\n for element in self.elements:\\n if is_wire(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n elif not is_cs(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n\\n # Set up the linear algebraic equation Ax=b\\n A = np.zeros((num, num))\\n b = np.zeros(num)\\n for row, element in lookup.items():\\n if is_wire(element) and element is not self.ground:\\n for two_sided in element.attached:\\n if is_cs(two_sided):\\n if two_sided.pos is element:\\n b[row] += -1 * two_sided.current\\n else:\\n b[row] += two_sided.current\\n else:\\n if two_sided.pos is element:\\n flow = 1\\n else:\\n flow = -1\\n A[row, r_lookup[two_sided]] = flow\\n elif is_vs(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n b[row] = element.voltage\\n elif is_resistor(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n A[row, r_lookup[element]] = -1 * element.resistance\\n\\n b = b.reshape((num, 1))\\n try:\\n x = np.linalg.solve(A, b)\\n except np.linalg.LinAlgError:\\n raise CircuitError('Insufficient information to solve circuit')\\n\\n # Assign values to all circuit components\\n for i in range(num):\\n item = lookup[i]\\n if is_wire(item):\\n item.potential = x[i, 0]\\n elif isinstance(item, DualSided):\\n item.current = x[i, 0]\\n\\n # Mark circuit as solved\\n self.been_solved = True\",\n \"def solve(self, solver):\\n solver.solve()\",\n \"def obtain_Q(self):\\n \\n #create the initial triangular matrix as a copy of the m x n - matrix A\\n \\n v_list = Householder.vector(self)\\n n_v = len(v_list) # number of vectors, not equal to number of columns in R\\n q_m = len(v_list[0]) # longest vector, should determine the shape of Q\\n \\n H_list = []\\n for i in list(range(n_v)):\\n \\n gamma = ((np.linalg.norm(v_list[i]))**2)/2\\n vvtrans = v_list[i] * np.transpose(v_list[i])\\n H = np.identity((q_m-i)) - (vvtrans/gamma)\\n \\n print(H.shape)\\n\\n m_H, n_H = H.shape\\n if m_H < q_m:\\n I = np.identity(q_m)\\n x = y = i\\n I [ x:x+H.shape[0], y:y+H.shape[1]] = H\\n H = I\\n H_list.append(H)\\n \\n # The transpose of Q is the result of the dot product H(n-1)...H1 \\n \\n len_H = len(H_list)\\n\\n H_temp = H_list[-1]\\n \\n for i in np.arange(len_H-1,0,-1):\\n \\n H_temp = np.matmul(H_temp, H_list[i-1])\\n \\n Q = np.transpose(H_temp)\\n \\n return(Q)\",\n \"def padeIIi(z, f_z, p_order, q_order):\\n\\n if len(z) != len(f_z):\\n raise ValueError(\\\"z, f_z should be the same length.\\\")\\n \\n #################\\n # Equation (2.25)\\n \\n dim = max(p_order, q_order) + 1\\n # z_ij\\n index_range = np.arange(dim)\\n I,J = np.meshgrid(index_range, index_range)\\n exponent = I+J\\n z_ij = np.sum(z ** exponent[:,:,None], axis=2)\\n \\n # Now f_ij, and f^(2)_ij\\n f_ij = np.sum(f_z * z ** exponent[:,:,None], axis=2)\\n f2_ij = np.sum(f_z**2 * z ** exponent[:,:,None], axis=2)\\n \\n # Finally, we get to (2.24), which we cast in matrix form to solve:\\n # M * poly = F\\n # Where poly = [p coeffs, q coeffs]\\n \\n M = np.concatenate(\\n (\\n np.concatenate(\\n (f_ij[1:q_order+1, 0:p_order+1] , -f2_ij[1:q_order+1, 1:q_order+1]),\\n axis=1,\\n ),\\n np.concatenate(\\n ( z_ij[0:p_order+1, 0:p_order+1] , -f_ij[0:p_order+1, 1:q_order+1]),\\n axis=1\\n )\\n ))\\n \\n F = np.concatenate((f2_ij[1:q_order+1, 0], f_ij[0:p_order+1, 0]))\\n \\n poly, residuals, rank, s = np.linalg.lstsq(M, F, rcond=0)\\n \\n P = poly[0:p_order+1][::-1]\\n Q = np.concatenate(([1], poly[-(q_order):]))[::-1]\\n \\n return (P,Q)\",\n \"def xBounds2cvxoptMatrix(p):\\n\\n #TODO: is reshape/flatten required in newest numpy versions?\\n indLB, indUB, indEQ = \\\\\\n where(isfinite(p.lb) & ~(p.lb == p.ub))[0], \\\\\\n where(isfinite(p.ub) & ~(p.lb == p.ub))[0], \\\\\\n where(p.lb == p.ub)[0] \\n \\n initLenB = Len(p.b)\\n initLenBeq = Len(p.beq)\\n nLB, nUB, nEQ = Len(indLB), Len(indUB), Len(indEQ)\\n\\n if nLB>0 or nUB>0:\\n A, b = copy(p.A), copy(p.b)\\n p.A = zeros([Len(p.b) + nLB+nUB, p.n])\\n p.b = zeros(Len(p.b) + nLB+nUB)\\n p.b[:Len(b)] = b.flatten() # sometimes flatten is needed when called before runProbSolver(), from tests\\n p.A[:Len(b)] = A\\n for i in range(len(indLB)):\\n p.A[initLenB+i, indLB[i]] = -1\\n p.b[initLenB+i] = -p.lb[indLB[i]]\\n for i in range(len(indUB)):\\n p.A[initLenB+len(indLB)+i, indUB[i]] = 1\\n p.b[initLenB+len(indLB)+i] = p.ub[indUB[i]]\\n\\n if nEQ>0:\\n Aeq, beq = copy(p.Aeq), copy(p.beq)\\n p.Aeq = zeros([Len(p.beq) + nEQ, p.n])\\n p.beq = zeros(Len(p.beq) + nEQ)\\n p.beq[:Len(beq)] = beq\\n p.Aeq[:Len(beq)] = Aeq\\n for i in range(len(indEQ)):\\n p.Aeq[initLenBeq+i, indEQ[i]] = 1\\n p.beq[initLenBeq+i] = p.lb[indEQ[i]] # = p.ub[indEQ[i]], because they are the same\\n\\n p.lb = -inf*ones(p.n)\\n p.ub = inf*ones(p.n)\",\n \"def solve(self):\\n \\n # Definition of the parameters\\n Q_pc = self.parameters.getParam(\\\"Q_pc\\\")\\n V_c = self.parameters.getParam(\\\"V_c\\\")\\n V_p = self.parameters.getParam(\\\"V_p\\\")\\n CL = self.parameters.getParam(\\\"CL\\\")\\n initial_conditions = [\\n self.parameters.getParam(\\\"q_c0\\\"),\\n self.parameters.getParam(\\\"q_p0\\\"),\\n ]\\n t_eval = np.linspace(0, self.timespan, self.nsteps)\\n\\n # Definition of the model ODEs\\n def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\\n \\\"\\\"\\\"Defines the differential equations for the PK IV model.\\n\\n Parameters:\\n :param t: time (h)\\n :param y: list of the state variables of the ODEs system, in the\\n form [q_c, q_p]\\n :param Q_pc: transition rate between central and peripheral\\n compartments (mL/h)\\n :param V_c: volume of central compartment (mL)\\n :param V_p: volume of peripheral compartment (mL)\\n :param CL: clearance/elimination rate from the central\\n compartment (mL/h)\\n\\n The parameters (except for t and y) are extracted from the\\n Parameter class, using getParam method.\\n\\n Returns list containing the differential equations, in the form:\\n [dqc_dt, dqp_dt]\\n \\\"\\\"\\\"\\n q_c, q_p = y\\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\\n dqp_dt = transfer\\n return [dqc_dt, dqp_dt]\\n\\n # Solving the model\\n sol = scipy.integrate.solve_ivp(\\n fun=lambda t, y: pk_iv_model(t, y, Q_pc, V_c, V_p, CL),\\n t_span=[t_eval[0], t_eval[-1]],\\n y0=initial_conditions,\\n t_eval=t_eval,\\n )\\n\\n # Feeding the solution line by line to solution class\\n t = sol.t\\n y = sol.y\\n N = t.shape[0]\\n columnNames = [\\\"t\\\", \\\"dose\\\", \\\"q_c\\\", \\\"q_p\\\"]\\n self.solution.begin(columnNames, N)\\n for i in range(N):\\n arr = np.zeros((len(columnNames), 1))\\n arr[0] = t[i]\\n arr[1] = self.dosefunction(t[i])\\n arr[2:, 0] = y[:, i]\\n self.solution.report(arr)\",\n \"def solucaoEspaco(arq,t,n,xf):\\n \\n parametros = open(arq,'r')\\n lista = []\\n for linha in parametros:\\n valores = linha.split()\\n lista.append( valores[1] )\\n Ks = float(lista[0]) # Conductibilidade na fase solida\\n Kl = float(lista[1]) # Conductibilidade na fase liquida\\n Tf = float(lista[2]) # temperatura de mudanca de fase\\n Tinf = float(lista[3]) # Temperatura inicial na fase liquida T0\\n Tw = float(lista[4]) # Temperatura na fronteira no instante inicial\\n L = float(lista[5]) # calor latente\\n cs = float(lista[6]) # calor especifico na zona solida\\n cl = float(lista[7]) # calor especifico na zona liquida\\n cf = float(lista[8]) # calor especifico na zona de mudanca de fase\\n p = float(lista[9]) # pho = massa especifica\\n parametros.close() \\n\\n lam = 0.5064 # chute inicial \\n T = np.zeros(n+1) # temperaturas\\n x = np.linspace(0.0,xf,n+1) # espaco\\n\\n T[0] = Tw\\n for i in range(1,n+1):\\n xx = x[i]\\n lamb = calculaLambda(funcao,lam,Tinf,Tf,Ks,Kl,L,cs,Tw)\\n frente = X_espaco(lamb,Ks,t)\\n if (frente > xx):\\n T[i] = temperaturaZonaSolida_espaco(Tf,Ks,lamb,xx,t,Tw)\\n elif (frente < xx):\\n T[i] = temperaturaZonaLiquida_espaco(Tinf,Tf,Ks,Kl,lamb,xx,t)\\n else:\\n T[i] = Tf\\n lam = lamb\\n return x,T\",\n \"def REINFORCEMENT(self, p, tau):\\n tau = np.array(tau)\\n T = len(tau)\\n A = tau[:, 1]\\n R = tau[:, 2]\\n\\n prob = p\\n estG = self.estG(R, self.gamma, T)\\n\\n for t in range(T):\\n prob += self.alpha * self.gamma**t * estG[t] * self.gradient(prob, A[t]) \\n\\n return prob\",\n \"def ppca(Y, Q, iterations=100):\\r\\n from numpy.ma import dot as madot\\r\\n N, D = Y.shape\\r\\n # Initialise W randomly\\r\\n W = np.random.randn(D, Q) * 1e-3\\r\\n Y = np.ma.masked_invalid(Y, copy=0)\\r\\n mu = Y.mean(0)\\r\\n Ycentered = Y - mu\\r\\n try:\\r\\n for _ in range(iterations):\\r\\n exp_x = np.asarray_chkfinite(np.linalg.solve(W.T.dot(W), madot(W.T, Ycentered.T))).T\\r\\n W = np.asarray_chkfinite(np.linalg.solve(exp_x.T.dot(exp_x), madot(exp_x.T, Ycentered))).T\\r\\n except np.linalg.linalg.LinAlgError:\\r\\n #\\\"converged\\\"\\r\\n pass\\r\\n return np.asarray_chkfinite(exp_x), np.asarray_chkfinite(W)\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def qaoa_step(state, H, n_qubits, params):\\n B=B_operator(n_qubits)\\n state=lasp.expm_multiply(1j*params[0]*H, state)\\n return lasp.expm_multiply(-1j*params[1]*B,state)\",\n \"def ap(self, P):\\n if P.divides(self.conductor()):\\n if (P*P).divides(self.conductor()):\\n # It is 0, because the reduction is additive.\\n return ZZ(0)\\n else:\\n # TODO: It is +1 or -1, but I do not yet know how to\\n # compute which without using the L-function.\\n return '?'\\n else:\\n return self._S.hecke_matrix(P)[0,0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7112369","0.6747462","0.67439276","0.6622388","0.6503022","0.63728845","0.6270085","0.6223849","0.6211934","0.6202324","0.61933964","0.61361104","0.61264217","0.60995156","0.6012261","0.6007698","0.5980388","0.5958294","0.5952482","0.5946611","0.59364825","0.5932282","0.59318167","0.59199506","0.589041","0.58624285","0.58590907","0.5838999","0.5833907","0.5827723","0.57910913","0.57891136","0.5771499","0.57687783","0.5760595","0.5759751","0.57541466","0.574806","0.57171667","0.57129633","0.5706716","0.570383","0.56921184","0.5691353","0.56840515","0.5681198","0.56811684","0.56761485","0.56742465","0.5668374","0.5658095","0.5655379","0.56534725","0.5649938","0.5640275","0.5628197","0.5628197","0.56208456","0.56155306","0.5610041","0.56083465","0.56019866","0.55987024","0.5598559","0.558735","0.55829567","0.55812687","0.55773306","0.5571389","0.55702406","0.5569696","0.55670774","0.5565411","0.5557925","0.5542241","0.55418575","0.5538871","0.5536465","0.55307513","0.5527765","0.5521067","0.5512668","0.5509093","0.5496247","0.54851407","0.5483078","0.5482454","0.5480004","0.5478122","0.5473918","0.54728013","0.5465531","0.54610735","0.5458683","0.54480195","0.54449373","0.5444238","0.54424167","0.5435975","0.543389"],"string":"[\n \"0.7112369\",\n \"0.6747462\",\n \"0.67439276\",\n \"0.6622388\",\n \"0.6503022\",\n \"0.63728845\",\n \"0.6270085\",\n \"0.6223849\",\n \"0.6211934\",\n \"0.6202324\",\n \"0.61933964\",\n \"0.61361104\",\n \"0.61264217\",\n \"0.60995156\",\n \"0.6012261\",\n \"0.6007698\",\n \"0.5980388\",\n \"0.5958294\",\n \"0.5952482\",\n \"0.5946611\",\n \"0.59364825\",\n \"0.5932282\",\n \"0.59318167\",\n \"0.59199506\",\n \"0.589041\",\n \"0.58624285\",\n \"0.58590907\",\n \"0.5838999\",\n \"0.5833907\",\n \"0.5827723\",\n \"0.57910913\",\n \"0.57891136\",\n \"0.5771499\",\n \"0.57687783\",\n \"0.5760595\",\n \"0.5759751\",\n \"0.57541466\",\n \"0.574806\",\n \"0.57171667\",\n \"0.57129633\",\n \"0.5706716\",\n \"0.570383\",\n \"0.56921184\",\n \"0.5691353\",\n \"0.56840515\",\n \"0.5681198\",\n \"0.56811684\",\n \"0.56761485\",\n \"0.56742465\",\n \"0.5668374\",\n \"0.5658095\",\n \"0.5655379\",\n \"0.56534725\",\n \"0.5649938\",\n \"0.5640275\",\n \"0.5628197\",\n \"0.5628197\",\n \"0.56208456\",\n \"0.56155306\",\n \"0.5610041\",\n \"0.56083465\",\n \"0.56019866\",\n \"0.55987024\",\n \"0.5598559\",\n \"0.558735\",\n \"0.55829567\",\n \"0.55812687\",\n \"0.55773306\",\n \"0.5571389\",\n \"0.55702406\",\n \"0.5569696\",\n \"0.55670774\",\n \"0.5565411\",\n \"0.5557925\",\n \"0.5542241\",\n \"0.55418575\",\n \"0.5538871\",\n \"0.5536465\",\n \"0.55307513\",\n \"0.5527765\",\n \"0.5521067\",\n \"0.5512668\",\n \"0.5509093\",\n \"0.5496247\",\n \"0.54851407\",\n \"0.5483078\",\n \"0.5482454\",\n \"0.5480004\",\n \"0.5478122\",\n \"0.5473918\",\n \"0.54728013\",\n \"0.5465531\",\n \"0.54610735\",\n \"0.5458683\",\n \"0.54480195\",\n \"0.54449373\",\n \"0.5444238\",\n \"0.54424167\",\n \"0.5435975\",\n \"0.543389\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.621849"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":89494,"cells":{"query":{"kind":"string","value":"Compute infinite time horizon average LQR cost. Returns 1e6 if A+BK is not stable"},"document":{"kind":"string","value":"def LQR_cost(A, B, K, Q, R, sigma_w):\n\n L = A + B.dot(K)\n if spectral_radius(L) >= 1:\n return 1e6\n\n M = Q + K.T.dot(R).dot(K)\n\n P = solve_discrete_lyapunov(L, M)\n\n return (sigma_w ** 2) * np.trace(P)"},"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 lksprob(alam):\r\n fac = 2.0\r\n sum = 0.0\r\n termbf = 0.0\r\n a2 = -2.0*alam*alam\r\n for j in range(1,201):\r\n term = fac*math.exp(a2*j*j)\r\n sum = sum + term\r\n if math.fabs(term) <= (0.001*termbf) or math.fabs(term) < (1.0e-8*sum):\r\n return sum\r\n fac = -fac\r\n termbf = math.fabs(term)\r\n return 1.0 # Get here only if fails to converge; was 0.0!!\r","def eady_growth_rate(data):\n N2 = ixr.brunt_vaisala(data)\n f = 2.0*omega*xruf.sin(xruf.deg2rad(data.lat))\n\n dz = ixr.domain.calculate_dz(data)\n du = ixr.domain.diff_pfull(data.ucomp, data)\n\n N = xruf.sqrt(N2.where(N2 > 0))\n\n egr = 0.31*du/dz*f/N\n return np.abs(egr)","def question_18():\n rbf = RadialBiasFunction()\n wins = 0.0\n for i in range(100):\n rbf.fit(1.5, 9)\n rbf_error = rbf.error()\n if rbf_error == 0:\n wins += 1\n rbf.resample()\n return wins / 100","def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\n return cost","def final_state_cost(x_tape):\n return np.linalg.norm(deviation_from_upright_equilibrium(x_tape[:, -1]))","def elongation_rate(R, r_AA, V=1E-15, K_D=5E-3, t=1, f_a = 1, rt_max=17.1):\n\n N_A = 6.022E23 # Avogadro's number\n prefix = K_D * N_A * V + R * f_a * rt_max * t + r_AA * t\n sqrt_a = (K_D * N_A * V)**2 + (r_AA * t)**2 + (R * f_a * rt_max * t)**2\n sqrt_b = 2 * (K_D * N_A * R * V * f_a * rt_max* t + K_D * N_A * V * r_AA * t -\\\n R * f_a * rt_max * r_AA * t**2)\n denom = 2 * R * f_a * t\n r_t = (prefix - np.sqrt(sqrt_a + sqrt_b)) / denom\n return r_t","def calc_rV(A):\n return np.sqrt(calc_rVsq(A))","def calc_rVsq(A):\n G, g = A2Gmat(A)\n rVsq = nl.det(G)\n if rVsq < 0:\n return 1\n return rVsq","def compute_lb_totalflow(self):\r\n lb_totalflow = np.amax(1 - np.exp(self.beta - self.b + self.phi * np.minimum(1, 1/self.l))) \r\n return max(0, lb_totalflow)","def dlqr(A,B,Q,R):\n #ref Bertsekas, p.151\n \n #first, try to solve the ricatti equation\n X = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\n \n #compute the LQR gain\n K = np.matrix(scipy.linalg.inv(B.T*X*B+R)*(B.T*X*A))\n \n eigVals, eigVecs = scipy.linalg.eig(A-B*K)\n \n return K, X, eigVals","def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\n phi = 0.0\n\n ## Approach A - NREL Approach\n if approach_call == \"A\":\n\n phi = float(Q_load_W) / float(Q_design_W)\n eta_max = 0.425 # from energy.gov\n\n if phi >= phi_threshold: # from NREL-Shape\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\n\n if phi < phi_threshold:\n if phi <= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\n\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3.0 + \\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\n\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\n\n eta_therm_max = 0.45 # constant, after energy.gov\n\n if phi < phi_threshold:\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\n\n else:\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\n\n ## Approach B - Empiric Approach\n if approach_call == \"B\":\n\n if Q_design_W > 0:\n phi = float(Q_load_W) / float(Q_design_W)\n\n else:\n phi = 0\n\n eta_el_max = 0.39\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\n\n eta_el = eta_el_max * eta_el_score\n eta_therm = eta_therm_max * eta_therm_score\n\n if phi < 0.2:\n eta_el = 0\n\n return eta_el, eta_therm","def test_avg_l(self):\n u_spec = leabra.UnitSpec(g_bar_e=0.3, g_bar_l=0.3, g_bar_i=1.0)\n u = leabra.Unit(spec=u_spec)\n\n for _ in range(20):\n u.add_excitatory(1.0)\n u.calculate_net_in()\n u.cycle('minus')\n\n self.assertEqual(u.avg_l, 0.40)\n u.spec.update_avg_l(u)\n self.assertTrue(np.allclose(0.52, u.avg_l, rtol=0.1, atol=0.1))\n #TODO: verify that 0.52 is the value of emergent\n\n for _ in range(100):\n u.spec.update_avg_l(u)\n self.assertTrue(np.allclose(1.64, u.avg_l, rtol=0.1, atol=0.1))\n #TODO: verify that 1.64 is the value of emergent","def length_vs_rate_2(Lmax=200, Lmin=102.4, p=75, fmax=1e12, p1=database['K+'],\r\n p2=database['pi+'], p3=database['p+'], E=1e6, n=20,\r\n ng=50, nl=50, nf=100, delta_p=1.6e-2, just_pi=False,\r\n set_freq=5.7e9, count=True):\r\n if set_freq == None:\r\n print('Estimated time: {0}'.format(timing(n*ng*nl*nf*3.84e-05)))\r\n else:\r\n print('Estimated time: {0}'.format(timing(n*ng*nl*3.84e-05)))\r\n i = 0\r\n while i < 1e7:\r\n i += 1\r\n start = time.time()\r\n L_range = np.linspace(Lmin, Lmax, n)\r\n opt_gap, opt_freq, opt_cav, opt_disp, rate = [], [], [], [], []\r\n for L in L_range:\r\n if count == True:\r\n print(f'L={L}')\r\n opt = cavity_gap_comp(L_t=L-22.8, p=p, fmax=fmax, p1=p1, p2=p2, p3=p3,\r\n E=E, plot=False, delta_p=delta_p, n=ng, nf=nf,\r\n nl=nl, just_pi=just_pi, set_freq=set_freq,\r\n count=count)\r\n opt_freq.append(opt[0])\r\n opt_gap.append(opt[1])\r\n opt_cav.append(opt[2])\r\n opt_disp.append(opt[3])\r\n rate.append(decay_rate(L, p1, p)*1e-6)\r\n opt_freq, opt_disp, rate = np.array(opt_freq), np.array(opt_disp), np.array(rate)\r\n# ratio = (opt_disp*rate)/(opt_freq*L)\r\n# ratio *= (np.max(opt_freq)-np.min(opt_freq))/(np.max(ratio)-np.min(ratio))\r\n# ratio += ((np.min(opt_freq))-np.min(ratio))\r\n fig = plt.figure(figsize=[14, 4])\r\n host = fig.add_subplot(1, 1, 1)\r\n fig.subplots_adjust(right=0.75)\r\n par1 = host.twinx()\r\n# par2 = host.twinx()\r\n# par2.spines['right'].set_position(('axes', 1.2))\r\n# make_patch_spines_invisible(par2)\r\n# par2.spines['right'].set_visible(True) \r\n p1, = host.plot(L_range, rate, 'r', alpha=0.8, lw=2, label='decay rate in decay region')\r\n p2, = par1.plot(L_range, opt_disp, 'b', alpha=0.8, lw=2, label='min disp')\r\n# p3, = par2.plot(L_range, opt_freq, 'b', alpha=0.8, lw=2, label='frequency')\r\n# p4, = par2.plot(L_range, ratio, 'g', alpha=0.8, lw=2, label='ratio')\r\n host.set_xlim(Lmin, Lmax)\r\n host.set_xlabel('Distance between Target and Decay Region / m', fontsize=15)\r\n host.set_ylabel('Decay Rate in Decay Region / MHz', fontsize=15)\r\n par1.set_ylabel('Minimum Displacement / mm', fontsize=15)\r\n# par2.set_ylabel('Frequency / Hz', fontsize=15)\r\n host.yaxis.label.set_color(p1.get_color())\r\n par1.yaxis.label.set_color(p2.get_color())\r\n# par2.yaxis.label.set_color(p3.get_color())\r\n host.tick_params(axis='y', colors=p1.get_color())\r\n par1.tick_params(axis='y', colors=p2.get_color())\r\n# par2.tick_params(axis='y', colors=p3.get_color())\r\n# lines = [p1, p2, p3, p4]\r\n# lines = [p1, p2]\r\n# host.legend(lines, [l.get_label() for l in lines], loc=[0.45, 0.8], fontsize=20)\r\n host.minorticks_on()\r\n par1.minorticks_on()\r\n host.set_ylim(0)\r\n par1.set_ylim(0)\r\n host.grid()\r\n host_yticks = np.arange(0, int(np.max(rate))+2, 1)\r\n par1_yticks = np.arange(0, (int(np.max(opt_disp)/100)+1)*100, 100)\r\n host.set_yticks(host_yticks)\r\n host.set_yticklabels(host_yticks)\r\n par1.set_yticks(par1_yticks)\r\n par1.set_yticklabels(par1_yticks)\r\n host.set_title(r'Unwanted particle displacement and observed $K^+$'+' decay rate\\nas a function of target distance', fontsize=15)\r\n plt.show()\r\n fig.savefig('Length_vs_Rate_75.pdf', bbox_inches='tight')\r\n index = np.argmax(opt_disp)\r\n# index = np.argmax(ratio)\r\n print(f'{timing(time.time()-start)}')\r\n return [opt_disp[index], L_range[index], opt_gap[index], opt_cav[index], opt_freq[index], rate[index]]","def get_duct_linear_heat_loss_coefficient() -> float:\n return 0.49","def cronbach_alpha(self) -> float:\n itemscores = np.stack([self.true, self.predicted])\n itemvars = itemscores.var(axis=1, ddof=1)\n tscores = itemscores.sum(axis=0)\n nitems = len(itemscores)\n return float(nitems / (nitems - 1.) * (1 - itemvars.sum() / tscores.var(ddof=1)))","def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\n m_over_N = float(m)/N \n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)","def __bestLambda(self):\n\t\t\n\t\t# Determine starting value for brent-method (to avoid local minimum).\n\t\tself.startValue = self.__findStartValue()\n\t\t\t\n\t\t# Check if there exists a minimum within the range of self.lamStart. \n\t\t# Otherwise, use fmin because we cannot provide an interval. \n\t\tif (self.startIdx != 0 and self.startIdx != self.nStartValues-1):\n\t\t\ts = scipy.optimize.brent(self.__minBayesianEvidence, brack=(self.logLamStart[self.startIdx-1], self.logLamStart[self.startIdx], self.logLamStart[self.startIdx+1]))\n\t\telse:\n\t\t\ts = scipy.optimize.fmin(self.__minBayesianEvidence, self.startValue, disp=False)[0]\n\t\t\n\t\treturn 10**s","def test_GBL_tau_star():\n z = 1.0\n\n # Fully ionized H and He\n x_ionH = 1.0\n x_ionHe = 2.0\n\n cosmo = {}\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\n cosmo['h'] = 0.65\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\n cosmo['Y_He'] = 0.24\n cd.set_omega_k_0(cosmo)\n\n tau_inst, tau_star = cr.optical_depth_instant(z, \n x_ionH=x_ionH, \n x_ionHe=x_ionHe, \n return_tau_star=True,\n **cosmo)\n print(\"tau_star = %.7f\" % (tau_star))\n print(\"tau_star/(h Omega_b) = %.7f =? 0.061\" % \n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\n\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\n 0.061,\n 2)\n\n print(\"(1 - Y_He/2) = %.3f =? 0.88\" % (1. - (cosmo['Y_He']/2.)))\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\n 0.88,\n 7)\n\n H_0 = cc.H100_s * cosmo['h']\n\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\n cc.sigma_T_Mpc) / \n (8. * math.pi * cc.G_const_Mpc_Msun_s * \n (cc.m_p_g/cc.M_sun_g))))\n\n print(\"tau_star_explicit = %.7f =? tau_star\" % (tau_star_explicit))\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)","def mbrae(self, benchmark: np.ndarray = None) -> float:\n return float(np.mean(self._bounded_relative_error(benchmark)))","def bPlusbStar(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == 1:\n ayxx = 0\n for j in range(self.prob.num):\n ayxx += self.alphas[j] * self.prob.Y[j] * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\n abcxx = 0\n for j in range(self.prob.num):\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\n abcxx *= (1 / self.prob.gamma)\n running_total += 1 - abcxx - ayxx\n return running_total","def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\n\n # number of periods in samples\n T = df_train.shape[0]\n T_test = df_test.shape[0]\n\n # number of agents\n K = df_test.shape[1]\n\n # individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # outcomes\n outcomes = df_train.iloc[:, 0].values\n\n # initialize matrices containing all predictions and bets\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\n\n # budget initialization\n budgets = np.full(K, 1, dtype=float)\n\n # training the market\n for i in range(T):\n\n # first round betting\n pred_mat[0, :] = F[i, :]\n bet_mat[0, :] = budgets * MaxRPT_r1\n budgets = budgets * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F[i, :]\n bet_mat[j, :] = budgets * MaxRPT\n budgets = budgets * (1-MaxRPT)\n\n # use IQR to determine outlier error threshold\n abs_errors = np.abs(outcomes[i] - pred_mat)\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\n IQR = Q3 - Q1\n oet = Q3 + (IQR*1.5)\n\n # reward the agents based on accuracy of their predictions\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\n score = np.log(accuracy)\n revenue = np.multiply(score, bet_mat)\n budgets = budgets + np.sum(revenue, axis=0)\n\n # rescaling the budget (only for computational reasons)\n budgets = budgets/np.sum(budgets)\n\n # using the market for the out-of-sample predictions\n pred = np.full(T_test, np.nan, dtype=float)\n for i in range(T_test):\n\n # reset test budget\n budgets_test = np.copy(budgets)\n\n # first round betting\n pred_mat[0, :] = F_test[i, :]\n bet_mat[0, :] = budgets_test * MaxRPT_r1\n budgets_test = budgets_test * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F_test[i, :]\n bet_mat[j, :] = budgets_test * MaxRPT\n budgets_test = budgets_test * (1-MaxRPT)\n\n # final round market prediction is the c-APM prediction\n pred[i] = np.dot(\n pred_mat[no_rounds-1, :],\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\n\n # output\n df_pred = pd.DataFrame(\n {\"c-APM (Constant)\": pred},\n index=df_test.index\n )\n\n return df_pred","def _compute_kl(self, lvl):\n kl = [] # kernal length\n for n in range(lvl):\n fct = self.scaling**n # up-sampling factor\n kl.append(fct*(self.nfreq-1)+1)\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\n return kl[::-1]","def learning_rate_fn(global_step):\n lr = tf.train.piecewise_constant(\n global_step, boundaries, vals)\n if warmup:\n warmup_steps = int(batches_per_epoch * 5)\n warmup_lr = (\n initial_learning_rate * tf.cast(global_step, tf.float32) / tf.cast(\n warmup_steps, tf.float32))\n return tf.cond(pred=global_step < warmup_steps,\n true_fn=lambda: warmup_lr,\n false_fn=lambda: lr)\n return lr # , initial_learning_rate, batches_per_epoch, vals","def apx_ratio_eval():\n print 'starting random eval'\n\n n_pl = randint(2, MAX_PL)\n n_target = randint(n_pl + 1, MAX_TARGETS)\n\n target_values = []\n for t in range(0,n_target):\n target_values.append(random())\n target_values = np.array(target_values)\n\n attacker_strategy = get_random_attacker_strategy(n_target)\n\n #I = get_random_covering_routes(n_pl, n_target)\n I = get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values)\n\n start_opt = time()\n br_opt = ilp.generate_row(I, attacker_strategy, target_values)\n opt_time = time() - start_opt\n\n start_apx = time()\n br_apx = greedy.generate_row(I, attacker_strategy, target_values)\n apx_time = time() - start_apx\n\n print 'opt time: ', opt_time, 'apx time: ', apx_time\n\n apx_val = get_value(br_apx, I, target_values, attacker_strategy)\n opt_val = get_value(br_opt, I, target_values, attacker_strategy)\n\n logging.info('ratio = %f - target = %d - pl = %f - max_r = %d - max_cov_t = %d',apx_val/opt_val, n_target, n_pl, MAX_ROUTES, MAX_ROUTE_LEN)\n\n return apx_val/opt_val, opt_time, apx_time","def calculate_initial_lr(cfg: OmegaConf) -> float:\n if cfg[\"parameter\"][\"linear_schedule\"]:\n scaled_lr = cfg[\"experiment\"][\"lr\"] * cfg[\"experiment\"][\"batches\"] / 256.\n else:\n scaled_lr = cfg[\"experiment\"][\"lr\"] * np.sqrt(cfg[\"experiment\"][\"batches\"])\n return scaled_lr","def lr_lambda(epoch):\n return 1 - min(epoch * T, flags.total_steps) / flags.total_steps #epoch * T * B if using B steps","def lapse(self):\n pass","def extinction_efficiency(self):\r\n n = np.arange(1, self.n + 1)\r\n return 2*np.sum((2*n+1)*np.real(self.a + self.b))/self.x**2","def eulerBuckle(dim):\n bst = dim[0]\n tst = dim[1]\n tsk = dim[2]\n\n ZEAZ = (Est*bst*tst*((tsk/2)+(bst/2)))\n ZEA = (Est*bst*tst)+(Esk*tsk*bsk)\n zbar = ZEAZ/ZEA # Neutral Axis\n\n EIbar = ((Esk*bsk*(tsk**3))/12)+(Esk*bsk*tsk*(zbar**2))+((Est*tst*bst**3)/12)+\\\n (Est*bst*tst*(((bst/2)+(tsk/2)-zbar)**2)) # Using Parallel Axis Theorm\n NxEuler = ((math.pi**2)*EIbar)/(ribSpace**2*bsk) # Critical Load\n rsf = NxEuler/Nx\n return rsf - 1.1 # Using a target Reserve Factor of >=1.1","def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\n\n xgain = 1\n xgainmax = 100\n exit = False\n while exit == False:\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\n\n if Mfl > 0:\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\n Tfl[2] = (Tin + Tout) / 2\n DT[2] = Tfl[2] - Te\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\n else:\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\n Tfl[2] = Tout\n DT[2] = Tfl[2] - Te\n qdiff = 5 * (DT[2] - DT[1])\n\n if abs(qdiff < 0.1):\n DT[1] = DT[2]\n exit = True\n else:\n if xgain > 40:\n DT[1] = (DT[1] + DT[2]) / 2\n if xgain == xgainmax:\n exit = True\n else:\n DT[1] = DT[2]\n xgain += 1\n\n # FIXME: redundant...\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\n # qbal = qgain - qout - qmtherm\n # if abs(qbal) > 1:\n # qbal = qbal\n return qgain_Whperm2","def lam(freq):\n return C / freq","def compute_cost(self, r):\n self.r_max = 1\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0","def golden_ratio(fun, a, b, E):\n K = (1 + sqrt(5)) / 2\n lam = b - (b - a) / K\n mu = a + (b - a) / K\n y1 = fun(lam)\n y2 = fun(mu)\n counter = 2\n n = 0\n while fabs(b - a) > E:\n if y1 > y2:\n a = lam\n lam = mu\n y1 = y2\n mu = a + (b - a) / K\n y2 = fun(mu)\n counter += 1\n else:\n b = mu\n mu = lam\n y2 = y1\n lam = b - (b - a) / K\n y1 = fun(lam)\n counter += 1\n n += 1\n return (b + a) / 2, counter","def grubbs(timeseries):\r\n\r\n series = scipy.array([x[1] for x in timeseries])\r\n stdDev = scipy.std(series)\r\n mean = np.mean(series)\r\n tail_average = tail_avg(timeseries)\r\n z_score = (tail_average - mean) / stdDev\r\n len_series = len(series)\r\n threshold = scipy.stats.t.isf(.05 / (2 * len_series) , len_series - 2)\r\n threshold_squared = threshold * threshold\r\n grubbs_score = ((len_series - 1) / np.sqrt(len_series)) * np.sqrt(threshold_squared / (len_series - 2 + threshold_squared))\r\n\r\n return z_score > grubbs_score","def GoodmanKruskalLambdaR_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n part1 = 0.5 * (max(TP + FP, FN + TN) + max(TP + FN, FP + TN))\n return (TP + TN - part1) / (n - part1)\n except Exception:\n return \"None\"","def compute_Rg(L):\n\treturn np.sqrt(np.dot(L,L))","def evap(self, lai, tl, ta, qa):#average ta and tl!!\n\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\n\t\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \n\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\n\t return 0.\n\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\n\t return (self.tx*self.ZT*self.TAI*10**6/dt)\n\t else:\n\t return fsev","def question_13(gamma):\n rbf = RadialBiasFunction()\n fails = 0.0\n my_svm = svm.SVC(C=np.inf, kernel='rbf', gamma=gamma)\n for i in range(1000):\n my_svm = my_svm.fit(rbf.X, rbf.Y)\n if my_svm.score(rbf.X, rbf.Y) != 1:\n fails += 1\n rbf.resample()\n return fails / 1000","def mb_r(self) -> float:\n # Calculate metric\n n = self.predicted.size\n tot = 0.0\n for i in range(n):\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\n mb = 1 - ((n ** 2) * mae_val / tot)\n\n return float(mb)","def hbl_rate_limit(self):\n tstar =4E4 \n [Ly,N] = self.b.shape\n print 'HBL RATE LIMITER CALLED....'\n\tprint 'tstar = ' + str(tstar) + ' seconds'\n\tfor j in range(Ly):\n dh_s = self.hbls[j] - self.hbls_old[j]\n\t if abs(dh_s) >= self.dt / tstar * self.hbls_old[j]:\n\t #print ' SBL RATE LIMIT BEING APPLIED at j = ' + str(j) \n #print ' dh_s = ' + str(dh_s) + 'm'\n\t dhm_s = self.dt / tstar * self.hbls_old[j]\n\t self.hbls[j] = self.hbls_old[j] + dhm_s*dh_s/abs(dh_s)\n\t if self.LMD_BKPP:\n\t dh_b = self.hbbl[j] - self.hbbl_old[j]\n if abs(dh_b) >= self.dt / tstar * self.hbbl_old[j]:\n dhm_b = self.dt / tstar * self.hbbl_old[j]\n\t self.hbbl[j] = self.hbbl_old[j] + dhm_b*dh_b/abs(dh_b)","def validation_cost(model, X_vala, L_vala, Y_vala):\n vala_costs = []\n for i in range(0,8-1+1):\n X_v, L_v, Y_v = X_vala[i], L_vala[i], Y_vala[i]\n c_v_s = model.get_cost(X_v,L_v,Y_v)\n vala_costs.append(c_v_s)\n return np.mean(vala_costs)","def overall_reduction(self):\n return 84","def GuttmanLambdaA_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n part1 = max(TP, FN) + max(FP, TN)\n part2 = max(TP + FP, FN + TN)\n return (part1 - part2) / (n - part2)\n except Exception:\n return \"None\"","def maclaurin_ln(value,k):\n \n global first_value \n first_value = 0.0\n \n #attempt to Approximate ln(1+x) for a given value\n try:\n \n error(value)\n for item in xrange(1,k,2):\n next_value =(value**item)/float(item)\n first_value += next_value\n \n for item in xrange(2,k,2):\n next_value = -1*(value**item)/float(item)\n first_value += next_value\n \n return first_value\n\n #Raise TypeError if input is not within\n #the interval of convergence\n except TypeError,exception:\n print exception","def penalty_calc(self):\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\n\n # fiber attenuation,\n self.p_atten = self.alpha*self.length # column B\n\n # calculate bandwidth for RIN test (exclude transmitter)\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\n rin_bw = 1.0 / rin_inverse_bw\n\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\n k_rin = 0.7\n\n # v_rin,\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\n math.pow(10.0,0.1*self.rin)) # column AK\n\n # Prin,\n print('v_rin: ', self.v_rin)\n print('Q: ',self.Q)\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\n print(\"P_rin : \", self.p_rin)\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\n print(\"isi_center : \", self.isi_center)\n\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\n\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\n\n\n # calculate the \"cross\" penalty contribution, column S\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\n self.p_cross_center = ( # column S\n arg3\n - self.p_blw # cell T13\n - self.p_isi_center # column J\n - self.p_isi_dj_center # column L\n - self.p_mpn # column Q\n - self.p_reflection # column N\n - self.p_rin # column R\n - self.pmn*self.l_1) # cell G13\n print('p_isi_center: ', self.p_isi_center)\n\n # calculate the total power budget evaluated at the center of the eye\n self.p_total_center = ( # column T\n self.p_isi_center # column J\n + self.p_isi_dj_center # column L\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1) # cell G13\n # calculate the total power budget evaluated at the corner of the eye\n self.p_total_corners = (\n self.p_isi_center # column J\n + self.p_isi_corners # column K\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1 # cell G13\n + self.p_isi_dj_corners)# column M\n\n # receiver stressed sensitivity\n self.margin = ( self.p_budget\n - self.p_total_center) # column W\n\n self.rx_stressed_sensitivity = (\n self.tx_oma_min*self.l_1\n - self.chil\n - self.p_mpn\n - self.p_reflection\n - self.p_rin\n - 0.5*self.p_cross_center\n - self.pmn*self.l_1\n - self.margin[self.lnum//2]*self.l_1)\n\n\n # end of GbE10.penalty_calc\n #======================================================================+","def estimate_arpu(x):\n arpu = 0\n if x['mean_luminosity_km2'] > 5:\n # #10 year time horizon\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (20*12) / (1 + 0.03) ** i\n # )\n return 20 * 12 * 10#arpu\n elif x['mean_luminosity_km2'] > 1:\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (5*12) / (1 + 0.03) ** i\n # )\n return 5 * 12 * 10#arpu\n else:\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (2*12) / (1 + 0.03) ** i\n # )\n return 2 * 12 * 10#arpu","def LangmuirCurve(x, B,a,N,K):\n return B+np.square(a*(((x+N+(55.5/K))-np.sqrt(np.square(x+N+(55.5/K))-(4*x*N)))/(2*N)));","def recommend_L(self):\n\n min_eigenvalue = torch.min(torch.linalg.eigvalsh(self.Wc))\n lamBda = 1 / (1 + 4*torch.abs(min_eigenvalue - self.vars['q_init']))\n return lamBda","def compute_cost(AL, Y):\n m = Y.shape[1]\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\n cost = np.sum(log_val) * (-1/m)\n cost = np.squeeze(cost)\n return cost","def _lr_schedule(self, epoch: int):\n penultimate_activ_func = K.function([self.model.layers[0].input], [self.model.layers[-2].output])\n\n Kz = 0.\n for i in range((len(self.x_train) - 1) // self.bs + 1):\n start_i = i * self.bs\n end_i = start_i + self.bs\n xb = self.x_train[start_i:end_i]\n\n activ = np.linalg.norm(penultimate_activ_func([xb]))\n if activ > Kz:\n Kz = activ\n\n K_ = ((self.n_classes - 1) * Kz) / (self.n_classes * self.bs)\n lr = 1 / K_\n\n self.lr_history.append(lr)\n return lr","def ComputeRegenerativeBraking(self):\r\n pass","def calc_reconstruction_error(self):\n logger.debug('Calculating reconstruction error')\n tic = time.time()\n Esig_w_tau = self.Esig_w_tau\n I_rec_w_tau = np.real(Esig_w_tau * np.conj(Esig_w_tau))\n I_w_tau = self.I_w_tau\n mx = I_w_tau.max()\n my = (I_w_tau * I_rec_w_tau).sum() / (I_rec_w_tau**2).sum()\n logger.debug(''.join(('My=', str(my))))\n # my = 1.0\n G = np.sqrt(((I_w_tau - my * I_rec_w_tau) ** 2).sum() / (I_rec_w_tau.shape[0] * I_rec_w_tau.shape[1])) / mx\n toc = time.time()\n logger.debug(''.join(('Time spent: ', str(toc - tic))))\n self.G_hist.append(G)\n return G","def _compute_rdp(q: float, sigma: float, alpha: float) -> float:\n if q == 0:\n return 0\n\n # no privacy\n if sigma == 0:\n return np.inf\n\n if q == 1.0:\n return alpha / (2 * sigma ** 2)\n\n if np.isinf(alpha):\n return np.inf\n\n return _compute_log_a(q, sigma, alpha) / (alpha - 1)","def get_RMSLE(pred, truth):\n assert len(pred) == len(truth)\n diff_vect = np.log(pred + 1) - np.log(truth + 1)\n diff_sum = np.sum(np.power(diff_vect, 2))\n return np.sqrt(diff_sum / len(pred))","def mamajek08_logRpHK_max():\n return -3.8918287373004357","def gmrae(self, benchmark: np.ndarray = None) -> float:\n return _geometric_mean(np.abs(self._relative_error(benchmark)))","def KL(P,Q):\n epsilon = 0.00001\n \n #You may want to instead make copies to avoid changing the np arrays.\n P = P+epsilon\n Q = Q+epsilon\n \n divergence = np.sum(P*np.log(P/Q))\n return divergence","def ensemble_cost(x_tapes):\n per_trajectory_costs = [final_state_cost(x_tape) for x_tape in x_tapes]\n # Return the L1-norm of the per-trajectory-costs, scaled by the number of\n # trajectories.\n return np.linalg.norm(per_trajectory_costs, 1) / len(x_tapes)","def acc_rate(L_acc, R, M):\n mdot = 1.25*L_acc*u.W*R*u.R_sun/(G*M*u.M_sun)\n mdot = mdot.decompose().to(u.M_sun/u.yr)\n return(mdot/(u.M_sun/u.yr))","def gaver_stehfest(time, lap_func):\n def nCr(n, r):\n return math.factorial(n)/(math.factorial(r)*\n math.factorial(n-r))\n def a(k, n):\n summation = 0.\n for j in range((k+1)/2, min(k, n)+1):\n current_summation = float(pow(j, n+1))/float(math.factorial(n))\n current_summation *= nCr(n, j)\n current_summation *= nCr(2*j, j)\n current_summation *= nCr(j, k-j)\n summation += current_summation\n return summation*pow(-1, n+k)\n n = 7\n total_sum = a(1, n)*lap_func(1.*np.log(2.)/time)\n for k in range(2, 2*n+1):\n total_sum += a(k, n)*lap_func(k*np.log(2.)/time)\n return total_sum*np.log(2.)/time","def lr_lambda_fun(current_iteration: int) -> float:\n current_epoch = float(current_iteration) / self.iterations\n if current_epoch <= self.hparams.warmup_epochs:\n alpha = current_epoch / float(self.hparams.warmup_epochs)\n return self.hparams.warmup_factor * (1.0 - alpha) + alpha\n else:\n return_val = 1.0\n if current_epoch >= self.hparams.lr_milestones[0] and current_epoch < self.hparams.lr_milestones2[0]:\n idx = bisect(self.hparams.lr_milestones, current_epoch)\n return_val = pow(self.hparams.lr_gamma, idx)\n elif current_epoch >= self.hparams.lr_milestones2[0]:\n idx = bisect(self.hparams.lr_milestones2, current_epoch)\n return_val = self.hparams.lr_gamma * pow(self.hparams.lr_gamma2, idx)\n return return_val","def compute_cost(n: int,\n lam: float,\n dE: float,\n L: int,\n Lxi: int,\n chi: int,\n beta: int,\n stps: int,\n verbose: bool = False) -> Tuple[int, int, int]:\n\n # The number of bits used for the second register.\n nxi = np.ceil(np.log2(n // 2))\n\n # The number of bits for the contiguous register.\n nLxi = np.ceil(np.log2(Lxi + n // 2))\n\n # The number of bits used for the first register.\n nL = np.ceil(np.log2(L + 1))\n\n # The power of 2 that is a factor of L + 1\n eta = power_two(L + 1)\n\n oh = [0] * 20\n for p in range(20):\n # JJG note: arccos arg may be > 1\n v = np.round(np.power(2,p+1) / (2 * np.pi) * arccos(np.power(2,nL) /\\\n np.sqrt((L + 1)/2**eta)/2))\n oh[p] = np.real(stps * (1 / (np.sin(3 * arcsin(np.cos(v * 2 * np.pi / \\\n np.power(2,p+1)) * \\\n np.sqrt((L + 1)/2**eta) / np.power(2,nL)))**2) - 1) + 4 * (p + 1))\n\n # Bits of precision for rotation\n br = int(np.argmin(oh) + 1)\n\n # The following costs are from the list starting on page 50.\n\n # The cost for preparing an equal superposition for preparing the first\n # register in step 1 (a). We double this cost to account for the inverse.\n cost1a = 2 * (3 * nL + 2 * br - 3 * eta - 9)\n\n # The output size for the QROM for the first state preparation in Eq. (C27)\n bp1 = nL + chi\n\n # The cost of the QROM for the first state preparation in step 1 (b) and\n # its inverse.\n cost1b = QR(L + 1, bp1)[1] + QI(L + 1)[1]\n\n # The cost for the inequality test, controlled swap and their inverse in\n # steps 1 (c) and (d)\n cost1cd = 2 * (chi + nL)\n\n # The total cost for preparing the first register in step 1.\n cost1 = cost1a + cost1b + cost1cd\n\n # The output size for the QROM for the data to prepare the equal\n # superposition on the second register, as given in Eq. (C29).\n bo = nxi + nLxi + br + 1\n\n # This is step 2. This is the cost of outputting the data to prepare the\n # equal superposition on the second register. We will assume it is not\n # uncomputed, because we want to keep the offset for applying the QROM for\n # outputting the rotations.\n cost2 = QR(L + 1, bo)[1] + QI(L + 1)[1]\n\n # The number of bits for rotating the ancilla for the second preparation.\n # We are just entering this manually because it is a typical value.\n br = 7\n\n # The cost of preparing an equal superposition over the second register in\n # a controlled way. We pay this cost 4 times.\n cost3a = 4 * (7 * nxi + 2 * br - 6)\n\n # The cost of the offset to apply the QROM for state preparation on the\n # second register.\n cost3b = 4 * (nLxi - 1)\n\n bp2 = nxi + chi + 2\n\n # The cost of the QROMs and inverse QROMs for the state preparation, where\n # in the first one we need + n/2 to account for the one-electron terms.\n cost3c = QR(Lxi + n // 2, bp2)[1] + QI(Lxi + n // 2)[1] + QR(\n Lxi, bp2)[1] + QI(Lxi)[1]\n\n # The inequality test and state preparations.\n cost3d = 4 * (nxi + chi)\n\n # The total costs for state preparations on register 2.\n cost3 = cost3a + cost3b + cost3c + cost3d\n\n # The cost of adding offsets in steps 4 (a) and (h).\n cost4ah = 4 * (nLxi - 1)\n\n # The costs of the QROMs and their inverses in steps 4 (b) and (g).\n cost4bg = QR(Lxi + n // 2, n * beta // 2)[1] + QI(Lxi + n // 2)[1] + QR(\n Lxi, n * beta // 2)[1] + QI(Lxi)[1]\n\n # The cost of the controlled swaps based on the spin qubit in steps 4c and f\n cost4cf = 2 * n\n\n # The controlled rotations in steps 4 (d) and (f).\n cost4df = 4 * n * (beta - 2)\n\n # The controlled Z operations in the middle for step 4 (e).\n cost4e = 3\n\n # This is the cost of the controlled rotations for step 4.\n cost4 = cost4ah + cost4bg + cost4cf + cost4df + cost4e\n\n # This is the cost of the reflection on the second register from step 6.\n cost6 = nxi + chi + 2\n\n # The cost of the final reflection req'd to construct the step of the\n # quantum walk from step 9.\n cost9 = nL + nxi + chi + 1\n\n # The extra two qubits for unary iteration and making the rflxn controlled.\n cost10 = 2\n\n # The Toffoli cost for a single step\n cost = cost1 + cost2 + cost3 + cost4 + cost6 + cost9 + cost10\n\n # The number of steps needed\n iters = np.ceil(np.pi * lam / (2 * dE))\n\n # Now the number of qubits from the list on page 54.\n\n k1 = np.power(2, QR(Lxi + n // 2, n * beta // 2)[0])\n\n # The control register for phase estimation and iteration on it.\n ac1 = np.ceil(np.log2(iters + 1)) * 2 - 1\n\n # The system qubits\n ac2 = n\n\n # The first register prepared, a rotated qubit and a flag qubit.\n ac3 = nL + 2\n\n # The output of the QROM, the equal superposition state and a flag qubit.\n ac4 = nL + chi * 2 + 1\n\n # The data used for preparing the equal superposition state on the 2nd reg\n ac5 = bo\n\n # The second register, a rotated qubit and a flag qubit.\n ac6 = nxi + 2\n\n # The second preparation QROM output.\n ac8 = bp2\n\n # The equal superposition state and the result of the inequality test.\n ac9 = chi + 1\n\n # The angles for rotations.\n ac10 = k1 * n * beta // 2\n\n # The phase gradient state.\n ac11 = beta\n\n # A control qubit for the spin.\n ac12 = 1\n\n # A T state.\n ac13 = 1\n\n if verbose:\n print(\"[*] Top of routine\")\n print(\" [+] nxi = \", nxi)\n print(\" [+] nLxi = \", nLxi)\n print(\" [+] nL = \", nL)\n print(\" [+] eta = \", eta)\n print(\" [+] cost3 = \", cost3)\n print(\" [+] cost4 = \", cost4)\n print(\" [+] cost = \", cost)\n print(\" [+] iters = \", iters)\n\n ancilla_cost = ac1 + ac2 + ac3 + ac4 + ac5 + ac6 + ac8 + ac9 + ac10 + ac11\\\n + ac12 + ac13\n\n # Sanity checks before returning as int\n assert cost.is_integer()\n assert iters.is_integer()\n assert ancilla_cost.is_integer()\n\n step_cost = int(cost)\n total_cost = int(cost * iters)\n ancilla_cost = int(ancilla_cost)\n\n return step_cost, total_cost, ancilla_cost","def regularized_bayes_risk(m_true, alpha, alpha0, m_probs, global_step, annealing_step=1000, max_lambda=1.0):\n\n risk = bayes_risk(m_true, alpha, alpha0, m_probs)\n kl = kullback_leibler_dirichlet(m_true, alpha)\n lamb = tf.cast(tf.minimum(max_lambda, global_step / annealing_step), dtype=tf.float32)\n loss = risk + lamb * kl\n return loss","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def bMinusbStar(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == -1:\n ayxx = 0\n for j in range(self.prob.num):\n ayxx += self.alphas[j] * self.prob.Y[j] * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\n abcxx = 0\n for j in range(self.prob.num):\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\n abcxx *= (1 / self.prob.gamma)\n running_total += -1 + abcxx - ayxx\n return running_total","def growthrate(cur, pre, y):\n return (cur-pre)/y","def hr_game(t0, tf, n, A, B, R, x0):\n # t0 - Initial time\n # tf - Final time\n # n - Number of steps\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Step in each iteration\n h = (tf - t0) / n\n # Result of each step, np.ndarray (N, S, n+1)\n y = np.zeros([N, S, n+1], dtype='double')\n y[:, :, 0] = x0\n k = np.zeros([N, S])\n # I still don't know why, but theres a problem with negative payoffs\n B = matrixTranslate(B)\n\n # Fourth order Runge-Kutta\n for t in range(n):\n k1 = np.multiply(h, hr_egn(A, B, R, y[:, :, t]))\n k2 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k1, 2))))\n k3 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k2, 2))))\n k4 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], k3)))\n # k = (k1 + 2*k2 + 2*k3 + k4)/6\n k = np.divide(np.add(np.add(k1, np.multiply(2, k2)), np.add(np.multiply(2, k3), k4)), 6)\n\n y[:, :, t+1] = np.add(y[:, :, t], k)\n\n # Filter results with machine epsilon\n for v in range(N):\n for s in range(S):\n if y[v, s, t+1] < np.sqrt(np.finfo('double').eps):\n y[v, s, t+1] = 0\n elif y[v, s, t+1] > np.subtract(1, np.sqrt(np.finfo('double').eps)):\n y[v, s, t + 1] = 1\n\n return y","def question_17():\n rbf = RadialBiasFunction()\n for i in range(20):\n rbf.fit(1.5, 9)\n error_in_lo = rbf.error()\n error_out_lo = rbf.error(in_sample=False)\n rbf.fit(2.0, 9)\n error_in_hi = rbf.error()\n error_out_hi = rbf.error(in_sample=False)\n print(\"Error (in/out) for gamma = 1.5: {0} / {1}\\nError (in/out) for gamma = 2.0: {2} / {3}\\n\"\n .format(error_in_lo, error_out_lo, error_in_hi, error_out_hi))\n rbf.resample()","def dishlist_avg_cal(n:list)->float:\r\n all_cal = dishlist_cal(n)\r\n return sum(all_cal)/len(all_cal)","def dlqr(a, b, q, r):\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\n p = scipy.linalg.solve_discrete_are(a, b, q, r)\n\n # LQR gain\n # k = (b.T * p * b + r)^-1 * (b.T * p * a)\n bp = b.T.dot(p)\n tmp1 = bp.dot(b)\n tmp1 += r\n tmp2 = bp.dot(a)\n k = np.linalg.solve(tmp1, tmp2)\n return k, p","def efficiency_vs_length(w=50, Lmax=1000, Lmin=102.4, p=75, fmax=5.7e9,\r\n p1=database['K+'], p2=database['pi+'],\r\n p3=database['p+'], E=1e6, delta_p=1.6e-2, n=1000,\r\n ng=50, nl=50, nf=100, resolution=0.01, plot=True,\r\n set_freq=5.7e9, present=False, count_L=True):\r\n current_target_rate = 53957518\r\n if count_L == True:\r\n if resolution == None:\r\n if set_freq == None:\r\n est = timing(n*ng*nl*nf*4e-05)\r\n else:\r\n est = timing(n*ng*nl*4e-05)\r\n print('Estimated time: {0}'.format(est))\r\n else:\r\n num = int(round(np.log10(Lmax-Lmin))-1)-np.log10(resolution)+1\r\n if set_freq == None:\r\n est = timing(10*num*ng*nl*nf*4e-05)\r\n else:\r\n est = timing(10*num*ng*nl*4e-05)\r\n print('Estimated maximum time: {0}'.format(est))\r\n start = time.time()\r\n if resolution == None:\r\n L_range = np.linspace(Lmin, Lmax, n)\r\n eff, purity = [], []\r\n for L in L_range:\r\n if count_L == True:\r\n print(L)\r\n eff.append(efficiency(w, L-22.8, p, fmax, p1, p2, p3, E, delta_p,\r\n 10000, ng, nl, nf, False, set_freq))\r\n# purity.append((target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False)))\r\n purity.append(100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False)))\r\n i = 0\r\n while eff[i] < purity[i] and i < np.size(L_range)-1:\r\n i += 1\r\n if i >= np.size(L_range)-1:\r\n return None\r\n output = [L_range[i], eff[i], purity[i]/6]\r\n else:\r\n if present == True:\r\n n = 10**(int(round(np.log10(Lmax-Lmin))-2))\r\n n1 = 10**(int(round(np.log10(Lmax-Lmin))-2))\r\n else:\r\n n = 10**(int(round(np.log10(Lmax-Lmin))-1))\r\n n1 = 10**(int(round(np.log10(Lmax-Lmin))-1))\r\n Lmin = Lmax - ((int(((Lmax-Lmin)/n))+1)*n)\r\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\r\n while n >= resolution:\r\n if n == n1 and plot==True:\r\n graph_Lmin = Lmin\r\n graph_Lmax = Lmax - n\r\n graph_L_range = np.arange(Lmin, Lmax, n)\r\n graph_eff, graph_purity, graph_intensity = [], [], []\r\n for L in graph_L_range:\r\n if count_L == True:\r\n print(L)\r\n graph_eff.append(efficiency(w, L-22.8, p, fmax, p1, p2,\r\n p3, E, delta_p, 10000, ng, nl,\r\n nf, False, set_freq))\r\n# graph_purity.append((target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False)))\r\n graph_purity.append(100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False)))\r\n graph_intensity.append((target_rate(L, p1, p)/current_target_rate)/Gaussian_integral(w/26.4, plot=False))\r\n i = 0\r\n while graph_eff[i] < graph_purity[i] and i < np.size(graph_L_range)-1:\r\n i += 1\r\n if i >= np.size(graph_L_range)-1:\r\n output = None\r\n break\r\n Lmin = graph_L_range[i-1]\r\n n = 10**(int(np.log10(n)-1))\r\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\r\n else:\r\n L_range = np.arange(Lmin, Lmax, n)\r\n eff, purity, intensity = 0, 0, 0\r\n i = 0\r\n while eff <= purity and i < np.size(L_range)-1:\r\n i += 1\r\n L= L_range[i]\r\n if count_L == True:\r\n print(L)\r\n eff = efficiency(w, L-22.8, p, fmax, p1, p2, p3, E, delta_p,\r\n 10000, ng, nl, nf, False, set_freq)\r\n# purity = (target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False))\r\n purity = 100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False))\r\n intensity = (target_rate(L, p1, p)/current_target_rate)/Gaussian_integral(w/26.4, plot=False)\r\n if i >= np.size(L_range)-1:\r\n return None\r\n output = [L_range[i], eff, intensity]\r\n Lmin = L_range[i-1]\r\n n = 10**(int(np.log10(n)-1))\r\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\r\n if plot == True:\r\n fig = plt.figure(figsize=[10, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n ax2 = ax.twinx()\r\n eff, purity, intensity, L_range = graph_eff, graph_purity, graph_intensity, graph_L_range\r\n Lmax, Lmin = graph_Lmax, graph_Lmin\r\n line1, = ax.plot(L_range, eff, 'r', lw=2, label='Beam Purity', alpha=0.6)\r\n line2, = ax.plot(L_range, purity, 'b', lw=2, label='Required Purity', alpha=0.6)\r\n line3, = ax2.plot(L_range, intensity, 'g', lw=2, label='Req. Intensity', alpha=0.6)\r\n# ax.axhline(24, color='k', label='Kaon percentage = 24%')\r\n ax.set_xlim(Lmin, Lmax)\r\n ax.set_ylim(0, 100)\r\n ax.set_xlabel('Distance between target and decay region / m', fontsize=20)\r\n ax.set_ylabel('Beam purity / %', fontsize=20)\r\n ax2.set_ylabel(r'Intensity / I$_0$', fontsize=20)\r\n ax2.set_ylim(0)\r\n ax2.yaxis.label.set_color(line3.get_color())\r\n ax2.tick_params(axis='y', colors=line3.get_color())\r\n# index = np.argmin(np.abs(eff-24))\r\n# if eff[index] >= 24:\r\n# min_L = L_range[index]\r\n# else:\r\n# min_L = L_range[index+1]\r\n# print(f'{timing(time.time()-start)}')\r\n# print('Minimum target distance required = {0:.1f} m'.format(min_L))\r\n# return min_L\r\n if output != None:\r\n line4 = ax.axvline(output[0], color='k', label='Intercept', dashes=[6, 2])\r\n lines = [line1, line2, line3, line4]\r\n else:\r\n lines = [line1, line2, line3]\r\n ax2.legend(lines, [l.get_label() for l in lines], loc='best', fontsize=15)\r\n ax.minorticks_on()\r\n ax2.minorticks_on()\r\n ax.grid()\r\n ax.set_title('Observed and required beam purities as a function of\\ntarget distance'+f' for E = {int(E*1e-6)} MV/m', fontsize=16)\r\n plt.show()\r\n fig.savefig(f'Purity_vs_Required_p_75_E_1e{int(round(np.log10(E)))}_with_Intensity.pdf', bbox_inches='tight')\r\n if count_L == True:\r\n print(f'{timing(time.time()-start)}')\r\n return output","def _get_learning_rate(self) -> float:\n if len(self.errors) > 1 and self.errors[-2] - self.errors[-1] < 0:\n self.learning_rate /= 2\n return self.learning_rate","def cost(self):\n lg = len(self.guarantees.cnf)\n la = len(self.assumptions.cnf)\n\n \"\"\"heuristic\n Low: guarantees while assuming little (assumption set is bigger)\n High: guarantees while assuming a lot (assumption set is smaller)\"\"\"\n\n return la / lg","def kA_func(self):\n\n i1 = self.inl[0].to_flow()\n i2 = self.inl[1].to_flow()\n o1 = self.outl[0].to_flow()\n o2 = self.outl[1].to_flow()\n\n T_i1 = T_bp_p(i1)\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\n\n if T_i1 <= T_o2 and not self.inl[0].T.val_set:\n T_i1 = T_o2 + 0.5\n if T_i1 <= T_o2 and not self.outl[1].T.val_set:\n T_o2 = T_i1 - 0.5\n\n if T_o1 <= T_i2 and not self.outl[0].T.val_set:\n T_o1 = T_i2 + 1\n if T_o1 <= T_i2 and not self.inl[1].T.val_set:\n T_i2 = T_o1 - 1\n\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\n\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log","def compute_cost(AL, Y):\n \n m = Y.shape[1]\n\n # Compute loss from aL and y.\n ### START CODE HERE ### (≈ 1 lines of code)\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\n ### END CODE HERE ###\n \n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n assert(cost.shape == ())\n \n return cost","def compute_average(self, error=None):\n\n nbjobs = len(self)\n if not nbjobs:\n return\n max_xsec = max(one.xsec for one in self)\n min_xsec = min(one.xsec for one in self)\n self.axsec = sum([one.axsec for one in self]) / nbjobs\n self.xsec = sum([one.xsec for one in self]) /nbjobs\n self.xerrc = sum([one.xerrc for one in self]) /nbjobs\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self])) /nbjobs\n if error:\n self.xerrc = error\n self.xerru = error\n\n self.nevents = sum([one.nevents for one in self])\n self.nw = 0#sum([one.nw for one in self])\n self.maxit = 0#len(self.yerr_iter) # \n self.nunwgt = sum([one.nunwgt for one in self]) \n self.wgt = 0\n self.luminosity = sum([one.luminosity for one in self])\n self.ysec_iter = []\n self.yerr_iter = []\n self.th_maxwgt = 0.0\n self.th_nunwgt = 0 \n for result in self:\n self.ysec_iter+=result.ysec_iter\n self.yerr_iter+=result.yerr_iter\n self.yasec_iter += result.yasec_iter\n self.eff_iter += result.eff_iter\n self.maxwgt_iter += result.maxwgt_iter\n\n #check full consistency\n onefail = False\n for one in list(self):\n if one.xsec < (self.xsec - 25* one.xerru):\n if not onefail:\n logger.debug('multi run are inconsistent: %s < %s - 25* %s: assign error %s', one.xsec, self.xsec, one.xerru, error if error else max_xsec-min_xsec)\n onefail = True\n self.remove(one)\n if onefail:\n if error:\n return self.compute_average(error)\n else:\n return self.compute_average((max_xsec-min_xsec)/2.)","def calc_loss(self, lambdas):\n # Rayleigh scattering [dB/km*um^4]\n # value 0.74 for SiO2 from Appl. Phys. Lett. 83, 5175 (2003)\n # value 2.33 for GeO2 from Appl. Optics 36(27) (1997)\n R = .74 + (2.33 - .74) * self.doping\n alphaR = R * lambdas**(-4) * 1e-3\n # measured fiber water peak\n alphaoh_1_38 = 2.43\n sigma_lambda = 0.030\n # Journal of Non-Crystalline Solids Volume 203 (1996)\n alphaoh = 0.00012 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.444) / (sigma_lambda))**2) + \\\n 0.00050 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.506) / (sigma_lambda))**2) + \\\n 0.00030 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.566) / (sigma_lambda))**2) + \\\n 0.00640 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.593) / (sigma_lambda))**2) + \\\n 0.00028 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.651) / (sigma_lambda))**2) + \\\n 0.00440 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.685) / (sigma_lambda))**2) + \\\n 0.07800 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.724) / (sigma_lambda))**2) + \\\n 0.00380 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.825) / (sigma_lambda))**2) + \\\n 0.08000 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.878) / (sigma_lambda))**2) + \\\n 1.6 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.943) / (sigma_lambda))**2) + \\\n 0.07 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.139) / (sigma_lambda))**2) + \\\n 2.7 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.246) / (sigma_lambda))**2) + \\\n alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.383) / (sigma_lambda))**2) + \\\n 0.84 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.894) / (sigma_lambda))**2) + \\\n 201 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 2.212) / (sigma_lambda))**2) + \\\n 10000 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 2.722) / (sigma_lambda))**2)\n # Hiroshi Murata, Handbook of optical fibers and cables (1996)\n alphaIR = 4.2e8 * np.exp(-47.5 / lambdas)\n a = (alphaoh + alphaR + alphaIR) / (10 / np.log(10))\n a[a > self.maxloss] = self.maxloss\n self.alpha = a","def extinction(lbda, AV, RV=3.1):\n\n xx = 1./lbda\n yy = xx - 1.82\n\n a_c = np.zeros_like(xx)\n b_c = np.zeros_like(xx)\n\n indices = np.where(xx < 1.1)[0]\n\n if len(indices) > 0:\n a_c[indices] = 0.574*np.power(xx[indices], 1.61)\n b_c[indices] = -0.527*np.power(xx[indices], 1.61)\n\n indices = np.where(xx >= 1.1)[0]\n\n if len(indices) > 0:\n a_c[indices] = 1. + 0.17699*yy[indices] - 0.50447*yy[indices]**2 - \\\n 0.02427*yy[indices]**3 + 0.72085*yy[indices]**4 + \\\n 0.01979*yy[indices]**5 - 0.77530*yy[indices]**6 + \\\n 0.32999*yy[indices]**7\n\n b_c[indices] = 1.41338*yy[indices] + 2.28305*yy[indices]**2 + \\\n 1.07233*yy[indices]**3 - 5.38434*yy[indices]**4 - \\\n 0.62251*yy[indices]**5 + 5.30260*yy[indices]**6 - \\\n 2.09002*yy[indices]**7\n\n return AV * (a_c + b_c/RV)","def tLoss(self, dt, qt, tl, ta, qa):\n\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))","def b_plus_bstar(self):\n running_total = 0\n for i in range(self.prob.num):\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == 1:\n ayxx = 0\n for j in range(self.prob.num):\n ayxx += (self.alphas[j] + self.etas[j]) * self.prob.Y[j] * self.prob.xkernel(self.prob.X[j],\n self.prob.X[i])\n abcxx = 0\n for j in range(self.prob.num):\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[j], self.prob.X[i])\n abcxx *= (1 / self.prob.gamma)\n running_total += 1 - abcxx - ayxx\n return running_total","def calculate_risk_tol(*args):\n global total_score\n risk_tol_start = 0.0\n\n for risk_per_pg in risk_tol_per_qs.iterkeys():\n try:\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\n except IndexError:\n pass\n total_score = risk_tol_start","def __learning_rate(self, lr0, epoch):\n \n \"\"\"\n Dan's Methos\n \"\"\"\n lrs = lr0 * 0.001\n c = np.power((lrs/lr0), 1.0/self.__maxEpoch)\n \n return lr0*np.power(c, epoch)","def lam(E):\n return (12398.4/E)*1e-10","def ComputeNrb(self):\r\n pass","def Rosenbrock(a, x):\r\n return (a-x[0])**2 + 100*(x[1]-x[0]**2)**2","def tune_lambda(Xtrain, ytrain, Xval, yval):\n #####################################################\n # TODO 5: Fill in your code here #\n #####################################################\n\n bestlambda = None\n mean_abs_err = 10000000\n power = -19\n while power < 20:\n lambda0 = 10 ** (power)\n w = regularized_linear_regression(Xtrain, ytrain, lambda0)\n err = mean_absolute_error(w, Xval, yval)\n if err < mean_abs_err:\n mean_abs_err = err\n bestlambda = lambda0\n power = power + 1\n return bestlambda","def checkCostFunction(lbd=0):\n # Create small problem\n X_t = np.random.rand(4, 3)\n Theta_t = np.random.rand(5, 3)\n\n # Zap out most entries\n Y = X_t.dot(Theta_t.T)\n Y[np.random.rand(Y.shape[0], Y.shape[1]) > .5] = 0\n R = np.zeros(Y.shape)\n R[Y == 0] = 1\n\n # Run Gradient Checking\n X = np.random.randn(X_t.shape[0], X_t.shape[1])\n Theta = np.random.randn(Theta_t.shape[0], Theta_t.shape[1])\n num_users = Y.shape[1]\n num_movies = Y.shape[0]\n num_features = Theta_t.shape[1]\n\n def Jfunc(t):\n return cofiCostFunc(t, Y, R, num_users, num_movies, num_features, lbd)\n\n numgrad = computeNumericalGradient(Jfunc, np.r_[X.flatten(), Theta.flatten()])\n\n cost, grad = cofiCostFunc(np.r_[X.flatten(), Theta.flatten()], Y, R, num_users, num_movies, num_features, lbd)\n\n print(np.c_[numgrad, grad])\n print('The above two columns you get should be very similar.')\n print('(Left-Your Numerical Gradient, Right-Analytical Gradient)\\n')\n\n diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)\n print('If your cost function implementation is correct, then')\n print('the relative difference will be small (less than 1e-9).')\n print('Relative Difference: %g\\n' % diff)","def dishlist_avg(n:list)->float:\r\n all_prices = dishlist_prices(n)\r\n return sum(all_prices)/len(all_prices)","def kl_divergence(eta_q, eta_p):\n return ev_t(eta_q) @ (eta_q - eta_p) - a(eta_q) + a(eta_p)","def cracking_rate_Ai2020(T_dim):\n k_cr = 3.9e-20\n Eac_cr = 0 # to be implemented\n arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15))\n return k_cr * arrhenius","def lqr(a, b, q, r):\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\n p = scipy.linalg.solve_continuous_are(a, b, q, r)\n\n # LQR gain\n k = np.linalg.solve(r, b.T.dot(p))\n\n return k, p","def graphite_cracking_rate_Ai2020(T_dim):\n k_cr = 3.9e-20\n Eac_cr = 0 # to be implemented\n arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15))\n return k_cr * arrhenius","def KL(p, q):\n return np.sum(p * np.log(p / q))","def aksprob(alam):\r\n if type(alam) == N.ndarray:\r\n frozen = -1 *N.ones(alam.shape,N.float64)\r\n alam = alam.astype(N.float64)\r\n arrayflag = 1\r\n else:\r\n frozen = N.array(-1.)\r\n alam = N.array(alam,N.float64)\r\n arrayflag = 1\r\n mask = N.zeros(alam.shape)\r\n fac = 2.0 *N.ones(alam.shape,N.float_)\r\n sum = N.zeros(alam.shape,N.float_)\r\n termbf = N.zeros(alam.shape,N.float_)\r\n a2 = N.array(-2.0*alam*alam,N.float64)\r\n totalelements = N.multiply.reduce(N.array(mask.shape))\r\n for j in range(1,201):\r\n if asum(mask) == totalelements:\r\n break\r\n exponents = (a2*j*j)\r\n overflowmask = N.less(exponents,-746)\r\n frozen = N.where(overflowmask,0,frozen)\r\n mask = mask+overflowmask\r\n term = fac*N.exp(exponents)\r\n sum = sum + term\r\n newmask = N.where(N.less_equal(abs(term),(0.001*termbf)) +\r\n N.less(abs(term),1.0e-8*sum), 1, 0)\r\n frozen = N.where(newmask*N.equal(mask,0), sum, frozen)\r\n mask = N.clip(mask+newmask,0,1)\r\n fac = -fac\r\n termbf = abs(term)\r\n if arrayflag:\r\n return N.where(N.equal(frozen,-1), 1.0, frozen) # 1.0 if doesn't converge\r\n else:\r\n return N.where(N.equal(frozen,-1), 1.0, frozen)[0] # 1.0 if doesn't converge\r","def kl_divergence(self) -> Tensor:\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()","def power_law_profile(n_core, nclad, q, a, x):\n delta = (n_core**2 - nclad**2) / 2 / n_core**2\n nsqr = n_core**2 * (1 - 2 * delta * (np.abs(x) / a)**q)\n if not np.isscalar(x):\n np.place(nsqr, abs(x) >= a, nclad**2)\n return np.sqrt(nsqr)","def eq510821ad1(ldb, lambda_rl, lambda_cf, lambda_rc, lambda_er, lambda_lw):\n\n ld = ldb * (lambda_rl*lambda_cf*lambda_rc*lambda_er)/lambda_lw\n\n# text = (f'ld = ldb * (lambda_rl*lambda_cf*lambda_rc*lambda_er)\\n' +\n# f'/lambda_lw\\n' +\n# f'ld = {ldb:.2f} * ({lambda_rl:.2f}*{lambda_cf:.2f}*' +\n# f'{lambda_rc:.2f}*{lambda_er:.2f})/{lambda:.2f}\\n' +\n# f'ld = {ld:.2f}')\n\n return ld, text","def runge(s1: float, s2: float, L: float, m: float):\n return (s2 - s1) / (L**m - 1)","def expected_performance(x):\n pm_pars = {'alpha': x[0], 'beta': x[1]}\n rm_pars = {'theta': x[2]}\n \n T = 100 #number of trials\n n_b = 2 #number of bandits\n rho = 0.01 #switch probability of the arm-reward contingencies\n \n n_env = 100 #number of environments\n n_blocks = 1 #number of experimental blocks\n ep = 0 # expected performance\n \n for n in range(n_env):\n #generate n_env mutli-armed bandit environmets\n env = MultiArmedBandit(T, rho = rho, n_b = n_b)\n pm = RescorlaWagner(env, n_b)\n for m in range(n_blocks):\n #in each environment repeat the experiment n_blocks times\n rm = SoftMaxResponses([], pm, d_r)\n rm.get_responses(pm_pars, rm_pars)\n #For each block compute the expected performance.\n ep += env.expected_performance()\n \n return ep/(n_env*n_blocks)","def learning_rate_range():\n # Lower and upper bounds\n #######\n lower_bound = 0.1 \n upper_bound = 1e-6\n #######\n return lower_bound, upper_bound"],"string":"[\n \"def lksprob(alam):\\r\\n fac = 2.0\\r\\n sum = 0.0\\r\\n termbf = 0.0\\r\\n a2 = -2.0*alam*alam\\r\\n for j in range(1,201):\\r\\n term = fac*math.exp(a2*j*j)\\r\\n sum = sum + term\\r\\n if math.fabs(term) <= (0.001*termbf) or math.fabs(term) < (1.0e-8*sum):\\r\\n return sum\\r\\n fac = -fac\\r\\n termbf = math.fabs(term)\\r\\n return 1.0 # Get here only if fails to converge; was 0.0!!\\r\",\n \"def eady_growth_rate(data):\\n N2 = ixr.brunt_vaisala(data)\\n f = 2.0*omega*xruf.sin(xruf.deg2rad(data.lat))\\n\\n dz = ixr.domain.calculate_dz(data)\\n du = ixr.domain.diff_pfull(data.ucomp, data)\\n\\n N = xruf.sqrt(N2.where(N2 > 0))\\n\\n egr = 0.31*du/dz*f/N\\n return np.abs(egr)\",\n \"def question_18():\\n rbf = RadialBiasFunction()\\n wins = 0.0\\n for i in range(100):\\n rbf.fit(1.5, 9)\\n rbf_error = rbf.error()\\n if rbf_error == 0:\\n wins += 1\\n rbf.resample()\\n return wins / 100\",\n \"def compute_cost(AL, Y, parameters ,lambd):\\n L = len(parameters) // 2\\n m = Y.shape[1]\\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\\n return cost\",\n \"def final_state_cost(x_tape):\\n return np.linalg.norm(deviation_from_upright_equilibrium(x_tape[:, -1]))\",\n \"def elongation_rate(R, r_AA, V=1E-15, K_D=5E-3, t=1, f_a = 1, rt_max=17.1):\\n\\n N_A = 6.022E23 # Avogadro's number\\n prefix = K_D * N_A * V + R * f_a * rt_max * t + r_AA * t\\n sqrt_a = (K_D * N_A * V)**2 + (r_AA * t)**2 + (R * f_a * rt_max * t)**2\\n sqrt_b = 2 * (K_D * N_A * R * V * f_a * rt_max* t + K_D * N_A * V * r_AA * t -\\\\\\n R * f_a * rt_max * r_AA * t**2)\\n denom = 2 * R * f_a * t\\n r_t = (prefix - np.sqrt(sqrt_a + sqrt_b)) / denom\\n return r_t\",\n \"def calc_rV(A):\\n return np.sqrt(calc_rVsq(A))\",\n \"def calc_rVsq(A):\\n G, g = A2Gmat(A)\\n rVsq = nl.det(G)\\n if rVsq < 0:\\n return 1\\n return rVsq\",\n \"def compute_lb_totalflow(self):\\r\\n lb_totalflow = np.amax(1 - np.exp(self.beta - self.b + self.phi * np.minimum(1, 1/self.l))) \\r\\n return max(0, lb_totalflow)\",\n \"def dlqr(A,B,Q,R):\\n #ref Bertsekas, p.151\\n \\n #first, try to solve the ricatti equation\\n X = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\\n \\n #compute the LQR gain\\n K = np.matrix(scipy.linalg.inv(B.T*X*B+R)*(B.T*X*A))\\n \\n eigVals, eigVecs = scipy.linalg.eig(A-B*K)\\n \\n return K, X, eigVals\",\n \"def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\\n phi = 0.0\\n\\n ## Approach A - NREL Approach\\n if approach_call == \\\"A\\\":\\n\\n phi = float(Q_load_W) / float(Q_design_W)\\n eta_max = 0.425 # from energy.gov\\n\\n if phi >= phi_threshold: # from NREL-Shape\\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\\n\\n if phi < phi_threshold:\\n if phi <= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\\n\\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3.0 + \\\\\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\\n\\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\\\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\\n\\n eta_therm_max = 0.45 # constant, after energy.gov\\n\\n if phi < phi_threshold:\\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\\n\\n else:\\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\\n\\n ## Approach B - Empiric Approach\\n if approach_call == \\\"B\\\":\\n\\n if Q_design_W > 0:\\n phi = float(Q_load_W) / float(Q_design_W)\\n\\n else:\\n phi = 0\\n\\n eta_el_max = 0.39\\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\\n\\n eta_el = eta_el_max * eta_el_score\\n eta_therm = eta_therm_max * eta_therm_score\\n\\n if phi < 0.2:\\n eta_el = 0\\n\\n return eta_el, eta_therm\",\n \"def test_avg_l(self):\\n u_spec = leabra.UnitSpec(g_bar_e=0.3, g_bar_l=0.3, g_bar_i=1.0)\\n u = leabra.Unit(spec=u_spec)\\n\\n for _ in range(20):\\n u.add_excitatory(1.0)\\n u.calculate_net_in()\\n u.cycle('minus')\\n\\n self.assertEqual(u.avg_l, 0.40)\\n u.spec.update_avg_l(u)\\n self.assertTrue(np.allclose(0.52, u.avg_l, rtol=0.1, atol=0.1))\\n #TODO: verify that 0.52 is the value of emergent\\n\\n for _ in range(100):\\n u.spec.update_avg_l(u)\\n self.assertTrue(np.allclose(1.64, u.avg_l, rtol=0.1, atol=0.1))\\n #TODO: verify that 1.64 is the value of emergent\",\n \"def length_vs_rate_2(Lmax=200, Lmin=102.4, p=75, fmax=1e12, p1=database['K+'],\\r\\n p2=database['pi+'], p3=database['p+'], E=1e6, n=20,\\r\\n ng=50, nl=50, nf=100, delta_p=1.6e-2, just_pi=False,\\r\\n set_freq=5.7e9, count=True):\\r\\n if set_freq == None:\\r\\n print('Estimated time: {0}'.format(timing(n*ng*nl*nf*3.84e-05)))\\r\\n else:\\r\\n print('Estimated time: {0}'.format(timing(n*ng*nl*3.84e-05)))\\r\\n i = 0\\r\\n while i < 1e7:\\r\\n i += 1\\r\\n start = time.time()\\r\\n L_range = np.linspace(Lmin, Lmax, n)\\r\\n opt_gap, opt_freq, opt_cav, opt_disp, rate = [], [], [], [], []\\r\\n for L in L_range:\\r\\n if count == True:\\r\\n print(f'L={L}')\\r\\n opt = cavity_gap_comp(L_t=L-22.8, p=p, fmax=fmax, p1=p1, p2=p2, p3=p3,\\r\\n E=E, plot=False, delta_p=delta_p, n=ng, nf=nf,\\r\\n nl=nl, just_pi=just_pi, set_freq=set_freq,\\r\\n count=count)\\r\\n opt_freq.append(opt[0])\\r\\n opt_gap.append(opt[1])\\r\\n opt_cav.append(opt[2])\\r\\n opt_disp.append(opt[3])\\r\\n rate.append(decay_rate(L, p1, p)*1e-6)\\r\\n opt_freq, opt_disp, rate = np.array(opt_freq), np.array(opt_disp), np.array(rate)\\r\\n# ratio = (opt_disp*rate)/(opt_freq*L)\\r\\n# ratio *= (np.max(opt_freq)-np.min(opt_freq))/(np.max(ratio)-np.min(ratio))\\r\\n# ratio += ((np.min(opt_freq))-np.min(ratio))\\r\\n fig = plt.figure(figsize=[14, 4])\\r\\n host = fig.add_subplot(1, 1, 1)\\r\\n fig.subplots_adjust(right=0.75)\\r\\n par1 = host.twinx()\\r\\n# par2 = host.twinx()\\r\\n# par2.spines['right'].set_position(('axes', 1.2))\\r\\n# make_patch_spines_invisible(par2)\\r\\n# par2.spines['right'].set_visible(True) \\r\\n p1, = host.plot(L_range, rate, 'r', alpha=0.8, lw=2, label='decay rate in decay region')\\r\\n p2, = par1.plot(L_range, opt_disp, 'b', alpha=0.8, lw=2, label='min disp')\\r\\n# p3, = par2.plot(L_range, opt_freq, 'b', alpha=0.8, lw=2, label='frequency')\\r\\n# p4, = par2.plot(L_range, ratio, 'g', alpha=0.8, lw=2, label='ratio')\\r\\n host.set_xlim(Lmin, Lmax)\\r\\n host.set_xlabel('Distance between Target and Decay Region / m', fontsize=15)\\r\\n host.set_ylabel('Decay Rate in Decay Region / MHz', fontsize=15)\\r\\n par1.set_ylabel('Minimum Displacement / mm', fontsize=15)\\r\\n# par2.set_ylabel('Frequency / Hz', fontsize=15)\\r\\n host.yaxis.label.set_color(p1.get_color())\\r\\n par1.yaxis.label.set_color(p2.get_color())\\r\\n# par2.yaxis.label.set_color(p3.get_color())\\r\\n host.tick_params(axis='y', colors=p1.get_color())\\r\\n par1.tick_params(axis='y', colors=p2.get_color())\\r\\n# par2.tick_params(axis='y', colors=p3.get_color())\\r\\n# lines = [p1, p2, p3, p4]\\r\\n# lines = [p1, p2]\\r\\n# host.legend(lines, [l.get_label() for l in lines], loc=[0.45, 0.8], fontsize=20)\\r\\n host.minorticks_on()\\r\\n par1.minorticks_on()\\r\\n host.set_ylim(0)\\r\\n par1.set_ylim(0)\\r\\n host.grid()\\r\\n host_yticks = np.arange(0, int(np.max(rate))+2, 1)\\r\\n par1_yticks = np.arange(0, (int(np.max(opt_disp)/100)+1)*100, 100)\\r\\n host.set_yticks(host_yticks)\\r\\n host.set_yticklabels(host_yticks)\\r\\n par1.set_yticks(par1_yticks)\\r\\n par1.set_yticklabels(par1_yticks)\\r\\n host.set_title(r'Unwanted particle displacement and observed $K^+$'+' decay rate\\\\nas a function of target distance', fontsize=15)\\r\\n plt.show()\\r\\n fig.savefig('Length_vs_Rate_75.pdf', bbox_inches='tight')\\r\\n index = np.argmax(opt_disp)\\r\\n# index = np.argmax(ratio)\\r\\n print(f'{timing(time.time()-start)}')\\r\\n return [opt_disp[index], L_range[index], opt_gap[index], opt_cav[index], opt_freq[index], rate[index]]\",\n \"def get_duct_linear_heat_loss_coefficient() -> float:\\n return 0.49\",\n \"def cronbach_alpha(self) -> float:\\n itemscores = np.stack([self.true, self.predicted])\\n itemvars = itemscores.var(axis=1, ddof=1)\\n tscores = itemscores.sum(axis=0)\\n nitems = len(itemscores)\\n return float(nitems / (nitems - 1.) * (1 - itemvars.sum() / tscores.var(ddof=1)))\",\n \"def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\\n m_over_N = float(m)/N \\n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \\n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)\",\n \"def __bestLambda(self):\\n\\t\\t\\n\\t\\t# Determine starting value for brent-method (to avoid local minimum).\\n\\t\\tself.startValue = self.__findStartValue()\\n\\t\\t\\t\\n\\t\\t# Check if there exists a minimum within the range of self.lamStart. \\n\\t\\t# Otherwise, use fmin because we cannot provide an interval. \\n\\t\\tif (self.startIdx != 0 and self.startIdx != self.nStartValues-1):\\n\\t\\t\\ts = scipy.optimize.brent(self.__minBayesianEvidence, brack=(self.logLamStart[self.startIdx-1], self.logLamStart[self.startIdx], self.logLamStart[self.startIdx+1]))\\n\\t\\telse:\\n\\t\\t\\ts = scipy.optimize.fmin(self.__minBayesianEvidence, self.startValue, disp=False)[0]\\n\\t\\t\\n\\t\\treturn 10**s\",\n \"def test_GBL_tau_star():\\n z = 1.0\\n\\n # Fully ionized H and He\\n x_ionH = 1.0\\n x_ionHe = 2.0\\n\\n cosmo = {}\\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\\n cosmo['h'] = 0.65\\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\\n cosmo['Y_He'] = 0.24\\n cd.set_omega_k_0(cosmo)\\n\\n tau_inst, tau_star = cr.optical_depth_instant(z, \\n x_ionH=x_ionH, \\n x_ionHe=x_ionHe, \\n return_tau_star=True,\\n **cosmo)\\n print(\\\"tau_star = %.7f\\\" % (tau_star))\\n print(\\\"tau_star/(h Omega_b) = %.7f =? 0.061\\\" % \\n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\\n\\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\\n 0.061,\\n 2)\\n\\n print(\\\"(1 - Y_He/2) = %.3f =? 0.88\\\" % (1. - (cosmo['Y_He']/2.)))\\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\\n 0.88,\\n 7)\\n\\n H_0 = cc.H100_s * cosmo['h']\\n\\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \\n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \\n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\\n cc.sigma_T_Mpc) / \\n (8. * math.pi * cc.G_const_Mpc_Msun_s * \\n (cc.m_p_g/cc.M_sun_g))))\\n\\n print(\\\"tau_star_explicit = %.7f =? tau_star\\\" % (tau_star_explicit))\\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)\",\n \"def mbrae(self, benchmark: np.ndarray = None) -> float:\\n return float(np.mean(self._bounded_relative_error(benchmark)))\",\n \"def bPlusbStar(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == 1:\\n ayxx = 0\\n for j in range(self.prob.num):\\n ayxx += self.alphas[j] * self.prob.Y[j] * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\\n abcxx = 0\\n for j in range(self.prob.num):\\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\\n abcxx *= (1 / self.prob.gamma)\\n running_total += 1 - abcxx - ayxx\\n return running_total\",\n \"def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\\n\\n # number of periods in samples\\n T = df_train.shape[0]\\n T_test = df_test.shape[0]\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # outcomes\\n outcomes = df_train.iloc[:, 0].values\\n\\n # initialize matrices containing all predictions and bets\\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n\\n # budget initialization\\n budgets = np.full(K, 1, dtype=float)\\n\\n # training the market\\n for i in range(T):\\n\\n # first round betting\\n pred_mat[0, :] = F[i, :]\\n bet_mat[0, :] = budgets * MaxRPT_r1\\n budgets = budgets * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F[i, :]\\n bet_mat[j, :] = budgets * MaxRPT\\n budgets = budgets * (1-MaxRPT)\\n\\n # use IQR to determine outlier error threshold\\n abs_errors = np.abs(outcomes[i] - pred_mat)\\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\\n IQR = Q3 - Q1\\n oet = Q3 + (IQR*1.5)\\n\\n # reward the agents based on accuracy of their predictions\\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\\n score = np.log(accuracy)\\n revenue = np.multiply(score, bet_mat)\\n budgets = budgets + np.sum(revenue, axis=0)\\n\\n # rescaling the budget (only for computational reasons)\\n budgets = budgets/np.sum(budgets)\\n\\n # using the market for the out-of-sample predictions\\n pred = np.full(T_test, np.nan, dtype=float)\\n for i in range(T_test):\\n\\n # reset test budget\\n budgets_test = np.copy(budgets)\\n\\n # first round betting\\n pred_mat[0, :] = F_test[i, :]\\n bet_mat[0, :] = budgets_test * MaxRPT_r1\\n budgets_test = budgets_test * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F_test[i, :]\\n bet_mat[j, :] = budgets_test * MaxRPT\\n budgets_test = budgets_test * (1-MaxRPT)\\n\\n # final round market prediction is the c-APM prediction\\n pred[i] = np.dot(\\n pred_mat[no_rounds-1, :],\\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"c-APM (Constant)\\\": pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def _compute_kl(self, lvl):\\n kl = [] # kernal length\\n for n in range(lvl):\\n fct = self.scaling**n # up-sampling factor\\n kl.append(fct*(self.nfreq-1)+1)\\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\\n return kl[::-1]\",\n \"def learning_rate_fn(global_step):\\n lr = tf.train.piecewise_constant(\\n global_step, boundaries, vals)\\n if warmup:\\n warmup_steps = int(batches_per_epoch * 5)\\n warmup_lr = (\\n initial_learning_rate * tf.cast(global_step, tf.float32) / tf.cast(\\n warmup_steps, tf.float32))\\n return tf.cond(pred=global_step < warmup_steps,\\n true_fn=lambda: warmup_lr,\\n false_fn=lambda: lr)\\n return lr # , initial_learning_rate, batches_per_epoch, vals\",\n \"def apx_ratio_eval():\\n print 'starting random eval'\\n\\n n_pl = randint(2, MAX_PL)\\n n_target = randint(n_pl + 1, MAX_TARGETS)\\n\\n target_values = []\\n for t in range(0,n_target):\\n target_values.append(random())\\n target_values = np.array(target_values)\\n\\n attacker_strategy = get_random_attacker_strategy(n_target)\\n\\n #I = get_random_covering_routes(n_pl, n_target)\\n I = get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values)\\n\\n start_opt = time()\\n br_opt = ilp.generate_row(I, attacker_strategy, target_values)\\n opt_time = time() - start_opt\\n\\n start_apx = time()\\n br_apx = greedy.generate_row(I, attacker_strategy, target_values)\\n apx_time = time() - start_apx\\n\\n print 'opt time: ', opt_time, 'apx time: ', apx_time\\n\\n apx_val = get_value(br_apx, I, target_values, attacker_strategy)\\n opt_val = get_value(br_opt, I, target_values, attacker_strategy)\\n\\n logging.info('ratio = %f - target = %d - pl = %f - max_r = %d - max_cov_t = %d',apx_val/opt_val, n_target, n_pl, MAX_ROUTES, MAX_ROUTE_LEN)\\n\\n return apx_val/opt_val, opt_time, apx_time\",\n \"def calculate_initial_lr(cfg: OmegaConf) -> float:\\n if cfg[\\\"parameter\\\"][\\\"linear_schedule\\\"]:\\n scaled_lr = cfg[\\\"experiment\\\"][\\\"lr\\\"] * cfg[\\\"experiment\\\"][\\\"batches\\\"] / 256.\\n else:\\n scaled_lr = cfg[\\\"experiment\\\"][\\\"lr\\\"] * np.sqrt(cfg[\\\"experiment\\\"][\\\"batches\\\"])\\n return scaled_lr\",\n \"def lr_lambda(epoch):\\n return 1 - min(epoch * T, flags.total_steps) / flags.total_steps #epoch * T * B if using B steps\",\n \"def lapse(self):\\n pass\",\n \"def extinction_efficiency(self):\\r\\n n = np.arange(1, self.n + 1)\\r\\n return 2*np.sum((2*n+1)*np.real(self.a + self.b))/self.x**2\",\n \"def eulerBuckle(dim):\\n bst = dim[0]\\n tst = dim[1]\\n tsk = dim[2]\\n\\n ZEAZ = (Est*bst*tst*((tsk/2)+(bst/2)))\\n ZEA = (Est*bst*tst)+(Esk*tsk*bsk)\\n zbar = ZEAZ/ZEA # Neutral Axis\\n\\n EIbar = ((Esk*bsk*(tsk**3))/12)+(Esk*bsk*tsk*(zbar**2))+((Est*tst*bst**3)/12)+\\\\\\n (Est*bst*tst*(((bst/2)+(tsk/2)-zbar)**2)) # Using Parallel Axis Theorm\\n NxEuler = ((math.pi**2)*EIbar)/(ribSpace**2*bsk) # Critical Load\\n rsf = NxEuler/Nx\\n return rsf - 1.1 # Using a target Reserve Factor of >=1.1\",\n \"def calc_q_gain(Tfl, Tabs, q_rad_Whperm2, DT, Tin, Tout, aperture_area_m2, c1, c2, Mfl, delts, Cp_waterglycol, C_eff, Te):\\n\\n xgain = 1\\n xgainmax = 100\\n exit = False\\n while exit == False:\\n qgain_Whperm2 = q_rad_Whperm2 - c1 * (DT[1]) - c2 * abs(DT[1]) * DT[1] # heat production from solar collector, eq.(5)\\n\\n if Mfl > 0:\\n Tout = ((Mfl * Cp_waterglycol * Tin) / aperture_area_m2 - (C_eff * Tin) / (2 * delts) + qgain_Whperm2 + (\\n C_eff * Tfl[1]) / delts) / (Mfl * Cp_waterglycol / aperture_area_m2 + C_eff / (2 * delts)) # eq.(6)\\n Tfl[2] = (Tin + Tout) / 2\\n DT[2] = Tfl[2] - Te\\n qdiff = Mfl / aperture_area_m2 * Cp_waterglycol * 2 * (DT[2] - DT[1])\\n else:\\n Tout = Tfl[1] + (qgain_Whperm2 * delts) / C_eff # eq.(8)\\n Tfl[2] = Tout\\n DT[2] = Tfl[2] - Te\\n qdiff = 5 * (DT[2] - DT[1])\\n\\n if abs(qdiff < 0.1):\\n DT[1] = DT[2]\\n exit = True\\n else:\\n if xgain > 40:\\n DT[1] = (DT[1] + DT[2]) / 2\\n if xgain == xgainmax:\\n exit = True\\n else:\\n DT[1] = DT[2]\\n xgain += 1\\n\\n # FIXME: redundant...\\n # qout = Mfl * Cp_waterglycol * (Tout - Tin) / aperture_area\\n # qmtherm = (Tfl[2] - Tfl[1]) * C_eff / delts\\n # qbal = qgain - qout - qmtherm\\n # if abs(qbal) > 1:\\n # qbal = qbal\\n return qgain_Whperm2\",\n \"def lam(freq):\\n return C / freq\",\n \"def compute_cost(self, r):\\n self.r_max = 1\\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0\",\n \"def golden_ratio(fun, a, b, E):\\n K = (1 + sqrt(5)) / 2\\n lam = b - (b - a) / K\\n mu = a + (b - a) / K\\n y1 = fun(lam)\\n y2 = fun(mu)\\n counter = 2\\n n = 0\\n while fabs(b - a) > E:\\n if y1 > y2:\\n a = lam\\n lam = mu\\n y1 = y2\\n mu = a + (b - a) / K\\n y2 = fun(mu)\\n counter += 1\\n else:\\n b = mu\\n mu = lam\\n y2 = y1\\n lam = b - (b - a) / K\\n y1 = fun(lam)\\n counter += 1\\n n += 1\\n return (b + a) / 2, counter\",\n \"def grubbs(timeseries):\\r\\n\\r\\n series = scipy.array([x[1] for x in timeseries])\\r\\n stdDev = scipy.std(series)\\r\\n mean = np.mean(series)\\r\\n tail_average = tail_avg(timeseries)\\r\\n z_score = (tail_average - mean) / stdDev\\r\\n len_series = len(series)\\r\\n threshold = scipy.stats.t.isf(.05 / (2 * len_series) , len_series - 2)\\r\\n threshold_squared = threshold * threshold\\r\\n grubbs_score = ((len_series - 1) / np.sqrt(len_series)) * np.sqrt(threshold_squared / (len_series - 2 + threshold_squared))\\r\\n\\r\\n return z_score > grubbs_score\",\n \"def GoodmanKruskalLambdaR_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n part1 = 0.5 * (max(TP + FP, FN + TN) + max(TP + FN, FP + TN))\\n return (TP + TN - part1) / (n - part1)\\n except Exception:\\n return \\\"None\\\"\",\n \"def compute_Rg(L):\\n\\treturn np.sqrt(np.dot(L,L))\",\n \"def evap(self, lai, tl, ta, qa):#average ta and tl!!\\n\\t fsev = max(self.TAI*self.GA*1000.*RHO_A/RHO_W*((.622*esat((tl+ta)/2)/P_ATM)-qa), 0.)\\n\\t\\t#if the amount of water in tank is less than amount that will evaporate in timestep dt, then what's left will evaporate \\n\\t if self.tx*self.ZT*self.TAI*10**6 <= 0:\\n\\t return 0.\\n\\t elif self.tx*self.ZT*self.TAI*10**6 <= fsev*dt:\\n\\t return (self.tx*self.ZT*self.TAI*10**6/dt)\\n\\t else:\\n\\t return fsev\",\n \"def question_13(gamma):\\n rbf = RadialBiasFunction()\\n fails = 0.0\\n my_svm = svm.SVC(C=np.inf, kernel='rbf', gamma=gamma)\\n for i in range(1000):\\n my_svm = my_svm.fit(rbf.X, rbf.Y)\\n if my_svm.score(rbf.X, rbf.Y) != 1:\\n fails += 1\\n rbf.resample()\\n return fails / 1000\",\n \"def mb_r(self) -> float:\\n # Calculate metric\\n n = self.predicted.size\\n tot = 0.0\\n for i in range(n):\\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\\n mb = 1 - ((n ** 2) * mae_val / tot)\\n\\n return float(mb)\",\n \"def hbl_rate_limit(self):\\n tstar =4E4 \\n [Ly,N] = self.b.shape\\n print 'HBL RATE LIMITER CALLED....'\\n\\tprint 'tstar = ' + str(tstar) + ' seconds'\\n\\tfor j in range(Ly):\\n dh_s = self.hbls[j] - self.hbls_old[j]\\n\\t if abs(dh_s) >= self.dt / tstar * self.hbls_old[j]:\\n\\t #print ' SBL RATE LIMIT BEING APPLIED at j = ' + str(j) \\n #print ' dh_s = ' + str(dh_s) + 'm'\\n\\t dhm_s = self.dt / tstar * self.hbls_old[j]\\n\\t self.hbls[j] = self.hbls_old[j] + dhm_s*dh_s/abs(dh_s)\\n\\t if self.LMD_BKPP:\\n\\t dh_b = self.hbbl[j] - self.hbbl_old[j]\\n if abs(dh_b) >= self.dt / tstar * self.hbbl_old[j]:\\n dhm_b = self.dt / tstar * self.hbbl_old[j]\\n\\t self.hbbl[j] = self.hbbl_old[j] + dhm_b*dh_b/abs(dh_b)\",\n \"def validation_cost(model, X_vala, L_vala, Y_vala):\\n vala_costs = []\\n for i in range(0,8-1+1):\\n X_v, L_v, Y_v = X_vala[i], L_vala[i], Y_vala[i]\\n c_v_s = model.get_cost(X_v,L_v,Y_v)\\n vala_costs.append(c_v_s)\\n return np.mean(vala_costs)\",\n \"def overall_reduction(self):\\n return 84\",\n \"def GuttmanLambdaA_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n part1 = max(TP, FN) + max(FP, TN)\\n part2 = max(TP + FP, FN + TN)\\n return (part1 - part2) / (n - part2)\\n except Exception:\\n return \\\"None\\\"\",\n \"def maclaurin_ln(value,k):\\n \\n global first_value \\n first_value = 0.0\\n \\n #attempt to Approximate ln(1+x) for a given value\\n try:\\n \\n error(value)\\n for item in xrange(1,k,2):\\n next_value =(value**item)/float(item)\\n first_value += next_value\\n \\n for item in xrange(2,k,2):\\n next_value = -1*(value**item)/float(item)\\n first_value += next_value\\n \\n return first_value\\n\\n #Raise TypeError if input is not within\\n #the interval of convergence\\n except TypeError,exception:\\n print exception\",\n \"def penalty_calc(self):\\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\\n\\n # fiber attenuation,\\n self.p_atten = self.alpha*self.length # column B\\n\\n # calculate bandwidth for RIN test (exclude transmitter)\\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\\n rin_bw = 1.0 / rin_inverse_bw\\n\\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\\n k_rin = 0.7\\n\\n # v_rin,\\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\\n math.pow(10.0,0.1*self.rin)) # column AK\\n\\n # Prin,\\n print('v_rin: ', self.v_rin)\\n print('Q: ',self.Q)\\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\\n print(\\\"P_rin : \\\", self.p_rin)\\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\\n print(\\\"isi_center : \\\", self.isi_center)\\n\\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\\n\\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\\n\\n\\n # calculate the \\\"cross\\\" penalty contribution, column S\\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\\n self.p_cross_center = ( # column S\\n arg3\\n - self.p_blw # cell T13\\n - self.p_isi_center # column J\\n - self.p_isi_dj_center # column L\\n - self.p_mpn # column Q\\n - self.p_reflection # column N\\n - self.p_rin # column R\\n - self.pmn*self.l_1) # cell G13\\n print('p_isi_center: ', self.p_isi_center)\\n\\n # calculate the total power budget evaluated at the center of the eye\\n self.p_total_center = ( # column T\\n self.p_isi_center # column J\\n + self.p_isi_dj_center # column L\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1) # cell G13\\n # calculate the total power budget evaluated at the corner of the eye\\n self.p_total_corners = (\\n self.p_isi_center # column J\\n + self.p_isi_corners # column K\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1 # cell G13\\n + self.p_isi_dj_corners)# column M\\n\\n # receiver stressed sensitivity\\n self.margin = ( self.p_budget\\n - self.p_total_center) # column W\\n\\n self.rx_stressed_sensitivity = (\\n self.tx_oma_min*self.l_1\\n - self.chil\\n - self.p_mpn\\n - self.p_reflection\\n - self.p_rin\\n - 0.5*self.p_cross_center\\n - self.pmn*self.l_1\\n - self.margin[self.lnum//2]*self.l_1)\\n\\n\\n # end of GbE10.penalty_calc\\n #======================================================================+\",\n \"def estimate_arpu(x):\\n arpu = 0\\n if x['mean_luminosity_km2'] > 5:\\n # #10 year time horizon\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (20*12) / (1 + 0.03) ** i\\n # )\\n return 20 * 12 * 10#arpu\\n elif x['mean_luminosity_km2'] > 1:\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (5*12) / (1 + 0.03) ** i\\n # )\\n return 5 * 12 * 10#arpu\\n else:\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (2*12) / (1 + 0.03) ** i\\n # )\\n return 2 * 12 * 10#arpu\",\n \"def LangmuirCurve(x, B,a,N,K):\\n return B+np.square(a*(((x+N+(55.5/K))-np.sqrt(np.square(x+N+(55.5/K))-(4*x*N)))/(2*N)));\",\n \"def recommend_L(self):\\n\\n min_eigenvalue = torch.min(torch.linalg.eigvalsh(self.Wc))\\n lamBda = 1 / (1 + 4*torch.abs(min_eigenvalue - self.vars['q_init']))\\n return lamBda\",\n \"def compute_cost(AL, Y):\\n m = Y.shape[1]\\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\\n cost = np.sum(log_val) * (-1/m)\\n cost = np.squeeze(cost)\\n return cost\",\n \"def _lr_schedule(self, epoch: int):\\n penultimate_activ_func = K.function([self.model.layers[0].input], [self.model.layers[-2].output])\\n\\n Kz = 0.\\n for i in range((len(self.x_train) - 1) // self.bs + 1):\\n start_i = i * self.bs\\n end_i = start_i + self.bs\\n xb = self.x_train[start_i:end_i]\\n\\n activ = np.linalg.norm(penultimate_activ_func([xb]))\\n if activ > Kz:\\n Kz = activ\\n\\n K_ = ((self.n_classes - 1) * Kz) / (self.n_classes * self.bs)\\n lr = 1 / K_\\n\\n self.lr_history.append(lr)\\n return lr\",\n \"def ComputeRegenerativeBraking(self):\\r\\n pass\",\n \"def calc_reconstruction_error(self):\\n logger.debug('Calculating reconstruction error')\\n tic = time.time()\\n Esig_w_tau = self.Esig_w_tau\\n I_rec_w_tau = np.real(Esig_w_tau * np.conj(Esig_w_tau))\\n I_w_tau = self.I_w_tau\\n mx = I_w_tau.max()\\n my = (I_w_tau * I_rec_w_tau).sum() / (I_rec_w_tau**2).sum()\\n logger.debug(''.join(('My=', str(my))))\\n # my = 1.0\\n G = np.sqrt(((I_w_tau - my * I_rec_w_tau) ** 2).sum() / (I_rec_w_tau.shape[0] * I_rec_w_tau.shape[1])) / mx\\n toc = time.time()\\n logger.debug(''.join(('Time spent: ', str(toc - tic))))\\n self.G_hist.append(G)\\n return G\",\n \"def _compute_rdp(q: float, sigma: float, alpha: float) -> float:\\n if q == 0:\\n return 0\\n\\n # no privacy\\n if sigma == 0:\\n return np.inf\\n\\n if q == 1.0:\\n return alpha / (2 * sigma ** 2)\\n\\n if np.isinf(alpha):\\n return np.inf\\n\\n return _compute_log_a(q, sigma, alpha) / (alpha - 1)\",\n \"def get_RMSLE(pred, truth):\\n assert len(pred) == len(truth)\\n diff_vect = np.log(pred + 1) - np.log(truth + 1)\\n diff_sum = np.sum(np.power(diff_vect, 2))\\n return np.sqrt(diff_sum / len(pred))\",\n \"def mamajek08_logRpHK_max():\\n return -3.8918287373004357\",\n \"def gmrae(self, benchmark: np.ndarray = None) -> float:\\n return _geometric_mean(np.abs(self._relative_error(benchmark)))\",\n \"def KL(P,Q):\\n epsilon = 0.00001\\n \\n #You may want to instead make copies to avoid changing the np arrays.\\n P = P+epsilon\\n Q = Q+epsilon\\n \\n divergence = np.sum(P*np.log(P/Q))\\n return divergence\",\n \"def ensemble_cost(x_tapes):\\n per_trajectory_costs = [final_state_cost(x_tape) for x_tape in x_tapes]\\n # Return the L1-norm of the per-trajectory-costs, scaled by the number of\\n # trajectories.\\n return np.linalg.norm(per_trajectory_costs, 1) / len(x_tapes)\",\n \"def acc_rate(L_acc, R, M):\\n mdot = 1.25*L_acc*u.W*R*u.R_sun/(G*M*u.M_sun)\\n mdot = mdot.decompose().to(u.M_sun/u.yr)\\n return(mdot/(u.M_sun/u.yr))\",\n \"def gaver_stehfest(time, lap_func):\\n def nCr(n, r):\\n return math.factorial(n)/(math.factorial(r)*\\n math.factorial(n-r))\\n def a(k, n):\\n summation = 0.\\n for j in range((k+1)/2, min(k, n)+1):\\n current_summation = float(pow(j, n+1))/float(math.factorial(n))\\n current_summation *= nCr(n, j)\\n current_summation *= nCr(2*j, j)\\n current_summation *= nCr(j, k-j)\\n summation += current_summation\\n return summation*pow(-1, n+k)\\n n = 7\\n total_sum = a(1, n)*lap_func(1.*np.log(2.)/time)\\n for k in range(2, 2*n+1):\\n total_sum += a(k, n)*lap_func(k*np.log(2.)/time)\\n return total_sum*np.log(2.)/time\",\n \"def lr_lambda_fun(current_iteration: int) -> float:\\n current_epoch = float(current_iteration) / self.iterations\\n if current_epoch <= self.hparams.warmup_epochs:\\n alpha = current_epoch / float(self.hparams.warmup_epochs)\\n return self.hparams.warmup_factor * (1.0 - alpha) + alpha\\n else:\\n return_val = 1.0\\n if current_epoch >= self.hparams.lr_milestones[0] and current_epoch < self.hparams.lr_milestones2[0]:\\n idx = bisect(self.hparams.lr_milestones, current_epoch)\\n return_val = pow(self.hparams.lr_gamma, idx)\\n elif current_epoch >= self.hparams.lr_milestones2[0]:\\n idx = bisect(self.hparams.lr_milestones2, current_epoch)\\n return_val = self.hparams.lr_gamma * pow(self.hparams.lr_gamma2, idx)\\n return return_val\",\n \"def compute_cost(n: int,\\n lam: float,\\n dE: float,\\n L: int,\\n Lxi: int,\\n chi: int,\\n beta: int,\\n stps: int,\\n verbose: bool = False) -> Tuple[int, int, int]:\\n\\n # The number of bits used for the second register.\\n nxi = np.ceil(np.log2(n // 2))\\n\\n # The number of bits for the contiguous register.\\n nLxi = np.ceil(np.log2(Lxi + n // 2))\\n\\n # The number of bits used for the first register.\\n nL = np.ceil(np.log2(L + 1))\\n\\n # The power of 2 that is a factor of L + 1\\n eta = power_two(L + 1)\\n\\n oh = [0] * 20\\n for p in range(20):\\n # JJG note: arccos arg may be > 1\\n v = np.round(np.power(2,p+1) / (2 * np.pi) * arccos(np.power(2,nL) /\\\\\\n np.sqrt((L + 1)/2**eta)/2))\\n oh[p] = np.real(stps * (1 / (np.sin(3 * arcsin(np.cos(v * 2 * np.pi / \\\\\\n np.power(2,p+1)) * \\\\\\n np.sqrt((L + 1)/2**eta) / np.power(2,nL)))**2) - 1) + 4 * (p + 1))\\n\\n # Bits of precision for rotation\\n br = int(np.argmin(oh) + 1)\\n\\n # The following costs are from the list starting on page 50.\\n\\n # The cost for preparing an equal superposition for preparing the first\\n # register in step 1 (a). We double this cost to account for the inverse.\\n cost1a = 2 * (3 * nL + 2 * br - 3 * eta - 9)\\n\\n # The output size for the QROM for the first state preparation in Eq. (C27)\\n bp1 = nL + chi\\n\\n # The cost of the QROM for the first state preparation in step 1 (b) and\\n # its inverse.\\n cost1b = QR(L + 1, bp1)[1] + QI(L + 1)[1]\\n\\n # The cost for the inequality test, controlled swap and their inverse in\\n # steps 1 (c) and (d)\\n cost1cd = 2 * (chi + nL)\\n\\n # The total cost for preparing the first register in step 1.\\n cost1 = cost1a + cost1b + cost1cd\\n\\n # The output size for the QROM for the data to prepare the equal\\n # superposition on the second register, as given in Eq. (C29).\\n bo = nxi + nLxi + br + 1\\n\\n # This is step 2. This is the cost of outputting the data to prepare the\\n # equal superposition on the second register. We will assume it is not\\n # uncomputed, because we want to keep the offset for applying the QROM for\\n # outputting the rotations.\\n cost2 = QR(L + 1, bo)[1] + QI(L + 1)[1]\\n\\n # The number of bits for rotating the ancilla for the second preparation.\\n # We are just entering this manually because it is a typical value.\\n br = 7\\n\\n # The cost of preparing an equal superposition over the second register in\\n # a controlled way. We pay this cost 4 times.\\n cost3a = 4 * (7 * nxi + 2 * br - 6)\\n\\n # The cost of the offset to apply the QROM for state preparation on the\\n # second register.\\n cost3b = 4 * (nLxi - 1)\\n\\n bp2 = nxi + chi + 2\\n\\n # The cost of the QROMs and inverse QROMs for the state preparation, where\\n # in the first one we need + n/2 to account for the one-electron terms.\\n cost3c = QR(Lxi + n // 2, bp2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, bp2)[1] + QI(Lxi)[1]\\n\\n # The inequality test and state preparations.\\n cost3d = 4 * (nxi + chi)\\n\\n # The total costs for state preparations on register 2.\\n cost3 = cost3a + cost3b + cost3c + cost3d\\n\\n # The cost of adding offsets in steps 4 (a) and (h).\\n cost4ah = 4 * (nLxi - 1)\\n\\n # The costs of the QROMs and their inverses in steps 4 (b) and (g).\\n cost4bg = QR(Lxi + n // 2, n * beta // 2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, n * beta // 2)[1] + QI(Lxi)[1]\\n\\n # The cost of the controlled swaps based on the spin qubit in steps 4c and f\\n cost4cf = 2 * n\\n\\n # The controlled rotations in steps 4 (d) and (f).\\n cost4df = 4 * n * (beta - 2)\\n\\n # The controlled Z operations in the middle for step 4 (e).\\n cost4e = 3\\n\\n # This is the cost of the controlled rotations for step 4.\\n cost4 = cost4ah + cost4bg + cost4cf + cost4df + cost4e\\n\\n # This is the cost of the reflection on the second register from step 6.\\n cost6 = nxi + chi + 2\\n\\n # The cost of the final reflection req'd to construct the step of the\\n # quantum walk from step 9.\\n cost9 = nL + nxi + chi + 1\\n\\n # The extra two qubits for unary iteration and making the rflxn controlled.\\n cost10 = 2\\n\\n # The Toffoli cost for a single step\\n cost = cost1 + cost2 + cost3 + cost4 + cost6 + cost9 + cost10\\n\\n # The number of steps needed\\n iters = np.ceil(np.pi * lam / (2 * dE))\\n\\n # Now the number of qubits from the list on page 54.\\n\\n k1 = np.power(2, QR(Lxi + n // 2, n * beta // 2)[0])\\n\\n # The control register for phase estimation and iteration on it.\\n ac1 = np.ceil(np.log2(iters + 1)) * 2 - 1\\n\\n # The system qubits\\n ac2 = n\\n\\n # The first register prepared, a rotated qubit and a flag qubit.\\n ac3 = nL + 2\\n\\n # The output of the QROM, the equal superposition state and a flag qubit.\\n ac4 = nL + chi * 2 + 1\\n\\n # The data used for preparing the equal superposition state on the 2nd reg\\n ac5 = bo\\n\\n # The second register, a rotated qubit and a flag qubit.\\n ac6 = nxi + 2\\n\\n # The second preparation QROM output.\\n ac8 = bp2\\n\\n # The equal superposition state and the result of the inequality test.\\n ac9 = chi + 1\\n\\n # The angles for rotations.\\n ac10 = k1 * n * beta // 2\\n\\n # The phase gradient state.\\n ac11 = beta\\n\\n # A control qubit for the spin.\\n ac12 = 1\\n\\n # A T state.\\n ac13 = 1\\n\\n if verbose:\\n print(\\\"[*] Top of routine\\\")\\n print(\\\" [+] nxi = \\\", nxi)\\n print(\\\" [+] nLxi = \\\", nLxi)\\n print(\\\" [+] nL = \\\", nL)\\n print(\\\" [+] eta = \\\", eta)\\n print(\\\" [+] cost3 = \\\", cost3)\\n print(\\\" [+] cost4 = \\\", cost4)\\n print(\\\" [+] cost = \\\", cost)\\n print(\\\" [+] iters = \\\", iters)\\n\\n ancilla_cost = ac1 + ac2 + ac3 + ac4 + ac5 + ac6 + ac8 + ac9 + ac10 + ac11\\\\\\n + ac12 + ac13\\n\\n # Sanity checks before returning as int\\n assert cost.is_integer()\\n assert iters.is_integer()\\n assert ancilla_cost.is_integer()\\n\\n step_cost = int(cost)\\n total_cost = int(cost * iters)\\n ancilla_cost = int(ancilla_cost)\\n\\n return step_cost, total_cost, ancilla_cost\",\n \"def regularized_bayes_risk(m_true, alpha, alpha0, m_probs, global_step, annealing_step=1000, max_lambda=1.0):\\n\\n risk = bayes_risk(m_true, alpha, alpha0, m_probs)\\n kl = kullback_leibler_dirichlet(m_true, alpha)\\n lamb = tf.cast(tf.minimum(max_lambda, global_step / annealing_step), dtype=tf.float32)\\n loss = risk + lamb * kl\\n return loss\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def bMinusbStar(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == -1:\\n ayxx = 0\\n for j in range(self.prob.num):\\n ayxx += self.alphas[j] * self.prob.Y[j] * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\\n abcxx = 0\\n for j in range(self.prob.num):\\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[i], self.prob.X[j])\\n abcxx *= (1 / self.prob.gamma)\\n running_total += -1 + abcxx - ayxx\\n return running_total\",\n \"def growthrate(cur, pre, y):\\n return (cur-pre)/y\",\n \"def hr_game(t0, tf, n, A, B, R, x0):\\n # t0 - Initial time\\n # tf - Final time\\n # n - Number of steps\\n # A - Adjacency matrix, np.ndarray (N,N)\\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\\n # R - Relationship or preference matrix, np.ndarray (N,N)\\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\\n\\n # Number of players\\n N = A[:, 0].size\\n # Number of strategies\\n S = x0[0, :].size\\n # Step in each iteration\\n h = (tf - t0) / n\\n # Result of each step, np.ndarray (N, S, n+1)\\n y = np.zeros([N, S, n+1], dtype='double')\\n y[:, :, 0] = x0\\n k = np.zeros([N, S])\\n # I still don't know why, but theres a problem with negative payoffs\\n B = matrixTranslate(B)\\n\\n # Fourth order Runge-Kutta\\n for t in range(n):\\n k1 = np.multiply(h, hr_egn(A, B, R, y[:, :, t]))\\n k2 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k1, 2))))\\n k3 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k2, 2))))\\n k4 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], k3)))\\n # k = (k1 + 2*k2 + 2*k3 + k4)/6\\n k = np.divide(np.add(np.add(k1, np.multiply(2, k2)), np.add(np.multiply(2, k3), k4)), 6)\\n\\n y[:, :, t+1] = np.add(y[:, :, t], k)\\n\\n # Filter results with machine epsilon\\n for v in range(N):\\n for s in range(S):\\n if y[v, s, t+1] < np.sqrt(np.finfo('double').eps):\\n y[v, s, t+1] = 0\\n elif y[v, s, t+1] > np.subtract(1, np.sqrt(np.finfo('double').eps)):\\n y[v, s, t + 1] = 1\\n\\n return y\",\n \"def question_17():\\n rbf = RadialBiasFunction()\\n for i in range(20):\\n rbf.fit(1.5, 9)\\n error_in_lo = rbf.error()\\n error_out_lo = rbf.error(in_sample=False)\\n rbf.fit(2.0, 9)\\n error_in_hi = rbf.error()\\n error_out_hi = rbf.error(in_sample=False)\\n print(\\\"Error (in/out) for gamma = 1.5: {0} / {1}\\\\nError (in/out) for gamma = 2.0: {2} / {3}\\\\n\\\"\\n .format(error_in_lo, error_out_lo, error_in_hi, error_out_hi))\\n rbf.resample()\",\n \"def dishlist_avg_cal(n:list)->float:\\r\\n all_cal = dishlist_cal(n)\\r\\n return sum(all_cal)/len(all_cal)\",\n \"def dlqr(a, b, q, r):\\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\\n p = scipy.linalg.solve_discrete_are(a, b, q, r)\\n\\n # LQR gain\\n # k = (b.T * p * b + r)^-1 * (b.T * p * a)\\n bp = b.T.dot(p)\\n tmp1 = bp.dot(b)\\n tmp1 += r\\n tmp2 = bp.dot(a)\\n k = np.linalg.solve(tmp1, tmp2)\\n return k, p\",\n \"def efficiency_vs_length(w=50, Lmax=1000, Lmin=102.4, p=75, fmax=5.7e9,\\r\\n p1=database['K+'], p2=database['pi+'],\\r\\n p3=database['p+'], E=1e6, delta_p=1.6e-2, n=1000,\\r\\n ng=50, nl=50, nf=100, resolution=0.01, plot=True,\\r\\n set_freq=5.7e9, present=False, count_L=True):\\r\\n current_target_rate = 53957518\\r\\n if count_L == True:\\r\\n if resolution == None:\\r\\n if set_freq == None:\\r\\n est = timing(n*ng*nl*nf*4e-05)\\r\\n else:\\r\\n est = timing(n*ng*nl*4e-05)\\r\\n print('Estimated time: {0}'.format(est))\\r\\n else:\\r\\n num = int(round(np.log10(Lmax-Lmin))-1)-np.log10(resolution)+1\\r\\n if set_freq == None:\\r\\n est = timing(10*num*ng*nl*nf*4e-05)\\r\\n else:\\r\\n est = timing(10*num*ng*nl*4e-05)\\r\\n print('Estimated maximum time: {0}'.format(est))\\r\\n start = time.time()\\r\\n if resolution == None:\\r\\n L_range = np.linspace(Lmin, Lmax, n)\\r\\n eff, purity = [], []\\r\\n for L in L_range:\\r\\n if count_L == True:\\r\\n print(L)\\r\\n eff.append(efficiency(w, L-22.8, p, fmax, p1, p2, p3, E, delta_p,\\r\\n 10000, ng, nl, nf, False, set_freq))\\r\\n# purity.append((target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False)))\\r\\n purity.append(100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False)))\\r\\n i = 0\\r\\n while eff[i] < purity[i] and i < np.size(L_range)-1:\\r\\n i += 1\\r\\n if i >= np.size(L_range)-1:\\r\\n return None\\r\\n output = [L_range[i], eff[i], purity[i]/6]\\r\\n else:\\r\\n if present == True:\\r\\n n = 10**(int(round(np.log10(Lmax-Lmin))-2))\\r\\n n1 = 10**(int(round(np.log10(Lmax-Lmin))-2))\\r\\n else:\\r\\n n = 10**(int(round(np.log10(Lmax-Lmin))-1))\\r\\n n1 = 10**(int(round(np.log10(Lmax-Lmin))-1))\\r\\n Lmin = Lmax - ((int(((Lmax-Lmin)/n))+1)*n)\\r\\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\\r\\n while n >= resolution:\\r\\n if n == n1 and plot==True:\\r\\n graph_Lmin = Lmin\\r\\n graph_Lmax = Lmax - n\\r\\n graph_L_range = np.arange(Lmin, Lmax, n)\\r\\n graph_eff, graph_purity, graph_intensity = [], [], []\\r\\n for L in graph_L_range:\\r\\n if count_L == True:\\r\\n print(L)\\r\\n graph_eff.append(efficiency(w, L-22.8, p, fmax, p1, p2,\\r\\n p3, E, delta_p, 10000, ng, nl,\\r\\n nf, False, set_freq))\\r\\n# graph_purity.append((target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False)))\\r\\n graph_purity.append(100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False)))\\r\\n graph_intensity.append((target_rate(L, p1, p)/current_target_rate)/Gaussian_integral(w/26.4, plot=False))\\r\\n i = 0\\r\\n while graph_eff[i] < graph_purity[i] and i < np.size(graph_L_range)-1:\\r\\n i += 1\\r\\n if i >= np.size(graph_L_range)-1:\\r\\n output = None\\r\\n break\\r\\n Lmin = graph_L_range[i-1]\\r\\n n = 10**(int(np.log10(n)-1))\\r\\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\\r\\n else:\\r\\n L_range = np.arange(Lmin, Lmax, n)\\r\\n eff, purity, intensity = 0, 0, 0\\r\\n i = 0\\r\\n while eff <= purity and i < np.size(L_range)-1:\\r\\n i += 1\\r\\n L= L_range[i]\\r\\n if count_L == True:\\r\\n print(L)\\r\\n eff = efficiency(w, L-22.8, p, fmax, p1, p2, p3, E, delta_p,\\r\\n 10000, ng, nl, nf, False, set_freq)\\r\\n# purity = (target_rate(L, p1, p)/current_target_rate)*(6/Gaussian_integral(w/26.4, mu=0, sigma=26.4, A=1, y0=0, plot=False))\\r\\n purity = 100*decay_proportion(L-22.8, p1, p, target_rate=target_rate(L, p1, p))/(750e6*Gaussian_integral(w/26.4, plot=False))\\r\\n intensity = (target_rate(L, p1, p)/current_target_rate)/Gaussian_integral(w/26.4, plot=False)\\r\\n if i >= np.size(L_range)-1:\\r\\n return None\\r\\n output = [L_range[i], eff, intensity]\\r\\n Lmin = L_range[i-1]\\r\\n n = 10**(int(np.log10(n)-1))\\r\\n Lmax = Lmin + ((int(((Lmax-Lmin)/n))+1)*n)\\r\\n if plot == True:\\r\\n fig = plt.figure(figsize=[10, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n ax2 = ax.twinx()\\r\\n eff, purity, intensity, L_range = graph_eff, graph_purity, graph_intensity, graph_L_range\\r\\n Lmax, Lmin = graph_Lmax, graph_Lmin\\r\\n line1, = ax.plot(L_range, eff, 'r', lw=2, label='Beam Purity', alpha=0.6)\\r\\n line2, = ax.plot(L_range, purity, 'b', lw=2, label='Required Purity', alpha=0.6)\\r\\n line3, = ax2.plot(L_range, intensity, 'g', lw=2, label='Req. Intensity', alpha=0.6)\\r\\n# ax.axhline(24, color='k', label='Kaon percentage = 24%')\\r\\n ax.set_xlim(Lmin, Lmax)\\r\\n ax.set_ylim(0, 100)\\r\\n ax.set_xlabel('Distance between target and decay region / m', fontsize=20)\\r\\n ax.set_ylabel('Beam purity / %', fontsize=20)\\r\\n ax2.set_ylabel(r'Intensity / I$_0$', fontsize=20)\\r\\n ax2.set_ylim(0)\\r\\n ax2.yaxis.label.set_color(line3.get_color())\\r\\n ax2.tick_params(axis='y', colors=line3.get_color())\\r\\n# index = np.argmin(np.abs(eff-24))\\r\\n# if eff[index] >= 24:\\r\\n# min_L = L_range[index]\\r\\n# else:\\r\\n# min_L = L_range[index+1]\\r\\n# print(f'{timing(time.time()-start)}')\\r\\n# print('Minimum target distance required = {0:.1f} m'.format(min_L))\\r\\n# return min_L\\r\\n if output != None:\\r\\n line4 = ax.axvline(output[0], color='k', label='Intercept', dashes=[6, 2])\\r\\n lines = [line1, line2, line3, line4]\\r\\n else:\\r\\n lines = [line1, line2, line3]\\r\\n ax2.legend(lines, [l.get_label() for l in lines], loc='best', fontsize=15)\\r\\n ax.minorticks_on()\\r\\n ax2.minorticks_on()\\r\\n ax.grid()\\r\\n ax.set_title('Observed and required beam purities as a function of\\\\ntarget distance'+f' for E = {int(E*1e-6)} MV/m', fontsize=16)\\r\\n plt.show()\\r\\n fig.savefig(f'Purity_vs_Required_p_75_E_1e{int(round(np.log10(E)))}_with_Intensity.pdf', bbox_inches='tight')\\r\\n if count_L == True:\\r\\n print(f'{timing(time.time()-start)}')\\r\\n return output\",\n \"def _get_learning_rate(self) -> float:\\n if len(self.errors) > 1 and self.errors[-2] - self.errors[-1] < 0:\\n self.learning_rate /= 2\\n return self.learning_rate\",\n \"def cost(self):\\n lg = len(self.guarantees.cnf)\\n la = len(self.assumptions.cnf)\\n\\n \\\"\\\"\\\"heuristic\\n Low: guarantees while assuming little (assumption set is bigger)\\n High: guarantees while assuming a lot (assumption set is smaller)\\\"\\\"\\\"\\n\\n return la / lg\",\n \"def kA_func(self):\\n\\n i1 = self.inl[0].to_flow()\\n i2 = self.inl[1].to_flow()\\n o1 = self.outl[0].to_flow()\\n o2 = self.outl[1].to_flow()\\n\\n T_i1 = T_bp_p(i1)\\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\\n\\n if T_i1 <= T_o2 and not self.inl[0].T.val_set:\\n T_i1 = T_o2 + 0.5\\n if T_i1 <= T_o2 and not self.outl[1].T.val_set:\\n T_o2 = T_i1 - 0.5\\n\\n if T_o1 <= T_i2 and not self.outl[0].T.val_set:\\n T_o1 = T_i2 + 1\\n if T_o1 <= T_i2 and not self.inl[1].T.val_set:\\n T_i2 = T_o1 - 1\\n\\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\\n\\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log\",\n \"def compute_cost(AL, Y):\\n \\n m = Y.shape[1]\\n\\n # Compute loss from aL and y.\\n ### START CODE HERE ### (≈ 1 lines of code)\\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\\n ### END CODE HERE ###\\n \\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\n assert(cost.shape == ())\\n \\n return cost\",\n \"def compute_average(self, error=None):\\n\\n nbjobs = len(self)\\n if not nbjobs:\\n return\\n max_xsec = max(one.xsec for one in self)\\n min_xsec = min(one.xsec for one in self)\\n self.axsec = sum([one.axsec for one in self]) / nbjobs\\n self.xsec = sum([one.xsec for one in self]) /nbjobs\\n self.xerrc = sum([one.xerrc for one in self]) /nbjobs\\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self])) /nbjobs\\n if error:\\n self.xerrc = error\\n self.xerru = error\\n\\n self.nevents = sum([one.nevents for one in self])\\n self.nw = 0#sum([one.nw for one in self])\\n self.maxit = 0#len(self.yerr_iter) # \\n self.nunwgt = sum([one.nunwgt for one in self]) \\n self.wgt = 0\\n self.luminosity = sum([one.luminosity for one in self])\\n self.ysec_iter = []\\n self.yerr_iter = []\\n self.th_maxwgt = 0.0\\n self.th_nunwgt = 0 \\n for result in self:\\n self.ysec_iter+=result.ysec_iter\\n self.yerr_iter+=result.yerr_iter\\n self.yasec_iter += result.yasec_iter\\n self.eff_iter += result.eff_iter\\n self.maxwgt_iter += result.maxwgt_iter\\n\\n #check full consistency\\n onefail = False\\n for one in list(self):\\n if one.xsec < (self.xsec - 25* one.xerru):\\n if not onefail:\\n logger.debug('multi run are inconsistent: %s < %s - 25* %s: assign error %s', one.xsec, self.xsec, one.xerru, error if error else max_xsec-min_xsec)\\n onefail = True\\n self.remove(one)\\n if onefail:\\n if error:\\n return self.compute_average(error)\\n else:\\n return self.compute_average((max_xsec-min_xsec)/2.)\",\n \"def calc_loss(self, lambdas):\\n # Rayleigh scattering [dB/km*um^4]\\n # value 0.74 for SiO2 from Appl. Phys. Lett. 83, 5175 (2003)\\n # value 2.33 for GeO2 from Appl. Optics 36(27) (1997)\\n R = .74 + (2.33 - .74) * self.doping\\n alphaR = R * lambdas**(-4) * 1e-3\\n # measured fiber water peak\\n alphaoh_1_38 = 2.43\\n sigma_lambda = 0.030\\n # Journal of Non-Crystalline Solids Volume 203 (1996)\\n alphaoh = 0.00012 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.444) / (sigma_lambda))**2) + \\\\\\n 0.00050 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.506) / (sigma_lambda))**2) + \\\\\\n 0.00030 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.566) / (sigma_lambda))**2) + \\\\\\n 0.00640 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.593) / (sigma_lambda))**2) + \\\\\\n 0.00028 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.651) / (sigma_lambda))**2) + \\\\\\n 0.00440 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.685) / (sigma_lambda))**2) + \\\\\\n 0.07800 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.724) / (sigma_lambda))**2) + \\\\\\n 0.00380 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.825) / (sigma_lambda))**2) + \\\\\\n 0.08000 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.878) / (sigma_lambda))**2) + \\\\\\n 1.6 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 0.943) / (sigma_lambda))**2) + \\\\\\n 0.07 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.139) / (sigma_lambda))**2) + \\\\\\n 2.7 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.246) / (sigma_lambda))**2) + \\\\\\n alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.383) / (sigma_lambda))**2) + \\\\\\n 0.84 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 1.894) / (sigma_lambda))**2) + \\\\\\n 201 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 2.212) / (sigma_lambda))**2) + \\\\\\n 10000 / 62.7 * alphaoh_1_38 * np.exp(-.5 * ((lambdas - 2.722) / (sigma_lambda))**2)\\n # Hiroshi Murata, Handbook of optical fibers and cables (1996)\\n alphaIR = 4.2e8 * np.exp(-47.5 / lambdas)\\n a = (alphaoh + alphaR + alphaIR) / (10 / np.log(10))\\n a[a > self.maxloss] = self.maxloss\\n self.alpha = a\",\n \"def extinction(lbda, AV, RV=3.1):\\n\\n xx = 1./lbda\\n yy = xx - 1.82\\n\\n a_c = np.zeros_like(xx)\\n b_c = np.zeros_like(xx)\\n\\n indices = np.where(xx < 1.1)[0]\\n\\n if len(indices) > 0:\\n a_c[indices] = 0.574*np.power(xx[indices], 1.61)\\n b_c[indices] = -0.527*np.power(xx[indices], 1.61)\\n\\n indices = np.where(xx >= 1.1)[0]\\n\\n if len(indices) > 0:\\n a_c[indices] = 1. + 0.17699*yy[indices] - 0.50447*yy[indices]**2 - \\\\\\n 0.02427*yy[indices]**3 + 0.72085*yy[indices]**4 + \\\\\\n 0.01979*yy[indices]**5 - 0.77530*yy[indices]**6 + \\\\\\n 0.32999*yy[indices]**7\\n\\n b_c[indices] = 1.41338*yy[indices] + 2.28305*yy[indices]**2 + \\\\\\n 1.07233*yy[indices]**3 - 5.38434*yy[indices]**4 - \\\\\\n 0.62251*yy[indices]**5 + 5.30260*yy[indices]**6 - \\\\\\n 2.09002*yy[indices]**7\\n\\n return AV * (a_c + b_c/RV)\",\n \"def tLoss(self, dt, qt, tl, ta, qa):\\n\\t return 1./(10.**6)*(qt+(self.evap(self.LAI, tl, ta, qa)))\",\n \"def b_plus_bstar(self):\\n running_total = 0\\n for i in range(self.prob.num):\\n if self.alphas[i] > 1e-5 and self.prob.Y[i] == 1:\\n ayxx = 0\\n for j in range(self.prob.num):\\n ayxx += (self.alphas[j] + self.etas[j]) * self.prob.Y[j] * self.prob.xkernel(self.prob.X[j],\\n self.prob.X[i])\\n abcxx = 0\\n for j in range(self.prob.num):\\n abcxx += (self.alphas[j] + self.deltas[j]) * self.prob.xkernel(self.prob.X[j], self.prob.X[i])\\n abcxx *= (1 / self.prob.gamma)\\n running_total += 1 - abcxx - ayxx\\n return running_total\",\n \"def calculate_risk_tol(*args):\\n global total_score\\n risk_tol_start = 0.0\\n\\n for risk_per_pg in risk_tol_per_qs.iterkeys():\\n try:\\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\\n except IndexError:\\n pass\\n total_score = risk_tol_start\",\n \"def __learning_rate(self, lr0, epoch):\\n \\n \\\"\\\"\\\"\\n Dan's Methos\\n \\\"\\\"\\\"\\n lrs = lr0 * 0.001\\n c = np.power((lrs/lr0), 1.0/self.__maxEpoch)\\n \\n return lr0*np.power(c, epoch)\",\n \"def lam(E):\\n return (12398.4/E)*1e-10\",\n \"def ComputeNrb(self):\\r\\n pass\",\n \"def Rosenbrock(a, x):\\r\\n return (a-x[0])**2 + 100*(x[1]-x[0]**2)**2\",\n \"def tune_lambda(Xtrain, ytrain, Xval, yval):\\n #####################################################\\n # TODO 5: Fill in your code here #\\n #####################################################\\n\\n bestlambda = None\\n mean_abs_err = 10000000\\n power = -19\\n while power < 20:\\n lambda0 = 10 ** (power)\\n w = regularized_linear_regression(Xtrain, ytrain, lambda0)\\n err = mean_absolute_error(w, Xval, yval)\\n if err < mean_abs_err:\\n mean_abs_err = err\\n bestlambda = lambda0\\n power = power + 1\\n return bestlambda\",\n \"def checkCostFunction(lbd=0):\\n # Create small problem\\n X_t = np.random.rand(4, 3)\\n Theta_t = np.random.rand(5, 3)\\n\\n # Zap out most entries\\n Y = X_t.dot(Theta_t.T)\\n Y[np.random.rand(Y.shape[0], Y.shape[1]) > .5] = 0\\n R = np.zeros(Y.shape)\\n R[Y == 0] = 1\\n\\n # Run Gradient Checking\\n X = np.random.randn(X_t.shape[0], X_t.shape[1])\\n Theta = np.random.randn(Theta_t.shape[0], Theta_t.shape[1])\\n num_users = Y.shape[1]\\n num_movies = Y.shape[0]\\n num_features = Theta_t.shape[1]\\n\\n def Jfunc(t):\\n return cofiCostFunc(t, Y, R, num_users, num_movies, num_features, lbd)\\n\\n numgrad = computeNumericalGradient(Jfunc, np.r_[X.flatten(), Theta.flatten()])\\n\\n cost, grad = cofiCostFunc(np.r_[X.flatten(), Theta.flatten()], Y, R, num_users, num_movies, num_features, lbd)\\n\\n print(np.c_[numgrad, grad])\\n print('The above two columns you get should be very similar.')\\n print('(Left-Your Numerical Gradient, Right-Analytical Gradient)\\\\n')\\n\\n diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)\\n print('If your cost function implementation is correct, then')\\n print('the relative difference will be small (less than 1e-9).')\\n print('Relative Difference: %g\\\\n' % diff)\",\n \"def dishlist_avg(n:list)->float:\\r\\n all_prices = dishlist_prices(n)\\r\\n return sum(all_prices)/len(all_prices)\",\n \"def kl_divergence(eta_q, eta_p):\\n return ev_t(eta_q) @ (eta_q - eta_p) - a(eta_q) + a(eta_p)\",\n \"def cracking_rate_Ai2020(T_dim):\\n k_cr = 3.9e-20\\n Eac_cr = 0 # to be implemented\\n arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15))\\n return k_cr * arrhenius\",\n \"def lqr(a, b, q, r):\\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\\n p = scipy.linalg.solve_continuous_are(a, b, q, r)\\n\\n # LQR gain\\n k = np.linalg.solve(r, b.T.dot(p))\\n\\n return k, p\",\n \"def graphite_cracking_rate_Ai2020(T_dim):\\n k_cr = 3.9e-20\\n Eac_cr = 0 # to be implemented\\n arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15))\\n return k_cr * arrhenius\",\n \"def KL(p, q):\\n return np.sum(p * np.log(p / q))\",\n \"def aksprob(alam):\\r\\n if type(alam) == N.ndarray:\\r\\n frozen = -1 *N.ones(alam.shape,N.float64)\\r\\n alam = alam.astype(N.float64)\\r\\n arrayflag = 1\\r\\n else:\\r\\n frozen = N.array(-1.)\\r\\n alam = N.array(alam,N.float64)\\r\\n arrayflag = 1\\r\\n mask = N.zeros(alam.shape)\\r\\n fac = 2.0 *N.ones(alam.shape,N.float_)\\r\\n sum = N.zeros(alam.shape,N.float_)\\r\\n termbf = N.zeros(alam.shape,N.float_)\\r\\n a2 = N.array(-2.0*alam*alam,N.float64)\\r\\n totalelements = N.multiply.reduce(N.array(mask.shape))\\r\\n for j in range(1,201):\\r\\n if asum(mask) == totalelements:\\r\\n break\\r\\n exponents = (a2*j*j)\\r\\n overflowmask = N.less(exponents,-746)\\r\\n frozen = N.where(overflowmask,0,frozen)\\r\\n mask = mask+overflowmask\\r\\n term = fac*N.exp(exponents)\\r\\n sum = sum + term\\r\\n newmask = N.where(N.less_equal(abs(term),(0.001*termbf)) +\\r\\n N.less(abs(term),1.0e-8*sum), 1, 0)\\r\\n frozen = N.where(newmask*N.equal(mask,0), sum, frozen)\\r\\n mask = N.clip(mask+newmask,0,1)\\r\\n fac = -fac\\r\\n termbf = abs(term)\\r\\n if arrayflag:\\r\\n return N.where(N.equal(frozen,-1), 1.0, frozen) # 1.0 if doesn't converge\\r\\n else:\\r\\n return N.where(N.equal(frozen,-1), 1.0, frozen)[0] # 1.0 if doesn't converge\\r\",\n \"def kl_divergence(self) -> Tensor:\\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()\",\n \"def power_law_profile(n_core, nclad, q, a, x):\\n delta = (n_core**2 - nclad**2) / 2 / n_core**2\\n nsqr = n_core**2 * (1 - 2 * delta * (np.abs(x) / a)**q)\\n if not np.isscalar(x):\\n np.place(nsqr, abs(x) >= a, nclad**2)\\n return np.sqrt(nsqr)\",\n \"def eq510821ad1(ldb, lambda_rl, lambda_cf, lambda_rc, lambda_er, lambda_lw):\\n\\n ld = ldb * (lambda_rl*lambda_cf*lambda_rc*lambda_er)/lambda_lw\\n\\n# text = (f'ld = ldb * (lambda_rl*lambda_cf*lambda_rc*lambda_er)\\\\n' +\\n# f'/lambda_lw\\\\n' +\\n# f'ld = {ldb:.2f} * ({lambda_rl:.2f}*{lambda_cf:.2f}*' +\\n# f'{lambda_rc:.2f}*{lambda_er:.2f})/{lambda:.2f}\\\\n' +\\n# f'ld = {ld:.2f}')\\n\\n return ld, text\",\n \"def runge(s1: float, s2: float, L: float, m: float):\\n return (s2 - s1) / (L**m - 1)\",\n \"def expected_performance(x):\\n pm_pars = {'alpha': x[0], 'beta': x[1]}\\n rm_pars = {'theta': x[2]}\\n \\n T = 100 #number of trials\\n n_b = 2 #number of bandits\\n rho = 0.01 #switch probability of the arm-reward contingencies\\n \\n n_env = 100 #number of environments\\n n_blocks = 1 #number of experimental blocks\\n ep = 0 # expected performance\\n \\n for n in range(n_env):\\n #generate n_env mutli-armed bandit environmets\\n env = MultiArmedBandit(T, rho = rho, n_b = n_b)\\n pm = RescorlaWagner(env, n_b)\\n for m in range(n_blocks):\\n #in each environment repeat the experiment n_blocks times\\n rm = SoftMaxResponses([], pm, d_r)\\n rm.get_responses(pm_pars, rm_pars)\\n #For each block compute the expected performance.\\n ep += env.expected_performance()\\n \\n return ep/(n_env*n_blocks)\",\n \"def learning_rate_range():\\n # Lower and upper bounds\\n #######\\n lower_bound = 0.1 \\n upper_bound = 1e-6\\n #######\\n return lower_bound, upper_bound\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60029477","0.5933232","0.58607453","0.5827601","0.57766134","0.57220405","0.5690132","0.5665845","0.56634825","0.56570524","0.5628769","0.5604078","0.55918825","0.5588187","0.5571809","0.55503905","0.55435735","0.55359924","0.5530741","0.55281013","0.5517934","0.5514012","0.55123943","0.5502164","0.55005944","0.5492454","0.5490584","0.54819626","0.5469577","0.5466371","0.54642594","0.54618275","0.54599833","0.5456084","0.5453884","0.54307026","0.54301727","0.54223716","0.54127026","0.5411542","0.541103","0.5406023","0.5403563","0.5403116","0.539723","0.53832173","0.5371384","0.5369347","0.5367429","0.53670704","0.53642666","0.5359604","0.53582764","0.53553796","0.5355313","0.5353073","0.5350303","0.5345836","0.53439933","0.53410083","0.5340114","0.5336721","0.5327064","0.5326978","0.53261566","0.53208816","0.5303275","0.5291618","0.52914876","0.52887106","0.52842176","0.5283282","0.5281174","0.52803564","0.5280017","0.5274337","0.52739537","0.5272655","0.52684784","0.5263154","0.5263103","0.52532834","0.5250217","0.5243546","0.52393913","0.52364653","0.5235817","0.52338773","0.5232777","0.52296424","0.52286005","0.5224702","0.5223852","0.5223729","0.5222813","0.5221728","0.5216465","0.5207901","0.5207605","0.520511"],"string":"[\n \"0.60029477\",\n \"0.5933232\",\n \"0.58607453\",\n \"0.5827601\",\n \"0.57766134\",\n \"0.57220405\",\n \"0.5690132\",\n \"0.5665845\",\n \"0.56634825\",\n \"0.56570524\",\n \"0.5628769\",\n \"0.5604078\",\n \"0.55918825\",\n \"0.5588187\",\n \"0.5571809\",\n \"0.55503905\",\n \"0.55435735\",\n \"0.55359924\",\n \"0.5530741\",\n \"0.55281013\",\n \"0.5517934\",\n \"0.5514012\",\n \"0.55123943\",\n \"0.5502164\",\n \"0.55005944\",\n \"0.5492454\",\n \"0.5490584\",\n \"0.54819626\",\n \"0.5469577\",\n \"0.5466371\",\n \"0.54642594\",\n \"0.54618275\",\n \"0.54599833\",\n \"0.5456084\",\n \"0.5453884\",\n \"0.54307026\",\n \"0.54301727\",\n \"0.54223716\",\n \"0.54127026\",\n \"0.5411542\",\n \"0.541103\",\n \"0.5406023\",\n \"0.5403563\",\n \"0.5403116\",\n \"0.539723\",\n \"0.53832173\",\n \"0.5371384\",\n \"0.5369347\",\n \"0.5367429\",\n \"0.53670704\",\n \"0.53642666\",\n \"0.5359604\",\n \"0.53582764\",\n \"0.53553796\",\n \"0.5355313\",\n \"0.5353073\",\n \"0.5350303\",\n \"0.5345836\",\n \"0.53439933\",\n \"0.53410083\",\n \"0.5340114\",\n \"0.5336721\",\n \"0.5327064\",\n \"0.5326978\",\n \"0.53261566\",\n \"0.53208816\",\n \"0.5303275\",\n \"0.5291618\",\n \"0.52914876\",\n \"0.52887106\",\n \"0.52842176\",\n \"0.5283282\",\n \"0.5281174\",\n \"0.52803564\",\n \"0.5280017\",\n \"0.5274337\",\n \"0.52739537\",\n \"0.5272655\",\n \"0.52684784\",\n \"0.5263154\",\n \"0.5263103\",\n \"0.52532834\",\n \"0.5250217\",\n \"0.5243546\",\n \"0.52393913\",\n \"0.52364653\",\n \"0.5235817\",\n \"0.52338773\",\n \"0.5232777\",\n \"0.52296424\",\n \"0.52286005\",\n \"0.5224702\",\n \"0.5223852\",\n \"0.5223729\",\n \"0.5222813\",\n \"0.5221728\",\n \"0.5216465\",\n \"0.5207901\",\n \"0.5207605\",\n \"0.520511\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6573204"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89495,"cells":{"query":{"kind":"string","value":"Solve for K recursively. Not used."},"document":{"kind":"string","value":"def estimate_K(self, horizon, A, B):\n Q, R = self.Q, self.R\n # Calculate P matrices first for each step\n P_matrices = np.zeros((horizon + 1, Q.shape[0], Q.shape[1]))\n P_matrices[horizon] = Q\n for i in range(horizon - 1, 0, -1):\n P_t = P_matrices[i + 1]\n P_matrices[i] = Q + (A.T @ P_t @ A) - (A.T @ P_t @ B @ np.matmul(inv(R + B.T @ P_t @ B), B.T @ P_t @ A))\n # Hardcoded shape of K, change to inferred shape for diverse testing\n K_matrices = np.zeros((horizon, self.dim, self.dim))\n for i in range(horizon):\n P_i = P_matrices[i + 1]\n K_matrices[i] = -np.matmul(inv(R + B.T @ P_i @ B), B.T @ P_i @ A)\n return K_matrices"},"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 iterate(rk):\n y = scipy.sparse.linalg.spsolve(P1, rk)\n RHS = scipy.sparse.csr_matrix.dot(P4, y) + rk\n zk = scipy.sparse.linalg.spsolve(P3, RHS)\n return zk","def fn(n, k):\n if n == k: return 1\n if k == 0: return 0\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007","def solve_dp(self, k, exp=1.0):\n self.initialize_dp(k)\n if not self.validate_tree(False):\n raise AttributeError(\"Invalid tree cannot run dynamic program\")\n self._solve_dp(self.nodes[self.root_id], exp=exp)\n\n return self.nodes[self.root_id].cost_matrix[self.k]","def solution2(nums, K):\n s = 0\n sum_til = []\n for n in nums:\n s += n\n sum_til.append(s)\n\n l = len(nums)\n for i in range(l):\n for j in range(i+1, l):\n sum_ij = sum_til[j] if i == 0 else sum_til[j] - sum_til[i-1]\n if K != 0 and sum_ij % K == 0:\n return True\n if K == 0 and sum_ij == 0:\n return True\n return False","def fn(n, k):\n if k == 1: return n \n if n == 0: return 0 \n ans = inf \n for x in range(1, n+1): \n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\n return ans","def fn(n, k):\n if k == 0: return 1 \n if n <= 0 or k < 0: return 0 \n return fn(n-1, k) + fn(n, k-1) - fn(n-1, k-n)","def fn(i, k):\n if i == len(nums): return 0\n if k < 0: return inf \n ans = inf\n rmx = -inf # range max \n rsm = 0 # range sum \n for j in range(i, len(nums)): \n rmx = max(rmx, nums[j])\n rsm += nums[j]\n ans = min(ans, rmx*(j-i+1) - rsm + fn(j+1, k-1))\n return ans","def solve(self):\n \n raise NotImplementedError(\"not implemented!\")","def _recover_solution(self, base_node, k):\n if base_node is None:\n print(\"None node passed to recover solution\")\n return []\n if k == 0:\n return []\n if base_node.is_leaf():\n return [base_node.node_id]\n optimal_left = base_node.left_optimal[k]\n optimal_right = base_node.right_optimal[k]\n left_solution = self._recover_solution(base_node.left_child, optimal_left)\n right_solution = self._recover_solution(base_node.right_child,\n optimal_right)\n\n return left_solution + right_solution","def solve_problem(self, ra, kx, ky=0):\n\n if self._eqn_set == 0:\n if self._atmosphere == 0:\n if self.threeD:\n self.atmosphere = polytropes.FC_polytrope_3d(\n dimensions=1, comm=MPI.COMM_SELF, \n grid_dtype=np.complex128, **self.atmo_kwargs)\n self._eqn_kwargs['ky'] = ky*2*np.pi/self.atmosphere.Lz\n else:\n self.atmosphere = polytropes.FC_polytrope_2d(\n dimensions=1, comm=MPI.COMM_SELF, \n grid_dtype=np.complex128, **self.atmo_kwargs)\n elif self._atmosphere == 1:\n self.atmosphere = multitropes.FC_multitrope(\n dimensions=1, comm=MPI.COMM_SELF, \n grid_dtype=np.complex128, **self.atmo_kwargs)\n kx_real = kx*2*np.pi/self.atmosphere.Lz\n\n #Set the eigenvalue problem using the atmosphere\n self.atmosphere.set_eigenvalue_problem(ra, \n *self._eqn_args, kx=kx_real, **self._eqn_kwargs)\n self.atmosphere.set_BC(**self._bc_kwargs)\n problem = self.atmosphere.get_problem()\n\n #Solve using eigentools Eigenproblem\n self.eigprob = Eigenproblem(problem)\n max_val, gr_ind, freq = self.eigprob.growth_rate({})\n #Initialize atmosphere\n if self.cf.rank == 0:\n logger.info('Solving for onset with ra {:.8g} / kx {:.8g} / ky {:.8g} on proc 0'.\\\n format(ra, kx, ky))\n logger.info('Maximum eigenvalue found at those values: {:.8g}'.format(max_val))\n \n\n if not np.isnan(max_val):\n val = max_val + 1j*freq\n if type(val) == np.ndarray:\n return val[0]\n else:\n return val\n else:\n return np.nan","def solve(k=[]):\n if len(k) < 2:\n return 1\n min_jumps = len(k)\n for i in reversed(range(k[0])):\n if i > len(k):\n return 1\n if k[i] != 0:\n sub_jumps = solve(k[i + 1 :])\n min_jumps = min(min_jumps, sub_jumps)\n return min_jumps","def fn(n, k):\n if n == 1: return k # base case \n return sum(fn(n-1, kk) for kk in range(1, k+1))","def _compute_parameters(self, p, k):\n for i in range(self._.d + 1):\n p[0, i, i] = k[i]\n p[i, 0, i] = Integer(1)\n p[i, i, 0] = Integer(1)\n for i in range(self._.d):\n p[i+1, 1, i+1] = self._.a[i+1]\n p[i, 1, i+1] = self._.b[i]\n p[i+1, 1, i] = self._.c[i+1]\n for i in range(2, self._.d + 1):\n for j in range(1, self._.d + 1):\n for h in range(1, self._.d):\n p[h, i, j] = self._check_parameter(\n h, i, j,\n _simplify(_expand((\n self._.c[h] * p[h-1, i-1, j]\n + self._.b[h] * p[h+1, i-1, j]\n - self._.b[i-2] * p[h, i-2, j]\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\n ) / self._.c[i])))\n p[self._.d, i, j] = self._check_parameter(\n self._.d, i, j,\n _simplify(_expand((\n self._.c[self._.d] * p[self._.d-1, i-1, j]\n - self._.b[i-2] * p[self._.d, i-2, j]\n + (self._.a[self._.d] - self._.a[i-1])\n * p[self._.d, i-1, j]\n ) / self._.c[i])))","def fn(k, i, j):\n if not (0 <= i < N and 0 <= j < N): return 0\n if k == 0: return 1 \n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))","def fn(m, k):\n if m == 0 or k == 0: return 0 \n return 1 + fn(m-1, k-1) + fn(m-1, k)","def solve(self):","def tri_recursion(k):\r\n if(k>0):\r\n result = k + tri_recursion(k-1)\r\n # print(result)\r\n else:\r\n result = 0\r\n\r\n return result","def dpsearch(points,k):\n\t#M = k\n\tpoints = np.sort(points,axis=0)\n\tL = len(points)\n\tM = k\n\tT = list(np.zeros(M+1,dtype='int'))\n\tT[0] = 0\t#first threshold is by default always set to index 0 in trellis graph.\n\tT[M] = L \t#last threshold is by default always set to last number in input points.\n\ttrellis_value = np.full((M+1,L+1),np.inf)\n\ttrellis_backpointer = np.full((M+1,L+1),np.inf)\n\n\t# Stage 1: m=1\t\n\tfor l in range(1,L-M+2):\n\t\ttrellis_value[1][l] = ((l-0)/float(L))*np.var(points[0:l])\n\t\ttrellis_backpointer[1][l] = 0\n\n\t\n\tif(M>2):\n\t\t# Stage 2: m=2 to m=M-1\n\t\tfor m in range(2,M):\n\t\t\tfor l in range(m,L-M+m+1):\n\t\t\t\t#finding optimal path\n\t\t\t\tJ_min = np.inf\n\t\t\t\tJ_temp = np.inf\n\t\t\t\tfor i in range(m-1,l):\n\t\t\t\t\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\n\t\t\t\t\tif J_temp < J_min:\n\t\t\t\t\t\tJ_min = J_temp\n\t\t\t\t\t\tptr = i\n\t\t\t\t\n\t\t\t\ttrellis_value[m][l],trellis_backpointer[m][l] = J_min,ptr\n\t\t\t\t\n\n\t# Stage 3: m=M\n\tm = M\n\tl = L\n\t#finding optimal path\n\tJ_min = np.inf\n\tJ_temp = np.inf\n\tfor i in range(m-1,l):\n\t\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\n\t\tif J_temp < J_min:\n\t\t\tJ_min = J_temp\n\t\t\tptr = i\n\n\t\n\ttrellis_value[M][L] = J_min\n\ttrellis_backpointer[M][L] = ptr\n\t\n\t\n\t# Backtracking\n\tl = L\n\tm = M\n\twhile m>=2:\n\t\tT[m-1] = int(trellis_backpointer[m][l])\n\t\tl = int(trellis_backpointer[m][l])\n\t\tm = m - 1\n\n\t#Assign cluster labels\n\tlabels = np.full(len(points),0)\n\tj = T[0]\n\tcounter = 0\n\tfor i in range(1,k+1):\n\t\tlabels[j:T[i]] = counter\n\t\tj = T[i]\n\t\tcounter += 1\n\n\n\treturn labels,T","def pow_derpy(x, k):\n if k == 1:\n return x\n if k == 0:\n return 1\n\n return x * pow_derpy(x, k - 1)","def nchoosek(n, k):\n if (n, k) in known:\n return known[(n,k)]\n if k == 0:\n return 1\n if n == k:\n return 1\n if n < k:\n return \"n must be greater than k\"\n result = nchoosek(n - 1, k - 1) + nchoosek(n - 1, k)\n known[(n,k)] = result\n return result","def solve(arr, k):\n if k < 1:\n return arr\n first_element = arr[0]\n for i in range(len(arr) - 1):\n arr[i] = arr[i + 1]\n arr[-1] = first_element\n return solve(arr, k - 1)","def fn(k):\n if k <= 1: return 1\n return fn(k-1) + fn(k-2)","def solve(k, text, pattern):\n # print(k, text, pattern)\n base = pow(10, 9)\n M1 = base + 7\n M2 = base + 9\n X = 263\n len_p = len(pattern)\n len_t = len(text)\n pattern1, pattern2 = pre_compute_hashes(pattern, M1, M2, X)\n text1, text2 = pre_compute_hashes(text, M1, M2, X)\n res = []\n p_hash1, p_hash2 = get_hash_value(\n pattern1, M1, X, 0, len_p), get_hash_value(pattern2, M2, X, 0, len_p)\n for i in range(len_t-len_p+1): # all possible candidates\n subs_hash1 = get_hash_value(text1, M1, X, i, len_p)\n subs_hash2 = get_hash_value(text2, M2, X, i, len_p)\n is_valid = find_num_matches(pattern1, pattern2, text1, text2, M1, M2, X, k, len_p, i)\n if is_valid:\n res.append(i)\n return res","def convergentOfSqrt2(k):\n if memo[k]:\n return memo[k]\n \n if k == 1:\n memo[1] = (3,2)\n else:\n a,b = convergentOfSqrt2(k-1)\n # add one, invert, add one\n a += b\n a,b = b,a\n a += b\n memo[k] = (a,b)\n\n return memo[k]","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def solve(self):\n pass","def solve(self):\n pass","def dynamic_iteration(k, n):\n # If only one egg remains, n attempts must be made to find the correct floor.\n if k == 1:\n return n\n # Lookup table for previous solutions.\n W = [[0 for y in range(n + 1)] for x in range(k)]\n # Initialize the first row.\n for i in range(n + 1):\n W[0][i] = i\n # Start on second row, working downward.\n for i in range(1, k):\n # Calculate values for each cell.\n for j in range(1, n + 1):\n W[i][j] = min((max(W[i][j - x], W[i - 1][x - 1]) for x in range(1, j + 1))) + 1\n # Return the result.\n return W[k - 1][n]","def solve(self):\n raise NotImplementedError(\"This method needs to be implemented.\")","def recover_dp_solution(self):\n return self._recover_solution(self.nodes[self.root_id], self.k)","def fn(k, i):\n ii = -1 \n for x in path:\n if gcd(nums[k], x) == 1: # coprime \n if path[x] and path[x][-1][1] > ii: \n ans[k] = path[x][-1][0]\n ii = path[x][-1][1]\n \n path.setdefault(nums[k], []).append((k, i))\n for kk in tree.get(k, []): \n if kk not in seen: \n seen.add(kk)\n fn(kk, i+1)\n path[nums[k]].pop()","def n_choose_k(N,K):\n return factorial(N) // (factorial(N - K) * factorial(K))","def f_exact(n, k):\n def fact(m):\n return math.factorial(m)\n\n partition = part(n, k)\n\n total = 0\n for p in partition:\n product = 1\n nodes_left = n\n counts = dict([(x, len(list(y))) for x, y in itertools.groupby(p)])\n for num in p:\n product *= fact(num - 1) * comb(nodes_left, num)\n nodes_left -= num\n for num in counts:\n product /= fact(counts[num])\n\n total += product\n return int(total)","def adjust_k(self, ):\n self.iteration += 1\n\n if self.max_violation:\n self.k = 1\n return 1.\n\n self.k = (1.-self.beta**np.float(self.iteration))\n return self.k","def adjust_k(self, ):\n self.iteration += 1\n\n if self.max_violation:\n self.k = 1\n return 1.\n\n self.k = (1.-self.beta**np.float(self.iteration))\n return self.k","def solve():\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\n return binomial_coefficient(20 + 20, 20)","def approxk( X, k ):\n U, D, Vt = svdk( X, k )\n return U.dot( diag( D ) ).dot( Vt )","def __kappa_mle(self, k, R):\n return (iv(1, k) / iv(0, k)) - R","def beautifulSubsets(self, nums: List[int], k: int) -> int:\n\n \"\"\"\n queue = deque([([], -1)])\n res = 0\n\n while queue:\n cur, idx = queue.popleft()\n res += 1\n\n for i in range(idx + 1, len(nums)):\n if nums[i] - k in cur or nums[i] + k in cur:\n continue\n\n queue.append((cur + [nums[i]], i))\n\n return res - 1\n \"\"\"\n\n \"\"\"\n # dp0 is the ways that without A[i]\n # dp1 is the ways that with A[i]\n\n count = [Counter() for i in range(k)]\n for n in nums:\n count[n % k][n] += 1\n\n res = 1\n for i in range(k):\n prev, dp0, dp1 = 0, 1, 0\n for n in sorted(count[i]):\n v = pow(2, count[i][n])\n if prev + k == n:\n dp0, dp1 = dp0 + dp1, dp0 * (v - 1)\n else:\n dp0, dp1 = dp0 + dp1, (dp0 + dp1) * (v - 1)\n\n prev = n\n\n res *= dp0 + dp1\n\n return res - 1\n \"\"\"\n\n # Count the frequency of A, and then consider all the arithmetic sequence with difference k.\n # Each arithmetic sequence can be solve as a hourse robber problem.\n # We solve the hourse robber by dp.\n # dp(a) return the result for sequence no bigger than a.\n\n # dp(a)[0] is the ways that without a\n # dp(a)[1] is the ways that with a\n\n # dp(a)[0] = dp(a - k)[0] + dp(a - k)[1]\n # dp(a)[1] = dp(a - k)[0] * (2 ^ count(a) - 1\n\n count = Counter(nums)\n\n def dp(n):\n dp0, dp1 = dp(n - k) if n - k in count else (1, 0)\n return dp0 + dp1, dp0 * (pow(2, count[n]) - 1)\n\n return functools.reduce(operator.mul, (sum(dp(n)) for n in count if not count[n + k])) - 1","def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn","def kktsolver(x, z, W):\n\n if debug:\n logger.debug(\"Setup kkt solver\")\n logger.debug(\"W\")\n for key in W.keys():\n logger.debug(\"key: %s\" % (key,))\n logger.debug(W[key])\n\n H = hessian(x)\n if debug:\n logger.debug(\"diag H\")\n logger.debug(np.diag(H))\n _H = cvxopt.spdiag(list(np.diag(H))) if H is not None else None\n\n wdi = W[\"di\"]\n Wdi2 = cvxopt.spdiag(cvxopt.mul(wdi, wdi))\n\n S = G.T * Wdi2\n P = S * G\n\n Q = _H + P\n # now, do the cholesky decomposition of Q\n cvxopt.lapack.potrf(Q)\n\n if False and fn is not None:\n logger.debug(\"At setup f(x) = %d\" % (fn(np.array(list(x))),))\n\n def f(x, y, z):\n if False and fn is not None:\n logger.debug(\"f(x) = %d\" % (fn(np.array(list(x))),))\n try:\n # logger.debug(\"Compute x := S * z + x...\")\n cvxopt.blas.gemv(S, z, x, alpha=1.0, beta=1.0) # x = S * z + x\n cvxopt.lapack.potrs(Q, x)\n except BaseException as e:\n logger.debug(exception_to_string(sys.exc_info()))\n raise e\n cvxopt.blas.gemv(G, x, z, alpha=1.0, beta=-1.0) # z = _G * x - z\n z[:] = cvxopt.mul(wdi, z) # scaled z\n # raise NotImplementedError(\"Method Not implemented yet\")\n return f","def solve(self):\n # check for jacobian and set it if present and to be used\n if self.use_sparse:\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\n jac = self.problem.sparse_jac\n else:\n jac = None\n else:\n if self._use_jac and hasattr(self.problem,'jac'):\n jac = self.problem.jac\n else:\n jac = None\n \n # Initialize solver and solve \n \n solved = False\n local_min = False\n\n res = N.zeros(self.x0.__len__())\n while (not solved) and self.reg_count < 2:\n try:\n if self._use_fscale:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\n else:\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\n start = time.clock()\n res = self.solver.KINSOL_solve(not self._use_ls)\n stop = time.clock()\n self.exec_time += (stop - start)\n solved = True\n except KINError as error:\n if error.value == 42:\n # Try the heuristic\n if hasattr(self.problem, 'get_heuristic_x0'):\n print \"----------------------------------------------------\"\n print \" Solver stuck with zero step-length.\"\n print \"----------------------------------------------------\"\n print \"The following variables have start value zero\"\n print \"and min set to zero causing the zero step-lenght.\"\n print \"These settings are either set by default or by user.\"\n print \"\"\n\n self.x0 = self.problem.get_heuristic_x0()\n self.reg_count += 1\n \n print \"\"\n print \"This setting (start and min to zero) can often\"\n print \"cause problem when initializing the system. \"\n print \"\"\n print \"To avoid this the above variables have\"\n print \"their start attributes reset to one.\"\n print \"\"\n print \"Trying to solve the system again...\"\n else:\n raise KINSOL_Exception(\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\")\n \n\n elif (error.value == 2):\n print \"---------------------------------------------------------\"\n print \"\"\n print \" !!! WARNING !!!\"\n print \"\"\n print \" KINSOL has returned a result but the algorithm has converged\"\n print \" to a local minima, the initial values are NOT consistant!\"\n print \"\"\n print \"---------------------------------------------------------\"\n solved = True\n local_min = True\n else:\n # Other error, send onward as exception\n self.problem.check_constraints(res)\n raise KINSOL_Exception(error.msg[error.value])\n \n if not solved:\n self.solver.Free_KINSOL()\n raise KINSOL_Exception(\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\")\n\n if self.check_with_model:\n self.problem.check_constraints(res)\n if not local_min:\n print \"Problem sent to KINSOL solved.\"\n \n return res","def naive_recursive(k, n):\n # If no floors remaining, no more attempts need to be made.\n if n == 0:\n return 0\n # It will take n attempts to find the correct floor if there is only one egg remaining.\n if k == 1:\n return n\n # Solve the problem recursively.\n return min((max(naive_recursive(k, n - x), naive_recursive(k - 1, x - 1)) + 1 for x in range(1, n + 1)))","def k(self):\n return add(self.k_b(), self.k_m())","def count_k(n, k):\n if n == 0:\n return 1\n elif n < 0:\n return 0\n else:\n total = 0\n i = 1\n while i <= k:\n total += count_k(n - i, k)\n i += 1\n return total","def pow_better(x, k):\n if k == 1:\n return x\n if k == 0:\n return 1\n\n if k % 2 == 1:\n return x * pow_better(x, k - 1)\n else:\n return pow_better(x * x, k / 2)","def solve(self):\n for step in self.run.values():\n step.solve()","def solve(self):\n ...","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def combination(n, k):\n if (k > n) or (n < 0) or (k < 0):\n return 0\n val = 1\n for j in range(min(k, N - k)):\n val = (val * (N - j)) // (j + 1)\n return val","def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\n ##\n if iszero ( C ) :\n return findroot ( fun , xmin , xmax , args = args )\n ##\n func = lambda x , *a : fun(x,*a)-C\n return findroot ( func , xmin , xmax , args = args )","def eval_K_chol(self, S, sigma_n, sigma_f):\n K = self.eval_K(S)\n K += sigma_n * np.eye(K.shape[0])\n K_chol = jitchol(K)\n return K_chol","def nCk(n, k):\n return factorial(n)//factorial(k)//factorial(n-k)","def calc(k):\n n = factorial(4*k) * (1103.0 + 26390.0*k)\n d = factorial(k)**4 * 396.0**(4.0*k)\n z = n/d\n return z","def fn(stack, x, k=0):\n if x == 0: return ans.append(stack.copy()) #store a copy \n for i in range(k, len(candidates)): \n if candidates[i] > x: break \n stack.append(candidates[i])\n fn(stack, x-candidates[i], i)\n stack.pop()","def solution(n: int, k: int, coins: list):\n \n path_best = deque([0])\n \n buff = Queue()\n buff.put(0)\n \n profit_curr = 0\n n_jumps = 0\n while not buff.empty():\n curr = buff.get()\n profit_max_ = None\n jump_best = None\n for delta in range(1, k+1):\n jump = delta + curr\n if jump >= n:\n break\n profit = profit_curr + coins[jump]\n if profit_max_ is None or profit_max_ < profit:\n jump_best = jump\n profit_max_ = profit\n if coins[jump] >= 0:\n break\n if jump_best is not None:\n profit_curr = profit_max_\n buff.put(jump_best)\n path_best.append(jump_best)\n n_jumps += 1\n return n_jumps, profit_curr, [x for x in path_best]","def K(self):\n\n # Calculate and return the stiffness matrix in global coordinates\n return matmul(matmul(inv(self.T()), self.k()), self.T())","def kepler(x, k=1.0):\n assert(x.shape[2] == 1)\n\n q,p = extract_q_p(x)\n # The derivative of r wrt q is 1/sqrt(sum(q^2)), which is singular in 0.\n # Cutoff r so that it is > eps.\n eps = 1e-5\n r = tf.sqrt(tf.reduce_sum(tf.square(q), axis=1) + eps)\n return tf.squeeze(0.5 * tf.reduce_sum(tf.square(p), axis=1) + k / r)","def find_k(i, j):\n\n result = ((i * i) + (j * j)) ** 0.5\n return result","def solve(self):\n # a stack of queries (aka subproblems to be solved)\n stack = []\n initial_query = (len(self.items), self.knapsack_size)\n stack.append(initial_query)\n # Run as long as there are subproblems that need to be solved.\n # - this might not pass through all possible subproblems; in fact, \n # we're counting on it\n # - it will only pass through the subproblems that the initial \n # problem needs solved\n while len(stack) > 0:\n (end, ksize) = stack[-1]\n # this is the subproblem where we have only items self.items[:end]\n # and the knapsack size is ksize\n if self.items[end - 1].size > ksize:\n # item end-1 does not fit\n try:\n # retrieve subproblem result from the cache\n self._cache[(end, ksize)] = self._cache[(end - 1, ksize)]\n except KeyError:\n # subproblem hasn't been solved yet, put it on the stack\n stack.append((end - 1, ksize))\n continue\n else:\n # item end-1 fits; we get two subproblems:\n # - one if we don't include item end-1 in the knapsack\n # - one if we do include it\n sub1 = (end - 1, ksize)\n sub2 = (end - 1, ksize - self.items[end - 1].size)\n try:\n # retrieve 1st subproblem's result from the cache and \n # compute max value if we don't include item end-1\n val1 = self._cache[sub1]\n except KeyError:\n # subproblem hasn't been solved yet, put it on the stack\n stack.append(sub1)\n continue\n try:\n # retrieve 2nd subproblem's result from the cache and\n # compute max value if we do include item end-1\n val2 = self.items[end - 1].value + self._cache[sub2]\n except KeyError:\n # subproblem hasn't been solved yet, put it on the stack\n stack.append(sub2)\n continue\n # is it better to include item end-1 or not?\n self._cache[(end, ksize)] = max(val1, val2)\n # done with this subproblem\n stack.pop()\n return self._cache[(initial_query)]","def _K_computations(self, X, X2):\r\n # First extract times and indices.\r\n self._extract_t_indices(X, X2)\r\n\r\n self._K_compute_eq()\r\n self._K_compute_ode_eq()\r\n if X2 is None:\r\n self._K_eq_ode = self._K_ode_eq.T\r\n else:\r\n self._K_compute_ode_eq(transpose=True)\r\n self._K_compute_ode()\r\n\r\n if X2 is None:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\r\n else:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\r\n\r\n # Reorder values of blocks for placing back into _K_dvar.\r\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\r\n np.hstack((self._K_ode_eq, self._K_ode))))\r\n self._K_dvar = self._K_dvar[self._rorder, :]\r\n self._K_dvar = self._K_dvar[:, self._rorder2]\r\n \r\n \r\n if X2 is None:\r\n # Matrix giving scales of each output\r\n self._scale = np.zeros((self._t.size, self._t.size))\r\n code=\"\"\"\r\n for(int i=0;i<N; i++){\r\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\r\n for(int j=0; j<i; j++){\r\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\r\n scale_mat[i+j*N] = scale_mat[j+i*N];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index = self._scale, self.B, self._index\r\n N, output_dim = self._t.size, self.output_dim\r\n weave.inline(code,['index',\r\n 'scale_mat', 'B',\r\n 'N', 'output_dim'])\r\n else:\r\n self._scale = np.zeros((self._t.size, self._t2.size))\r\n code = \"\"\"\r\n for(int i=0; i<N; i++){\r\n for(int j=0; j<N2; j++){\r\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\r\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\r\n weave.inline(code, ['index', 'index2',\r\n 'scale_mat', 'B',\r\n 'N', 'N2', 'output_dim'])","def solve(self, cipher):\n N, K, C = cipher\n\n C.sort(reverse=True)\n\n group_cnt = N / K + 1 # 1 is the last remaining group\n total_cost = 0\n for i in xrange(group_cnt):\n unit_cost = i + 1\n total_cost += unit_cost * sum(C[i * K:(i + 1) * K])\n return total_cost","def func_ludwik(eps,k,sig0,n):\n return sig0 + k*eps**n","def fn(stack, x, k=0):\n if x == 0: return ans.append(stack.copy())\n for i in range(k, len(candidates)):\n if candidates[i] > x: break \n if i > k and candidates[i] == candidates[i-1]: continue\n stack.append(candidates[i])\n fn(stack, x - candidates[i], i+1)\n stack.pop()","def solver(self, theta):\n\n m = len(self.x)\n n = len(self.t[0])\n h = self.step_x\n k = self.step_t\n lamb = k / (h * h)\n w = np.zeros(m + 1)\n l = np.zeros(m + 1)\n u = np.zeros(m + 1)\n\n uK = np.zeros(self.x.shape)\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\n startTime = time.clock()\n if self.first:\n self.uR = np.zeros(self.x.shape)\n self.first = False\n error = 0\n errorCurve = np.zeros(self.x.shape)\n z = np.zeros(m + 1)\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\n for i in range(1, m - 1):\n w[i] = self.g(i * h)\n\n l[1] = 1 + lamb\n u[1] = -lamb / (2 * l[1])\n for i in range(2, m - 1):\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\n u[i] = -lamb / (2 * l[i])\n\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\n for j in range(1, n + 1):\n t = j * k # current t\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\n for i in range(2, m):\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\n w[m - 1] = z[m - 1]\n for i in range(m - 2, 0, -1):\n w[i] = z[i] - u[i] * w[i + 1]\n\n for i in range(0, m + 1):\n x = i * h\n # print(x, w[i])\n # print('oi')\n uK[i - 1, j - 1] = w[i]\n self.t[i - 1, j - 1] = t\n self.x[i - 1, j - 1] = x\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\n return (uK, error, errorCurve, theta)","def solution(N, K):\n\n # not really sure what to return if N=1, it should be invalid?\n rounds = N - 1\n next_num = N\n while K > 0 and next_num >= 4:\n next_num = next_num - next_num % 2\n next_num = next_num // 2\n rounds -= (next_num - 1)\n K -= 1\n return rounds","def solve():\n n = int(input())\n m = int(input())\n Ks = list(map(int, input().split()))\n\n # 4重ループにより全探索\n for a in range(n):\n for b in range(n):\n for c in range(n):\n for d in range(n):\n if Ks[a]+Ks[b]+Ks[c]+Ks[d] == m:\n print(\"Yes\")\n return\n print(\"No\")","def _cal_limb(self, S, Y, k):\r\n if k > S.shape[0]:\r\n k = S.shape[0]\r\n \r\n S1 = S - np.diag(np.diag(S)) # ensure diagonal elements are 0\r\n neigh = NearestNeighbors(n_neighbors=k, metric='precomputed')\r\n neigh.fit(np.zeros(S1.shape))\r\n knns = neigh.kneighbors(1 - S1, return_distance=False)\r\n \r\n C = np.zeros(Y.shape, dtype=float)\r\n for i in range(Y.shape[0]):\r\n ii = knns[i]\r\n for j in range(Y.shape[1]):\r\n if Y[i,j] == 1: # only consider \"1\" \r\n C[i,j] = k-np.sum(Y[ii,j])\r\n C = C/k\r\n \r\n return C","def solve(n, k):\n o = [True] + [False] * n + [True] # whether it's occupied\n # initialize Ls and Rs\n Ls = [-1] + [i for i in range(n)] + [-1]\n Rs = Ls[::-1] # Ls reversed\n\n for i in range(k):\n # find where min(Ls,Rs) is maximal\n min_ = 0\n for j in range(n+1):\n if not o[j]:\n if min(Ls[j], Rs[j]) > min_:\n min_ = min(Ls[j], Rs[j])\n\n # check if there is more than one\n pos = None\n max_ = 0\n for j in range(n+1):\n if not o[j]:\n if min(Ls[j], Rs[j]) == min_:\n if (pos is None) or (pos is not None and max(Ls[j], Rs[j]) > max_):\n pos = j\n max_ = max(Ls[j], Rs[j])\n\n # take pos\n maxs = max(Rs[pos], Ls[pos])\n mins = min(Rs[pos], Ls[pos])\n\n o[pos] = True\n Rs[pos] = -1\n Ls[pos] = -1\n\n # update Ls and Rs\n l = pos # index of first occupied left to position taken\n while l > 0 and not o[l - 1]:\n l -= 1\n for x in range(pos - l):\n Ls[l + x] = x\n Rs[l + x] = pos - l - x - 1\n\n r = pos # index of first occupied right to position taken\n while r <= n and not o[r + 1]:\n r += 1\n for x in range(r - pos):\n Ls[pos + x + 1] = x\n Rs[pos + x + 1] = r - pos - x - 1\n\n return str(maxs) + \" \" + str(mins)","def choose(n, k):\n\n if n == k:\n return 1\n elif k == 1:\n return n\n elif k == 2:\n return n * (n - 1) // 2\n else:\n return fact(n) // (fact(n - k) * fact(k))","def fn(n, k):\n if n <= k: return 0 # one mailbox for each house\n if k == 1: return mdist[0][n-1]\n ans = inf \n for nn in range(k-1, n): \n ans = min(ans, fn(nn, k-1) + mdist[nn][n-1])\n return ans","def eval_K(self, S):\n K = (self.eigenfunctions[self.X] * S[None, :]) @ \\\n self.eigenfunctions[self.X].T # shape (n,n)\n return K","def _K_computations(self, X, X2):\r\n if self.ARD:\r\n pass\r\n else:\r\n if X2 is None:\r\n self._K_inner_prod = np.dot(X,X.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\r\n vec = np.diag(self._K_numer) + 1.\r\n self._K_denom = np.sqrt(np.outer(vec,vec))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\r\n else:\r\n self._K_inner_prod = np.dot(X,X2.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\r\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)","def newton(n, k):\n if k == 0 or k == n:\n return 1\n else:\n return newton(n - 1, k - 1) + newton(n - 1, k)","def solve(max_k=12000, min_k=2):\r\n float_inf = float('inf')\r\n min_ps_numbers = [float_inf] * (max_k - min_k + 1)\r\n\r\n for i in count(1):\r\n # I would like a better way of looking for the max than just checking to see that all values are\r\n # not inf, however this is only a minor portion of the runtime.\r\n if float_inf not in min_ps_numbers:\r\n break\r\n\r\n composite_factoring = factorint(i, multiple=True)\r\n for prod_len in range(2, len(composite_factoring) + 1):\r\n for multiplicative_partition in kbins(composite_factoring, prod_len, 0):\r\n multiplicative_partition = [prod(x) for x in multiplicative_partition]\r\n multiplicative_partition_sum = sum(multiplicative_partition)\r\n one_count = i - multiplicative_partition_sum\r\n k = one_count + len(multiplicative_partition)\r\n array_k = k - min_k\r\n if array_k < len(min_ps_numbers) and min_ps_numbers[array_k] > i:\r\n min_ps_numbers[array_k] = i\r\n\r\n return sum(set(min_ps_numbers))","def optimization_rel_disp_K(self, step_size, dof1, dof2, controlDOF):\n \"\"\"First, the initial variance of the system is computed for the matrices given by the user\"\"\"\n Variance = []\n \"\"\"The sign variable keeps track of the direction the algorithm is stepping\"\"\"\n sign = [0]\n Variance.append(self.VarianceOfResponse())\n\n \"\"\"The matrix K is incremented by one step with size = step_size. for the spring that connects dof1 and dof2\"\"\"\n sign.append(1)\n self.incrementK(step_size, dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n\n \"\"\"Loop that iteratively steps down the optimal direction of increasing or reducing K\"\"\"\n i = 0\n while len(sign) < 4 or np.sum(sign[-4:]) != 0 or i < 100:\n i += 1\n print(abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]))\n \"\"\"First condition demands a minimum of 4 steps. Second condition sums up the direction of the last 4 steps\n if the sum equals 0, the minimum value for the variance has been found.\"\"\"\n if abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\n > abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\n \"\"\"If the last variance is smaller than the variance before, keep going in that direction.\"\"\"\n self.incrementK(step_size * sign[-1], dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n sign.append(sign[-1])\n elif abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\n < abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\n \"\"\"If the last variance is bigger than the one before, turn around and go the other way.\"\"\"\n self.incrementK(step_size * sign[-1] * -1, dof1, dof2)\n Variance.append(self.VarianceOfResponse())\n sign.append(sign[-1] * -1)\n return Variance","def solution(A, K):\n if len(A) == 0 or len(A) == 1 or len(A) == K:\n return A\n\n K = K % len(A)\n\n if K == 1:\n return A[-1:] + A[:-1]\n\n return A[-K:] + A[:-K]","def calc_k_dot_r(self):\n\t\n\tself.k_dot_r = self.k[0]*self.rij[0,:,:,:] + self.k[1]*self.rij[1,:,:,:] + self.k[2]*self.rij[2,:,:,:]\n\t\n\treturn","def _K_computations(self, X, X2=None):\r\n self._lengthscales=self.mapping.f(X)\r\n self._lengthscales2=np.square(self._lengthscales)\r\n if X2==None:\r\n self._lengthscales_two = self._lengthscales\r\n self._lengthscales_two2 = self._lengthscales2\r\n Xsquare = np.square(X).sum(1)\r\n self._K_dist2 = -2.*tdot(X) + Xsquare[:, None] + Xsquare[None, :]\r\n else:\r\n self._lengthscales_two = self.mapping.f(X2)\r\n self._lengthscales_two2 = np.square(self._lengthscales_two)\r\n self._K_dist2 = -2.*np.dot(X, X2.T) + np.square(X).sum(1)[:, None] + np.square(X2).sum(1)[None, :]\r\n self._w2 = self._lengthscales2 + self._lengthscales_two2.T\r\n prod_length = self._lengthscales*self._lengthscales_two.T\r\n self._K_exponential = np.exp(-self._K_dist2/self._w2)\r\n self._K_dvar = np.sign(prod_length)*(2*np.abs(prod_length)/self._w2)**(self.input_dim/2.)*np.exp(-self._K_dist2/self._w2)","def solve(self):\n\n # Open status display\n fmtstr, nsep = self.display_start()\n\n # Start solve timer\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Main optimisation iterations\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\n\n # Update record of X and Y from previous iteration\n self.on_iteration_start()\n\n # Compute backtracking\n if self.opt['Backtrack'] is not None and self.k >= 0:\n self.timer.stop('solve_wo_btrack')\n # Compute backtracking\n self.backtrack.update(self)\n self.timer.start('solve_wo_btrack')\n else:\n # Compute just proximal step\n self.xstep()\n # Update by combining previous iterates\n self.ystep()\n\n # Compute residuals and stopping thresholds\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n frcxd, adapt_tol = self.compute_residuals()\n self.timer.start('solve_wo_rsdl')\n\n # Compute and record other iteration statistics and\n # display iteration stats if Verbose option enabled\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n if not self.opt['FastSolve']:\n itst = self.iteration_stats(self.k, frcxd)\n self.itstat.append(itst)\n self.display_status(fmtstr, itst)\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Call callback function if defined\n if self.opt['Callback'] is not None:\n if self.opt['Callback'](self):\n break\n\n # Stop if residual-based stopping tolerances reached\n if not self.opt['FastSolve']:\n if frcxd < adapt_tol:\n break\n\n # Increment iteration count\n self.k += 1\n\n # Record solve time\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\n 'solve_wo_btrack'])\n\n # Print final separator string if Verbose option enabled\n self.display_end(nsep)\n\n return self.getmin()","def choose(n, k):\n ans, k = 1, min(k, n-k)\n for i in range(k):\n ans *= n-i\n ans //= i+1\n return ans","def kspace_linear_solve(self, other):\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\n self_k = transform(self, np.fft.fftn, n_points = n_points)\n other_k = transform(other, np.fft.fftn, n_points = n_points)\n\n ret = tmat()\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\n #ret = self_k*1.0\n ret.blocks*=0.0\n\n #ret.blocks[:-1] = np.einsum(\"ijk,ikl->ijl\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\n\n for i in np.arange(len(self_k.blocks)-1):\n ret.blocks[i] = np.linalg.solve(self_k.blocks[i],other_k.blocks[i])\n\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\n return ret","def kruskal(self):\n k = self.cc().max() + 1\n E = 2 * self.V - 2\n V = self.V\n Kedges = np.zeros((E, 2)).astype(np.int_)\n Kweights = np.zeros(E)\n iw = np.argsort(self.weights)\n label = np.arange(V)\n j = 0\n for i in range(V - k):\n a, b = self.edges[iw[j]]\n d = self.weights[iw[j]]\n while label[a] == label[b]:\n j = j + 1\n a, b = self.edges[iw[j]]\n d = self.weights[iw[j]]\n\n if label[a] != label[b]:\n lb = label[b]\n label[label == lb] = label[a]\n Kedges[2 * i] = np.array([a, b])\n Kedges[2 * i + 1] = np.array([b, a])\n Kweights[2 * i: 2 * i + 2] = d\n\n K = WeightedGraph(V, Kedges, Kweights)\n return K","def n_choose_k(n: int, k: int) -> int:\n # Edge case, no possible way to choose.\n if k > n or k < 0 or n < 0: return 0\n # We choose the min of k or n - k\n # since nCk == nC(n - k).\n k = min(k, n - k)\n # The numerator represents the product\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\n numerator = reduce(mul, range(n, n - k, -1), 1)\n # The denominator represents the product\n # 1 * 2 * ... * k\n denominator = reduce(mul, range(1, k + 1), 1)\n # return the result as an integer.\n return numerator // denominator","def ACM_Kruskal(G):\n pass","def kspace_cholesky_solve_(self, other):\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\n self_k = transform(self, np.fft.fftn, n_points = n_points)\n other_k = transform(other, np.fft.fftn, n_points = n_points)\n\n ret = tmat()\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\n #ret = self_k*1.0\n ret.blocks*=0.0\n\n #ret.blocks[:-1] = np.einsum(\"ijk,ikl->ijl\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\n\n for i in np.arange(len(self_k.blocks)-1):\n \n #print(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i])))\n #assert(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i]))<1e-10), \"not symmetric\"\n #assert(np.linalg.norm(self_k.blocks[i].T-self_k.blocks[i])<1e-10), \"not symmetric\"\n Mk = np.linalg.cholesky(self_k.blocks[i])\n yk = np.linalg.solve(Mk, other_k.blocks[i])\n\n\n ret.blocks[i] = np.linalg.solve(Mk.conj().T, yk)\n\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\n return ret","def check_solution(self, potential_solution):\n\n old_k = self.K\n new_k = potential_solution.set_K(self.len_connections)\n\n # accept the new state when K is higher\n if new_k > old_k:\n self.state = potential_solution\n self.K = new_k","def K(self, X, Xstar):\n r = l2norm_(X, Xstar)\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\n res = f * bessel\n res[np.isnan(res)] = 1\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\n return (res)","def cdf(self, k):\n\n if k < 0 or k > self.n:\n return 0\n\n k = int(k)\n ans = 0\n for i in range(0, k + 1):\n ans += self.pmf(i)\n return ans","def solve(self, **kwargs) -> OptimizationResult:\n raise NotImplementedError","def KL(self):\n\n self.build_cholesky_if_needed()\n\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\n\n for nd in range(self.num_nodes):\n q_sqrt_nd = self.q_sqrt_lst[nd]\n with params_as_tensors_for(q_sqrt_nd, convert=True):\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\n\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\n KL += 0.5 * tf.reduce_sum(\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\n\n return KL","def ref_main(l, k):\n S = sum(binomial(k, z)*(2*z-k)**l for z in range(k+1))\n return S / 2**k","def ref_main(l, k):\n S = sum(binomial(k, z)*(2*z-k)**l for z in range(k+1))\n return S / 2**k","def solution3(nums, K):\n modSeen = {0:-1}\n s = 0\n for i in range(len(nums)):\n n = nums[i]\n s += n\n mod = s % K if K != 0 else s\n if mod in modSeen:\n if i - modSeen[mod] > 1:\n return True\n else:\n modSeen[mod] = i\n return False","def C(n,k):\n if 0 <= k <= n:\n ntok = 1\n ktok = 1\n for t in xrange(1, min(k, n - k) + 1):\n ntok *= n\n ktok *= t\n n -= 1\n return ntok // ktok\n else:\n return 0","def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:\n\n if not nums:\n return 0\n\n if k <= 1:\n return 0\n\n count = 0\n lo = 0\n product = 1\n for hi in range(len(nums)):\n product *= nums[hi]\n while product >= k:\n product /= nums[lo]\n lo += 1\n count += hi - lo + 1\n return count","def dfs_recursion(self, tour, sque_v, gain):\n i = int(len(sque_v)/2) # step i done already\n dahuitou = (i + 1) % self.max_exchange == 0\n v_2i_2, v_2i_1 = sque_v[-2], sque_v[-1]\n # step i+1: search for (v_2i, v_2ip1)\n for v_2i in self.candidates[v_2i_1]:\n if v_2i in sque_v: # disjunctivity criterion\n continue\n new_gain = gain + self.cost[v_2i_2, v_2i_1] - self.cost[v_2i_1, v_2i]\n if new_gain <= 0:\n continue\n for v_2ip1 in tour.neighbours(v_2i):\n if v_2ip1 in sque_v: # disjunctivity criterion\n continue\n if dahuitou:\n if tour.check_feasible(sque_v+[v_2i, v_2ip1]):\n if new_gain + self.cost[v_2i, v_2ip1] - self.cost[v_2ip1, sque_v[0]] > 0:\n tour.k_exchange(sque_v + [v_2i, v_2ip1])\n return tour\n else:\n return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\n else: # optional, can be deleted\n continue\n else:\n if new_gain + self.cost[v_2i, v_2ip1] - self.cost[v_2ip1, sque_v[0]] > 0 and \\\n tour.check_feasible(sque_v+[v_2i, v_2ip1]):\n tour.k_exchange(sque_v + [v_2i, v_2ip1])\n return tour\n else:\n return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\n # if (i + 1) % self.max_exchange == 0:\n # continue\n # return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\n # gain += - self.cost[v_2i_1, v_2i] + self.cost[v_2i, v_2ip1]\n # if gain - self.cost[v_2ip1, sque_v[0]] > 0:\n # # check feasibility immediately\n # if tour.check_feasible(sque_v+[v_2i, v_2ip1]):\n # tour.k_exchange(sque_v + [v_2i, v_2ip1])\n # return tour\n # # if not feasible, check whether stop or search for next two nodes\n # if (i+1) % self.max_exchange == 0:\n # continue\n # delta_gain = self.cost[sque_v[2 * i - 2], sque_v[2 * i - 1]] - self.cost[sque_v[2 * i - 1], v_2i]\n # return self.dfs_recursion(tour, sque_v+[v_2i, v_2ip1], gain+delta_gain)\n return","def sym_K(self):\n raise NotImplementedError","def KRC(self, ik, ipd, ipl, t):\n idx = ik - 1\n\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\n num1 = self.delta[idx] * self.thetak[idx]\n ins = num1 / den1\n\n for l in np.arange(0, self.L):\n pl = self.coca.PL(l, t)\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\n\n ans = ipd * np.exp(t * ipl) * ins\n\n return ans","def solve(self, use_cache=True):\n if self.parallel:\n self.solve_all_parallel(use_cache)\n else:\n self.solve_all(use_cache)"],"string":"[\n \"def iterate(rk):\\n y = scipy.sparse.linalg.spsolve(P1, rk)\\n RHS = scipy.sparse.csr_matrix.dot(P4, y) + rk\\n zk = scipy.sparse.linalg.spsolve(P3, RHS)\\n return zk\",\n \"def fn(n, k):\\n if n == k: return 1\\n if k == 0: return 0\\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007\",\n \"def solve_dp(self, k, exp=1.0):\\n self.initialize_dp(k)\\n if not self.validate_tree(False):\\n raise AttributeError(\\\"Invalid tree cannot run dynamic program\\\")\\n self._solve_dp(self.nodes[self.root_id], exp=exp)\\n\\n return self.nodes[self.root_id].cost_matrix[self.k]\",\n \"def solution2(nums, K):\\n s = 0\\n sum_til = []\\n for n in nums:\\n s += n\\n sum_til.append(s)\\n\\n l = len(nums)\\n for i in range(l):\\n for j in range(i+1, l):\\n sum_ij = sum_til[j] if i == 0 else sum_til[j] - sum_til[i-1]\\n if K != 0 and sum_ij % K == 0:\\n return True\\n if K == 0 and sum_ij == 0:\\n return True\\n return False\",\n \"def fn(n, k):\\n if k == 1: return n \\n if n == 0: return 0 \\n ans = inf \\n for x in range(1, n+1): \\n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\\n return ans\",\n \"def fn(n, k):\\n if k == 0: return 1 \\n if n <= 0 or k < 0: return 0 \\n return fn(n-1, k) + fn(n, k-1) - fn(n-1, k-n)\",\n \"def fn(i, k):\\n if i == len(nums): return 0\\n if k < 0: return inf \\n ans = inf\\n rmx = -inf # range max \\n rsm = 0 # range sum \\n for j in range(i, len(nums)): \\n rmx = max(rmx, nums[j])\\n rsm += nums[j]\\n ans = min(ans, rmx*(j-i+1) - rsm + fn(j+1, k-1))\\n return ans\",\n \"def solve(self):\\n \\n raise NotImplementedError(\\\"not implemented!\\\")\",\n \"def _recover_solution(self, base_node, k):\\n if base_node is None:\\n print(\\\"None node passed to recover solution\\\")\\n return []\\n if k == 0:\\n return []\\n if base_node.is_leaf():\\n return [base_node.node_id]\\n optimal_left = base_node.left_optimal[k]\\n optimal_right = base_node.right_optimal[k]\\n left_solution = self._recover_solution(base_node.left_child, optimal_left)\\n right_solution = self._recover_solution(base_node.right_child,\\n optimal_right)\\n\\n return left_solution + right_solution\",\n \"def solve_problem(self, ra, kx, ky=0):\\n\\n if self._eqn_set == 0:\\n if self._atmosphere == 0:\\n if self.threeD:\\n self.atmosphere = polytropes.FC_polytrope_3d(\\n dimensions=1, comm=MPI.COMM_SELF, \\n grid_dtype=np.complex128, **self.atmo_kwargs)\\n self._eqn_kwargs['ky'] = ky*2*np.pi/self.atmosphere.Lz\\n else:\\n self.atmosphere = polytropes.FC_polytrope_2d(\\n dimensions=1, comm=MPI.COMM_SELF, \\n grid_dtype=np.complex128, **self.atmo_kwargs)\\n elif self._atmosphere == 1:\\n self.atmosphere = multitropes.FC_multitrope(\\n dimensions=1, comm=MPI.COMM_SELF, \\n grid_dtype=np.complex128, **self.atmo_kwargs)\\n kx_real = kx*2*np.pi/self.atmosphere.Lz\\n\\n #Set the eigenvalue problem using the atmosphere\\n self.atmosphere.set_eigenvalue_problem(ra, \\n *self._eqn_args, kx=kx_real, **self._eqn_kwargs)\\n self.atmosphere.set_BC(**self._bc_kwargs)\\n problem = self.atmosphere.get_problem()\\n\\n #Solve using eigentools Eigenproblem\\n self.eigprob = Eigenproblem(problem)\\n max_val, gr_ind, freq = self.eigprob.growth_rate({})\\n #Initialize atmosphere\\n if self.cf.rank == 0:\\n logger.info('Solving for onset with ra {:.8g} / kx {:.8g} / ky {:.8g} on proc 0'.\\\\\\n format(ra, kx, ky))\\n logger.info('Maximum eigenvalue found at those values: {:.8g}'.format(max_val))\\n \\n\\n if not np.isnan(max_val):\\n val = max_val + 1j*freq\\n if type(val) == np.ndarray:\\n return val[0]\\n else:\\n return val\\n else:\\n return np.nan\",\n \"def solve(k=[]):\\n if len(k) < 2:\\n return 1\\n min_jumps = len(k)\\n for i in reversed(range(k[0])):\\n if i > len(k):\\n return 1\\n if k[i] != 0:\\n sub_jumps = solve(k[i + 1 :])\\n min_jumps = min(min_jumps, sub_jumps)\\n return min_jumps\",\n \"def fn(n, k):\\n if n == 1: return k # base case \\n return sum(fn(n-1, kk) for kk in range(1, k+1))\",\n \"def _compute_parameters(self, p, k):\\n for i in range(self._.d + 1):\\n p[0, i, i] = k[i]\\n p[i, 0, i] = Integer(1)\\n p[i, i, 0] = Integer(1)\\n for i in range(self._.d):\\n p[i+1, 1, i+1] = self._.a[i+1]\\n p[i, 1, i+1] = self._.b[i]\\n p[i+1, 1, i] = self._.c[i+1]\\n for i in range(2, self._.d + 1):\\n for j in range(1, self._.d + 1):\\n for h in range(1, self._.d):\\n p[h, i, j] = self._check_parameter(\\n h, i, j,\\n _simplify(_expand((\\n self._.c[h] * p[h-1, i-1, j]\\n + self._.b[h] * p[h+1, i-1, j]\\n - self._.b[i-2] * p[h, i-2, j]\\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\\n ) / self._.c[i])))\\n p[self._.d, i, j] = self._check_parameter(\\n self._.d, i, j,\\n _simplify(_expand((\\n self._.c[self._.d] * p[self._.d-1, i-1, j]\\n - self._.b[i-2] * p[self._.d, i-2, j]\\n + (self._.a[self._.d] - self._.a[i-1])\\n * p[self._.d, i-1, j]\\n ) / self._.c[i])))\",\n \"def fn(k, i, j):\\n if not (0 <= i < N and 0 <= j < N): return 0\\n if k == 0: return 1 \\n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))\",\n \"def fn(m, k):\\n if m == 0 or k == 0: return 0 \\n return 1 + fn(m-1, k-1) + fn(m-1, k)\",\n \"def solve(self):\",\n \"def tri_recursion(k):\\r\\n if(k>0):\\r\\n result = k + tri_recursion(k-1)\\r\\n # print(result)\\r\\n else:\\r\\n result = 0\\r\\n\\r\\n return result\",\n \"def dpsearch(points,k):\\n\\t#M = k\\n\\tpoints = np.sort(points,axis=0)\\n\\tL = len(points)\\n\\tM = k\\n\\tT = list(np.zeros(M+1,dtype='int'))\\n\\tT[0] = 0\\t#first threshold is by default always set to index 0 in trellis graph.\\n\\tT[M] = L \\t#last threshold is by default always set to last number in input points.\\n\\ttrellis_value = np.full((M+1,L+1),np.inf)\\n\\ttrellis_backpointer = np.full((M+1,L+1),np.inf)\\n\\n\\t# Stage 1: m=1\\t\\n\\tfor l in range(1,L-M+2):\\n\\t\\ttrellis_value[1][l] = ((l-0)/float(L))*np.var(points[0:l])\\n\\t\\ttrellis_backpointer[1][l] = 0\\n\\n\\t\\n\\tif(M>2):\\n\\t\\t# Stage 2: m=2 to m=M-1\\n\\t\\tfor m in range(2,M):\\n\\t\\t\\tfor l in range(m,L-M+m+1):\\n\\t\\t\\t\\t#finding optimal path\\n\\t\\t\\t\\tJ_min = np.inf\\n\\t\\t\\t\\tJ_temp = np.inf\\n\\t\\t\\t\\tfor i in range(m-1,l):\\n\\t\\t\\t\\t\\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\\n\\t\\t\\t\\t\\tif J_temp < J_min:\\n\\t\\t\\t\\t\\t\\tJ_min = J_temp\\n\\t\\t\\t\\t\\t\\tptr = i\\n\\t\\t\\t\\t\\n\\t\\t\\t\\ttrellis_value[m][l],trellis_backpointer[m][l] = J_min,ptr\\n\\t\\t\\t\\t\\n\\n\\t# Stage 3: m=M\\n\\tm = M\\n\\tl = L\\n\\t#finding optimal path\\n\\tJ_min = np.inf\\n\\tJ_temp = np.inf\\n\\tfor i in range(m-1,l):\\n\\t\\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\\n\\t\\tif J_temp < J_min:\\n\\t\\t\\tJ_min = J_temp\\n\\t\\t\\tptr = i\\n\\n\\t\\n\\ttrellis_value[M][L] = J_min\\n\\ttrellis_backpointer[M][L] = ptr\\n\\t\\n\\t\\n\\t# Backtracking\\n\\tl = L\\n\\tm = M\\n\\twhile m>=2:\\n\\t\\tT[m-1] = int(trellis_backpointer[m][l])\\n\\t\\tl = int(trellis_backpointer[m][l])\\n\\t\\tm = m - 1\\n\\n\\t#Assign cluster labels\\n\\tlabels = np.full(len(points),0)\\n\\tj = T[0]\\n\\tcounter = 0\\n\\tfor i in range(1,k+1):\\n\\t\\tlabels[j:T[i]] = counter\\n\\t\\tj = T[i]\\n\\t\\tcounter += 1\\n\\n\\n\\treturn labels,T\",\n \"def pow_derpy(x, k):\\n if k == 1:\\n return x\\n if k == 0:\\n return 1\\n\\n return x * pow_derpy(x, k - 1)\",\n \"def nchoosek(n, k):\\n if (n, k) in known:\\n return known[(n,k)]\\n if k == 0:\\n return 1\\n if n == k:\\n return 1\\n if n < k:\\n return \\\"n must be greater than k\\\"\\n result = nchoosek(n - 1, k - 1) + nchoosek(n - 1, k)\\n known[(n,k)] = result\\n return result\",\n \"def solve(arr, k):\\n if k < 1:\\n return arr\\n first_element = arr[0]\\n for i in range(len(arr) - 1):\\n arr[i] = arr[i + 1]\\n arr[-1] = first_element\\n return solve(arr, k - 1)\",\n \"def fn(k):\\n if k <= 1: return 1\\n return fn(k-1) + fn(k-2)\",\n \"def solve(k, text, pattern):\\n # print(k, text, pattern)\\n base = pow(10, 9)\\n M1 = base + 7\\n M2 = base + 9\\n X = 263\\n len_p = len(pattern)\\n len_t = len(text)\\n pattern1, pattern2 = pre_compute_hashes(pattern, M1, M2, X)\\n text1, text2 = pre_compute_hashes(text, M1, M2, X)\\n res = []\\n p_hash1, p_hash2 = get_hash_value(\\n pattern1, M1, X, 0, len_p), get_hash_value(pattern2, M2, X, 0, len_p)\\n for i in range(len_t-len_p+1): # all possible candidates\\n subs_hash1 = get_hash_value(text1, M1, X, i, len_p)\\n subs_hash2 = get_hash_value(text2, M2, X, i, len_p)\\n is_valid = find_num_matches(pattern1, pattern2, text1, text2, M1, M2, X, k, len_p, i)\\n if is_valid:\\n res.append(i)\\n return res\",\n \"def convergentOfSqrt2(k):\\n if memo[k]:\\n return memo[k]\\n \\n if k == 1:\\n memo[1] = (3,2)\\n else:\\n a,b = convergentOfSqrt2(k-1)\\n # add one, invert, add one\\n a += b\\n a,b = b,a\\n a += b\\n memo[k] = (a,b)\\n\\n return memo[k]\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def solve(self):\\n pass\",\n \"def solve(self):\\n pass\",\n \"def dynamic_iteration(k, n):\\n # If only one egg remains, n attempts must be made to find the correct floor.\\n if k == 1:\\n return n\\n # Lookup table for previous solutions.\\n W = [[0 for y in range(n + 1)] for x in range(k)]\\n # Initialize the first row.\\n for i in range(n + 1):\\n W[0][i] = i\\n # Start on second row, working downward.\\n for i in range(1, k):\\n # Calculate values for each cell.\\n for j in range(1, n + 1):\\n W[i][j] = min((max(W[i][j - x], W[i - 1][x - 1]) for x in range(1, j + 1))) + 1\\n # Return the result.\\n return W[k - 1][n]\",\n \"def solve(self):\\n raise NotImplementedError(\\\"This method needs to be implemented.\\\")\",\n \"def recover_dp_solution(self):\\n return self._recover_solution(self.nodes[self.root_id], self.k)\",\n \"def fn(k, i):\\n ii = -1 \\n for x in path:\\n if gcd(nums[k], x) == 1: # coprime \\n if path[x] and path[x][-1][1] > ii: \\n ans[k] = path[x][-1][0]\\n ii = path[x][-1][1]\\n \\n path.setdefault(nums[k], []).append((k, i))\\n for kk in tree.get(k, []): \\n if kk not in seen: \\n seen.add(kk)\\n fn(kk, i+1)\\n path[nums[k]].pop()\",\n \"def n_choose_k(N,K):\\n return factorial(N) // (factorial(N - K) * factorial(K))\",\n \"def f_exact(n, k):\\n def fact(m):\\n return math.factorial(m)\\n\\n partition = part(n, k)\\n\\n total = 0\\n for p in partition:\\n product = 1\\n nodes_left = n\\n counts = dict([(x, len(list(y))) for x, y in itertools.groupby(p)])\\n for num in p:\\n product *= fact(num - 1) * comb(nodes_left, num)\\n nodes_left -= num\\n for num in counts:\\n product /= fact(counts[num])\\n\\n total += product\\n return int(total)\",\n \"def adjust_k(self, ):\\n self.iteration += 1\\n\\n if self.max_violation:\\n self.k = 1\\n return 1.\\n\\n self.k = (1.-self.beta**np.float(self.iteration))\\n return self.k\",\n \"def adjust_k(self, ):\\n self.iteration += 1\\n\\n if self.max_violation:\\n self.k = 1\\n return 1.\\n\\n self.k = (1.-self.beta**np.float(self.iteration))\\n return self.k\",\n \"def solve():\\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\\n return binomial_coefficient(20 + 20, 20)\",\n \"def approxk( X, k ):\\n U, D, Vt = svdk( X, k )\\n return U.dot( diag( D ) ).dot( Vt )\",\n \"def __kappa_mle(self, k, R):\\n return (iv(1, k) / iv(0, k)) - R\",\n \"def beautifulSubsets(self, nums: List[int], k: int) -> int:\\n\\n \\\"\\\"\\\"\\n queue = deque([([], -1)])\\n res = 0\\n\\n while queue:\\n cur, idx = queue.popleft()\\n res += 1\\n\\n for i in range(idx + 1, len(nums)):\\n if nums[i] - k in cur or nums[i] + k in cur:\\n continue\\n\\n queue.append((cur + [nums[i]], i))\\n\\n return res - 1\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n # dp0 is the ways that without A[i]\\n # dp1 is the ways that with A[i]\\n\\n count = [Counter() for i in range(k)]\\n for n in nums:\\n count[n % k][n] += 1\\n\\n res = 1\\n for i in range(k):\\n prev, dp0, dp1 = 0, 1, 0\\n for n in sorted(count[i]):\\n v = pow(2, count[i][n])\\n if prev + k == n:\\n dp0, dp1 = dp0 + dp1, dp0 * (v - 1)\\n else:\\n dp0, dp1 = dp0 + dp1, (dp0 + dp1) * (v - 1)\\n\\n prev = n\\n\\n res *= dp0 + dp1\\n\\n return res - 1\\n \\\"\\\"\\\"\\n\\n # Count the frequency of A, and then consider all the arithmetic sequence with difference k.\\n # Each arithmetic sequence can be solve as a hourse robber problem.\\n # We solve the hourse robber by dp.\\n # dp(a) return the result for sequence no bigger than a.\\n\\n # dp(a)[0] is the ways that without a\\n # dp(a)[1] is the ways that with a\\n\\n # dp(a)[0] = dp(a - k)[0] + dp(a - k)[1]\\n # dp(a)[1] = dp(a - k)[0] * (2 ^ count(a) - 1\\n\\n count = Counter(nums)\\n\\n def dp(n):\\n dp0, dp1 = dp(n - k) if n - k in count else (1, 0)\\n return dp0 + dp1, dp0 * (pow(2, count[n]) - 1)\\n\\n return functools.reduce(operator.mul, (sum(dp(n)) for n in count if not count[n + k])) - 1\",\n \"def calc_k(self):\\n\\t\\n\\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\\n\\n\\treturn\",\n \"def kktsolver(x, z, W):\\n\\n if debug:\\n logger.debug(\\\"Setup kkt solver\\\")\\n logger.debug(\\\"W\\\")\\n for key in W.keys():\\n logger.debug(\\\"key: %s\\\" % (key,))\\n logger.debug(W[key])\\n\\n H = hessian(x)\\n if debug:\\n logger.debug(\\\"diag H\\\")\\n logger.debug(np.diag(H))\\n _H = cvxopt.spdiag(list(np.diag(H))) if H is not None else None\\n\\n wdi = W[\\\"di\\\"]\\n Wdi2 = cvxopt.spdiag(cvxopt.mul(wdi, wdi))\\n\\n S = G.T * Wdi2\\n P = S * G\\n\\n Q = _H + P\\n # now, do the cholesky decomposition of Q\\n cvxopt.lapack.potrf(Q)\\n\\n if False and fn is not None:\\n logger.debug(\\\"At setup f(x) = %d\\\" % (fn(np.array(list(x))),))\\n\\n def f(x, y, z):\\n if False and fn is not None:\\n logger.debug(\\\"f(x) = %d\\\" % (fn(np.array(list(x))),))\\n try:\\n # logger.debug(\\\"Compute x := S * z + x...\\\")\\n cvxopt.blas.gemv(S, z, x, alpha=1.0, beta=1.0) # x = S * z + x\\n cvxopt.lapack.potrs(Q, x)\\n except BaseException as e:\\n logger.debug(exception_to_string(sys.exc_info()))\\n raise e\\n cvxopt.blas.gemv(G, x, z, alpha=1.0, beta=-1.0) # z = _G * x - z\\n z[:] = cvxopt.mul(wdi, z) # scaled z\\n # raise NotImplementedError(\\\"Method Not implemented yet\\\")\\n return f\",\n \"def solve(self):\\n # check for jacobian and set it if present and to be used\\n if self.use_sparse:\\n if self._use_jac and hasattr(self.problem,'sparse_jac'):\\n jac = self.problem.sparse_jac\\n else:\\n jac = None\\n else:\\n if self._use_jac and hasattr(self.problem,'jac'):\\n jac = self.problem.jac\\n else:\\n jac = None\\n \\n # Initialize solver and solve \\n \\n solved = False\\n local_min = False\\n\\n res = N.zeros(self.x0.__len__())\\n while (not solved) and self.reg_count < 2:\\n try:\\n if self._use_fscale:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,self.fscale)\\n else:\\n self.solver.KINSOL_init(self.func,self.x0,self.dim,jac,self.constraints,self.use_sparse,self.verbosity,self.norm_of_res,self.reg_param,None)\\n start = time.clock()\\n res = self.solver.KINSOL_solve(not self._use_ls)\\n stop = time.clock()\\n self.exec_time += (stop - start)\\n solved = True\\n except KINError as error:\\n if error.value == 42:\\n # Try the heuristic\\n if hasattr(self.problem, 'get_heuristic_x0'):\\n print \\\"----------------------------------------------------\\\"\\n print \\\" Solver stuck with zero step-length.\\\"\\n print \\\"----------------------------------------------------\\\"\\n print \\\"The following variables have start value zero\\\"\\n print \\\"and min set to zero causing the zero step-lenght.\\\"\\n print \\\"These settings are either set by default or by user.\\\"\\n print \\\"\\\"\\n\\n self.x0 = self.problem.get_heuristic_x0()\\n self.reg_count += 1\\n \\n print \\\"\\\"\\n print \\\"This setting (start and min to zero) can often\\\"\\n print \\\"cause problem when initializing the system. \\\"\\n print \\\"\\\"\\n print \\\"To avoid this the above variables have\\\"\\n print \\\"their start attributes reset to one.\\\"\\n print \\\"\\\"\\n print \\\"Trying to solve the system again...\\\"\\n else:\\n raise KINSOL_Exception(\\\"Regularization failed due to constraints, tried getting heuristic initial guess but failed.\\\")\\n \\n\\n elif (error.value == 2):\\n print \\\"---------------------------------------------------------\\\"\\n print \\\"\\\"\\n print \\\" !!! WARNING !!!\\\"\\n print \\\"\\\"\\n print \\\" KINSOL has returned a result but the algorithm has converged\\\"\\n print \\\" to a local minima, the initial values are NOT consistant!\\\"\\n print \\\"\\\"\\n print \\\"---------------------------------------------------------\\\"\\n solved = True\\n local_min = True\\n else:\\n # Other error, send onward as exception\\n self.problem.check_constraints(res)\\n raise KINSOL_Exception(error.msg[error.value])\\n \\n if not solved:\\n self.solver.Free_KINSOL()\\n raise KINSOL_Exception(\\\"Algorithm exited solution loop without finding a solution, please contact Assimulo support.\\\")\\n\\n if self.check_with_model:\\n self.problem.check_constraints(res)\\n if not local_min:\\n print \\\"Problem sent to KINSOL solved.\\\"\\n \\n return res\",\n \"def naive_recursive(k, n):\\n # If no floors remaining, no more attempts need to be made.\\n if n == 0:\\n return 0\\n # It will take n attempts to find the correct floor if there is only one egg remaining.\\n if k == 1:\\n return n\\n # Solve the problem recursively.\\n return min((max(naive_recursive(k, n - x), naive_recursive(k - 1, x - 1)) + 1 for x in range(1, n + 1)))\",\n \"def k(self):\\n return add(self.k_b(), self.k_m())\",\n \"def count_k(n, k):\\n if n == 0:\\n return 1\\n elif n < 0:\\n return 0\\n else:\\n total = 0\\n i = 1\\n while i <= k:\\n total += count_k(n - i, k)\\n i += 1\\n return total\",\n \"def pow_better(x, k):\\n if k == 1:\\n return x\\n if k == 0:\\n return 1\\n\\n if k % 2 == 1:\\n return x * pow_better(x, k - 1)\\n else:\\n return pow_better(x * x, k / 2)\",\n \"def solve(self):\\n for step in self.run.values():\\n step.solve()\",\n \"def solve(self):\\n ...\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def combination(n, k):\\n if (k > n) or (n < 0) or (k < 0):\\n return 0\\n val = 1\\n for j in range(min(k, N - k)):\\n val = (val * (N - j)) // (j + 1)\\n return val\",\n \"def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\\n ##\\n if iszero ( C ) :\\n return findroot ( fun , xmin , xmax , args = args )\\n ##\\n func = lambda x , *a : fun(x,*a)-C\\n return findroot ( func , xmin , xmax , args = args )\",\n \"def eval_K_chol(self, S, sigma_n, sigma_f):\\n K = self.eval_K(S)\\n K += sigma_n * np.eye(K.shape[0])\\n K_chol = jitchol(K)\\n return K_chol\",\n \"def nCk(n, k):\\n return factorial(n)//factorial(k)//factorial(n-k)\",\n \"def calc(k):\\n n = factorial(4*k) * (1103.0 + 26390.0*k)\\n d = factorial(k)**4 * 396.0**(4.0*k)\\n z = n/d\\n return z\",\n \"def fn(stack, x, k=0):\\n if x == 0: return ans.append(stack.copy()) #store a copy \\n for i in range(k, len(candidates)): \\n if candidates[i] > x: break \\n stack.append(candidates[i])\\n fn(stack, x-candidates[i], i)\\n stack.pop()\",\n \"def solution(n: int, k: int, coins: list):\\n \\n path_best = deque([0])\\n \\n buff = Queue()\\n buff.put(0)\\n \\n profit_curr = 0\\n n_jumps = 0\\n while not buff.empty():\\n curr = buff.get()\\n profit_max_ = None\\n jump_best = None\\n for delta in range(1, k+1):\\n jump = delta + curr\\n if jump >= n:\\n break\\n profit = profit_curr + coins[jump]\\n if profit_max_ is None or profit_max_ < profit:\\n jump_best = jump\\n profit_max_ = profit\\n if coins[jump] >= 0:\\n break\\n if jump_best is not None:\\n profit_curr = profit_max_\\n buff.put(jump_best)\\n path_best.append(jump_best)\\n n_jumps += 1\\n return n_jumps, profit_curr, [x for x in path_best]\",\n \"def K(self):\\n\\n # Calculate and return the stiffness matrix in global coordinates\\n return matmul(matmul(inv(self.T()), self.k()), self.T())\",\n \"def kepler(x, k=1.0):\\n assert(x.shape[2] == 1)\\n\\n q,p = extract_q_p(x)\\n # The derivative of r wrt q is 1/sqrt(sum(q^2)), which is singular in 0.\\n # Cutoff r so that it is > eps.\\n eps = 1e-5\\n r = tf.sqrt(tf.reduce_sum(tf.square(q), axis=1) + eps)\\n return tf.squeeze(0.5 * tf.reduce_sum(tf.square(p), axis=1) + k / r)\",\n \"def find_k(i, j):\\n\\n result = ((i * i) + (j * j)) ** 0.5\\n return result\",\n \"def solve(self):\\n # a stack of queries (aka subproblems to be solved)\\n stack = []\\n initial_query = (len(self.items), self.knapsack_size)\\n stack.append(initial_query)\\n # Run as long as there are subproblems that need to be solved.\\n # - this might not pass through all possible subproblems; in fact, \\n # we're counting on it\\n # - it will only pass through the subproblems that the initial \\n # problem needs solved\\n while len(stack) > 0:\\n (end, ksize) = stack[-1]\\n # this is the subproblem where we have only items self.items[:end]\\n # and the knapsack size is ksize\\n if self.items[end - 1].size > ksize:\\n # item end-1 does not fit\\n try:\\n # retrieve subproblem result from the cache\\n self._cache[(end, ksize)] = self._cache[(end - 1, ksize)]\\n except KeyError:\\n # subproblem hasn't been solved yet, put it on the stack\\n stack.append((end - 1, ksize))\\n continue\\n else:\\n # item end-1 fits; we get two subproblems:\\n # - one if we don't include item end-1 in the knapsack\\n # - one if we do include it\\n sub1 = (end - 1, ksize)\\n sub2 = (end - 1, ksize - self.items[end - 1].size)\\n try:\\n # retrieve 1st subproblem's result from the cache and \\n # compute max value if we don't include item end-1\\n val1 = self._cache[sub1]\\n except KeyError:\\n # subproblem hasn't been solved yet, put it on the stack\\n stack.append(sub1)\\n continue\\n try:\\n # retrieve 2nd subproblem's result from the cache and\\n # compute max value if we do include item end-1\\n val2 = self.items[end - 1].value + self._cache[sub2]\\n except KeyError:\\n # subproblem hasn't been solved yet, put it on the stack\\n stack.append(sub2)\\n continue\\n # is it better to include item end-1 or not?\\n self._cache[(end, ksize)] = max(val1, val2)\\n # done with this subproblem\\n stack.pop()\\n return self._cache[(initial_query)]\",\n \"def _K_computations(self, X, X2):\\r\\n # First extract times and indices.\\r\\n self._extract_t_indices(X, X2)\\r\\n\\r\\n self._K_compute_eq()\\r\\n self._K_compute_ode_eq()\\r\\n if X2 is None:\\r\\n self._K_eq_ode = self._K_ode_eq.T\\r\\n else:\\r\\n self._K_compute_ode_eq(transpose=True)\\r\\n self._K_compute_ode()\\r\\n\\r\\n if X2 is None:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\\r\\n else:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\\r\\n\\r\\n # Reorder values of blocks for placing back into _K_dvar.\\r\\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\\r\\n np.hstack((self._K_ode_eq, self._K_ode))))\\r\\n self._K_dvar = self._K_dvar[self._rorder, :]\\r\\n self._K_dvar = self._K_dvar[:, self._rorder2]\\r\\n \\r\\n \\r\\n if X2 is None:\\r\\n # Matrix giving scales of each output\\r\\n self._scale = np.zeros((self._t.size, self._t.size))\\r\\n code=\\\"\\\"\\\"\\r\\n for(int i=0;i<N; i++){\\r\\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\\r\\n for(int j=0; j<i; j++){\\r\\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\\r\\n scale_mat[i+j*N] = scale_mat[j+i*N];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index = self._scale, self.B, self._index\\r\\n N, output_dim = self._t.size, self.output_dim\\r\\n weave.inline(code,['index',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'output_dim'])\\r\\n else:\\r\\n self._scale = np.zeros((self._t.size, self._t2.size))\\r\\n code = \\\"\\\"\\\"\\r\\n for(int i=0; i<N; i++){\\r\\n for(int j=0; j<N2; j++){\\r\\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\\r\\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\\r\\n weave.inline(code, ['index', 'index2',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'N2', 'output_dim'])\",\n \"def solve(self, cipher):\\n N, K, C = cipher\\n\\n C.sort(reverse=True)\\n\\n group_cnt = N / K + 1 # 1 is the last remaining group\\n total_cost = 0\\n for i in xrange(group_cnt):\\n unit_cost = i + 1\\n total_cost += unit_cost * sum(C[i * K:(i + 1) * K])\\n return total_cost\",\n \"def func_ludwik(eps,k,sig0,n):\\n return sig0 + k*eps**n\",\n \"def fn(stack, x, k=0):\\n if x == 0: return ans.append(stack.copy())\\n for i in range(k, len(candidates)):\\n if candidates[i] > x: break \\n if i > k and candidates[i] == candidates[i-1]: continue\\n stack.append(candidates[i])\\n fn(stack, x - candidates[i], i+1)\\n stack.pop()\",\n \"def solver(self, theta):\\n\\n m = len(self.x)\\n n = len(self.t[0])\\n h = self.step_x\\n k = self.step_t\\n lamb = k / (h * h)\\n w = np.zeros(m + 1)\\n l = np.zeros(m + 1)\\n u = np.zeros(m + 1)\\n\\n uK = np.zeros(self.x.shape)\\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\\n startTime = time.clock()\\n if self.first:\\n self.uR = np.zeros(self.x.shape)\\n self.first = False\\n error = 0\\n errorCurve = np.zeros(self.x.shape)\\n z = np.zeros(m + 1)\\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\\n for i in range(1, m - 1):\\n w[i] = self.g(i * h)\\n\\n l[1] = 1 + lamb\\n u[1] = -lamb / (2 * l[1])\\n for i in range(2, m - 1):\\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\\n u[i] = -lamb / (2 * l[i])\\n\\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\\n for j in range(1, n + 1):\\n t = j * k # current t\\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\\n for i in range(2, m):\\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\\n w[m - 1] = z[m - 1]\\n for i in range(m - 2, 0, -1):\\n w[i] = z[i] - u[i] * w[i + 1]\\n\\n for i in range(0, m + 1):\\n x = i * h\\n # print(x, w[i])\\n # print('oi')\\n uK[i - 1, j - 1] = w[i]\\n self.t[i - 1, j - 1] = t\\n self.x[i - 1, j - 1] = x\\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\\n return (uK, error, errorCurve, theta)\",\n \"def solution(N, K):\\n\\n # not really sure what to return if N=1, it should be invalid?\\n rounds = N - 1\\n next_num = N\\n while K > 0 and next_num >= 4:\\n next_num = next_num - next_num % 2\\n next_num = next_num // 2\\n rounds -= (next_num - 1)\\n K -= 1\\n return rounds\",\n \"def solve():\\n n = int(input())\\n m = int(input())\\n Ks = list(map(int, input().split()))\\n\\n # 4重ループにより全探索\\n for a in range(n):\\n for b in range(n):\\n for c in range(n):\\n for d in range(n):\\n if Ks[a]+Ks[b]+Ks[c]+Ks[d] == m:\\n print(\\\"Yes\\\")\\n return\\n print(\\\"No\\\")\",\n \"def _cal_limb(self, S, Y, k):\\r\\n if k > S.shape[0]:\\r\\n k = S.shape[0]\\r\\n \\r\\n S1 = S - np.diag(np.diag(S)) # ensure diagonal elements are 0\\r\\n neigh = NearestNeighbors(n_neighbors=k, metric='precomputed')\\r\\n neigh.fit(np.zeros(S1.shape))\\r\\n knns = neigh.kneighbors(1 - S1, return_distance=False)\\r\\n \\r\\n C = np.zeros(Y.shape, dtype=float)\\r\\n for i in range(Y.shape[0]):\\r\\n ii = knns[i]\\r\\n for j in range(Y.shape[1]):\\r\\n if Y[i,j] == 1: # only consider \\\"1\\\" \\r\\n C[i,j] = k-np.sum(Y[ii,j])\\r\\n C = C/k\\r\\n \\r\\n return C\",\n \"def solve(n, k):\\n o = [True] + [False] * n + [True] # whether it's occupied\\n # initialize Ls and Rs\\n Ls = [-1] + [i for i in range(n)] + [-1]\\n Rs = Ls[::-1] # Ls reversed\\n\\n for i in range(k):\\n # find where min(Ls,Rs) is maximal\\n min_ = 0\\n for j in range(n+1):\\n if not o[j]:\\n if min(Ls[j], Rs[j]) > min_:\\n min_ = min(Ls[j], Rs[j])\\n\\n # check if there is more than one\\n pos = None\\n max_ = 0\\n for j in range(n+1):\\n if not o[j]:\\n if min(Ls[j], Rs[j]) == min_:\\n if (pos is None) or (pos is not None and max(Ls[j], Rs[j]) > max_):\\n pos = j\\n max_ = max(Ls[j], Rs[j])\\n\\n # take pos\\n maxs = max(Rs[pos], Ls[pos])\\n mins = min(Rs[pos], Ls[pos])\\n\\n o[pos] = True\\n Rs[pos] = -1\\n Ls[pos] = -1\\n\\n # update Ls and Rs\\n l = pos # index of first occupied left to position taken\\n while l > 0 and not o[l - 1]:\\n l -= 1\\n for x in range(pos - l):\\n Ls[l + x] = x\\n Rs[l + x] = pos - l - x - 1\\n\\n r = pos # index of first occupied right to position taken\\n while r <= n and not o[r + 1]:\\n r += 1\\n for x in range(r - pos):\\n Ls[pos + x + 1] = x\\n Rs[pos + x + 1] = r - pos - x - 1\\n\\n return str(maxs) + \\\" \\\" + str(mins)\",\n \"def choose(n, k):\\n\\n if n == k:\\n return 1\\n elif k == 1:\\n return n\\n elif k == 2:\\n return n * (n - 1) // 2\\n else:\\n return fact(n) // (fact(n - k) * fact(k))\",\n \"def fn(n, k):\\n if n <= k: return 0 # one mailbox for each house\\n if k == 1: return mdist[0][n-1]\\n ans = inf \\n for nn in range(k-1, n): \\n ans = min(ans, fn(nn, k-1) + mdist[nn][n-1])\\n return ans\",\n \"def eval_K(self, S):\\n K = (self.eigenfunctions[self.X] * S[None, :]) @ \\\\\\n self.eigenfunctions[self.X].T # shape (n,n)\\n return K\",\n \"def _K_computations(self, X, X2):\\r\\n if self.ARD:\\r\\n pass\\r\\n else:\\r\\n if X2 is None:\\r\\n self._K_inner_prod = np.dot(X,X.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\\r\\n vec = np.diag(self._K_numer) + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec,vec))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\\r\\n else:\\r\\n self._K_inner_prod = np.dot(X,X2.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\\r\\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\",\n \"def newton(n, k):\\n if k == 0 or k == n:\\n return 1\\n else:\\n return newton(n - 1, k - 1) + newton(n - 1, k)\",\n \"def solve(max_k=12000, min_k=2):\\r\\n float_inf = float('inf')\\r\\n min_ps_numbers = [float_inf] * (max_k - min_k + 1)\\r\\n\\r\\n for i in count(1):\\r\\n # I would like a better way of looking for the max than just checking to see that all values are\\r\\n # not inf, however this is only a minor portion of the runtime.\\r\\n if float_inf not in min_ps_numbers:\\r\\n break\\r\\n\\r\\n composite_factoring = factorint(i, multiple=True)\\r\\n for prod_len in range(2, len(composite_factoring) + 1):\\r\\n for multiplicative_partition in kbins(composite_factoring, prod_len, 0):\\r\\n multiplicative_partition = [prod(x) for x in multiplicative_partition]\\r\\n multiplicative_partition_sum = sum(multiplicative_partition)\\r\\n one_count = i - multiplicative_partition_sum\\r\\n k = one_count + len(multiplicative_partition)\\r\\n array_k = k - min_k\\r\\n if array_k < len(min_ps_numbers) and min_ps_numbers[array_k] > i:\\r\\n min_ps_numbers[array_k] = i\\r\\n\\r\\n return sum(set(min_ps_numbers))\",\n \"def optimization_rel_disp_K(self, step_size, dof1, dof2, controlDOF):\\n \\\"\\\"\\\"First, the initial variance of the system is computed for the matrices given by the user\\\"\\\"\\\"\\n Variance = []\\n \\\"\\\"\\\"The sign variable keeps track of the direction the algorithm is stepping\\\"\\\"\\\"\\n sign = [0]\\n Variance.append(self.VarianceOfResponse())\\n\\n \\\"\\\"\\\"The matrix K is incremented by one step with size = step_size. for the spring that connects dof1 and dof2\\\"\\\"\\\"\\n sign.append(1)\\n self.incrementK(step_size, dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n\\n \\\"\\\"\\\"Loop that iteratively steps down the optimal direction of increasing or reducing K\\\"\\\"\\\"\\n i = 0\\n while len(sign) < 4 or np.sum(sign[-4:]) != 0 or i < 100:\\n i += 1\\n print(abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]))\\n \\\"\\\"\\\"First condition demands a minimum of 4 steps. Second condition sums up the direction of the last 4 steps\\n if the sum equals 0, the minimum value for the variance has been found.\\\"\\\"\\\"\\n if abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\\\\n > abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\\n \\\"\\\"\\\"If the last variance is smaller than the variance before, keep going in that direction.\\\"\\\"\\\"\\n self.incrementK(step_size * sign[-1], dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n sign.append(sign[-1])\\n elif abs(Variance[-2][int(controlDOF[0] - 1)] - Variance[-2][int(controlDOF[1] - 1)]) \\\\\\n < abs(Variance[-1][int(controlDOF[0] - 1)] - Variance[-1][int(controlDOF[1] - 1)]):\\n \\\"\\\"\\\"If the last variance is bigger than the one before, turn around and go the other way.\\\"\\\"\\\"\\n self.incrementK(step_size * sign[-1] * -1, dof1, dof2)\\n Variance.append(self.VarianceOfResponse())\\n sign.append(sign[-1] * -1)\\n return Variance\",\n \"def solution(A, K):\\n if len(A) == 0 or len(A) == 1 or len(A) == K:\\n return A\\n\\n K = K % len(A)\\n\\n if K == 1:\\n return A[-1:] + A[:-1]\\n\\n return A[-K:] + A[:-K]\",\n \"def calc_k_dot_r(self):\\n\\t\\n\\tself.k_dot_r = self.k[0]*self.rij[0,:,:,:] + self.k[1]*self.rij[1,:,:,:] + self.k[2]*self.rij[2,:,:,:]\\n\\t\\n\\treturn\",\n \"def _K_computations(self, X, X2=None):\\r\\n self._lengthscales=self.mapping.f(X)\\r\\n self._lengthscales2=np.square(self._lengthscales)\\r\\n if X2==None:\\r\\n self._lengthscales_two = self._lengthscales\\r\\n self._lengthscales_two2 = self._lengthscales2\\r\\n Xsquare = np.square(X).sum(1)\\r\\n self._K_dist2 = -2.*tdot(X) + Xsquare[:, None] + Xsquare[None, :]\\r\\n else:\\r\\n self._lengthscales_two = self.mapping.f(X2)\\r\\n self._lengthscales_two2 = np.square(self._lengthscales_two)\\r\\n self._K_dist2 = -2.*np.dot(X, X2.T) + np.square(X).sum(1)[:, None] + np.square(X2).sum(1)[None, :]\\r\\n self._w2 = self._lengthscales2 + self._lengthscales_two2.T\\r\\n prod_length = self._lengthscales*self._lengthscales_two.T\\r\\n self._K_exponential = np.exp(-self._K_dist2/self._w2)\\r\\n self._K_dvar = np.sign(prod_length)*(2*np.abs(prod_length)/self._w2)**(self.input_dim/2.)*np.exp(-self._K_dist2/self._w2)\",\n \"def solve(self):\\n\\n # Open status display\\n fmtstr, nsep = self.display_start()\\n\\n # Start solve timer\\n self.timer.start(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Main optimisation iterations\\n for self.k in range(self.k, self.k + self.opt['MaxMainIter']):\\n\\n # Update record of X and Y from previous iteration\\n self.on_iteration_start()\\n\\n # Compute backtracking\\n if self.opt['Backtrack'] is not None and self.k >= 0:\\n self.timer.stop('solve_wo_btrack')\\n # Compute backtracking\\n self.backtrack.update(self)\\n self.timer.start('solve_wo_btrack')\\n else:\\n # Compute just proximal step\\n self.xstep()\\n # Update by combining previous iterates\\n self.ystep()\\n\\n # Compute residuals and stopping thresholds\\n self.timer.stop(['solve_wo_rsdl', 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n frcxd, adapt_tol = self.compute_residuals()\\n self.timer.start('solve_wo_rsdl')\\n\\n # Compute and record other iteration statistics and\\n # display iteration stats if Verbose option enabled\\n self.timer.stop(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n if not self.opt['FastSolve']:\\n itst = self.iteration_stats(self.k, frcxd)\\n self.itstat.append(itst)\\n self.display_status(fmtstr, itst)\\n self.timer.start(['solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Call callback function if defined\\n if self.opt['Callback'] is not None:\\n if self.opt['Callback'](self):\\n break\\n\\n # Stop if residual-based stopping tolerances reached\\n if not self.opt['FastSolve']:\\n if frcxd < adapt_tol:\\n break\\n\\n # Increment iteration count\\n self.k += 1\\n\\n # Record solve time\\n self.timer.stop(['solve', 'solve_wo_func', 'solve_wo_rsdl',\\n 'solve_wo_btrack'])\\n\\n # Print final separator string if Verbose option enabled\\n self.display_end(nsep)\\n\\n return self.getmin()\",\n \"def choose(n, k):\\n ans, k = 1, min(k, n-k)\\n for i in range(k):\\n ans *= n-i\\n ans //= i+1\\n return ans\",\n \"def kspace_linear_solve(self, other):\\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\\n self_k = transform(self, np.fft.fftn, n_points = n_points)\\n other_k = transform(other, np.fft.fftn, n_points = n_points)\\n\\n ret = tmat()\\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\\n #ret = self_k*1.0\\n ret.blocks*=0.0\\n\\n #ret.blocks[:-1] = np.einsum(\\\"ijk,ikl->ijl\\\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\\n\\n for i in np.arange(len(self_k.blocks)-1):\\n ret.blocks[i] = np.linalg.solve(self_k.blocks[i],other_k.blocks[i])\\n\\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\\n return ret\",\n \"def kruskal(self):\\n k = self.cc().max() + 1\\n E = 2 * self.V - 2\\n V = self.V\\n Kedges = np.zeros((E, 2)).astype(np.int_)\\n Kweights = np.zeros(E)\\n iw = np.argsort(self.weights)\\n label = np.arange(V)\\n j = 0\\n for i in range(V - k):\\n a, b = self.edges[iw[j]]\\n d = self.weights[iw[j]]\\n while label[a] == label[b]:\\n j = j + 1\\n a, b = self.edges[iw[j]]\\n d = self.weights[iw[j]]\\n\\n if label[a] != label[b]:\\n lb = label[b]\\n label[label == lb] = label[a]\\n Kedges[2 * i] = np.array([a, b])\\n Kedges[2 * i + 1] = np.array([b, a])\\n Kweights[2 * i: 2 * i + 2] = d\\n\\n K = WeightedGraph(V, Kedges, Kweights)\\n return K\",\n \"def n_choose_k(n: int, k: int) -> int:\\n # Edge case, no possible way to choose.\\n if k > n or k < 0 or n < 0: return 0\\n # We choose the min of k or n - k\\n # since nCk == nC(n - k).\\n k = min(k, n - k)\\n # The numerator represents the product\\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\\n numerator = reduce(mul, range(n, n - k, -1), 1)\\n # The denominator represents the product\\n # 1 * 2 * ... * k\\n denominator = reduce(mul, range(1, k + 1), 1)\\n # return the result as an integer.\\n return numerator // denominator\",\n \"def ACM_Kruskal(G):\\n pass\",\n \"def kspace_cholesky_solve_(self, other):\\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\\n self_k = transform(self, np.fft.fftn, n_points = n_points)\\n other_k = transform(other, np.fft.fftn, n_points = n_points)\\n\\n ret = tmat()\\n ret.load_nparray(np.ones((self_k.coords.shape[0],self_k.blockshape[0], other_k.blockshape[1]), dtype = np.complex), self_k.coords, safemode = False)\\n #ret = self_k*1.0\\n ret.blocks*=0.0\\n\\n #ret.blocks[:-1] = np.einsum(\\\"ijk,ikl->ijl\\\", self_k.blocks[:-1], other_k.blocks[:-1], optimize = True)\\n\\n for i in np.arange(len(self_k.blocks)-1):\\n \\n #print(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i])))\\n #assert(np.max(np.abs(self_k.blocks[i].T-self_k.blocks[i]))<1e-10), \\\"not symmetric\\\"\\n #assert(np.linalg.norm(self_k.blocks[i].T-self_k.blocks[i])<1e-10), \\\"not symmetric\\\"\\n Mk = np.linalg.cholesky(self_k.blocks[i])\\n yk = np.linalg.solve(Mk, other_k.blocks[i])\\n\\n\\n ret.blocks[i] = np.linalg.solve(Mk.conj().T, yk)\\n\\n ret = transform(ret, np.fft.ifftn, n_points = n_points, complx = False)\\n return ret\",\n \"def check_solution(self, potential_solution):\\n\\n old_k = self.K\\n new_k = potential_solution.set_K(self.len_connections)\\n\\n # accept the new state when K is higher\\n if new_k > old_k:\\n self.state = potential_solution\\n self.K = new_k\",\n \"def K(self, X, Xstar):\\n r = l2norm_(X, Xstar)\\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\\n res = f * bessel\\n res[np.isnan(res)] = 1\\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\\n return (res)\",\n \"def cdf(self, k):\\n\\n if k < 0 or k > self.n:\\n return 0\\n\\n k = int(k)\\n ans = 0\\n for i in range(0, k + 1):\\n ans += self.pmf(i)\\n return ans\",\n \"def solve(self, **kwargs) -> OptimizationResult:\\n raise NotImplementedError\",\n \"def KL(self):\\n\\n self.build_cholesky_if_needed()\\n\\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\\n\\n for nd in range(self.num_nodes):\\n q_sqrt_nd = self.q_sqrt_lst[nd]\\n with params_as_tensors_for(q_sqrt_nd, convert=True):\\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\\n\\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\\n KL += 0.5 * tf.reduce_sum(\\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\\n\\n return KL\",\n \"def ref_main(l, k):\\n S = sum(binomial(k, z)*(2*z-k)**l for z in range(k+1))\\n return S / 2**k\",\n \"def ref_main(l, k):\\n S = sum(binomial(k, z)*(2*z-k)**l for z in range(k+1))\\n return S / 2**k\",\n \"def solution3(nums, K):\\n modSeen = {0:-1}\\n s = 0\\n for i in range(len(nums)):\\n n = nums[i]\\n s += n\\n mod = s % K if K != 0 else s\\n if mod in modSeen:\\n if i - modSeen[mod] > 1:\\n return True\\n else:\\n modSeen[mod] = i\\n return False\",\n \"def C(n,k):\\n if 0 <= k <= n:\\n ntok = 1\\n ktok = 1\\n for t in xrange(1, min(k, n - k) + 1):\\n ntok *= n\\n ktok *= t\\n n -= 1\\n return ntok // ktok\\n else:\\n return 0\",\n \"def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:\\n\\n if not nums:\\n return 0\\n\\n if k <= 1:\\n return 0\\n\\n count = 0\\n lo = 0\\n product = 1\\n for hi in range(len(nums)):\\n product *= nums[hi]\\n while product >= k:\\n product /= nums[lo]\\n lo += 1\\n count += hi - lo + 1\\n return count\",\n \"def dfs_recursion(self, tour, sque_v, gain):\\n i = int(len(sque_v)/2) # step i done already\\n dahuitou = (i + 1) % self.max_exchange == 0\\n v_2i_2, v_2i_1 = sque_v[-2], sque_v[-1]\\n # step i+1: search for (v_2i, v_2ip1)\\n for v_2i in self.candidates[v_2i_1]:\\n if v_2i in sque_v: # disjunctivity criterion\\n continue\\n new_gain = gain + self.cost[v_2i_2, v_2i_1] - self.cost[v_2i_1, v_2i]\\n if new_gain <= 0:\\n continue\\n for v_2ip1 in tour.neighbours(v_2i):\\n if v_2ip1 in sque_v: # disjunctivity criterion\\n continue\\n if dahuitou:\\n if tour.check_feasible(sque_v+[v_2i, v_2ip1]):\\n if new_gain + self.cost[v_2i, v_2ip1] - self.cost[v_2ip1, sque_v[0]] > 0:\\n tour.k_exchange(sque_v + [v_2i, v_2ip1])\\n return tour\\n else:\\n return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\\n else: # optional, can be deleted\\n continue\\n else:\\n if new_gain + self.cost[v_2i, v_2ip1] - self.cost[v_2ip1, sque_v[0]] > 0 and \\\\\\n tour.check_feasible(sque_v+[v_2i, v_2ip1]):\\n tour.k_exchange(sque_v + [v_2i, v_2ip1])\\n return tour\\n else:\\n return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\\n # if (i + 1) % self.max_exchange == 0:\\n # continue\\n # return self.dfs_recursion(tour, sque_v + [v_2i, v_2ip1], new_gain)\\n # gain += - self.cost[v_2i_1, v_2i] + self.cost[v_2i, v_2ip1]\\n # if gain - self.cost[v_2ip1, sque_v[0]] > 0:\\n # # check feasibility immediately\\n # if tour.check_feasible(sque_v+[v_2i, v_2ip1]):\\n # tour.k_exchange(sque_v + [v_2i, v_2ip1])\\n # return tour\\n # # if not feasible, check whether stop or search for next two nodes\\n # if (i+1) % self.max_exchange == 0:\\n # continue\\n # delta_gain = self.cost[sque_v[2 * i - 2], sque_v[2 * i - 1]] - self.cost[sque_v[2 * i - 1], v_2i]\\n # return self.dfs_recursion(tour, sque_v+[v_2i, v_2ip1], gain+delta_gain)\\n return\",\n \"def sym_K(self):\\n raise NotImplementedError\",\n \"def KRC(self, ik, ipd, ipl, t):\\n idx = ik - 1\\n\\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\\n num1 = self.delta[idx] * self.thetak[idx]\\n ins = num1 / den1\\n\\n for l in np.arange(0, self.L):\\n pl = self.coca.PL(l, t)\\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\\n\\n ans = ipd * np.exp(t * ipl) * ins\\n\\n return ans\",\n \"def solve(self, use_cache=True):\\n if self.parallel:\\n self.solve_all_parallel(use_cache)\\n else:\\n self.solve_all(use_cache)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65435326","0.6303995","0.62335324","0.6223404","0.61771244","0.61697197","0.6146142","0.6124515","0.61158085","0.6081433","0.60603875","0.60549337","0.6022816","0.6015567","0.60017824","0.5987519","0.59837985","0.59735906","0.5944474","0.59432894","0.59206957","0.5911351","0.59098786","0.589455","0.5885227","0.58825266","0.58825266","0.58800876","0.5852641","0.584931","0.58245564","0.5816167","0.58153677","0.5810349","0.5810349","0.5789912","0.57831573","0.5778981","0.57723683","0.57674277","0.5753043","0.5747107","0.5744978","0.57417697","0.5733849","0.5730602","0.572556","0.5723342","0.5716827","0.5716827","0.57160735","0.57149506","0.5709784","0.5706591","0.5699453","0.56936306","0.56931406","0.56918657","0.56878215","0.5677103","0.5667096","0.566602","0.56654245","0.56478834","0.5645559","0.5643193","0.56052285","0.5604936","0.56019807","0.56001973","0.55976385","0.5594705","0.55903625","0.5588342","0.55850714","0.55837315","0.5574414","0.5571407","0.55617964","0.5557645","0.55543655","0.55465937","0.55436575","0.5542588","0.5539761","0.5538586","0.5537916","0.5536747","0.5522778","0.5521793","0.55148095","0.5511941","0.55117404","0.55117404","0.54986835","0.5498515","0.5496505","0.5489695","0.54836446","0.5474343","0.54707056"],"string":"[\n \"0.65435326\",\n \"0.6303995\",\n \"0.62335324\",\n \"0.6223404\",\n \"0.61771244\",\n \"0.61697197\",\n \"0.6146142\",\n \"0.6124515\",\n \"0.61158085\",\n \"0.6081433\",\n \"0.60603875\",\n \"0.60549337\",\n \"0.6022816\",\n \"0.6015567\",\n \"0.60017824\",\n \"0.5987519\",\n \"0.59837985\",\n \"0.59735906\",\n \"0.5944474\",\n \"0.59432894\",\n \"0.59206957\",\n \"0.5911351\",\n \"0.59098786\",\n \"0.589455\",\n \"0.5885227\",\n \"0.58825266\",\n \"0.58825266\",\n \"0.58800876\",\n \"0.5852641\",\n \"0.584931\",\n \"0.58245564\",\n \"0.5816167\",\n \"0.58153677\",\n \"0.5810349\",\n \"0.5810349\",\n \"0.5789912\",\n \"0.57831573\",\n \"0.5778981\",\n \"0.57723683\",\n \"0.57674277\",\n \"0.5753043\",\n \"0.5747107\",\n \"0.5744978\",\n \"0.57417697\",\n \"0.5733849\",\n \"0.5730602\",\n \"0.572556\",\n \"0.5723342\",\n \"0.5716827\",\n \"0.5716827\",\n \"0.57160735\",\n \"0.57149506\",\n \"0.5709784\",\n \"0.5706591\",\n \"0.5699453\",\n \"0.56936306\",\n \"0.56931406\",\n \"0.56918657\",\n \"0.56878215\",\n \"0.5677103\",\n \"0.5667096\",\n \"0.566602\",\n \"0.56654245\",\n \"0.56478834\",\n \"0.5645559\",\n \"0.5643193\",\n \"0.56052285\",\n \"0.5604936\",\n \"0.56019807\",\n \"0.56001973\",\n \"0.55976385\",\n \"0.5594705\",\n \"0.55903625\",\n \"0.5588342\",\n \"0.55850714\",\n \"0.55837315\",\n \"0.5574414\",\n \"0.5571407\",\n \"0.55617964\",\n \"0.5557645\",\n \"0.55543655\",\n \"0.55465937\",\n \"0.55436575\",\n \"0.5542588\",\n \"0.5539761\",\n \"0.5538586\",\n \"0.5537916\",\n \"0.5536747\",\n \"0.5522778\",\n \"0.5521793\",\n \"0.55148095\",\n \"0.5511941\",\n \"0.55117404\",\n \"0.55117404\",\n \"0.54986835\",\n \"0.5498515\",\n \"0.5496505\",\n \"0.5489695\",\n \"0.54836446\",\n \"0.5474343\",\n \"0.54707056\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89496,"cells":{"query":{"kind":"string","value":"Solve the discrete time lqr controller. x[k+1] = A x[k] + B u[k] cost = sum x[k].TQx[k] + u[k].TRu[k]"},"document":{"kind":"string","value":"def dlqr(A,B,Q=None,R=None):\n #ref Bertsekas, p.151\n if Q is None:\n Q = np.eye(A.shape[0])\n if R is None:\n R = np.eye(B.shape[1])\n\n P = scipy.linalg.solve_discrete_are(A, B, Q, R)\n K = -scipy.linalg.solve(B.T.dot(P).dot(B) + R, B.T.dot(P).dot(A), sym_pos=True)\n\n A_c = A + B.dot(K)\n TOL = 1e-5\n if spectral_radius(A_c) >= 1 + TOL:\n print(\"WARNING: spectral radius of closed loop is:\", spectral_radius(A_c))\n\n return P, K"},"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 LQRStep(n_state,\n n_ctrl,\n T,\n u_lower=None,\n u_upper=None,\n u_zero_I=None,\n delta_u=None,\n linesearch_decay=0.2,\n max_linesearch_iter=10,\n true_cost=None,\n true_dynamics=None,\n delta_space=True,\n current_x=None,\n current_u=None,\n verbose=0,\n back_eps=1e-3,\n no_op_forward=False):\n # @profile\n def lqr_backward(ctx, C, c, F, f):\n n_batch = C.size(1)\n\n u = ctx.current_u\n Ks = []\n ks = []\n prev_kt = None\n n_total_qp_iter = 0\n Vtp1 = vtp1 = None\n for t in range(T-1, -1, -1):\n if t == T-1:\n Qt = C[t]\n qt = c[t]\n else:\n Ft = F[t]\n Ft_T = Ft.transpose(1,2)\n Qt = C[t] + Ft_T.bmm(Vtp1).bmm(Ft)\n if f is None or f.nelement() == 0:\n qt = c[t] + Ft_T.bmm(vtp1.unsqueeze(2)).squeeze(2)\n else:\n ft = f[t]\n qt = c[t] + Ft_T.bmm(Vtp1).bmm(ft.unsqueeze(2)).squeeze(2) + \\\n Ft_T.bmm(vtp1.unsqueeze(2)).squeeze(2)\n\n Qt_xx = Qt[:, :n_state, :n_state]\n Qt_xu = Qt[:, :n_state, n_state:]\n Qt_ux = Qt[:, n_state:, :n_state]\n Qt_uu = Qt[:, n_state:, n_state:]\n qt_x = qt[:, :n_state]\n qt_u = qt[:, n_state:]\n\n if u_lower is None:\n if n_ctrl == 1 and u_zero_I is None:\n Kt = -(1./Qt_uu)*Qt_ux\n kt = -(1./Qt_uu.squeeze(2))*qt_u\n else:\n if u_zero_I is None:\n Qt_uu_inv = [\n torch.pinverse(Qt_uu[i]) for i in range(Qt_uu.shape[0])\n ]\n Qt_uu_inv = torch.stack(Qt_uu_inv)\n Kt = -Qt_uu_inv.bmm(Qt_ux)\n kt = util.bmv(-Qt_uu_inv, qt_u)\n\n # Qt_uu_LU = Qt_uu.lu()\n # Kt = -Qt_ux.lu_solve(*Qt_uu_LU)\n # kt = -qt_u.lu_solve(*Qt_uu_LU)\n else:\n # Solve with zero constraints on the active controls.\n I = u_zero_I[t].float()\n notI = 1-I\n\n qt_u_ = qt_u.clone()\n qt_u_[I.bool()] = 0\n\n Qt_uu_ = Qt_uu.clone()\n\n if I.is_cuda:\n notI_ = notI.float()\n Qt_uu_I = (1-util.bger(notI_, notI_)).type_as(I)\n else:\n Qt_uu_I = 1-util.bger(notI, notI)\n\n Qt_uu_[Qt_uu_I.bool()] = 0.\n Qt_uu_[util.bdiag(I).bool()] += 1e-8\n\n Qt_ux_ = Qt_ux.clone()\n Qt_ux_[I.unsqueeze(2).repeat(1,1,Qt_ux.size(2)).bool()] = 0.\n\n if n_ctrl == 1:\n Kt = -(1./Qt_uu_)*Qt_ux_\n kt = -(1./Qt_uu.squeeze(2))*qt_u_\n else:\n Qt_uu_LU_ = Qt_uu_.lu()\n Kt = -Qt_ux_.lu_solve(*Qt_uu_LU_)\n kt = -qt_u_.unsqueeze(2).lu_solve(*Qt_uu_LU_).squeeze(2)\n else:\n assert delta_space\n lb = get_bound('lower', t) - u[t]\n ub = get_bound('upper', t) - u[t]\n if delta_u is not None:\n lb[lb < -delta_u] = -delta_u\n ub[ub > delta_u] = delta_u\n kt, Qt_uu_free_LU, If, n_qp_iter = pnqp(\n Qt_uu, qt_u, lb, ub,\n x_init=prev_kt, n_iter=20)\n if verbose > 1:\n print(' + n_qp_iter: ', n_qp_iter+1)\n n_total_qp_iter += 1+n_qp_iter\n prev_kt = kt\n Qt_ux_ = Qt_ux.clone()\n Qt_ux_[(1-If).unsqueeze(2).repeat(1,1,Qt_ux.size(2)).bool()] = 0\n if n_ctrl == 1:\n # Bad naming, Qt_uu_free_LU isn't the LU in this case.\n Kt = -((1./Qt_uu_free_LU)*Qt_ux_)\n else:\n Kt = -Qt_ux_.lu_solve(*Qt_uu_free_LU)\n\n Kt_T = Kt.transpose(1,2)\n\n Ks.append(Kt)\n ks.append(kt)\n\n Vtp1 = Qt_xx + Qt_xu.bmm(Kt) + Kt_T.bmm(Qt_ux) + Kt_T.bmm(Qt_uu).bmm(Kt)\n vtp1 = qt_x + Qt_xu.bmm(kt.unsqueeze(2)).squeeze(2) + \\\n Kt_T.bmm(qt_u.unsqueeze(2)).squeeze(2) + \\\n Kt_T.bmm(Qt_uu).bmm(kt.unsqueeze(2)).squeeze(2)\n\n return Ks, ks, n_total_qp_iter\n\n\n # @profile\n def lqr_forward(ctx, x_init, C, c, F, f, Ks, ks):\n x = ctx.current_x\n u = ctx.current_u\n n_batch = C.size(1)\n\n old_cost = util.get_cost(T, u, true_cost, true_dynamics, x=x)\n\n current_cost = None\n alphas = torch.ones(n_batch).type_as(C)\n full_du_norm = None\n\n i = 0\n while (current_cost is None or \\\n (old_cost is not None and \\\n torch.any((current_cost > old_cost)).cpu().item() == 1)) and \\\n i < max_linesearch_iter:\n new_u = []\n new_x = [x_init]\n dx = [torch.zeros_like(x_init)]\n objs = []\n for t in range(T):\n t_rev = T-1-t\n Kt = Ks[t_rev]\n kt = ks[t_rev]\n new_xt = new_x[t]\n xt = x[t]\n ut = u[t]\n dxt = dx[t]\n new_ut = util.bmv(Kt, dxt) + ut + torch.diag(alphas).mm(kt)\n\n # Currently unimplemented:\n assert not ((delta_u is not None) and (u_lower is None))\n\n if u_zero_I is not None:\n new_ut[u_zero_I[t]] = 0.\n\n if u_lower is not None:\n lb = get_bound('lower', t)\n ub = get_bound('upper', t)\n\n if delta_u is not None:\n lb_limit, ub_limit = lb, ub\n lb = u[t] - delta_u\n ub = u[t] + delta_u\n I = lb < lb_limit\n lb[I] = lb_limit if isinstance(lb_limit, float) else lb_limit[I]\n I = ub > ub_limit\n ub[I] = ub_limit if isinstance(lb_limit, float) else ub_limit[I]\n # TODO(eugenevinitsky) why do we need to do this here?\n new_ut = util.eclamp(new_ut, lb, ub)\n new_u.append(new_ut)\n\n new_xut = torch.cat((new_xt, new_ut), dim=1)\n if t < T-1:\n if isinstance(true_dynamics, mpc.LinDx):\n F, f = true_dynamics.F, true_dynamics.f\n new_xtp1 = util.bmv(F[t], new_xut)\n if f is not None and f.nelement() > 0:\n new_xtp1 += f[t]\n else:\n new_xtp1 = true_dynamics(\n Variable(new_xt), Variable(new_ut)).data\n\n new_x.append(new_xtp1)\n dx.append(new_xtp1 - x[t+1])\n\n if isinstance(true_cost, mpc.QuadCost):\n C, c = true_cost.C, true_cost.c\n obj = 0.5*util.bquad(new_xut, C[t]) + util.bdot(new_xut, c[t])\n else:\n obj = true_cost(new_xut)\n\n objs.append(obj)\n\n objs = torch.stack(objs)\n current_cost = torch.sum(objs, dim=0)\n\n new_u = torch.stack(new_u)\n new_x = torch.stack(new_x)\n if full_du_norm is None:\n full_du_norm = (u-new_u).transpose(1,2).contiguous().view(\n n_batch, -1).norm(2, 1)\n\n alphas[current_cost > old_cost] *= linesearch_decay\n i += 1\n\n # If the iteration limit is hit, some alphas\n # are one step too small.\n alphas[current_cost > old_cost] /= linesearch_decay\n alpha_du_norm = (u-new_u).transpose(1,2).contiguous().view(\n n_batch, -1).norm(2, 1)\n\n return new_x, new_u, LqrForOut(\n objs, full_du_norm,\n alpha_du_norm,\n torch.mean(alphas),\n current_cost\n )\n\n\n def get_bound(side, t):\n if side == 'lower':\n v = u_lower\n if side == 'upper':\n v = u_upper\n if isinstance(v, float):\n return v\n else:\n return v[t]\n\n class LQRStepFn(Function):\n # @profile\n @staticmethod\n def forward(ctx, x_init, C, c, F, f=None):\n if no_op_forward:\n ctx.save_for_backward(\n x_init, C, c, F, f, current_x, current_u)\n ctx.current_x, ctx.current_u = current_x, current_u\n return current_x, current_u\n\n if delta_space:\n # Taylor-expand the objective to do the backward pass in\n # the delta space.\n assert current_x is not None\n assert current_u is not None\n c_back = []\n for t in range(T):\n xt = current_x[t]\n ut = current_u[t]\n xut = torch.cat((xt, ut), 1)\n c_back.append(util.bmv(C[t], xut) + c[t])\n c_back = torch.stack(c_back)\n f_back = None\n else:\n assert False\n\n ctx.current_x = current_x\n ctx.current_u = current_u\n\n Ks, ks, n_total_qp_iter = lqr_backward(ctx, C, c_back, F, f_back)\n new_x, new_u, for_out = lqr_forward(ctx,\n x_init, C, c, F, f, Ks, ks)\n ctx.save_for_backward(x_init, C, c, F, f, new_x, new_u)\n\n return new_x, new_u, torch.Tensor([n_total_qp_iter]), \\\n for_out.costs, for_out.full_du_norm, for_out.mean_alphas\n\n @staticmethod\n def backward(ctx, dl_dx, dl_du, temp=None, temp2=None):\n start = time.time()\n x_init, C, c, F, f, new_x, new_u = ctx.saved_tensors\n\n r = []\n for t in range(T):\n rt = torch.cat((dl_dx[t], dl_du[t]), 1)\n r.append(rt)\n r = torch.stack(r)\n\n if u_lower is None:\n I = None\n else:\n I = (torch.abs(new_u - u_lower) <= 1e-8) | \\\n (torch.abs(new_u - u_upper) <= 1e-8)\n dx_init = Variable(torch.zeros_like(x_init))\n _mpc = mpc.MPC(\n n_state, n_ctrl, T,\n u_zero_I=I,\n u_init=None,\n lqr_iter=1,\n verbose=-1,\n n_batch=C.size(1),\n delta_u=None,\n # exit_unconverged=True, # It's really bad if this doesn't converge.\n exit_unconverged=False, # It's really bad if this doesn't converge.\n eps=back_eps,\n )\n dx, du, _ = _mpc(dx_init, mpc.QuadCost(C, -r), mpc.LinDx(F, None))\n\n dx, du = dx.data, du.data\n dxu = torch.cat((dx, du), 2)\n xu = torch.cat((new_x, new_u), 2)\n\n dC = torch.zeros_like(C)\n for t in range(T):\n xut = torch.cat((new_x[t], new_u[t]), 1)\n dxut = dxu[t]\n dCt = -0.5*(util.bger(dxut, xut) + util.bger(xut, dxut))\n dC[t] = dCt\n\n dc = -dxu\n\n lams = []\n prev_lam = None\n for t in range(T-1, -1, -1):\n Ct_xx = C[t,:,:n_state,:n_state]\n Ct_xu = C[t,:,:n_state,n_state:]\n ct_x = c[t,:,:n_state]\n xt = new_x[t]\n ut = new_u[t]\n lamt = util.bmv(Ct_xx, xt) + util.bmv(Ct_xu, ut) + ct_x\n if prev_lam is not None:\n Fxt = F[t,:,:,:n_state].transpose(1, 2)\n lamt += util.bmv(Fxt, prev_lam)\n lams.append(lamt)\n prev_lam = lamt\n lams = list(reversed(lams))\n\n dlams = []\n prev_dlam = None\n for t in range(T-1, -1, -1):\n dCt_xx = C[t,:,:n_state,:n_state]\n dCt_xu = C[t,:,:n_state,n_state:]\n drt_x = -r[t,:,:n_state]\n dxt = dx[t]\n dut = du[t]\n dlamt = util.bmv(dCt_xx, dxt) + util.bmv(dCt_xu, dut) + drt_x\n if prev_dlam is not None:\n Fxt = F[t,:,:,:n_state].transpose(1, 2)\n dlamt += util.bmv(Fxt, prev_dlam)\n dlams.append(dlamt)\n prev_dlam = dlamt\n dlams = torch.stack(list(reversed(dlams)))\n\n dF = torch.zeros_like(F)\n for t in range(T-1):\n xut = xu[t]\n lamt = lams[t+1]\n\n dxut = dxu[t]\n dlamt = dlams[t+1]\n\n dF[t] = -(util.bger(dlamt, xut) + util.bger(lamt, dxut))\n\n if f.nelement() > 0:\n _dlams = dlams[1:]\n assert _dlams.shape == f.shape\n df = -_dlams\n else:\n df = torch.Tensor()\n\n dx_init = -dlams[0]\n\n backward_time = time.time()-start\n return dx_init, dC, dc, dF, df\n\n return LQRStepFn.apply","def lfunc(x,u):\n return mpc.mtimes(u.T, R, u) + mpc.mtimes((x-goal).T, Q, (x-goal))","def deriv(self, u, t, K):\n\n # Generate control voltages, clip at saturation voltage\n self.v[0] = np.clip(float(-K[0]*matrix((u)).T), 0, self.params['Vsat'])\n self.v[1] = np.clip(float(-K[1]*matrix((u)).T), 0, self.params['Vsat'])\n self.v[2] = 0\n\n '''\n Definitions:\n x1 = q0\n x2 = q1\n x3 = q2\n x4 = W rod X\n x5 = W rod Y\n x6 = W rod Z (not in use)\n x7 = W wheel X\n x8 = W wheel Y\n x9 = W wheel Z (not in use)\n '''\n x1, x2, x3, x4, x5, x6, x7, x8, x9 = u\n x1_dt = 0.5*x4\n x2_dt = 0.5*x5\n x3_dt = 0.5*x6\n x4_dt = self.params['Km']*self.v[0]/self.params['Rm']/self.params['Ix'] \\\n + 2*self.params['g']*self.params['lp']*self.params['Mp']/(self.params['Ix'])*x1 \\\n + self.params['Bx']/(self.params['Ix'])*x4 - self.params['Bw']/(self.params['Ix'])*x7\n x5_dt = self.params['Km']*self.v[1]/self.params['Rm']/self.params['Iy'] \\\n + 2*self.params['g']*self.params['lp']*self.params['Mp']/(self.params['Iy'])*x2 \\\n + self.params['By']/(self.params['Iy'])*x5 - self.params['Bw']/(self.params['Iy'])*x8\n x6_dt = self.params['Km']*self.v[2]/self.params['Rm']/self.params['Iz'] \\\n + 2*self.params['g']*self.params['Fspin_z']/(self.params['Iz'])*x3 \\\n + self.params['Bz']/(self.params['Iz'])*x6 - self.params['Bw']/(self.params['Iz'])*x9\n x7_dt = self.params['Km']*self.v[0]/self.params['Rm']/self.params['Iw'] \\\n + -self.params['Bw']/self.params['Iw']*x7\n x8_dt = self.params['Km']*self.v[1]/self.params['Rm']/self.params['Iw'] \\\n + -self.params['Bw']/self.params['Iw']*x8\n x9_dt = self.params['Km']*self.v[2]/self.params['Rm']/self.params['Iw'] \\\n + -self.params['Bw']/self.params['Iw']*x9\n\n dxdt = [x1_dt, x2_dt, x3_dt, x4_dt, x5_dt, x6_dt, x7_dt, x8_dt, x9_dt]\n\n return dxdt","def solver(self, theta):\n\n m = len(self.x)\n n = len(self.t[0])\n h = self.step_x\n k = self.step_t\n lamb = k / (h * h)\n w = np.zeros(m + 1)\n l = np.zeros(m + 1)\n u = np.zeros(m + 1)\n\n uK = np.zeros(self.x.shape)\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\n startTime = time.clock()\n if self.first:\n self.uR = np.zeros(self.x.shape)\n self.first = False\n error = 0\n errorCurve = np.zeros(self.x.shape)\n z = np.zeros(m + 1)\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\n for i in range(1, m - 1):\n w[i] = self.g(i * h)\n\n l[1] = 1 + lamb\n u[1] = -lamb / (2 * l[1])\n for i in range(2, m - 1):\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\n u[i] = -lamb / (2 * l[i])\n\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\n for j in range(1, n + 1):\n t = j * k # current t\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\n for i in range(2, m):\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\n w[m - 1] = z[m - 1]\n for i in range(m - 2, 0, -1):\n w[i] = z[i] - u[i] * w[i + 1]\n\n for i in range(0, m + 1):\n x = i * h\n # print(x, w[i])\n # print('oi')\n uK[i - 1, j - 1] = w[i]\n self.t[i - 1, j - 1] = t\n self.x[i - 1, j - 1] = x\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\n return (uK, error, errorCurve, theta)","def solve_LF(self):\n self.u = zeros(self.N)\n self.u[0] = self.u0\n self.u[1] = self.u1\n u = self.u\n f= self.f\n dt = self.dt\n t = self.t\n N = self.N\n for n in xrange(1,N-1):\n u[n+1] = 2*dt*f(u[n],t[n]) + u[n-1]\n #return t,u","def sim(self, (K,T), (j0,x0), dt, rx, **params):\n dt0 = dt \n\n k = 0\n t = [0.]\n j = deepcopy(j0)\n x = [deepcopy(x0)]\n\n trj = dict(k=k,t=t,j=j,x=x)\n trjs = []\n\n while ( trj['t'][-1] <= T # don't exceed max continuous time\n and trj['k'] < K # don't exceed max discrete transitions\n and not trj['j'] is None ): # don't allow discrete state is None\n k0 = trj['k']\n t0 = trj['t'][-1]\n j0 = trj['j']\n x0 = trj['x'][-1]\n if 0: # forward Euler\n dx = self.F((k0,t0), (j0,x0), **params)\n else: # 4th-order Runge-Kutta \n f = lambda t,x : self.F((k0,t), (j0,x), **params)\n dx1 = f( t0, x0 ) * dt\n dx2 = f( t0+.5*dt, x0+.5*dx1 ) * dt\n dx3 = f( t0+.5*dt, x0+.5*dx2 ) * dt\n dx4 = f( t0+dt, x0+dx3 ) * dt\n dx = (1./6.)*( dx1 + 2*dx2 + 2*dx3 + dx4 ) / dt\n\n k = k0\n j = j0\n t = t0 + dt\n x = x0 + dt * dx\n g = self.G((k,t), (j,x), **params)\n\n # halve step size until trajectory doesn't violate guard more than rx\n i = 0\n imax = 50\n while np.any(g < -rx) and (i <= imax):\n dt = dt/2.\n t = t0 + dt\n x = x0 + dt * dx\n g = self.G((k,t), (j,x), **params)\n i += 1\n\n #if (i >= imax):\n # raise RuntimeError,'(sim) guard iterations exceeded -- you probably have a buggy guard'\n\n # append state to trj\n trj['t'].append(t)\n trj['x'].append(x)\n\n if 0 and 'debug' in params and params['debug']:\n print ' : (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s, dx = %s' % (k,t,j,x,dt,g,x,dx)\n\n # if in guard \n if np.any(g < 0):\n\n # spend time in guard\n if i >= imax:\n t = t + rx\n else:\n t = t + (rx + g.min())\n trj['t'].append(t)\n trj['x'].append(x)\n\n if 'debug' in params and params['debug']:\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n\n # append trj to trjs\n trjs.append(trj)\n\n if 'Zeno' in params and params['Zeno'] and (len(trj['t']) <= 4):\n\n print '(sim) possible Zeno @ stepsize dt = %0.6f' % dt0\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n return trjs\n\n # apply reset to modify trj\n (k,t),(j,x) = self.R((k,t), (j,x), **params)\n trj = dict(k=k,t=[t],j=j,x=[x])\n\n # re-initialize step size\n dt = dt0\n\n if 'debug' in params and params['debug']:\n g = self.G((k,t), (j,x), **params)\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n\n trjs.append(trj)\n\n return trjs","def R(self, (k,t), (j,x), **params):\n d = len(x)/2\n q,dq = x[:d],x[d:]\n g = self.G((k,t), (j,x), **params)\n I = (g < 0.).nonzero()[0] # constraint indices that are activating or deactivating\n J = deepcopy(j)\n J[I] = np.logical_not(J[I])\n Delta = self.Delta( (k,t), (J,q,dq), **params )\n dq_ = util.dot( Delta, dq )\n k_ = k+1\n t_ = t\n j_ = 1 * J\n x_ = np.hstack([q,dq_])\n return (k_,t_),(j_,x_)","def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\n\n # Raise('NotImplementedError: only adjusted the arguments.')\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\n #precompute the expensive operation:\n lin_penalties = 1/np.sqrt(2*eta_lin)\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\n #!!!!\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\n #!!!!\n u_prev = u_init + 1\n u = u_init\n count = 0\n obj_history = []\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\n start = time.time()\n \n u_prev = np.copy(u)\n w_0 = w_0_update(eta_0, u, T, alpha, B) \n w = w_update(u, H, gamma, D, C) \n w_lin = w_lin_update(u, L_lhs, L_rhs)\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\n #!!!!\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\n #!!!!\n count += 1 \n if count == 10:\n u_inf = np.copy(u)\n w_0_inf = w_0[:]\n w_inf = w[:]\n w_lin_inf = w_lin[:]\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\n \n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\n obj_history.append(cur_obj)\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\n relaxed_obj_history.append(cur_relaxed_obj) \n \n stop = time.time()\n duration = stop-start\n \n if count%1 == 0 and verbose: \n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\n print(' This iteration took: {}'.format(duration))\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history","def learned_RHS(t,y,q,x,desc):\n \n \n Ux_mat = create_Ux_mat(x)\n Uxx_mat = create_Uxx_mat(x)\n\n return (q[desc.index('u_{x}')]*Ux_mat.dot(y) + \n q[desc.index('u_{xx}')]*Uxx_mat.dot(y) +\n q[desc.index('u^2')]*y**2 +\n q[desc.index('u')]*y + \n q[desc.index('u^2u_{x}')]*(y**2)*Ux_mat.dot(y) + \n q[desc.index('uu_{x}')]*y*Ux_mat.dot(y) + \n q[desc.index('u^2u_{xx}')]*(y**2)*Uxx_mat.dot(y) + \n q[desc.index('uu_{xx}')]*y*Uxx_mat.dot(y) + \n q[desc.index('u_{x}^2')]*Ux_mat.dot(y)**2)","def g_solving_subproblem_of_LR(self,vehicle_id):\r\n global_LB=-10000\r\n global_UB=10000\r\n iteration_for_RSP=20\r\n optimal_solution_for_RSP=None\r\n optimal_value_y=0\r\n self.multiplier_v=0.5\r\n\r\n #solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\r\n #obtain the variance\r\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB=0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\r\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\r\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\r\n optimal_value_y = y\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n\r\n\r\n # step 3: update multipliers\r\n if variance-y!= 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB-global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB","def build_linear_system(u, dt, dx, D = 3, P = 3,time_diff = 'poly',space_diff = 'poly',lam_t = None,lam_x = None, width_x = None,width_t = None, deg_x = 5,deg_t = None,sigma = 2):\n\n n, m = u.shape\n\n if width_x == None: width_x = n/10\n if width_t == None: width_t = m/10\n if deg_t == None: deg_t = deg_x\n\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\n if time_diff == 'poly': \n m2 = m-2*width_t\n offset_t = width_t\n else: \n m2 = m\n offset_t = 0\n if space_diff == 'poly': \n n2 = n-2*width_x\n offset_x = width_x\n else: \n n2 = n\n offset_x = 0\n\n if lam_t == None: lam_t = 1.0/m\n if lam_x == None: lam_x = 1.0/n\n\n ########################\n # First take the time derivaitve for the left hand side of the equation\n ########################\n ut = np.zeros((n2,m2), dtype=u.dtype)\n\n if time_diff == 'FDconv':\n Usmooth = np.zeros((n,m), dtype=u.dtype)\n # Smooth across x cross-sections\n for j in range(m):\n Usmooth[:,j] = ConvSmoother(u[:,j],width_t,sigma)\n # Now take finite differences\n for i in range(n2):\n ut[i,:] = FiniteDiff(Usmooth[i + offset_x,:],dt,1)\n\n elif time_diff == 'poly':\n T= np.linspace(0,(m-1)*dt,m)\n for i in range(n2):\n ut[i,:] = PolyDiff(u[i+offset_x,:],T,diff=1,width=width_t,deg=deg_t)[:,0]\n\n elif time_diff == 'Tik':\n for i in range(n2):\n ut[i,:] = TikhonovDiff(u[i + offset_x,:], dt, lam_t)\n\n else:\n for i in range(n2):\n ut[i,:] = FiniteDiff(u[i + offset_x,:],dt,1)\n \n ut = np.reshape(ut, (n2*m2,1), order='F')\n\n ########################\n # Now form the rhs one column at a time, and record what each one is\n ########################\n\n u2 = u[offset_x:n-offset_x,offset_t:m-offset_t]\n Theta = np.zeros((n2*m2, (D+1)*(P+1)), dtype=u.dtype)\n ux = np.zeros((n2,m2), dtype=u.dtype)\n rhs_description = ['' for i in range((D+1)*(P+1))]\n\n if space_diff == 'poly': \n Du = {}\n for i in range(m2):\n Du[i] = PolyDiff(u[:,i+offset_t],np.linspace(0,(n-1)*dx,n),diff=D,width=width_x,deg=deg_x)\n if space_diff == 'Fourier': ik = 2*np.pi*1j*np.fft.fftfreq(n, d = dx)\n \n for d in range(D+1):\n\n if d > 0:\n for i in range(m2):\n if space_diff == 'Tik': ux[:,i] = TikhonovDiff(u[:,i+offset_t], dx, lam_x, d=d)\n elif space_diff == 'FDconv':\n Usmooth = ConvSmoother(u[:,i+offset_t],width_x,sigma)\n ux[:,i] = FiniteDiff(Usmooth,dx,d)\n elif space_diff == 'FD': ux[:,i] = FiniteDiff(u[:,i+offset_t],dx,d)\n elif space_diff == 'poly': ux[:,i] = Du[i][:,d-1]\n elif space_diff == 'Fourier': ux[:,i] = np.fft.ifft(ik**d*np.fft.fft(u[:,i]))\n else: ux = np.ones((n2,m2), dtype=u.dtype) \n \n for p in range(P+1):\n Theta[:, d*(P+1)+p] = np.reshape(np.multiply(ux, np.power(u2,p)), (n2*m2), order='F')\n\n if p == 1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u'\n elif p>1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u^' + str(p)\n if d > 0: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+\\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\n\n return ut, Theta, rhs_description","def _call(self, x):\n u = functional.tmp_u_prox\n v = functional.tmp_v_prox\n\n # Running generalized Sinkhorn iterations\n for j in range(functional.niter):\n # Safe-guarded u-update, to avoid divide-by-zero error.\n u_old = u.copy()\n tmp1 = functional.K_op(v)\n if np.min(tmp1) < 1e-30 or np.max(tmp1) > 1e+50:\n print('Numerical instability, truncation in Transport prox (Kv)',\n str(np.min(tmp1)), str(np.max(tmp1)))\n\n tmp = np.fmax(tmp1, 1e-30)\n\n\n u = functional.mu0 / tmp\n if np.min(u) < 1e-30 or np.max(u) > 1e+50:\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\n\n # Safe-guarded v-update, to avoid divide-by-zero error.\n v_old = v.copy()\n\n tmp3 = functional.K_op_adjoint(u)\n if np.min(tmp3) < 1e-30 or np.max(tmp3) > 1e+50:\n print('Truncation in Transport prox (KTu)',\n str(np.min(tmp3)), str(np.max(tmp3)))\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\n\n tmp4 = (self.const * tmp3 * np.exp(self.const * x))\n\n if np.min(tmp4) < 1e-30 or np.max(tmp4) > 1e+200:\n print('Argument in lambdert omega (min/max)',\n str(np.min(tmp4)), str(np.max(tmp4)))\n\n v = np.exp(self.const * x - lambertw_fulfix(tmp4))\n\n v1 = np.exp(self.const * x - scipy.special.lambertw(\n tmp4))\n if (v-v1).norm() > 1e-10:\n print('diff pga ny lambderw omega funciton',\n str((v-v1).norm()))\n print('v (min/max)', str(np.min(v)), str(np.max(v)))\n print('Argument in lambdert omega (min/max)',\n str(np.min(tmp4)), str(np.max(tmp4)))\n\n # If the updates in both u and v are small, break the loop\n if ((np.log(v)-np.log(v_old)).norm() < 1e-8 and\n (np.log(u)-np.log(u_old)).norm() < 1e-8):\n break\n\n # Store the u and v in the internal temporary variables of the\n # functional\n functional.tmp_u_prox = u\n functional.tmp_v_prox = v\n\n return x - self.sigma * functional.epsilon * np.log(v)","def LQR_cost(A, B, K, Q, R, sigma_w):\n\n L = A + B.dot(K)\n if spectral_radius(L) >= 1:\n return 1e6\n\n M = Q + K.T.dot(R).dot(K)\n\n P = solve_discrete_lyapunov(L, M)\n\n return (sigma_w ** 2) * np.trace(P)","def optimize_linearized_model(self, A, B, initial_state, Q, R, target, time_horizon=10, verbose=False):\n assert len(initial_state) == self.state_len\n # Create variables\n x = opt.Variable(self.state_len, time_horizon + 1, name='states')\n u = opt.Variable(self.action_len, time_horizon, name='actions')\n\n # Loop through the entire time_horizon and append costs\n cost_function = []\n\n for t in range(time_horizon):\n # _cost = opt.norm(x[2, t + 1],2)*50 + opt.norm(x[3, t + 1],2)*50 + opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(u[:, t]-u[:, t-1], R*0.1)\n _cost = opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(\n u[:, t] - u[:, t - 1], R * 0.1)\n _constraints = [x[:, t + 1] == A * x[:, t] + B * u[:, t],\n u[0, t] >= MAIN_ENGINE_POWER/1.8, u[0, t] <= MAIN_ENGINE_POWER / 1.05,\n u[1, t] >= -SIDE_ENGINE_POWER, u[1, t] <= SIDE_ENGINE_POWER,\n u[2, t] >= -self.angle_limit, u[2, t] <= self.angle_limit,\n opt.norm(target[:, t + 1] - x[:, t + 1], 1) <= 0.01]\n\n cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=_constraints))\n\n # Add final cost\n problem = sum(cost_function)\n problem.constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 0.001,\n x[:, 0] == initial_state]\n # Minimize Problem\n problem.solve(verbose=verbose, solver=opt.SCS)\n # u[0, :].value.A.flatten()\n return x, u","def quintic_trajectory_planning(q0, qf, qd0, qdf, qdd0, qddf, m = 100):\n n = q0.shape[0]\n\n # Polynomial Parameters\n a0 = np.copy(q0)\n a1 = np.copy(qd0) \n a2 = np.copy(qdd0) / 2\n a3 = (20 * qf - 20 * q0 - 8 * qdf - 12 * qd0 - 3 * qdd0 + qddf) / 2\n a4 = (30 * q0 - 30 * qf + 14 * qdf + 16 * qd0 + 3 * qdd0 - 2 * qddf) / 2\n a5 = (12 * qf - 12 * q0 - 6 * qdf - 6 * qd0 - qdd0 + qddf) / 2\n\n timesteps = np.linspace(0, 1, num = m)\n\n q = np.zeros((n, m))\n qd = np.zeros((n, m))\n qdd = np.zeros((n, m))\n\n for i in range(len(timesteps)):\n t = timesteps[i]\n t_2 = t * t\n t_3 = t_2 * t\n t_4 = t_3 * t\n t_5 = t_4 * t\n\n q[:, i] = (a0) + (a1 * t) + (a2 * t_2) + (a3 * t_3) + (a4 * t_4) + (a5 * t_5)\n qd[:, i] = (a1) + (2 * a2 * t) + (3 * a3 * t_2) + (4 * a4 * t_3) + (5 * a5 * t_4)\n qdd[:, i] = (2 * a2) + (6 * a3 * t) + (12 * a4 * t_2) + (20 * a5 * t_3)\n\n return q, qd, qdd","def EstimateKFTimeStep(u1,y1,z0,Xxd,Xud,Yx,Yu,P0,Q,R):\n \n # estimate next step\n z1m = Xxd.dot(z0) + Xud.dot(u1)\n y1hat = Yx.dot(z1m) + Yu.dot(u1)\n P1m = (Xxd.dot(P0)).dot(Xxd.T) + Q\n \n # Calculate Kalman gain\n # same as Lk from [1] - And their Rtilde_k is G*P1m*G'+R\n Kk = np.dot(P1m,Yx.T).dot( np.linalg.inv(((Yx.dot(P1m)).dot(Yx.T) + R))) \n # update estimate with measurement\n z1 = z1m + Kk.dot(y1 - y1hat)\n \n P1 = (np.eye(Xxd.shape[0]) - Kk.dot(Yx) ).dot(P1m)\n return z1,P1,Kk","def advance(self):\n\n f, n, rtol, atol, neq = \\\n self.f, self.n, self.rtol, self.atol, self.neq\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\n dt = t_next - t_n\n\n first_step = dt # try one big step to next desired level\n\n def middle(x,y,z): # Auxilary function\n return sorted([x,y,z])[1]\n\n # Extract coefficients from Butcher-tableau\n table = self._butcher_tableau\n k_len = table.shape[1] - 1 # number of internal stages\n\n # coefficients for internal stages\n factors_u = np.asarray(table[:k_len, 1:])\n # coefficients for t\n factors_t = table[:k_len, 0]\n # coefficients for u_new\n factors_u_new = table[k_len, 1:]\n\n # coefficients for local error between 2 levels\n factors_error = table[k_len+1, 1:] - factors_u_new\n\n u_intermediate = [u_n,]\n t_intermediate = [t_n,]\n u, t, h = u_n, t_n, first_step # initial values\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\n\n if self.verbose > 0:\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\n\n # Loop until next time point is reached\n while (abs(t - t_n) < abs(t_next - t_n)):\n u, t = u_intermediate[-1], t_intermediate[-1]\n\n # Internal steps\n k[:, :] = 0. # initialization for next step\n for m in range(k_len):\n k_factors = (np.dot(factors_u, k))[m]\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\n u_new = u + h*(np.dot(factors_u_new, k))\n\n self.info['rejected'] += 1 # reduced below if accepted\n if self.verbose > 0:\n print ' u(t=%g)=%g: ' % (t+h, u_new),\n\n # local error between 2 levels\n error = h*np.abs(np.dot(factors_error, k))\n # Acceptable error tolerance\n tol = rtol*np.abs(u_new) + atol\n\n accurate = (error <= tol).all()\n\n if accurate or h <= self.min_step or h >= self.max_step:\n # Accurate enough,\n # or the step size exceeds valid range,\n # must accept this solution\n u_intermediate.append(u_new)\n t_intermediate.append(t+h)\n if not self.disk_storage:\n self.u_all.append(u_new)\n self.t_all.append(t+h)\n self.info['rejected'] -= 1\n\n if self.verbose > 0:\n print 'accepted, ',\n else:\n if self.verbose > 0:\n print 'rejected, ',\n\n if self.verbose > 0:\n print 'err=%s, ' % str(error),\n if hasattr(self, 'u_exact') and callable(self.u_exact):\n print 'exact-err=%s, ' % \\\n (np.asarray(self.u_exact(t+h))-u_new),\n if h <= self.min_step:\n print 'h=min_step!! ',\n\n\n # Replace 0 values by 1e-16 since we will divide by error\n error = np.asarray([(1e-16 if x == 0. else x) \\\n for x in error])\n\n # Normarized error rate\n rms = error/tol\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\n\n order = float(self._method_order[0])\n # factor to adjust the size of next step\n # Formula is from <Numerical Methods for Engineers,\n # Chappra & Cannle>\n s = .8 *((1./rms_norm)**(1/order))\n # scalar should be in range(0.1, 4.)\n # for better accuracy and smoothness\n s = middle(s, 0.1, 4.0)\n h *= s\n\n # step size should be in range [min_step, max_step]\n h = middle(h, self.min_step, self.max_step)\n # adjust h to fit the last step\n h = min(h, t_next - t_intermediate[-1])\n\n if self.verbose > 0:\n print 'new h=%g' % h\n\n if h == 0:\n break\n\n return u_new","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[uD]\n \n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\n \n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\n \n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \n \n return T","def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[uD]\n \n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\n \n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\n \n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \n \n return T","def return_quadratic_cost_function_expansion_variables(\n X,U,dt,\n RunningCost=\"Minimize Input Energy\"):\n\n if type(RunningCost)==str:\n assert RunningCost in ['Minimize Input Energy',\n 'Minimize time away from target angle',\n 'Minimize time away from target angular velocity'],\\\n \"RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'.\"\n else:\n assert type(RunningCost)==list, \"RunningCost must be a list of cost types.\"\n for el in RunningCost:\n assert type(el)==str, \"Each element of RunningCost must be a string. Not \" + str(type(el)) + \".\"\n assert el in ['Minimize Input Energy',\n 'Minimize time away from target angle',\n 'Minimize time away from target angular velocity'],\\\n \"Each element of RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'. '\" + el + \"' not accepted.\"\n\n # returns a list of length len(Time)-1, each element with shape (1,1), where n is the number of states.\n l_func = return_l_func(RunningCost=RunningCost)\n l = list(\n map(\n lambda X,U: l_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,1), where n is the number of states.\n lx_func = return_lx_func(RunningCost=RunningCost)\n lx = list(\n map(\n lambda X,U: lx_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,1), where n is the number of states.\n lu_func = return_lu_func(RunningCost=RunningCost)\n lu = list(\n map(\n lambda X,U: lu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,n), where m is the number of inputs and n is the number of states.\n lux_func = return_lux_func(RunningCost=RunningCost)\n lux = list(\n map(\n lambda X,U: lux_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,m), where n is the number of states and m is the number of inputs.\n lxu_func = return_lxu_func(RunningCost=RunningCost)\n lxu = list(\n map(\n lambda X,U: lxu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,m), where m is the number of inputs.\n luu_func = return_luu_func(RunningCost=RunningCost)\n luu = list(\n map(\n lambda X,U: luu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,n), where n is the number of states.\n lxx_func = return_lxx_func(RunningCost=RunningCost)\n lxx = list(\n map(\n lambda X,U: lxx_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n return(l,lx,lu,lux,lxu,luu,lxx)","def dlqr(a, b, q, r):\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\n p = scipy.linalg.solve_discrete_are(a, b, q, r)\n\n # LQR gain\n # k = (b.T * p * b + r)^-1 * (b.T * p * a)\n bp = b.T.dot(p)\n tmp1 = bp.dot(b)\n tmp1 += r\n tmp2 = bp.dot(a)\n k = np.linalg.solve(tmp1, tmp2)\n return k, p","def trisolve(l, u, c, b):\n n = shape(b)[0]\n for k in range(1, n):\n b[k] -= l[k-1]*b[k - 1]\n b[n-1] /= u[n-1]\n for k in range(n-2,-1,-1):\n b[k] -= c[k]*b[k + 1]\n b[k] /= u[k]","def lqr(a, b, q, r):\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\n p = scipy.linalg.solve_continuous_are(a, b, q, r)\n\n # LQR gain\n k = np.linalg.solve(r, b.T.dot(p))\n\n return k, p","def time_update(self, U):\n self.X = self.runge_kutta(self.process_model, self.X, U, self.dt)\n \n J = self.F.subs({'d_t': self.dt, 'v': U[0], '\\Theta': self.X[2]})\n \n self.P = J*self.P*J.T + self.Q","def application_test():\n # Choice of nonlinear coefficient\n m = 2\n\n def q(u):\n return (1+u)**m\n\n def Dq(u):\n return m*(1+u)**(m-1)\n\n usage = 'manual|automatic Krylov|direct degree nx ny nz'\n try:\n import sys\n J_comp = sys.argv[1]\n linear_solver = sys.argv[2]\n degree = int(sys.argv[3])\n divisions = [int(arg) for arg in sys.argv[4:]]\n except:\n print('Usage: %s' % sys.argv[0], usage)\n sys.exit(0)\n\n u = solver(q, Dq, f, divisions, degree,\n 'pde_Newton', J_comp, linear_solver)\n\n # Find max error\n u_exact = Expression(\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\n u_e = interpolate(u_exact, u.function_space())\n import numpy as np\n error = np.abs(u_e.vector().array() -\n u.vector().array()).max()\n print('error: %.2E' % error)","def solver(I, f, c, U_0, U_L, L, n, dt, tstop,\n user_action=None, version='scalar'):\n import time\n t0 = time.clock()\n \n dx = L/float(n)\n x = linspace(0, L, n+1) # grid points in x dir\n if dt <= 0: dt = dx/float(c) # max time step?\n\n u = zeros(n+1) # NumPy solution array\n rhs = u.copy()\n \n # set initial condition (pointwise - allows straight if-tests):\n t = 0.0\n u = ic_scalar(u, x, I, U_0, U_L)\n with_bc = False #True\n F = WaveRHS(rhs, u, c, f, x, n, dx, version, with_bc, U_0, U_L)\n solver = ODESolver(F, dt, u, user_action, [x])\n solver.timeloop(tstop)\n \n t1 = time.clock()\n return dt, x, t1-t0","def j(U, Q, mesh, T, num_steps, params):\n \n # Define parameters for cost functional\n alpha = params[\"alpha\"]\n u_d = params[\"u_d\"]\n \n # Compute integrals with time\n I1 = 0\n I3 = 0\n \n t = 0\n dt = T/num_steps\n for i in range(num_steps + 1):\n I1_int = assemble((U[i] - u_d[i])*(U[i] - u_d[i])*dx(mesh))\n I3_int = assemble(Q[i]*Q[i]*dx(mesh))\n \n if i == 0 or i == num_steps:\n I1_int *= 0.5\n I3_int *= 0.5\n \n I1 += I1_int\n I3 += I3_int\n \n t += dt\n \n \n I1 *= dt\n I3 *= dt*alpha/2\n \n # Compute end time integral\n \n print(\"Cost Functional Data\")\n print(\"I1: {}\".format(I1))\n print(\"I3: {}\".format(I3))\n print()\n \n return I1 + I3","def solve_release_time(mvi, con):\n nd, m = mvi.nd, mvi.nc\n\n # If the first state is already close enough to release, step integrator back\n # and use the state as the release state.\n if abs(mvi.lambda1c[con.index]) < LAMBDA_TOL:\n mvi.set_single_state(2, mvi.t1, mvi.q1, mvi.p1)\n mvi.lambda1 = mvi.lambda0\n return {'t': mvi.t2, 'q': mvi.q2, 'p': mvi.p2, 'lambda1': mvi.lambda1}\n\n set_system_state(mvi, 1)\n Dh1T = np.transpose(Dh(mvi))\n D2h1 = D2h(mvi)\n\n t_guess, q_guess = linear_interpolate_release(mvi, con.index)\n\n # No impacts at state 1 - solve normal release time problem.\n if not mvi._state1_impacts:\n\n x0 = np.hstack((q_guess[:nd], mvi.lambda0, t_guess))\n\n # The root-solving problem is to find (DEL, h(qr, tr), lambda_{cont}) = 0. \n def func(x):\n mvi.t2 = x[-1]\n mvi.lambda1 = x[nd:-1]\n mvi.q2 = np.append(x[:nd], mvi.kin_config(x[-1]))\n\n mvi.set_midpoint()\n f1 = mvi.p1+D1L2(mvi)+fm2(mvi)-np.dot(Dh1T,mvi.lambda1)\n\n set_system_state(mvi, 2)\n f2 = h(mvi)\n f3 = mvi.system.lambda_(constraint=con)\n\n return np.hstack((f1, f2, f3))\n\n\n def fprime(x):\n mvi.t2 = x[-1]\n mvi.q2 = np.append(x[:nd], mvi.kin_config(x[-1]))\n mvi.lambda1 = x[(nd):(nd+m)]\n \n mvi.set_midpoint()\n Df11 = D2D1L2(mvi) + D2fm2(mvi)\n Df13 = D4D1L2(mvi) + D4fm2(mvi)\n \n set_system_state(mvi, 2)\n Df21 = Dh(mvi)\n Df23 = D2h(mvi).reshape((mvi.nc, 1))\n lam_dq = (mvi.system.lambda_dq(constraint=con)+\n mvi.system.lambda_ddq(constraint=con)/(mvi.t2-mvi.t1))[:nd]\n lam_dt = -1.0/(mvi.t2-mvi.t1)*np.dot(mvi.system.dq[:nd], \n mvi.system.lambda_ddq(constraint=con)[:nd])\n\n Df1 = np.hstack((Df11, -Dh1T, Df13))\n Df2 = np.hstack((Df21, np.zeros((mvi.nc, mvi.nc)), Df23))\n Df3 = np.hstack((lam_dq, np.zeros(m), lam_dt))\n\n return np.vstack((Df1, Df2, Df3))\n\n # Impacts have occurred at state 1 - solve impact update with additional unknown \n # release time.\n else:\n\n impact_surfaces = mvi._state1_impacts\n p = len(impact_surfaces)\n\n tau = mvi.tau2 # Is set by most recent impact solver.\n\n x0 = np.hstack((q_guess[:nd], mvi.lambda1, t_guess, np.dot(D2h1, mvi.lambda1)-tau))\n\n def func(x): \n mvi.t2 = x[nd+m]\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\n mvi.lambda1 = x[nd:(nd+m)]\n Ec = x[-1]\n\n mvi.set_midpoint()\n f1 = mvi.p1+D1L2(mvi)+fm2(mvi)-np.dot(Dh1T,mvi.lambda1)\n f3 = tau+D3L2(mvi)-np.dot(D2h1, mvi.lambda1)+Ec\n\n set_system_state(mvi, 2)\n f2 = h(mvi)\n f4 = mvi.system.lambda_(constraint=con)\n \n return np.hstack((f1, f2, f3, f4))\n\n def fprime(x):\n mvi.t2 = x[nd+m]\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\n mvi.lambda1 = x[nd:(nd+m)]\n Ec = x[-1]\n \n mvi.set_midpoint()\n Df11 = D2D1L2(mvi) + D2fm2(mvi)\n Df13 = D4D1L2(mvi) + D4fm2(mvi)\n Df31 = D2D3L2(mvi)\n Df33 = D4D3L2(mvi)\n \n set_system_state(mvi, 2)\n Df21 = Dh(mvi)\n Df23 = D2h(mvi).reshape((m, 1))\n Df32 = -D2h(mvi)\n Df41 = D2LAM2(mvi, con)\n Df43 = D4LAM2(mvi, con)\n\n Df1 = np.hstack((Df11, -Dh1T, Df13, np.zeros((nd,1))))\n Df2 = np.hstack((Df21, np.zeros((m, m)), Df23, np.zeros((m,1))))\n Df3 = np.hstack((Df31, Df32, Df33, (1.0,)))\n Df4 = np.hstack((Df41, np.zeros(m), Df43, np.zeros(1)))\n\n return np.vstack((Df1, Df2, Df3, Df4))\n\n \n (x, infodict, ier, mesg) = scipy.optimize.fsolve(func, x0, full_output=True)\n\n if ier != 1:\n print mesg\n raise trep.ConvergenceError(\"Release solver failed to converge.\") \n\n mvi.t2 = x[nd+m]\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\n mvi.lambda1 = x[nd:(nd+m)]\n mvi.set_midpoint() \n mvi.p2 = D2L2(mvi)\n\n return {'t': mvi.t2, 'q': mvi.q2, 'p': mvi.p2, 'lambda1': mvi.lambda1}","def hr_game(t0, tf, n, A, B, R, x0):\n # t0 - Initial time\n # tf - Final time\n # n - Number of steps\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Step in each iteration\n h = (tf - t0) / n\n # Result of each step, np.ndarray (N, S, n+1)\n y = np.zeros([N, S, n+1], dtype='double')\n y[:, :, 0] = x0\n k = np.zeros([N, S])\n # I still don't know why, but theres a problem with negative payoffs\n B = matrixTranslate(B)\n\n # Fourth order Runge-Kutta\n for t in range(n):\n k1 = np.multiply(h, hr_egn(A, B, R, y[:, :, t]))\n k2 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k1, 2))))\n k3 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k2, 2))))\n k4 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], k3)))\n # k = (k1 + 2*k2 + 2*k3 + k4)/6\n k = np.divide(np.add(np.add(k1, np.multiply(2, k2)), np.add(np.multiply(2, k3), k4)), 6)\n\n y[:, :, t+1] = np.add(y[:, :, t], k)\n\n # Filter results with machine epsilon\n for v in range(N):\n for s in range(S):\n if y[v, s, t+1] < np.sqrt(np.finfo('double').eps):\n y[v, s, t+1] = 0\n elif y[v, s, t+1] > np.subtract(1, np.sqrt(np.finfo('double').eps)):\n y[v, s, t + 1] = 1\n\n return y","def integrate(self,u,x,Dt,t,bc):\n time=t[0]\n i=1\n result=interfaces.State()\n result.x=scipy.zeros((len(x),len(t)),scipy.float64)\n result.x[:,0]=x\n s=list(scipy.shape(u))\n s.append(len(t))\n result.u=scipy.zeros(s,scipy.float64)\n result.u[:,:,0]=u\n result.time=t\n \n while not scipy.allclose(time,t[-1],rtol=1e-8,atol=1e-10):\n k1=self.estimator.estimate(u,time,x,bc)\n\t k2=self.estimator.estimate(u+0.5*Dt*k1,time+0.5*Dt,x,bc)\n\t k3=self.estimator.estimate(u+0.5*Dt*k2,time+0.5*Dt,x,bc)\n\t k4=self.estimator.estimate(u+Dt*k3,time+Dt,x,bc)\n\t u=u+Dt*(1./6.*k1+1./3.*k2+1./3.*k3+1./6.*k4)\n time=time+Dt\n\t if scipy.allclose(time,t[i],rtol=1e-8,atol=1e-10):\n \tresult.x[:,i]=x\n result.u[:,:,i]=u\n \ti+=1\n return result","def compute_ul_ur(self, dt):\n\n g = self.grid\n # compute the piecewise linear slopes\n # here we define the range cells considered, including 1 ghost cell\n # on each side\n ib = g.ng-1\n ie = g.ng + g.N\n\n u = g.u\n \n # initialize empty arrays\n dc = np.zeros((g.N+2*g.ng))\n dl = np.zeros((g.N+2*g.ng))\n dr = np.zeros((g.N+2*g.ng))\n \n dc[ib:ie+1] = 0.5*(u[ib+1:ie+2] - u[ib-1:ie ])\n dl[ib:ie+1] = u[ib+1:ie+2] - u[ib :ie+1]\n dr[ib:ie+1] = u[ib :ie+1] - u[ib-1:ie ]\n\n # minmod()\n # fabs is the absolute value for real valued inputs\n # where does np.where(condition,if true keep this value, else this)\n # d1 = 2.0*np.where(np.fabs(dl) < np.fabs(dr), dl, dr)\n d1 = np.zeros((len(dl)))\n for i in range(len(dl)):\n if np.fabs(dl[i]) < np.fabs(dr[i]):\n d1[i] = dl[i]\n else:\n d1[i] = dr[i]\n d1 = 2.0*d1\n \n d2 = np.zeros((len(dc)))\n for i in range(len(dc)):\n if np.fabs(dc[i]) < np.fabs(d1[i]):\n d2[i] = dc[i]\n else:\n d2[i] = d1[i] \n \n # d2 = np.where(np.fabs(dc) < np.fabs(d1), dc, d1)\n ldeltau = np.zeros((len(d2)))\n for i in range(len(d2)):\n if dl[i]*dr[i] > 0.0:\n ldeltau[i] = d2[i]\n else:\n ldeltau[i] = 0.0\n # ldeltau = np.where(dl*dr > 0.0, d2, 0.0)\n\n # interface states. \n # Note from hydro_examples:\n # note that there are 1 more interfaces than zones\n ul = np.zeros((g.N+2*g.ng))\n ur = np.zeros((g.N+2*g.ng))\n\n ur[ib:ie+2] = u[ib:ie+2] - \\\n 0.5*(1.0 + u[ib:ie+2]*dt/self.grid.dx)*ldeltau[ib:ie+2]\n\n ul[ib+1:ie+2] = u[ib:ie+1] + \\\n 0.5*(1.0 - u[ib:ie+1]*dt/self.grid.dx)*ldeltau[ib:ie+1]\n\n return ul, ur","def drx_solver_numpy(tol, steps, factor, C, Ct, X, M, k0, l0, f0, ind_c, ind_t, P, S, B, V, refresh,\n beams, inds, indi, indf, EIx, EIy, callback, **kwargs):\n res = 1000 * tol\n ts, Uo = 0, 0\n M = factor * tile(M.reshape((-1, 1)), (1, 3))\n\n while (ts <= steps) and (res > tol):\n\n uvw, l = uvw_lengths(C, X) # noqa: E741\n f = f0 + k0 * (l.ravel() - l0)\n\n if ind_t:\n f[ind_t] *= f[ind_t] > 0\n if ind_c:\n f[ind_c] *= f[ind_c] < 0\n\n if beams:\n S = _beam_shear(S, X, inds, indi, indf, EIx, EIy)\n\n q = f[:, newaxis] / l\n qt = tile(q, (1, 3))\n R = (P - S - Ct.dot(uvw * qt)) * B\n res = mean(normrow(R))\n\n V += R / M\n Un = sum(M * V**2)\n if Un < Uo:\n V *= 0\n Uo = Un\n\n X += V\n\n if refresh:\n if (ts % refresh == 0) or (res < tol):\n print('Step:{0} Residual:{1:.3f}'.format(ts, res))\n if callback:\n callback(X, **kwargs)\n\n ts += 1\n\n return X, f, l","def solver(u,f,n=50,m=100,t0=0,t1=1000,dt=.1,nu=1):\n \n u_new=[[u[i][j] for j in range(m)]for i in range(n)]\n loopCounter=t0\n while(loopCounter<=t1):\n for i in xrange(1,n-1):\n for j in xrange(1,m-1):\n u_new[i][j]=u[i][j] + dt * (nu*u[i-1][j] + nu*u[i][j-1] - 4*nu*u[i][j] + nu*u[i][j+1] + nu*u[i+1][j] + f[i][j])\n loopCounter+=dt\n u=[[u_new[i][j] for j in range(m)]for i in range(n)]\n\n return u","def solve(self, time_points):\n self.t = np.asarray(time_points)\n n = self.t.size\n if self.neq == 1: # scalar ODEs\n self.u = np.zeros(n)\n else: # systems of ODEs\n self.u = np.zeros((n, self.neq))\n\n # Assume self.t[0] corresponds to self.U0\n self.u[0] = self.U0\n\n # Time loop\n for k in range(n - 1):\n self.k = k\n self.u[k + 1] = self.advance()\n return self.u, self.t","def solve_step(self, bc_left=0):\n status = 0\n self.t += self.dt\n\n\n ### Construct the RHS vector\n # Implicit terms\n #cff1 = 0. # Fully implicit\n #cff2 = 0.\n cff1 = 0.5*(1. - 2.*self.c_im)*self.dt\n cff2 = 0.5*self.c_im*self.dt\n RHS = cff1*self.L_rhs.dot(self.B) +\\\n cff2*self.L_rhs.dot(self.B_n_m1)\n\n # Nonlinear (explicit) terms\n cff3 = self.dt*(3 + self.b_ex)*0.5\n cff4 = -self.dt*(1+2*self.b_ex)*0.5\n cff5 = self.dt*(self.b_ex)*0.5\n \n RHS += cff3*self.calc_nonlinear_rhs(self.B)\n RHS += cff4*self.calc_nonlinear_rhs(self.B_n_m1)\n RHS += cff5*self.calc_nonlinear_rhs(self.B_n_m2)\n\n # Other terms from the time-derivative\n RHS += self.B\n\n # Add the BCs to the RHS\n cff0 = 0.5*(1 + self.c_im)*self.dt\n self.add_bcs(RHS, bc_left, cff0, cff1, cff2)\n\n # Use the direct banded matrix solver (faster)\n self.B_n_p1[:] = la.solve_banded( (self._j,self._j), self.L_lhs.data[::-1,:], RHS)\n\n # Check solutions\n if np.any( np.isnan(self.B_n_p1)):\n return -1\n\n # Update the terms last\n self.B_n_m2[:] = self.B_n_m1\n self.B_n_m1[:] = self.B\n self.B[:] = self.B_n_p1\n\n ## Update the boundary terms in these equations\n self.bcs[2] = self.bcs[1]\n self.bcs[1] = self.bcs[0]\n self.bcs[0] = bc_left\n\n return status","def rhs(y, t, l, m, g):\n # Unpack the states so you can use the variable names in the\n # sympy.physics.mechanics equations\n q1 = y[0]\n q2 = y[1]\n u1 = y[2]\n u2 = y[3]\n # or you can make use of python's tuple unpacking for a one liner\n # q1, q2, u1, u2 = y\n\n # Initialize a vector for the derivatives.\n dydt = zeros((len(y)))\n\n # Compute the derivatives, these are pasted in from the\n # sympy.physics.mechanics results.\n dydt[0] = u1\n dydt[1] = u2\n dydt[2] = (-g*sin(q1)*sin(q2)**2 + 2*g*sin(q1) -\n g*sin(q2)*cos(q1)*cos(q2) + 2*l*u1**2*sin(q1)*cos(q1)*cos(q2)**2 -\n l*u1**2*sin(q1)*cos(q1) - 2*l*u1**2*sin(q2)*cos(q1)**2*cos(q2) +\n l*u1**2*sin(q2)*cos(q2) + l*u2**2*sin(q1)*cos(q2) -\n l*u2**2*sin(q2)*cos(q1))/(l*(sin(q1)**2*sin(q2)**2 +\n 2*sin(q1)*sin(q2)*cos(q1)*cos(q2) + cos(q1)**2*cos(q2)**2 - 2))\n dydt[3] = (-sin(q1)*sin(q2)/2 - cos(q1)*cos(q2)/2)*(2*g*l*m*sin(q1) -\n l**2*m*(-sin(q1)*cos(q2) +\n sin(q2)*cos(q1))*u2**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2)) -\n l**2*m) + (g*l*m*sin(q2) - l**2*m*(sin(q1)*cos(q2) -\n sin(q2)*cos(q1))*u1**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2))\n - l**2*m)\n\n # Return the derivatives.\n return dydt","def g_solving_subproblem_of_ALR(self,vehicle_id):\r\n global_LB = -10000\r\n global_UB = 10000\r\n iteration_for_RSP = 20\r\n optimal_solution_for_RSP = None\r\n self.multiplier_v = 0.5\r\n\r\n # solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\r\n\r\n # obtain the variance\r\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB = 0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\r\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\r\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\r\n\r\n # step 3: update multipliers\r\n if variance- y != 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB - global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB","def _gv_linear(self, r, t):\n mv1t = torch.matmul(self.mv1.weight, t.T) # [k, b]\n mv2r = torch.matmul(self.mv2.weight, r.T) # [k, b]\n return (mv1t + mv2r + self.bv.weight).T # [b, k]","def dlqr(A,B,Q,R):\n #ref Bertsekas, p.151\n \n #first, try to solve the ricatti equation\n X = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\n \n #compute the LQR gain\n K = np.matrix(scipy.linalg.inv(B.T*X*B+R)*(B.T*X*A))\n \n eigVals, eigVecs = scipy.linalg.eig(A-B*K)\n \n return K, X, eigVals","def T(self, q = np.zeros(1) , dq = np.zeros(1) , ddq = np.zeros(1) , R = 1 ): \n \n F = self.F( q , dq , ddq )\n \n Tl = self.Tlosses( dq , ddq )\n \n T = np.dot( 1. / R , F ) + np.dot( R , Tl ) \n \n return T","def f(t, x, y):\n Iq, UC, U = x # time continous state vector\n dIq = (Uq(t) - R*Iq - UC - U) / L\n dUC = Iq / C\n dU = Iq / Cp\n return array([dIq, dUC, dU])","def dynamics(self,eta,nu,u_actual,u_control,sampleTime): \n \n # Current velocities\n u_c = self.V_c * math.cos(self.beta_c - eta[5]) # current surge velocity\n v_c = self.V_c * math.sin(self.beta_c - eta[5]) # current sway velocity \n \n nu_c = np.array([u_c,v_c,0,0,0,0],float) # current velocity vector\n nu_r = nu - nu_c # relative velocity vector\n \n U_r = math.sqrt( nu_r[0]**2 + nu_r[1]**2 ) # relative speed\n \n # Rudder command and actual rudder angle\n delta_c = u_control[0]\n delta = u_actual[0]\n \n # Rudder forces and moment (Fossen 2021, Chapter 9.5.1)\n b = 0.7 * self.T # rudder height\n AR = b**2 / self.Lambda # aspect ratio: Lamdba = b**2/AR \n CN = 6.13 * self.Lambda / ( self.Lambda + 2.25 ) # normal coefficient\n t_R = 1 - 0.28 * self.Cb - 0.55\n a_H = 0.4\n x_R = -0.45 * self.L\n x_H = -1.0 * self.L\n\n Xdd = -0.5 * ( 1 - t_R ) * self.rho * U_r**2 * AR * CN\n Yd = -0.25 * ( 1 + a_H ) * self.rho * U_r**2 * AR * CN \n Nd = -0.25 * ( x_R + a_H * x_H ) * self.rho * U_r**2 * AR * CN \n \n # Control forces and moment\n delta_R = -delta # physical rudder angle (rad)\n T = self.tau_X # thrust (N)\n t_deduction = 0.1 # thrust deduction number\n tau1 = ( 1 - t_deduction ) * T - Xdd * math.sin( delta_R )**2 \n tau2 = -Yd * math.sin( 2 * delta_R ) \n tau6 = -Nd * math.sin( 2 * delta_R ) \n tau = np.array( [ tau1, tau2, tau6 ],float) \n \n # Linear maneuvering model\n T_surge = self.L # approx. time constant in surge (s)\n xg = 0 # approx. x-coordinate, CG (m) \n \n # 3-DOF ship model\n [M,N] = clarke83(U_r,self.L, self.B, self.T,self.Cb,self.R66,xg,T_surge)\n Minv = np.linalg.inv(M)\n nu3 = np.array( [ nu_r[0], nu_r[1], nu_r[5] ]) \n nu3_dot = np.matmul( Minv, tau - np.matmul(N,nu3) ) \n \n # 6-DOF ship model\n nu_dot = np.array( [ nu3_dot[0],nu3_dot[1],0,0,0,nu3_dot[2] ]) \n\n # Rudder angle saturation\n if ( abs(delta) >= self.deltaMax * math.pi / 180 ):\n delta = np.sign(delta) * self.deltaMax * math.pi / 180\n \n # Rudder dynamics\n delta_dot = (delta_c - delta) / self.T_delta \n\n # Forward Euler integration [k+1]\n nu = nu + sampleTime * nu_dot\n delta = delta + sampleTime * delta_dot\n\n u_actual = np.array([delta],float) \n\n return nu, u_actual","def __call__(self, p, q, verbosity=1, warn=True):\n if self.exactly_zero: return 0.0 # shortcut for trivial case\n if self.weight == 0:\n return _np.sum(_np.abs(q - p)) / 2\n\n #Set parameter values\n self.P.value[:] = p[:]\n self.Q.value[:] = q[:]\n\n treg_factor_ok = False\n self.Treg_factor.value = self.initial_treg_factor\n while not treg_factor_ok:\n\n obj1 = self._obj(self.t_params)\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\n **default_cvxpy_args(self.solver))\n\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed: # sanity check\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\n\n self.warning_msg = None\n if failed:\n if self.solver == \"SCS\":\n #raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\n if REBUILD:\n self._rebuild_problem()\n else:\n self._build_problem()\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\n failed = self.T.value is None # or self.resid_tvd.value is None\n\n if not failed:\n t_chk = self.build_transfer_mx(self.T_params.value)\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\n\n if eps > 1e-4:\n self.warning_msg = (\"ResidualTVD: Needed to increase eps to %g.\"\n \" The resulting ResidualTVD values are less precise.\") % eps\n if warn: print(self.warning_msg)\n break\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n else:\n raise ValueError(\"ResidualTVD: Convex optimizer failure\")\n\n #check that Treg_factor term doesn't dominate\n\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\n treg_factor_ok = True\n\n # ------------------------------------------------------------------\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\n # ------------------------------------------------------------------\n\n #resid_tvd = self._obj(self.T_params.value)\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\n # Treg_factor_ok = True\n #else:\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\n\n #obj2 = self._obj(self.T_params.value)\n #if obj2 < obj1:\n # Treg_factor_ok = True\n #else:\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\n # self.T_params.value[:] = self.t_params[:] #REVERT\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\n # self.Treg_factor.value = self.Treg_factor.value / 10\n # if self.Treg_factor.value > 1e-7:\n # print(\"REDUCING treg factor to: \", self.Treg_factor.value)\n # else:\n # Treg_factor_ok = True # give up!\n\n if self.Treg_factor.value != self.initial_treg_factor:\n if verbosity > 0: print(\"NOTE: Treg_factor was reduced to %g.\" % self.Treg_factor.value)\n #_warnings.warn((\"Initial Treg_factor (%g) was too large, and was reduced to %g.\"\n # \" Consider reducing the initial value to avoid repeating calculations.\")\n # % (self.initial_treg_factor, self.Treg_factor.value))\n\n obj2 = self._obj(self.T_params.value)\n if obj2 <= obj1:\n self.t_params[:] = self.T_params.value[:]\n else:\n print_revert_msg(\"ResidualTVD failed to reduce objective function (%g > %g)\", (obj2, obj1), verbosity)\n self.T_params.value[:] = self.t_params[:]\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\n\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization","def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\n coef2, R, b1, b2, sigmas, concomitant=False,\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\n max_iter_ot=20, max_iter_cd=2000,\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\n ot_threshold=0):\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\n 'stable': stable, \"objcd\": [], \"fot1\": [0.], \"fot2\": [0.],\n 'reweighting_loss': [], \"n_coords\": [], \"obj\": 0.}\n n_samples, n_features = Xf[0].shape\n n_tasks = len(Xf)\n if n_jobs == -1:\n n_jobs = n_tasks\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\n\n theta1 = coef1.copy()\n theta2 = coef2.copy()\n theta = theta1 - theta2\n\n thetaold = theta.copy()\n\n ot_img = True\n if len(M) == n_features:\n ot_img = False\n\n update_ot_1 = set_ot_func(stable, ot_img)\n update_ot_2 = set_ot_func(stable, ot_img)\n\n xp = utils.set_module(gpu)\n M = xp.asarray(- M / epsilon)\n if b1 is not None:\n b1 = xp.asarray(b1)\n if b2 is not None:\n b2 = xp.asarray(b2)\n\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\n\n if positive:\n theta2 *= 0.\n thetabar2 *= 0.\n theta = theta1\n a = n_samples * alpha * gamma\n beta1 = n_samples * beta1\n beta2 = n_samples * beta2\n\n if concomitant:\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\n else:\n sigma0 = 0.\n with Parallel(n_jobs=n_jobs, backend=\"threading\") as pll:\n if alpha == 0.:\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\n Ls, marginals1,\n sigmas, a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd,\n positive=positive)\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\n theta1, theta2 = utils.get_unsigned(theta)\n log['loss'].append(obj)\n else:\n for i in range(max_iter):\n obj = 0.\n if not positive:\n Y1 = utils.residual(Xf, - theta2, y)\n else:\n Y1 = y\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\n Ls,\n marginals1,\n sigmas,\n a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n if not positive:\n Y2 = utils.residual(Xf, theta1, y)\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\n R,\n Ls,\n marginals2,\n sigmas,\n a, beta2,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n theta = theta1 - theta2\n else:\n theta = theta1\n\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\n theta.max())\n dx = dx.max()\n thetaold = theta.copy()\n if alpha:\n if (theta1 > ot_threshold).any(0).all():\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma,\n b=b1, tol=tol_ot,\n max_iter=max_iter_ot,\n threshold=ot_threshold)\n if fot1 is None or not theta1.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b1 = xp.log(b1 + 1e-100, out=b1)\n stable = True\n update_ot_1 = set_ot_func(True, ot_img)\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\n tol=tol_ot, max_iter=max_iter_ot,\n threshold=ot_threshold)\n\n log[\"log_sinkhorn1\"].append(log_ot1)\n thetabar1 = q1\n log[\"fot1\"].append(fot1)\n obj += alpha * fot1\n if not positive and (theta2 > ot_threshold).any(0).all():\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\n\n if fot2 is None or not theta2.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b2 = xp.log(b2 + 1e-100, out=b2)\n stable = True\n update_ot_2 = set_ot_func(True, ot_img)\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot,\n max_iter=max_iter_ot)\n\n log[\"log_sinkhorn2\"].append(log_ot2)\n thetabar2 = q2\n log[\"fot2\"].append(fot2)\n obj += alpha * fot2\n\n log['loss'].append(obj)\n log['dloss'].append(dx)\n\n if dx < tol:\n break\n if i == max_iter - 1:\n warnings.warn('Objective did not converge.' +\n ' You might want' +\n ' to increase the number of iterations.' +\n ' Fitting data with very small alpha and' +\n ' beta may cause precision problems.',\n ConvergenceWarning)\n log['stable'] = stable\n\n if positive:\n theta2 *= 0.\n thetabar2 = xp.zeros_like(thetabar1)\n try:\n thetabar2 = thetabar2.get()\n except AttributeError:\n pass\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)","def KRC(self, ik, ipd, ipl, t):\n idx = ik - 1\n\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\n num1 = self.delta[idx] * self.thetak[idx]\n ins = num1 / den1\n\n for l in np.arange(0, self.L):\n pl = self.coca.PL(l, t)\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\n\n ans = ipd * np.exp(t * ipl) * ins\n\n return ans","def optimize_analytical_model(self, initial_state, previous_state, Q, R, target, time_horizon=10, time_step=1 / 60,\n verbose=False, env=None):\n assert len(initial_state) == self.state_len\n # Create variables\n m = env.lander.mass\n J = env.lander.inertia\n\n x = opt.Variable(self.state_len, time_horizon + 2, name='x')\n # mass = opt.Variable(time_horizon + 1, name='mass')\n u = opt.Variable(self.action_len, time_horizon, name='actions')\n\n # Loop through the entire time_horizon and append costs\n cost_function = []\n # @TODO: Change to Matrix Form\n for t in range(time_horizon):\n _cost = opt.quad_form(target[:, t + 1] - x[:, t + 2], Q) + opt.quad_form(u[:, t], R)\n\n A = [(u[0, t] * (x[4, t] + u[2, t]) + u[1, t]) * (time_step ** 2) / m + 2 * x[0, t + 1] - x[0, t],\n (u[0, t] - u[1, t] * x[4, t] - m * GRAVITY) * time_step ** 2 / m + 2 * x[1, t + 1] - x[1, t],\n (x[0, t + 1] - x[0, t]) / time_step,\n (x[1, t + 1] - x[1, t]) / time_step,\n (-u[0, t] * u[2, t] * (L1 + LN) + L2 * u[1, t]) * time_step ** 2 / J + 2 * x[4, t + 1] - x[4, t],\n (x[4, t + 1] - x[4, t]) / time_step]\n # Dynamics\n dynamic_constraints = [x[i, t + 2] == expr for i, expr in enumerate(A)]\n limit_constraints = [\n # mass[t + 1] == mass[t] - 0.007, #* opt.exp(\n # -u[0, t] * MAIN_ENGINE_FUEL_COST - u[1, t] * SIDE_ENGINE_FUEL_COST),\n # --------------------------------------------------------------------------------\n # Actions\n u[0, t] >= MAIN_ENGINE_POWER / 6, u[0, t] <= MAIN_ENGINE_POWER,\n u[1, t] >= -SIDE_ENGINE_POWER, u[1, t] <= SIDE_ENGINE_POWER,\n u[2, t] >= -self.angle_limit, u[2, t] <= self.angle_limit]\n\n _constraints = np.append(dynamic_constraints, limit_constraints)\n cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=list(limit_constraints)))\n\n # Add final cost\n problem = sum(cost_function)\n problem.constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 10.01,\n x[:, 0] == previous_state,\n x[:, 1] == initial_state]\n\n # Minimize Problem\n problem.solve(verbose=verbose, solver=opt.SCS)\n # u[0, :].value.A.flatten()\n return x[:, 2:], u","def calc_refl(velocity, shotloc_x, shotloc_z, layer_idxs):\n solver_dg = pykonal.EikonalSolver(coord_sys=\"cartesian\")\n solver_dg.vv.min_coords = velocity.min_coords\n solver_dg.vv.node_intervals = velocity.node_intervals\n solver_dg.vv.npts = velocity.npts\n solver_dg.vv.values = velocity.values\n\n #shotloc = 2.56 # km\n src_idx = (int((shotloc_x - velocity.min_coords[0])/velocity.node_intervals[0]), int(shotloc_z/velocity.node_intervals[1]), 0)\n solver_dg.tt.values[src_idx] = 0\n solver_dg.unknown[src_idx] = False\n solver_dg.trial.push(*src_idx)\n solver_dg.solve()\n\n solver_ug = pykonal.EikonalSolver(coord_sys=\"cartesian\")\n solver_ug.vv.min_coords = solver_dg.vv.min_coords\n solver_ug.vv.node_intervals = solver_dg.vv.node_intervals\n solver_ug.vv.npts = solver_dg.vv.npts\n solver_ug.vv.values = solver_dg.vv.values\n\n for ix in range(solver_ug.tt.npts[0]):\n #idx = (ix, solver_ug.tt.npts[1]-1, 0)\n idx = (ix, layer_idxs[ix], 0)\n solver_ug.tt.values[idx] = solver_dg.tt.values[idx]\n #print(idx, solver_dg.tt.values[idx])\n solver_ug.unknown[idx] = False\n solver_ug.trial.push(*idx)\n solver_ug.solve()\n \n return solver_ug.tt.values[:,0,0]","def quasi_optimalityTV(f, lam_init = 2.0, q = 0.9):\n \n lam = lam_init\n max_iter = 50\n error = np.zeros(max_iter)\n #alt_error = np.zeros(max_iter)\n u_old = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n for i in range(1, max_iter):\n lam = lam_init * (q ** i)\n u_new = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n error[i] = np.linalg.norm(u_old - u_new)\n #alt_error[i] = np.linalg.norm(u_old - u_new) /abs(lam_init*(q ** i - q ** (i-1)))\n u_old = np.copy(u_new)\n\n #plt.plot(error)\n #plt.plot(alt_error)\n #plt.show()\n opt_idx = np.argmin(error[error != 0.0])\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\n lam = lam_init * (q ** opt_idx)\n u= ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n \n return u, t","def calc_control_and_trajectory(x, dw, goal, ob):\n x_init = np.array(x)\n\n best_u = [0.0, 0.0]\n best_trajectory = None\n\n u_samples = []\n traj_samples = []\n cost_samples = []\n # evaluate all trajectory with sampled input in dynamic window\n for v in np.arange(dw[0], dw[1], Config.v_resolution):\n for y in np.arange(dw[2], dw[3], Config.yaw_rate_resolution):\n\n trajectory = predict_trajectory(x_init, v, y)\n # calc cost\n to_goal_cost = calc_to_goal_cost(trajectory, goal)\n speed_cost = (Config.max_speed - trajectory[-1, 3])\n ob_cost = calc_obstacle_cost(trajectory, ob)\n\n cost_samples.append([to_goal_cost,speed_cost,ob_cost])\n u_samples.append([v, y])\n traj_samples.append(trajectory)\n cost_samples = np.array(cost_samples)\n # normalization\n def normalize_0_1(x):\n if np.max(x)-np.min(x)>1e-4:\n return (x-np.min(x))/(np.max(x)-np.min(x))\n else:\n return np.zeros_like(x)\n\n def normalize_div_sum(x):\n if np.sum(x) > 1e-4:\n return x/np.sum(x)\n else:\n return np.zeros_like(x)\n\n # for i in range(3):\n # non_inf = cost_samples[:,i] != np.inf\n # if np.sum(non_inf) >0:\n # cost_samples[non_inf,i] = normalize_0_1(cost_samples[non_inf,i])\n \n cost_samples = Config.to_goal_cost_gain*cost_samples[:,0]+Config.speed_cost_gain*cost_samples[:,1]+Config.obstacle_cost_gain*cost_samples[:,2]\n ind = np.argmin(cost_samples)\n best_u = u_samples[ind]\n best_trajectory = traj_samples[ind]\n\n if abs(best_u[0]) < Config.robot_stuck_flag_cons \\\n and abs(x[3]) < Config.robot_stuck_flag_cons:\n # to ensure the robot do not get stuck in\n # [v,w] = [0,0], force the robot rotate\n best_u[1] = -Config.max_delta_yaw_rate\n return best_u, best_trajectory","def dopri853core(\n n, func, x, t, hmax, h, rtol, atol, nmax, safe, beta, fac1, fac2, pos_neg, args\n):\n # array to store the result\n result = numpy.zeros((len(t), n))\n\n # initial preparations\n facold = 1.0e-4\n expo1 = 1.0 / 8.0 - beta * 0.2\n facc1 = 1.0 / fac1\n facc2 = 1.0 / fac2\n\n k1 = numpy.array(func(x, t[0], *args))\n hmax = numpy.fabs(hmax)\n iord = 8\n\n if h == 0.0: # estimate initial time step\n h, k1, k2, k3 = hinit(func, x, t, pos_neg, k1, iord, hmax, rtol, atol, args)\n\n reject = 0\n t_current = t[\n 0\n ] # store current integration time internally (not the current time wanted by user!!)\n t_old = t[0]\n finished_user_t_ii = 0 # times indices wanted by user\n\n result[0, :] = x\n\n # basic integration step\n while (\n finished_user_t_ii < len(t) - 1\n ): # check if the current computed time indices less than total inices needed\n # keep time step not too small\n h = pos_neg * numpy.max([numpy.fabs(h), 1e3 * uround])\n\n # the twelve stages\n xx1 = x + h * a21 * k1\n k2 = numpy.array(func(xx1, t_current + c2 * h, *args))\n\n xx1 = x + h * (a31 * k1 + a32 * k2)\n k3 = numpy.array(func(xx1, t_current + c3 * h, *args))\n\n xx1 = x + h * (a41 * k1 + a43 * k3)\n k4 = numpy.array(func(xx1, t_current + c4 * h, *args))\n\n xx1 = x + h * (a51 * k1 + a53 * k3 + a54 * k4)\n k5 = numpy.array(func(xx1, t_current + c5 * h, *args))\n\n xx1 = x + h * (a61 * k1 + a64 * k4 + a65 * k5)\n k6 = numpy.array(func(xx1, t_current + c6 * h, *args))\n\n xx1 = x + h * (a71 * k1 + a74 * k4 + a75 * k5 + a76 * k6)\n k7 = numpy.array(func(xx1, t_current + c7 * h, *args))\n\n xx1 = x + h * (a81 * k1 + a84 * k4 + a85 * k5 + a86 * k6 + a87 * k7)\n k8 = numpy.array(func(xx1, t_current + c8 * h, *args))\n\n xx1 = x + h * (a91 * k1 + a94 * k4 + a95 * k5 + a96 * k6 + a97 * k7 + a98 * k8)\n k9 = numpy.array(func(xx1, t_current + c9 * h, *args))\n\n xx1 = x + h * (\n a101 * k1\n + a104 * k4\n + a105 * k5\n + a106 * k6\n + a107 * k7\n + a108 * k8\n + a109 * k9\n )\n k10 = numpy.array(func(xx1, t_current + c10 * h, *args))\n\n xx1 = x + h * (\n a111 * k1\n + a114 * k4\n + a115 * k5\n + a116 * k6\n + a117 * k7\n + a118 * k8\n + a119 * k9\n + a1110 * k10\n )\n k2 = numpy.array(func(xx1, t_current + c11 * h, *args))\n\n xx1 = x + h * (\n a121 * k1\n + a124 * k4\n + a125 * k5\n + a126 * k6\n + a127 * k7\n + a128 * k8\n + a129 * k9\n + a1210 * k10\n + a1211 * k2\n )\n\n t_old_older = numpy.copy(t_old)\n t_old = numpy.copy(t_current)\n t_current += h\n\n k3 = numpy.array(func(xx1, t_current, *args))\n\n k4 = (\n b1 * k1\n + b6 * k6\n + b7 * k7\n + b8 * k8\n + b9 * k9\n + b10 * k10\n + b11 * k2\n + b12 * k3\n )\n k5 = x + h * k4\n\n # error estimation\n sk = atol + rtol * numpy.max([numpy.fabs(x), numpy.fabs(k5)], axis=0)\n erri = k4 - bhh1 * k1 - bhh2 * k9 - bhh3 * k3\n err2 = numpy.sum(numpy.square(erri / sk), axis=0)\n erri = (\n er1 * k1\n + er6 * k6\n + er7 * k7\n + er8 * k8\n + er9 * k9\n + er10 * k10\n + er11 * k2\n + er12 * k3\n )\n err = numpy.sum(numpy.square(erri / sk), axis=0)\n\n deno = err + 0.01 * err2\n deno = 1.0 if deno <= 0.0 else deno\n err = numpy.fabs(h) * err * numpy.sqrt(1.0 / (deno * n))\n\n # computation of hnew\n fac11 = numpy.power(err, expo1)\n\n # Lund-stabilization\n fac = fac11 / pow(facold, beta)\n\n # we require fac1 <= hnew / h <= fac2\n fac = numpy.max([facc2, numpy.min([facc1, fac / safe])])\n hnew = h / fac\n\n if err <= 1.0:\n # step accepted\n facold = numpy.max([err, 1.0e-4])\n k4 = numpy.array(func(k5, t_current, *args))\n\n # final preparation for dense output\n rcont1 = numpy.copy(x)\n xdiff = k5 - x\n rcont2 = xdiff\n bspl = h * k1 - xdiff\n rcont3 = numpy.copy(bspl)\n rcont4 = xdiff - h * k4 - bspl\n rcont5 = (\n d41 * k1\n + d46 * k6\n + d47 * k7\n + d48 * k8\n + d49 * k9\n + d410 * k10\n + d411 * k2\n + d412 * k3\n )\n rcont6 = (\n d51 * k1\n + d56 * k6\n + d57 * k7\n + d58 * k8\n + d59 * k9\n + d510 * k10\n + d511 * k2\n + d512 * k3\n )\n rcont7 = (\n d61 * k1\n + d66 * k6\n + d67 * k7\n + d68 * k8\n + d69 * k9\n + d610 * k10\n + d611 * k2\n + d612 * k3\n )\n rcont8 = (\n d71 * k1\n + d76 * k6\n + d77 * k7\n + d78 * k8\n + d79 * k9\n + d710 * k10\n + d711 * k2\n + d712 * k3\n )\n\n # the next three function evaluations\n xx1 = x + h * (\n a141 * k1\n + a147 * k7\n + a148 * k8\n + a149 * k9\n + a1410 * k10\n + a1411 * k2\n + a1412 * k3\n + a1413 * k4\n )\n k10 = numpy.array(func(xx1, t_old + c14 * h, *args))\n xx1 = x + h * (\n a151 * k1\n + a156 * k6\n + a157 * k7\n + a158 * k8\n + a1511 * k2\n + a1512 * k3\n + a1513 * k4\n + a1514 * k10\n )\n k2 = numpy.array(func(xx1, t_old + c15 * h, *args))\n xx1 = x + h * (\n a161 * k1\n + a166 * k6\n + a167 * k7\n + a168 * k8\n + a169 * k9\n + a1613 * k4\n + a1614 * k10\n + a1615 * k2\n )\n k3 = numpy.array(func(xx1, t_old + c16 * h, *args))\n\n # final preparation\n rcont5 = h * (rcont5 + d413 * k4 + d414 * k10 + d415 * k2 + d416 * k3)\n rcont6 = h * (rcont6 + d513 * k4 + d514 * k10 + d515 * k2 + d516 * k3)\n rcont7 = h * (rcont7 + d613 * k4 + d614 * k10 + d615 * k2 + d616 * k3)\n rcont8 = h * (rcont8 + d713 * k4 + d714 * k10 + d715 * k2 + d716 * k3)\n\n k1 = numpy.copy(k4)\n x = numpy.copy(k5)\n\n # loop for dense output in this time slot\n while (finished_user_t_ii < len(t) - 1) and (\n pos_neg * t[finished_user_t_ii + 1] < pos_neg * t_current\n ):\n result[finished_user_t_ii + 1, :] = dense_output(\n t[finished_user_t_ii + 1],\n t_old,\n h,\n [rcont1, rcont2, rcont3, rcont4, rcont5, rcont6, rcont7, rcont8],\n )\n finished_user_t_ii += 1\n\n if numpy.fabs(hnew) > hmax:\n hnew = pos_neg * hmax\n if reject:\n hnew = pos_neg * numpy.min([numpy.fabs(hnew), numpy.fabs(h)])\n\n reject = 0\n else:\n # step rejected since error too big\n hnew = h / numpy.min([facc1, fac11 / safe])\n reject = 1\n\n # reverse time increment since error rejected\n t_current = numpy.copy(t_old)\n t_old = numpy.copy(t_old_older)\n\n h = numpy.copy(hnew) # current h\n\n return result","def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \n bc_surface, sigma):\n\n # temperatures are reported as a data frame, where each column is a step in time\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\n\n # extract the necessary parameters to determine the surface heat losses\n if bc_surface[0] == \"linear\":\n h = bc_surface[1] + bc_surface[2]\n hc = 0\n emissivity = 0\n elif bc_surface[0] == \"non-linear\":\n h = 0\n hc = bc_surface[1]\n emissivity = bc_surface[2]\n\n # initialize temperature arrays for present and future temperatures\n T = np.zeros_like(x_grid) + temp_initial\n Tn = np.zeros_like(x_grid)\n\n # iterate over each time step\n temperatures.iloc[:,0] = T\n for j, t in enumerate(t_grid[:-1]):\n \n # create tri-diagonal matrix A\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\n \n # create vector b\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \n emissivity = emissivity, sigma = sigma, j = j)\n \n # calculate value of future temperature\n Tn = np.linalg.solve(A,b)\n \n # update present temperature\n T = Tn.copy()\n \n # store temperature profile at this time in the data frame\n temperatures.iloc[:, j+1] = Tn\n \n return temperatures","def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def get_lqr_feedback(self, x_0=None, u_0=None):\n q = self.wx_feedback\n r = self.wu_feedback\n\n if x_0 is None:\n x_0 = np.zeros((self.n_s, 1))\n if u_0 is None:\n u_0 = np.zeros((self.n_u, 1))\n\n if self.lin_prior:\n a = self.a\n b = self.b\n\n k_lqr, _, _ = dlqr(a, b, q, r)\n k_fb = -k_lqr\n else:\n\n raise NotImplementedError(\n \"Cannot compute feed-back matrices without prior model\")\n\n return k_fb.reshape((1, self.n_s * self.n_u))","def L_curveTV(f,lam_init = 2.0, q = 0.9):\n lam = lam_init\n max_iter = 50\n residual_list = np.zeros(max_iter)\n size_list = np.zeros(max_iter)\n error = np.zeros(max_iter)\n alt_error = np.zeros(max_iter)\n \n for i in range(max_iter): #range(max_iter):\n u = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc=True, tol = 1.0e-5)\n #u, _, j = projected_gradient_alt(f,lam, tau = 0.2, tol = 1.0e-4)\n lam = lam_init * (q ** i)\n residual_list[i] = np.linalg.norm(u - f)\n size_list[i] = np.linalg.norm(u)\n error[i] = np.linalg.norm(u - f) * np.linalg.norm(u)\n #plt.loglog(residual_list,size_list)\n #plt.show()\n opt_idx = np.argmin(error)\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\n lam = lam_init * (q ** opt_idx)\n u = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\n return u, t","def LinealizeCarModel(xb, u, dt, lr):\n\n x = xb[0]\n y = xb[1]\n v = xb[2]\n theta = xb[3]\n\n a = u[0]\n beta = u[1]\n\n t1 = -dt * v * sin(theta + beta)\n t2 = dt * v * cos(theta + beta)\n\n A = np.eye(xb.shape[0])\n A[0, 2] = dt * cos(theta + beta)\n A[1, 2] = dt * sin(theta + beta)\n A[3, 2] = dt * sin(beta) / lr\n A[0, 3] = t1\n A[1, 3] = t2\n\n B = np.zeros((xb.shape[0], u.shape[0]))\n B[2, 0] = dt\n B[0, 1] = t1\n B[1, 1] = t2\n B[3, 1] = dt * v * cos(beta) / lr\n\n tm = np.zeros((4, 1))\n tm[0, 0] = v * cos(theta + beta) * dt\n tm[1, 0] = v * sin(theta + beta) * dt\n tm[2, 0] = a * dt\n tm[3, 0] = v / lr * sin(beta) * dt\n C = xb + tm\n C = C - A * xb - B * u\n\n return A, B, C","def Langmuir_Knudsen_mdot(D, T_p, Psat, Re, mu_g, cp_g, lambda_g, P_g, R_g, Sc_g, R_v, Yinf):\n Pr_g = mu_g * cp_g / lambda_g # Gas Prandtl Number\n Sh = 2.0 + 0.552 * math.sqrt(Re) * Sc_g ** (1.0/3.0) \n Re_b = 0.0 #Blowing Reynolds number \n Re_b0 = Re_b \n Xseq = min(Psat / P_g, 1.0) #Molar mass fraction\n theta2 = R_v / R_g ;\n Yseq = min(Xseq /max(Xseq + (1.0 - Xseq) * theta2, 1e-30), 1.0) \n yMin = min(Yseq, Yinf) \n yMax = max(Yseq, Yinf) \n\n # Iterate to converge on Re_b\n # This part could be optimized\n Lk = computeLK(T_p,R_v,mu_g,Sc_g,P_g) \n Re_b0 = estimate_re_b(yMin, yMax, Yinf, Sh, Sc_g)\n \n max_solver_iterations = 100\n for i in range(max_solver_iterations): \n Ysneq = computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b) \n #Bound Ysneq so that it lies between Yseq and Yinf\n Ysneq = max(yMin, min(yMax, Ysneq)) \n BMneq = (Ysneq - Yinf) / max(1.0 - Ysneq, 1e-30) \n Hm = math.log(max(1.0 + BMneq, 1e-40)) \n Re_b0 = Re_b \n Re_b = Hm * Sh / Sc_g \n factor = min(0.8, 0.5 * D / Lk) #Damping factor\n\n if i >= max_solver_iterations:\n print('Mdot Calculation failed to converge')\n\n if abs(Re_b - Re_b0) < 1.0e-6:\n break \n\n #Relax update to help convergence\n Re_b = factor * Re_b + (1.0 - factor) * Re_b0 \n \n #Chris debug\n beta = 0.5 * Pr_g * Re_b ;\n if i > -1: \n format_string = 'i= {0:<4d} Re_b= {1:<8.4f} Ysneq= {2:<8.4f} Hm= {3:<8.4f} ' \\\n 'BMneq= {4:<8.4f} Lk= {5:<8.4e} Lk/D= {6:<8.4e} factor= {7:<8.4e} beta= {8:<8.4f}'\n print(format_string.format(i, Re_b, computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b), Hm, BMneq, Lk, Lk/D, factor, beta))\n \n # Back out mdot from blowing reunolds number\n mdot = -Re_b * D * mu_g * math.pi \n return mdot","def forward(self):\n R = self.LP.cost.R\n A = self.LP.dyn.A\n B = self.LP.dyn.B\n\n x = self.LP.x0\n self.x[0] = x\n for i in range(self.LP.N):\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\n if self.LP.dyn.u_dim == 1:\n self.u[i] = float(u)\n else:\n self.u[i] = u\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\n\n if i == 0:\n self.J[i] = self.LP.cost.loss(x, u, i)\n else:\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\n x = self.LP.dyn.next_state(x, u)\n self.x[i+1] = x\n\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\n\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\n + self.W[self.LP.N].T.dot(x)) #up to constant","def solve_lsqr(self, b, rho=None, v=None, x_init=None, options=None):\n\n # Add additional linear terms for the rho terms\n sizev = 0\n if rho is not None:\n vf = v.flatten() * np.sqrt(rho / 2.0)\n sizeb = self.K.input_size\n sizev = np.prod(v.shape)\n b = np.hstack((b, vf))\n\n input_data = np.zeros(self.K.input_size)\n output_data = np.zeros(self.K.output_size + sizev)\n\n def matvec(x, output_data):\n if rho is None:\n # Traverse compgraph\n self.K.forward(x, output_data)\n else:\n # Compgraph and additional terms\n self.K.forward(x, output_data[0:0 + sizeb])\n np.copyto(output_data[sizeb:sizeb + sizev],\n x * np.sqrt(rho / 2.0))\n\n return output_data\n\n def rmatvec(y, input_data):\n if rho is None:\n self.K.adjoint(y, input_data)\n else:\n self.K.adjoint(y[0:0 + sizeb], input_data)\n input_data += y[sizeb:sizeb + sizev] * np.sqrt(rho / 2.0)\n\n return input_data\n\n # Define linear operator\n def matvecComp(x):\n return matvec(x, output_data)\n\n def rmatvecComp(y):\n return rmatvec(y, input_data)\n\n K = LinearOperator((self.K.output_size + sizev, self.K.input_size),\n matvecComp, rmatvecComp)\n\n # Options\n if options is None:\n # Default options\n return lsqr(K, b)[0]\n else:\n if not isinstance(options, lsqr_options):\n raise Exception(\"Invalid LSQR options.\")\n return lsqr(K,\n b,\n atol=options.atol,\n btol=options.btol,\n show=options.show,\n iter_lim=options.iter_lim)[0]","def RHSnet(y,t,a,b0,b1,g,k,w):\n S = y[:N]\n E = y[N:2*N]\n C = y[2*N:3*N]\n b = b0 + b1*(1+np.cos(2*np.pi*t))\n dy = np.zeros(3*N)\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\n return dy","def solve(self):\n \n # Definition of the parameters\n Q_pc = self.parameters.getParam(\"Q_pc\")\n V_c = self.parameters.getParam(\"V_c\")\n V_p = self.parameters.getParam(\"V_p\")\n CL = self.parameters.getParam(\"CL\")\n initial_conditions = [\n self.parameters.getParam(\"q_c0\"),\n self.parameters.getParam(\"q_p0\"),\n ]\n t_eval = np.linspace(0, self.timespan, self.nsteps)\n\n # Definition of the model ODEs\n def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\n \"\"\"Defines the differential equations for the PK IV model.\n\n Parameters:\n :param t: time (h)\n :param y: list of the state variables of the ODEs system, in the\n form [q_c, q_p]\n :param Q_pc: transition rate between central and peripheral\n compartments (mL/h)\n :param V_c: volume of central compartment (mL)\n :param V_p: volume of peripheral compartment (mL)\n :param CL: clearance/elimination rate from the central\n compartment (mL/h)\n\n The parameters (except for t and y) are extracted from the\n Parameter class, using getParam method.\n\n Returns list containing the differential equations, in the form:\n [dqc_dt, dqp_dt]\n \"\"\"\n q_c, q_p = y\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\n dqp_dt = transfer\n return [dqc_dt, dqp_dt]\n\n # Solving the model\n sol = scipy.integrate.solve_ivp(\n fun=lambda t, y: pk_iv_model(t, y, Q_pc, V_c, V_p, CL),\n t_span=[t_eval[0], t_eval[-1]],\n y0=initial_conditions,\n t_eval=t_eval,\n )\n\n # Feeding the solution line by line to solution class\n t = sol.t\n y = sol.y\n N = t.shape[0]\n columnNames = [\"t\", \"dose\", \"q_c\", \"q_p\"]\n self.solution.begin(columnNames, N)\n for i in range(N):\n arr = np.zeros((len(columnNames), 1))\n arr[0] = t[i]\n arr[1] = self.dosefunction(t[i])\n arr[2:, 0] = y[:, i]\n self.solution.report(arr)","def build_system(u, dt, dx, D=4, C=1, time_diff='FD', space_diff='FD', width_x=None,\n width_t=None, deg_x=5, deg_t=None):\n\n n, m = u.shape\n\n if width_x == None: width_x = n / 10\n if width_t == None: width_t = m / 10\n if deg_t == None: deg_t = deg_x\n\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\n if time_diff == 'poly':\n m2 = m - 2 * width_t\n offset_t = width_t\n else:\n m2 = m\n offset_t = 0\n if space_diff == 'poly':\n n2 = n - 2 * width_x\n offset_x = width_x\n else:\n n2 = n\n offset_x = 0\n\n ########################\n # First take the time derivaitve for the left hand side of the equation\n ########################\n ut = np.zeros((n2, m2), dtype=np.complex64)\n\n if time_diff == 'poly':\n T = np.linspace(0, (m - 1) * dt, m)\n for i in range(n2):\n ut[i, :] = PolyDiff(u[i + offset_x, :], T, diff=1, width=width_t, deg=deg_t)[:, 0]\n\n else:\n for i in range(n2):\n ut[i, :] = FiniteDiff(u[i + offset_x, :], dt, 1)\n\n ut = np.reshape(ut, (n2 * m2, 1), order='F')\n\n ########################\n # Now form the rhs one column at a time, and record what each one is\n ########################\n\n u2 = u[offset_x:n - offset_x, offset_t:m - offset_t]\n Theta = np.zeros((n2 * m2, (D + 1) * C), dtype=np.complex64)\n ux = np.zeros((n2, m2), dtype=np.complex64)\n rhs_description = ['' for i in range((D + 1) * C)]\n\n if space_diff == 'poly':\n Du = {}\n for i in range(m2):\n Du[i] = PolyDiff(u[:, i + offset_t], np.linspace(0, (n - 1) * dx, n), diff=D, width=width_x, deg=deg_x)\n if space_diff == 'Fourier': ik = 1j * np.fft.fftfreq(n) * n\n\n for d in range(D + 1):\n # compute derivatives of d degree\n if d > 0:\n for i in range(m2):\n if space_diff == 'FD':\n ux[:, i] = FiniteDiff(u[:, i + offset_t], dx, d)\n elif space_diff == 'poly':\n ux[:, i] = Du[i][:, d - 1]\n else:\n ux = np.array(u2, dtype=np.complex64)\n # if d == 1: print(ux)\n\n # compute polynomials of all terms, c used as c+1\n for c in range(C):\n Theta[:, d * C + c] = np.reshape(np.power(ux, c+1), (n2 * m2), order='F')\n # print('d:{}, c:{}, mean:{}'.format(d, c, np.mean(Theta[:, d * C + c])))\n\n if d > 0:\n rhs_description[d * C + c] = rhs_description[d * C + c] + \\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\n else:\n rhs_description[d * C + c] = rhs_description[d * C + c] + 'u'\n\n if c > 0:\n rhs_description[d * C + c] = rhs_description[d * C + c] + '^' + str(c+1)\n\n # print(rhs_description)\n features, rhs = create_cross_features(Theta, rhs_description)\n features = np.concatenate((Theta, features), 1)\n rhs = np.concatenate((rhs_description, rhs), 0)\n\n return ut, features, rhs","def _q_x(self):\n lambda_r = self.latt_par['lambda_r'].value \n return 2*np.pi*self.k/lambda_r","def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\n \n # INPUTS FROM TTTW SYSTEM\n self.b = b #buoyancy field: [Ly,N]\n self.u = u # x-component of velocity [Ly,N]\n self.v = v # y-component of velocity [Ly+1,N]\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\n self.grid_dict = grid_dict #gridded data\n self.f = f #coriolis parameter\n # KPP-SPECIFIC VARIABLES \n self.hbls = np.zeros([self.b.shape[0]])\n self.hbbl = np.zeros([self.b.shape[0]])\n self.ustar = []\n self.bvf = [] \n self.kmo = []\n self.C_h_MO = []\n self.kbl = []\n self.Cr = [] \n self.Fc = []\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\n self.dt = dt","def _gcl(x, r, D, Ia, Ct):\n\n Area = np.pi * D ** 2.0 / 4.0\n m = 1.0 / (np.sqrt(1.0 - Ct))\n k = np.sqrt((m + 1.0) / 2.0)\n\n a1 = 0.435449861 # empirically determined\n a2 = 0.797853685\n a3 = -0.124807893\n a4 = 0.136821858\n b1 = 15.6298\n b2 = 1.0\n R96 = a1 * (np.exp(a2 * Ct * Ct + a3 * Ct + a4)) * (b1 * Ia + b2) * D\n\n x0 = (9.6 * D) / ((2.0 * R96 / (k * D)) ** 3.0 - 1.0)\n term1 = (k * D / 2.0) ** (5.0 / 2.0)\n term2 = (105.0 / (2.0 * np.pi)) ** (-0.5)\n term3 = (Ct * Area * x0) ** (-5.0 / 6.0)\n c1 = term1 * term2 * term3\n # c45=3*(c1) ** 2\n\n term10 = 0.1111 # * WindSpeed # U/9.0\n term20 = (Ct * Area * (x + x0) ** (-2.0)) ** (1.0 / 3.0)\n term310 = (r ** (3.0 / 2.0))\n term320 = (3.0 * c1 * c1 * Ct * Area * (x + x0)) ** (-0.5)\n term30 = term310 * term320\n term40 = ((35.0 / (2.0 * np.pi)) ** (3.0 / 10.0)) * \\\n (3.0 * c1 * c1) ** (-1.0 / 5.0)\n DU1 = -term10 * term20 * (term30 - term40) ** 2.0\n\n DU = DU1 # + w2 * DU2\n Rw = ((105 * c1 ** 2.0 / (2 * np.pi)) ** (1. / 5.)) * \\\n (Ct * Area * (x + x0)) ** (1. / 3.)\n return DU, Rw","def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\n auto_param_obj_history = []\n auto_param_relaxed_obj_history = []\n \n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\n eta = np.array([eta_0/len(H)]*len(H))*0.9\n eta_lin = np.ones(L_lhs.shape[0])*0.01\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Feasibility')\n count = 0\n num_violated = -1\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n count += 1\n num_violated_prev = np.copy(num_violated)\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\n \n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\n eta[cnstr['Relaxed'] == False] *= eta_step\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n # eta_lin *= eta_step\n \n if num_violated == num_violated_prev:\n print('Increase enforcement')\n if num_violated_lin > 0:\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n #eta_lin *= eta_step\n if num_violated_oar > 0:\n eta[cnstr['Relaxed'] == False] *= eta_step\n # eta_0 *= eta_step*2\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Optimality')\n count = 0\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\n count += 1\n print('Opt Iter', count)\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\n u_prev = np.copy(u)\n eta_0 *= eta_step_tumor\n print('Current eta_0:', eta_0)\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n \n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\n print('No improvement, increase enforcement')\n eta_step_tumor *= 0.1\n eta_0 *= eta_step_tumor\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # break\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\n \n print('Finding the correct solution:')\n u = u_prev\n eta_0 = eta_0/eta_step_tumor\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\n print(\"OBJJJJJ:\", obj_u_opt_N_fixed(u, T, alpha, B))\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history","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 path(self, t=10, u=None, x0=None):\n if x0 is None:\n x0 = np.zeros(3)\n\n def dynamics(t, x, vehicle, u):\n # u = vehicle.control(demand, x)\n \n return vehicle.deriv(x, u)\n\n if base.isscalar(t):\n t_span = (0, t)\n t_eval = np.linspace(0, t, 100)\n elif isinstance(t, np.ndarray):\n t_span = (t[0], t[-1])\n t_eval = t\n else:\n raise ValueError('bad time argument')\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\"RK45\", args=(self, u))\n\n return (sol.t, sol.y.T)","def run(self):\n self.errList = []\n self.initialize()\n\n for i in range(self.maxiter):\n # update U\n for k in range(self.K):\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\n full_matrices=False)\n self.U[k] = q.T.dot(p.T)\n self.U[k] = self.U[k].real\n\n # calculate temporal variable y\n y = np.zeros([self.rank, self.L, self.K])\n for k in range(self.K):\n y[:, :, k] = self.U[k].T.dot(self.X[k])\n\n # get H, V, and temps by running a single iteration of CP_ALS\n if i == 0:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1, printitn=0)\n else:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1,\n init=[self.H, self.V, temps], printitn=0)\n self.H = cp.Us[0]\n self.V = cp.Us[1]\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\n\n # update S\n for k in range(self.K):\n self.S[:, :, k] = np.diag(temps[k, :])\n\n # checking the stop criteria\n # error = 0\n for k in range(self.K):\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\n\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\n self.errList.append(error)\n if (i + 1) % self.printitn == 0:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n elif error < self.tol:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n\n if error < self.tol:\n break\n else:\n self.sigma_old = self.sigma_new\n self.sigma_new = 0\n\n for k in range(self.K):\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)","def ft_ll(m, t, y, x, x_kernel, x_kernel_params, t_kernel, t_kernel_params):\n # Take copies of everything - this is a function\n m = copy.deepcopy(m)\n t = copy.deepcopy(t)\n y = copy.deepcopy(y)\n x = copy.deepcopy(x)\n\n K_x = x_kernel(x, x, **x_kernel_params)\n N = len(y)\n\n lambd = np.zeros((N, 1))\n gamma = np.zeros((N, 1))\n\n K_t = [None] * N\n\n for n in range(N):\n K_t[n] = t_kernel(t[n], t[n], **t_kernel_params)\n lambd[n] = np.dot(np.ones((1, len(t[n]))), np.linalg.solve(K_t[n], np.ones((len(t[n]), 1))))\n # Making sure y[n] is a column vector\n y[n] = np.array(y[n], ndmin=2)\n if y[n].shape[0] == 1:\n y[n] = y[n].T\n gamma[n] = np.dot(np.ones((1, len(t[n]))), np.linalg.solve(K_t[n], y[n] - m[n] * np.ones(y[n].shape)))\n\n Lambd = np.diag(lambd.ravel())\n\n ll = 0\n\n # Terms relating to individual curves\n for n in range(N):\n ll += - 0.5 * np.dot((y[n] - m[n] * np.ones(y[n].shape)).T,\n np.linalg.solve(K_t[n], y[n] - m[n] * np.ones(y[n].shape)))\n ll += - 0.5 * np.log(np.linalg.det(K_t[n]))\n\n # Terms relating to K_x\n ll += + 0.5 * np.dot(gamma.T, np.linalg.solve(np.linalg.inv(K_x) + Lambd, gamma))\n ll += - 0.5 * np.log(np.linalg.det(np.linalg.inv(K_x) + Lambd))\n ll += - 0.5 * np.log(np.linalg.det(K_x))\n\n return ll","def f_model(self, X_f=None):\n # M*D2q + k = q + B*u\n # y = [q1; q2; dq1_dt; dq2_dt]\n\n if X_f is None:\n t = self.t\n x0 = self.x0\n u = self.u\n else:\n t = self.tensor(X_f[:, 0:1])\n x0 = self.tensor(X_f[:, 1:5])\n u = self.tensor(X_f[:, 5:7])\n\n i_PR90 = tf.ones(len(t), dtype=tf.float64) * 161\n\n with tf.GradientTape(persistent=True) as tape:\n tape.watch(t)\n y_pred = self.model(tf.concat([t, x0, u], axis=1))\n\n q1 = y_pred[:, 0:1]\n q2 = y_pred[:, 1:2]\n dq1_dt = y_pred[:, 2:3]\n dq2_dt = y_pred[:, 3:4]\n dq_dt = tf.stack([dq1_dt, dq2_dt], axis=1)\n\n dq1_dt_tf = tape.gradient(q1, t)[:, 0]\n dq2_dt_tf = tape.gradient(q2, t)[:, 0]\n dq_dt_tf = tf.stack([dq1_dt_tf, dq2_dt_tf], axis=1)\n\n d2q1_dt_tf = tape.gradient(dq1_dt, t)[:, 0]\n d2q2_dt_tf = tape.gradient(dq2_dt, t)[:, 0]\n d2q_dt_tf = tf.stack([d2q1_dt_tf, d2q2_dt_tf], axis=1)\n\n M_tf = M_tensor(q2[:, 0], i_PR90)\n k_tf = k_tensor(dq1_dt_tf, q2[:, 0], dq2_dt_tf)\n q_tf = q_tensor(q1[:, 0], dq1_dt_tf, q2[:, 0], dq2_dt_tf)\n B_tf = B_tensor(i_PR90)\n\n f_pred = tf.concat([dq_dt_tf - dq_dt[:, :, 0],\n tf.linalg.matvec(M_tf, d2q_dt_tf) + k_tf - q_tf - tf.linalg.matvec(B_tf, u)], axis=1)\n\n return f_pred","def PDE_RHS_FKPP(t,y,q,x,description=None):\n \n \n D_mat = create_Uxx_mat(x)\n\n return (q[0]*D_mat.dot(y) + \n q[1]*y*(1-y))","def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\n\n # def Q_gen(I, R):\n # w = I * I * R\n # return w\n\n # def Q_rad_in(I_sun, A_s, a_s):\n # w = I_sun * D * a_s\n # return w\n\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\n # w = htcoeff * A_s * (T_line - T_amb)\n # return w\n\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\n # return w\n\n def reynolds(V, D, v, Mair=1.103):\n r = V * D / v\n return r\n\n def nusselt(Re, Pr):\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\n c = (Re / 282000) ** (5.0/8.0)\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\n return n\n\n def air_prop(T_amb):\n # temp v k Pr\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\n [250, 11.44e-6, 22.3e-3, 0.720],\n [300, 15.89e-6, 26.3e-3, 0.707],\n [350, 20.92e-6, 30.0e-3, 0.700],\n [400, 26.41e-6, 33.8e-3, 0.690],\n [450, 32.39e-6, 37.3e-3, 0.686],\n [500, 38.79e-6, 40.7e-3, 0.684],\n [550, 45.57e-6, 43.9e-3, 0.683],\n [600, 52.69e-6, 46.9e-3, 0.685]])\n\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\n 0, air_prop[:,1:])\n return v, k, Pr\n\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\n if 273 <= T_line <= 323:\n R = ((R_lo + \n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\n *(T_line - T_range[0]))/N_cond)\n elif T_line > 323:\n R = ((R_mid + \n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\n *(T_line - T_range[1]))/N_cond)\n else:\n R = R_lo\n print('Out of bounds')\n return R\n\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\n temp_factor = 1\n wind_factor = 1\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\n\n T_amb = T_amb*temp_factor\n V = V*wind_factor\n\n v, k, Pr = air_prop(T_amb)\n Re = reynolds(V, D, v)\n htcoeff = nusselt(Re, Pr) * k / D\n\n def T_line(T_init):\n \n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\n print R\n\n C4 = e_s * sigma * D * math.pi\n C3 = 0.0\n C2 = 0.0\n C1 = htcoeff * D * math.pi\n C0 = - ( I ** 2 * R\n + I_sun * a_s * D\n + htcoeff * D * math.pi * T_amb\n + e_s * D * math.pi * sigma * (T_amb ** 4))\n\n return np.roots([C4, C3, C2, C1, C0])\n\n T_c = T_amb\n \n for i in range(n_iter):\n T_arr = T_line(T_c)\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\n print T_c\n\n return T_c","def dynstall_mhh_dxdt_simple(t, x, U, U_dot, omega, alpha_34, p):\n # States\n x1=x[0] # Downwash memory term 1\n x2=x[1] # Downwash memory term 2\n x3=x[2] # Clp', Lift coefficient with a time lag to the attached lift coeff\n x4=x[3] # f'' , Final separation point function\n # Parameters\n alpha0 = p['alpha0']\n Cla = p['Cla']\n c = p['chord']\n A1 = p['A1']\n A2 = p['A2']\n b1 = p['b1']\n b2 = p['b2']\n F_st = p['F_st']\n # Variables derived from inputs\n U = max(U, 0.01)\n Tu = max(c/(2*U), 1e-4) # Eq. 23\n Tf = p['Tf0']*Tu # OLD was twice: Tf = p['Tf0']*c/U\n Tp = p['Tp0']*Tu # OLD was twice: Tp = p['Tp0']*c/U\n # Variables derived from states\n if p['alpha0_in_x1x2']:\n alphaE = alpha_34*(1-A1-A2)+ x1 + x2 # Eq. 12\n else:\n alphaE = (alpha_34-alpha0)*(1-A1-A2)+ x1 + x2 + alpha0 # Eq. 12\n\n# alphaE = u['alphaE'](t) # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< HACK HACK TODO TODO TODO TODO TODO\n\n Clp = Cla * (alphaE-alpha0) + np.pi * Tu * omega # Eq. 13\n alphaF = x3/Cla+alpha0 # p. 13\n fs_aF = F_st(alphaF) # p. 13\n if(fs_aF<0):\n print('Problematic fs:',fs_aF)\n x4 = np.clip(x4, 1e-16, 1.0) # Constraining x4 between 0 and 1 increases numerical stability\n # State equation\n xdot = [0]*4\n if p['alpha0_in_x1x2']:\n xdot[0] = -1/Tu * (b1 + c * U_dot/(2*U**2)) * x1 + b1 * A1 / Tu * alpha_34\n xdot[1] = -1/Tu * (b2 + c * U_dot/(2*U**2)) * x2 + b2 * A2 / Tu * alpha_34\n else:\n xdot[0] = -1/Tu * (b1 + c * U_dot/(2*U**2)) * x1 + b1 * A1 / Tu * (alpha_34-alpha0)\n xdot[1] = -1/Tu * (b2 + c * U_dot/(2*U**2)) * x2 + b2 * A2 / Tu * (alpha_34-alpha0)\n xdot[2] = -1/Tp * x3 + 1/Tp * Clp\n xdot[3] = -1/Tf * x4 + 1/Tf * fs_aF\n return xdot","def test_solver():\n # Choice of nonlinear coefficient\n m = 2\n\n def q(u):\n return (1+u)**m\n\n def Dq(u):\n return m*(1+u)**(m-1)\n\n u_exact = Expression(\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\n linear_solver = 'direct'\n errors = []\n for method in 'alg_Newton', 'pde_Newton':\n for J_comp in 'manual', 'automatic':\n for degree in 1, 2, 3:\n error_prev = -1\n for divisions in [(10, 10), (20, 20), (40, 40)]:\n u = solver(\n q, Dq, f, divisions, degree,\n method, J_comp,\n linear_solver,\n abs_tol_Krylov=1E-10,\n rel_tol_Krylov=1E-10,\n abs_tol_Newton=1E-10,\n rel_tol_Newton=1E-10)\n\n # Find max error\n u_e = interpolate(u_exact, u.function_space())\n import numpy as np\n error = np.abs(u_e.vector().array() -\n u.vector().array()).max()\n # Expect convergence as h**(degree+1)\n if error_prev > 0:\n frac = abs(error - error_prev/2**(degree+1))\n errors.append(frac)\n error_prev = error\n tol = 4E-5\n for error_reduction in errors:\n assert error_reduction < tol, error_reduction","def run_main(sst, ft_qv, use_NT):\n\n dtout=10. #minutes\n end_time=8*24. #hours\n del_time=dtout*60. #seconds\n end_time=end_time*3600. #seconds\n #sst=297\n D=5.e-6 #s-1\n U=7 #m/s\n psfc=100. #kPa\n qsfc=tf.qs_tp(sst,psfc)\n ft_intercept = 292 #K\n ft_gamma = 6.e-3 #K/m\n #ft_qv = 2.e-3\n k=0.2 #entrainment efficiency\n Cd = 1.e-3 #drag coefficient\n tspan = np.arange(0.,end_time,del_time)\n vars_init=[285.,400.,8.e-3] #theta (K), height (m) qv (kg/kg) to start\n the_tup=dict(D=D,U=U,sst=sst,ft_intercept=ft_intercept,ft_gamma=ft_gamma,\n qsfc=qsfc,ft_qv=ft_qv,k=k,Cd=Cd,radcool=30.,use_NT=use_NT) # include use_NT\n the_tup=make_tuple(the_tup,'coeffs')\n output=integrate.odeint(dmixed_vars, vars_init, tspan,(the_tup,))\n result=pd.DataFrame.from_records(output,columns=['theta','h','qv'])\n\n # save time/computation by only doing calculations for the last timestep (equilibrium)\n result['time']=tspan[-1]/3600./24. #days\n result['deltheta'] = theta_ft(result['h'].values[-1],ft_intercept,ft_gamma) - result['theta'].iloc[-1]\n result['delqv'] = ft_qv - result['qv'].iloc[-1]\n result['LCL'] = calc_lcl(result.iloc[-1], psfc)\n result['q_flux_0']=calc_sfc_qvap_flux(result.iloc[-1],the_tup)\n result['T_flux_0']=calc_sfc_theta_flux(result.iloc[-1],the_tup)\n result['entflux_theta']=calc_entflux_theta(result.iloc[-1],the_tup)\n \n # decide how to calculate entrainment\n the_vars = [result['theta'].iloc[-1],result['h'].iloc[-1],result['qv'].iloc[-1]]\n if use_NT:\n result['went']=calc_went_NT(the_vars, the_tup, result['deltheta'].iloc[-1], \n result['T_flux_0'].iloc[-1], result['q_flux_0'].iloc[-1])\n else:\n result['went']=calc_went(result.iloc[-1],the_tup)\n\n result['entflux_qv']=calc_entflux_qv(result.iloc[-1],the_tup)\n\n with open('dumpmodel.csv','w') as f:\n result.to_csv(f,index=False)\n \n return None","def reconstruct_solution(spikes,sol,uval,twin,ics,tau,variable,**kwargs):\n\n # Model parameters\n pars = {'dt' : 1e-3}\n pars = gu.varargin(pars,**kwargs)\n\n # Generate time vector\n time = np.arange(twin[0],twin[-1],pars['dt'])\n time = np.sort(np.r_[time,spikes])\n # Generate spike vector\n tspk = np.copy(time)\n for i in range(1,len(spikes)):\n tspk[np.where(np.logical_and(time>=spikes[i-1],time<spikes[i]))[0]] = spikes[i-1]\n tspk[np.where(time >= spikes[len(spikes)-1])[0]] = spikes[len(spikes)-1]\n tspk[np.where(time < spikes[0])[0]] = 0\n # Generate general solution vector\n vsol = np.ones(time.size)\n if (variable=='x') and isscalar(uval):\n uval = uval * np.ones(sol.size)\n if variable=='x':\n for i in range(1, len(spikes)):\n # x must be given at x(t_i^+) according to xsol\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]*(1-uval[i-1])\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]*(1-uval[len(spikes)-1])\n else:\n for i in range(1, len(spikes)):\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]\n vsol[np.where(time < spikes[0])[0]] = ics\n # Compute effective solution\n solution = np.zeros((2, time.size))\n solution[0] = time\n\n if variable=='x':\n # Assumes that the first ICs is x(0)\n solution[1] = xsol(vsol,time-tspk,tau)\n else:\n solution[1] = usol(vsol,time-tspk,tau)\n\n return solution","def leastsquares(A,b,qr=qrfact.qri_mgs_piv,alpha=0.5):\n \n\n A = numpy.array(A, dtype=float)\n m,n = A.shape\n z = numpy.zeros( n )\n a = numpy.zeros( n )\n x = numpy.zeros( n )\n b = numpy.transpose(b)[0]\n\n # do the QR factorization\n try:\n Q,R = qr(A)[:2] # Some QR routines return a third permutation P solving AP=QR.\n PA = A\n except TypeError:\n Q,R,P = qr(A,alpha)[:3] # Some QR routines return a third permutation P solving AP=QR.\n AP = numpy.dot( A, P )\n\n # Step 1'': orthogonalization of b against Q\n u = b\n for j in range( 0, n ) :\n # print \"Qj = \", Q[:,j]\n # print \"u = \", u\n # print \"dot = \", numpy.dot( Q[:,j], u )\n z[j] = numpy.dot( Q[:,j], u )\n u = u - z[j] * Q[:,j]\n\n # Step 2'': iterative orthogonalization of u\n ul2norm = numpy.linalg.norm( u )\n ii = 0\n while True : # iterate\n for j in range( 0, n ) :\n a[j] = numpy.dot( Q[:,j], u )\n z[j] = z[j] + a[j]\n u = u - a[j] * Q[:,j]\n\n ii = ii + 1\n ulnorm = ul2norm\n ul2norm = numpy.linalg.norm( u )\n\n #print ul2norm, ulnorm\n \n if (ul2norm > alpha * ulnorm) or ul2norm == 0 :\n # print \"used\", ii, \"orthogonalizations\"\n break\n\n #print z\n #print R\n\n # Step 3'': use back substitution to solve Rx = z\n for i in range( n-1, -1, -1 ) :\n x[i] = z[i]\n for j in range( i+1, n ) :\n x[i] = x[i] - R[i,j] * x[j]\n x[i] = x[i] / R[i,i]\n #print x\n\n #need to permute x according to permutation matrix P\n \n return numpy.dot( P, x )","def solveFluNet(T,Ntime,a,b0,b1,g,k,w,y0,P,N,RHS=3):\n #I have added the variables P the transport matrix \n #and N the network size because they are needed\n #in the RHS.\n #I have added the variable RHS to be able to \n #choose which RHS method we want to use when running\n #solveFluNet\n \n #add input variables to RHS functions if needed\n def RHSnet(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\"\"\"\n S = y[:N]\n E = y[N:2*N]\n C = y[2*N:3*N]\n b = b0 + b1*(1+np.cos(2*np.pi*t))\n dy = np.zeros(3*N)\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\n return dy\n \n def RHSnetF(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\"\n Calculations carried out by fn.rhs\n \"\"\"\n dy = fn.rhs(P,y,t,a,b0,b1,g,k,w)\n return dy\n \n def RHSnetFomp(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\n Calculations carried out by fn.rhs_omp\n \"\"\"\n dy = fn.rhs_omp(P,y,t,a,b0,b1,g,k,w,2)\n return dy\n\n #Add code here and to RHS functions above to simulate network flu model\n t = np.linspace(0,T,Ntime)\n if (RHS==1):\n sol = odeint(RHSnet,y0,t,args=(a,b0,b1,g,k,w))\n if (RHS==2):\n sol = odeint(RHSnetF,y0,t,args=(a,b0,b1,g,k,w))\n if (RHS==3):\n sol = odeint(RHSnetFomp,y0,t,args=(a,b0,b1,g,k,w))\n S = sol[:,:N]\n E = sol[:,N:2*N]\n C = sol[:,2*N:3*N]\n return t,S,E,C","def MyGRRK3_step(f, t, qn, dt, r, e, w):\r\n assert((not np.any(np.isnan(t))) and np.all(np.isfinite(t)) and\r\n np.all(np.isreal(t))), \\\r\n \"t must be real, finite and not NaN\"\r\n assert((not np.any(np.isnan(dt))) and np.all(np.isfinite(dt)) and\r\n np.all(np.isreal(dt))), \\\r\n \"dt must be real, finite and not NaN\"\r\n assert(len(qn) == 2), \"qn must have length 2\"\r\n assert(hasattr(f, '__call__')), \\\r\n \"f must be a callable function\"\r\n assert((not np.any(np.isnan(r))) and np.all(np.isfinite(r)) and\r\n np.all(np.isreal(r))), \\\r\n \"r must be real, finite and not NaN\"\r\n assert((not np.any(np.isnan(e))) and np.all(np.isfinite(e)) and\r\n np.all(np.isreal(e))), \\\r\n \"e must be real, finite and not NaN\"\r\n assert((not np.any(np.isnan(w))) and np.all(np.isfinite(w)) and\r\n np.all(np.isreal(w))), \\\r\n \"w must be real, finite and not NaN\"\r\n\r\n def F(k0):\r\n \"\"\"\r\n Function defines the set of nonlinear equations describing k1 and k2\r\n of the third order explicit Runge-Kutta algorithm\r\n\r\n Parameters\r\n ----------\r\n\r\n k0 : vector\r\n intial guess for roots of the problem\r\n\r\n Returns\r\n -------\r\n\r\n f3 : vector\r\n set of nonlinear equations of k1 and k2\r\n \"\"\"\r\n assert((not np.any(np.isnan(k0))) and np.all(np.isfinite(k0)) and\r\n np.all(np.isreal(k0))),\\\r\n \"k0 must be real, finite and not NaN\"\r\n assert(len(k0) == 4), \"K must have length 4\"\r\n assert(hasattr(F, '__call__')), \\\r\n \"F must be a callable function\"\r\n k1 = np.array([k0[0], k0[1]])\r\n k2 = np.array([k0[2], k0[3]])\r\n f1 = k1 - np.array([f(t + dt / 3,\r\n qn + (dt / 12) * (5 * k1 - k2), r, e, w)])\r\n f2 = k2 - np.array([f(t + dt,\r\n qn + (dt / 4) * (3 * k1 + k2), r, e, w)])\r\n f3 = np.reshape(np.array([f1, f2]), (4,))\r\n return f3\r\n\r\n k0 = np.reshape(np.array([f(t + dt / 3, qn, r, e, w),\r\n f(t + dt, qn, r, e, w)]), (4,))\r\n k = fsolve(F, k0)\r\n k1 = np.array([k[0], k[1]])\r\n k2 = np.array([k[2], k[3]])\r\n qnpG1 = qn + (dt / 4) * (3 * k1 + k2)\r\n return qnpG1","def solver(\n kappa, f, u_D, Nx, Ny, degree=1,\n linear_solver='Krylov', # Alternative: 'direct'\n abs_tol=1E-5, # Absolute tolerance in Krylov solver\n rel_tol=1E-3, # Relative tolerance in Krylov solver\n max_iter=1000, # Max no of iterations in Krylov solver\n log_level=PROGRESS, # Amount of solver output\n dump_parameters=False, # Write out parameter database?\n ):\n # Create mesh and define function space\n mesh = UnitSquareMesh(Nx, Ny)\n V = FunctionSpace(mesh, 'P', degree)\n\n def boundary(x, on_boundary):\n return on_boundary\n\n bc = DirichletBC(V, u_D, boundary)\n\n # Define variational problem\n u = TrialFunction(V)\n v = TestFunction(V)\n a = kappa*dot(grad(u), grad(v))*dx\n L = f*v*dx\n\n # Compute solution\n u = Function(V)\n\n if linear_solver == 'Krylov':\n prm = parameters['krylov_solver'] # short form\n prm['absolute_tolerance'] = abs_tol\n prm['relative_tolerance'] = rel_tol\n prm['maximum_iterations'] = max_iter\n print(parameters['linear_algebra_backend'])\n set_log_level(log_level)\n if dump_parameters:\n info(parameters, True)\n solver_parameters = {'linear_solver': 'gmres',\n 'preconditioner': 'ilu'}\n else:\n solver_parameters = {'linear_solver': 'lu'}\n\n solve(a == L, u, bc, solver_parameters=solver_parameters)\n return u","def Lq(self):\n if not self.isVaild():\n pass\n temp = ((self.r()**self.C)*self.Rho()) / \\\n (math.factorial(self.C)*((1 - self.Rho())**2))\n return temp*self.P0()","def ers(self, qL, qR, A, xt):\n hL, hR, uL, uR, cL, cR = self.get_param(qL, qR)\n fL = self.flux(qL)\n fR = self.flux(qR)\n # Find starting value for Newton-Rhapson iterative method\n hS = self.start_exact(hL, hR, cL, cR, uL, uR)\n h0 = hS\n # Start iteration\n for _ in range(self.n_iter):\n fL, fld = self.geofun(hS, hL, cL)\n fR, frd = self.geofun(hS, hR, cR)\n hS = hS - (fL + fR + uR - uL)/(fld + frd)\n if abs(hS - h0) / (0.5 * (hS + h0) ) <= self.tol: break\n if hS < 0.: hS = self.tol\n h0 = hS\n # Check if converged or not\n if _ == self.n_iter and abs(hS - h0) / (0.5 * (hS + h0) ) > self.tol:\n raise 'Solution not converged, try to increase n_iter value'\n else:\n # Converged solution for depth hS in Star Region.\n # Compute velocity uS in Star Region\n uS = 0.5*(uL + uR) + 0.5*(fR - fL);\n cS = math.sqrt(9.81*hS);\n # Sample solution\n h, u = self.samwet(hL, hR, hS, uL, uR, uS, cL, cR, cS, xt)\n return h, h*u","def u_t(self):\n\t\tdim = self.dim \n\t\ttim_all = self.tim_all\n\t\t#ctrl = self.ctrl\n\t\tH0 = self.H0\n\t\tHctrl = self.Hctrl\n\n\t\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\n\t\tu_all[0,:,:] = np.eye(dim)\n\n\t\tfor tim in xrange(tim_all):\n\t\t\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\n\t\t\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\n\n\n\t\treturn u_all","def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[ int(uD) ]\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \n \n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\n \n dJ_a = self.jacobian_actuators_diff( q , dq )\n \n C = self.C( q , dq )\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\n \n D = self.D( q , dq )\n Da = np.dot( B , np.dot( self.Da , B.T ) )\n \n CD_all = C + D + Ca + Da\n \n G = self.G( q )\n \n # External forces\n J_e = self.jacobian_endeffector( q )\n f_e = self.F_ext( q , dq )\n \n # Disturbance force\n f_d = self.F_dist( t )\n \n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\n \n return ddq","def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[ int(uD) ]\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \n \n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\n \n dJ_a = self.jacobian_actuators_diff( q , dq )\n \n C = self.C( q , dq )\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\n \n D = self.D( q , dq )\n Da = np.dot( B , np.dot( self.Da , B.T ) )\n \n CD_all = C + D + Ca + Da\n \n G = self.G( q )\n \n # External forces\n J_e = self.jacobian_endeffector( q )\n f_e = self.F_ext( q , dq )\n \n # Disturbance force\n f_d = self.F_dist( t )\n \n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\n \n return ddq","def sys(self, t, x, u):\n xk = fft(x)\n\n # 4/3 truncation rule\n # dealiasing due to triple nonlinearity\n # note: you could do zero-padding to improve memory\n # efficiency\n xk[self.n_states // 4 : 3 * self.n_states // 4] = 0j\n x = ifft(xk)\n\n yk = (-self.k**2 * xk.ravel() / 2) * 1j\n y = ifft(yk) + 1j * abs(x) ** 2 * x + u\n return y","def quintic_polynomials_planner(sx, sy, syaw, sv, sa, gx, gy, gyaw, gv, ga,\n max_accel, max_jerk, dt):\n\n vxs = sv * math.cos(syaw)\n vys = sv * math.sin(syaw)\n vxg = gv * math.cos(gyaw)\n vyg = gv * math.sin(gyaw)\n\n axs = sa * math.cos(syaw)\n ays = sa * math.sin(syaw)\n axg = ga * math.cos(gyaw)\n ayg = ga * math.sin(gyaw)\n\n time, rx, ry, ryaw, rv, ra, rj = [], [], [], [], [], [], []\n\n for T in np.arange(MIN_T, MAX_T, MIN_T):\n xqp = QuinticPolynomial(sx, vxs, axs, gx, vxg, axg, T)\n yqp = QuinticPolynomial(sy, vys, ays, gy, vyg, ayg, T)\n\n time, rx, ry, ryaw, rv, ra, rj = [], [], [], [], [], [], []\n\n for t in np.arange(0.0, T + dt, dt):\n time.append(t)\n rx.append(xqp.calc_point(t))\n ry.append(yqp.calc_point(t))\n\n vx = xqp.calc_first_derivative(t)\n vy = yqp.calc_first_derivative(t)\n v = np.hypot(vx, vy)\n yaw = math.atan2(vy, vx)\n rv.append(v)\n ryaw.append(yaw)\n\n ax = xqp.calc_second_derivative(t)\n ay = yqp.calc_second_derivative(t)\n a = np.hypot(ax, ay)\n if len(rv) >= 2 and rv[-1] - rv[-2] < 0.0:\n a *= -1\n ra.append(a)\n\n jx = xqp.calc_third_derivative(t)\n jy = yqp.calc_third_derivative(t)\n j = np.hypot(jx, jy)\n if len(ra) >= 2 and ra[-1] - ra[-2] < 0.0:\n j *= -1\n rj.append(j)\n\n if max([abs(i) for i in ra]) <= max_accel and \\\n max([abs(i) for i in rj]) <= max_jerk:\n print(\"find path!!\")\n break\n\n return time, rx, ry, ryaw, rv, ra, rj","def solve_rocket_equations():\n # initial data\n u0 = numpy.array([h0,v0,mp0])\n t = [0.0] # The array of times\n u = [u0] # The array of evolved solutions\n # Evolve!\n while u[-1][0] >= 0.0:\n t.append(t[-1]+dt)\n u.append(euler_step(u[-1],t[-1],rhs,dt))\n return numpy.array(t),numpy.array(u)","def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\n q_c, q_p = y\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\n dqp_dt = transfer\n return [dqc_dt, dqp_dt]","def step(self, u=None, dt=None):\n\n dt = dt if dt is not None else self.dt\n u = u if u is not None else np.zeros(self.n_dofs)\n\n qdd = np.linalg.inv(self.M) @ (u - self.C - self.B @ self.qd).T\n self.qd += np.array(qdd).flatten() * dt\n self.q += self.qd * dt\n self.t += dt","def __call__(self, u, t):\n S, I, R = u\n return [-self.beta(t)*S*I, self.beta(t)*S*I - self.nu(t)*I, self.nu(t)*I]","def a(self, x, t0):\n dummy = 0.0 * t0\n x_1 = x[0]\n x_2 = x[1]\n x_3 = x[2]\n x_4 = x[3]\n x_5 = x[4]\n x_6 = x[5]\n x_7 = x[6]\n # Load parameters.\n e_1_tilde = self.e_1_tilde\n e_2_tilde = self.e_2_tilde\n r = self.rr\n z_1 = self.z_1\n z_1_tilde = self.z_1_tilde\n z_2_tilde = self.z_2_tilde\n alpha_1 = self.alpha_1\n alpha_2 = self.alpha_2\n alpha_2_tilde = self.alpha_2_tilde\n alpha_11_tilde = self.alpha_11_tilde\n alpha_12_tilde = self.alpha_12_tilde\n mu_H_tilde = self.mu_H_tilde\n mu_1_tilde = self.mu_1_tilde\n mu_2_tilde = self.mu_2_tilde\n sigma_H = self.sigma_H\n sigma_1_tilde = self.sigma_1_tilde\n sigma_2_tilde = self.sigma_2_tilde\n sigma_11 = self.sigma_11\n sigma_12 = self.sigma_12\n #\n # Right hand side of model.\n #\n f_1 = z_1 * alpha_1 * x_3 * (1.0 - x_1) - mu_H_tilde * x_1\n f_2 = (1.0 - x_2) * (\n x_3 * (z_1_tilde * alpha_11_tilde + z_2_tilde * alpha_12_tilde)\n + z_1_tilde * alpha_2_tilde * x_6) - mu_1_tilde * x_2\n f_3 = (z_1 * sigma_H * x_1 +\n (z_1_tilde * sigma_11 + z_2_tilde * sigma_12) * x_2) \\\n * (x_4 - x_3) - (e_1_tilde + x_4) * x_3\n f_4 = x_4 * (1 - x_4)\n f_5 = z_2_tilde * alpha_2 * x_6 * (1.0 - x_5) - mu_2_tilde * x_5\n f_6 = (z_1_tilde * sigma_1_tilde * x_2\n + z_2_tilde * sigma_2_tilde * x_5) * (x_7 - x_6) \\\n - (e_2_tilde + r * x_7) * x_6\n f_7 = r * x_7 * (1.0 - x_7)\n r = np.array([f_1, f_2, f_3, f_4, f_5, f_6, f_7])\n return r","def refit_pll_opt(model,data):\n data = toPM(data);\n import scipy.optimize\n from scipy.sparse import triu\n def to_vector(L,h):\n return np.hstack((h,triu(L,k=1).tocoo().data))\n def from_vector(x):\n h = x[:len(model.h)];\n tmp = triu(model.L,k=1).tocoo();\n L = csr((x[len(model.h):],(tmp.row,tmp.col)),shape=model.L.shape)\n return L+L.T,h\n def f0(x0):\n L,h = from_vector(x0)\n return -__pll(L,h,data).mean()\n def jac(x0):\n L,h = from_vector(x0)\n return -to_vector(*__dpll(L,h,data))\n\n x0 = to_vector(model.L,model.h)\n res = scipy.optimize.minimize(f0,x0, method='BFGS',jac=jac)\n #print(\"Success? \",res.success)\n model.L,model.h = from_vector(res.x)\n return res","def l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # z >= 0 \n \n c = matrix(n*[0.0] + m*[1.0])\n h = matrix([q, -q])\n\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \n if trans == 'N':\n # y := alpha * [P, -I; -P, -I] * x + beta*y\n u = P*x[:n]\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\n\n else:\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\n\n\n def Fkkt(W): \n\n # Returns a function f(x, y, z) that solves\n #\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\n #\n # On entry bx, bz are stored in x, z.\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\n # returned instead of z). \n\n d1, d2 = W['d'][:m], W['d'][m:]\n D = 4*(d1**2 + d2**2)**-1\n A = P.T * spdiag(D) * P\n lapack.potrf(A)\n\n def f(x, y, z):\n\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \n + mul( .5*D, z[:m]-z[m:] ) )\n lapack.potrs(A, x)\n\n u = P*x[:n]\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\n\n z[:m] = div(u-x[n:]-z[:m], d1)\n z[m:] = div(-u-x[n:]-z[m:], d2)\n\n return f\n\n\n # Initial primal and dual points from least-squares solution.\n\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\n uls = +q\n lapack.gels(+P, uls)\n rls = P*uls[:n] - q \n\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \n s0 = +h\n Fi(x0, s0, alpha=-1, beta=1) \n\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \n # if rls is nonzero and w = 0 otherwise.\n if max(abs(rls)) > 1e-10: \n w = .9/max(abs(rls)) * rls\n else: \n w = matrix(0.0, (m,1))\n z0 = matrix([.5*(1+w), .5*(1-w)])\n\n dims = {'l': 2*m, 'q': [], 's': []}\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\n return sol['x'][:n]","def test_lu_forward_sub():\t\n\t# test 1\n\tL = np.array([\n\t\t[ 2, 3,-4, 2],\n\t\t[-2, 1,-2, 1],\n\t\t[ 1,-1, 3,-1],\n\t\t[-3, 2, 2, 2]])\t\n\n\tb = np.array([4, -8, 9, 6])\n\n\ty = lu_forward_sub(L, b) \t\t\n\ty_soln = np.array([4,0,5,8])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y - y_soln) < 1.e-10\n\n\t# test 2\n\tL2 = np.array([\n\t\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\n\t\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\n\t\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\n\t\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\n\t\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\n\t\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\n\t\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\n\t\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\n\n\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\n\n\ty2 = lu_forward_sub(L2, b2) \t\t\n\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y2 - y_soln2) < 1.e-10","def main(init_state, end_state, Q, R, sys_params, curr_time_str, results_dir,render=False):\n # initialize environment\n\n env = gym.make('cp-custom-v0')\n if render:\n video_path = results_dir + '/vid.mp4'\n vid = video_recorder.VideoRecorder(env, path=video_path)\n env.seed(1) # seed for reproducibility\n\n obs = env.reset(init_state=init_state,\n end_state=end_state,\n action_noise_std=sys_params[4],\n obs_noise_std=sys_params[5]\n )\n\n n_states = obs.shape[0]\n x_OUT = np.zeros((n_states, 1))\n u_OUT = np.zeros((1))\n done = False\n step_count = 0\n max_steps = 1000\n\n A, B, C, D = get_model_matrix_lqr()\n lqr = LQR(A, B, C, D, Q, R)\n controller_time = []\n while True:\n if render:\n env.render()\n vid.capture_frame()\n\n # check if bar is near the top \"stable\" region\n theta_std = standardize_angle(obs[2])\n\n # uncomment if you want to do a swing up\n \"\"\"\n if (-0.5 < theta_std < 0.5):\n # action = mpc_control(obs, Q, R, sys_params)\n _, action = lqr.apply_state_controller(lqr.K, obs)\n else:\n action = energy_shaping_control(obs, sys_params)\n \"\"\"\n\n start_time = time.time()\n action = mpc_control(obs, Q, R, sys_params)\n # _, action = lqr.apply_state_controller(lqr.K, obs)\n controller_time.append(time.time() - start_time)\n\n # if step_count % 100 == 0:\n # print(step_count)\n\n # apply action\n obs, reward, done, end_state_reached, _ = env.step(action)\n x_OUT = np.append(x_OUT, obs, axis=1)\n u_OUT = np.append(u_OUT, action)\n step_count += 1\n\n if (done) or (step_count >= max_steps):\n # print(f'Terminated after {step_count+1} iterations \\n Final State: {obs}\\n Target State: {xf}')\n # print(np.mean(controller_time))\n break\n\n env.close()\n return x_OUT[:, 1:], u_OUT[1:], end_state_reached, step_count+1","def update_nodes(self):\n\n L = self.level\n P = L.prob\n\n # only if the level has been touched before\n assert L.status.unlocked\n\n # get number of collocation nodes for easier access\n M = self.coll.num_nodes\n\n # gather all terms which are known already (e.g. from the previous iteration)\n # this corresponds to u0 + QF(u^k) - QdF(u^k) + tau\n\n # get QF(u^k)\n integral = self.integrate()\n for m in range(M):\n # get -QdF(u^k)_m\n for j in range(1, M + 1):\n integral[m] -= L.dt * self.QI[m + 1, j] * L.f[j]\n\n # add initial value\n integral[m] += L.u[0]\n # add tau if associated\n if L.tau[m] is not None:\n integral[m] += L.tau[m]\n\n # do the sweep\n for m in range(0, M):\n # build rhs, consisting of the known values from above and new values from previous nodes (at k+1)\n rhs = P.dtype_u(integral[m])\n for j in range(1, m + 1):\n rhs += L.dt * self.QI[m + 1, j] * L.f[j]\n\n # implicit solve with prefactor stemming from the diagonal of Qd\n L.u[m + 1] = P.solve_system(\n rhs, L.dt * self.QI[m + 1, m + 1], L.u[m + 1], L.time + L.dt * self.coll.nodes[m]\n )\n # update function values\n L.f[m + 1] = P.eval_f(L.u[m + 1], L.time + L.dt * self.coll.nodes[m])\n\n # indicate presence of new values at this level\n L.status.updated = True\n\n return None","def solve_rossler(alpha = 1.0, beta = 1.0, gamma = 1.0, max_time = 10, N = 5):\n resolution = 72\n \n fig1 = plt.figure(dpi = resolution)\n ax1, ax2, ax3 = fig1.subplots(3, 1)\n\n fig = plt.figure()\n ax = fig.add_axes([0, 0, 1, 1], projection='3d')\n # ax.axis('off')\n \n def rossler_deriv(xi, t0, alpha=alpha, beta = beta, gamma = gamma):\n \"\"\"Compute the time-derivative of a Lorenz system.\"\"\"\n \n xi1, xi2, xi3 = xi\n \n xi1_dot = -xi1 - exp(xi3)\n xi2_dot = xi1 + alpha * xi2\n xi3_dot = gamma * exp(-xi3) + xi1 - beta\n \n return [xi1_dot, xi2_dot, xi3_dot]\n\n # Choose random starting points, uniformly distributed from -15 to 15\n np.random.seed(1)\n xi0 = -15 + 30 * np.random.random((N, 3))\n xi0[:,2] = np.log(abs(xi0[:,2]))\n\n # Solve for the trajectories\n t = np.linspace(0, max_time, int(250*max_time))\n xi_t = np.asarray([integrate.odeint(rossler_deriv, xi0i, t)\n for xi0i in xi0])\n \n # choose a different color for each trajectory\n colors = plt.cm.viridis(np.linspace(0, 1, N))\n\n for i in range(N):\n xi1, xi2, xi3= xi_t[i,:,:].T\n \n ax1.plot(t, xi1, '-', c=colors[i])\n ax1.set_title('xi1')\n \n ax2.plot(t, xi2, '-', c=colors[i])\n ax2.set_title('xi2')\n \n ax3.plot(t, xi3, '-', c=colors[i])\n ax3.set_title('xi3')\n \n lines = ax.plot(xi1, xi2, xi3, '-', c=colors[i])\n plt.setp(lines, linewidth=2)\n angle = 104\n ax.view_init(30, angle)\n plt.show()\n\n return t, xi_t","def solve_model(self): \n \n t0 = time.time() #start the clock\n \n # a. benchmark case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(1)\n \n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(self.tau_benchmark) #set tax system\n \n #iii. benchmark equilibrium\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Benchmark Stationary Equilibrium\")\n print(\"-----------------------------------------\")\n print(f\"ss output = {self.Yss_b:.2f}\")\n print(f\"ss capital = {self.Kss_b:.2f}\")\n print(f\"ss tfp = {self.TFPss_b:.2f}\")\n print(f\"ss wage = {self.w_ss_b:.2f}\")\n print(f\"entry mass = {self.E_star_b:.3f}\")\n print(f\"avg. firm size = {self.average_firm_size_b:.2f}\")\n \n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\n \n if self.plott:\n #i. initialize\n employed = [4.99, 49.99]\n firm_size_by_employee = np.zeros(len(employed)+1)\n share_employment = np.zeros(len(employed)+1)\n \n \n #i. percentage of firms that employ employed\n \n for i_e in range(len(employed)):\n summ = np.sum(firm_size_by_employee)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\n firm_size_by_employee[i_e] = interpolate - summ\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\n \n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Size of Firms by Firm Size (Number of Employees)')\n plt.savefig('firm_size_rr08.pdf')\n plt.show()\n \n \n #ii. employment percentage by firm size\n for i_e in range(len(employed)):\n summ = np.sum(share_employment)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\n share_employment[i_e] = interpolate - summ\n share_employment[-1] = 1 - np.sum(share_employment)\n \n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Employment Share by Firm Size (Number of Employees)')\n plt.savefig('employment_by_firm_size_rr08.pdf')\n plt.show()\n \n #iii. productivity cdf and employment cdf\n plt.plot(self.grid_s, self.cdf_stationary_b)\n plt.plot(self.grid_s, self.cdf_emp_b)\n plt.title('Stationary CDF' )\n plt.xlabel('Productivity level')\n plt.ylabel('Cumulative Sum')\n plt.legend(['Firms by Productivity Level','Share of Employment'])\n plt.savefig('cdf_rr08.pdf')\n plt.show()\n \n \n \n #c. distortion case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(0)\n \n #ii. compute stationary economy for each tau\n \n for idx, tau in enumerate(self.tau_vector):\n \n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\n self.tau_s[idx] = self.find_subsidy_rate(tau)\n \n # set tax system with newly found tau_s and given tau\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv) #set tax system\n \n #v. distorted stationary equilibrium\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\n _, _ = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Distorted Stationary Equilibrium\")\n print(\"-----------------------------------------\\n\")\n if self.distortion_case == 1:\n print(\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\")\n print(\"(low productivity firms recieve subsidy, high productivity taxed)\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Positively Correlated with Firm Level Producitivity\")\n print(\"(high productivity firms recieve subsidy, low productivity taxed)\\n\")\n if self.policy_type == 1 :\n print(\"Tax Type: Tax on output\\n\")\n elif self.policy_type == 2 :\n print(\"Tax Type: Tax on capital\\n\")\n elif self.policy_type == 3 :\n print(\"Tax Type: Tax on labor\\n\")\n print(f\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\")\n print(f\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\")\n print(f\"fraction of firms excempt = {self.excempt_frac:.2f}\")\n print(\"-----------------------------------------\\n\")\n \n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\n [], \n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \"Tax = \"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\n \n\n t1 = time.time()\n print(f'\\nTotal Run Time: {t1-t0:.2f} seconds')","def predict(self, u):\n\n dtheta_l = self.current_state_estimate[0,0]\n dtheta_r = self.current_state_estimate[1,0]\n v = self.current_state_estimate[2,0]\n w = self.current_state_estimate[3,0]\n x = self.current_state_estimate[4,0]\n y = self.current_state_estimate[5,0]\n theta = self.current_state_estimate[6,0]\n vl = u[0,0]\n vr = u[1,0]\n \n # Vary noise with input voltage\n if abs(self.current_state_estimate[0,0]) < .03:\n self.Q[0,0] = .0000001\n dtheta_l = 0\n\n else:\n self.Q[0,0] = abs(vl)*.03/3000+.03\n\n if abs(self.current_state_estimate[1,0]) < .03:\n self.Q[1,1] = .0000001\n dtheta_r = 0\n else:\n self.Q[1,1] = abs(vr)*.03/3000+.03\n\n ## TRANSITION ESTIMATE\n self.current_state_estimate[0] += self.dt*(self.k2_l*dtheta_l + self.k1_l*vl)\n self.current_state_estimate[1] += self.dt*(self.k2_r*dtheta_r + self.k1_r*vr)\n self.current_state_estimate[2] = self.r/2 * (self.current_state_estimate[0] + self.current_state_estimate[1])\n self.current_state_estimate[3] = self.r/self.l * (self.current_state_estimate[1] - self.current_state_estimate[0])\n self.current_state_estimate[4] += (self.dt)*self.current_state_estimate[2]*math.cos(theta)\n self.current_state_estimate[5] += (self.dt)*self.current_state_estimate[2]*math.sin(theta)\n self.current_state_estimate[6] += (self.dt)*self.current_state_estimate[3]\n \n ## TRANISTION PROBABILITY\n # only propogate the things that can move\n self.A[0:7, 0:7] = np.array([[1+self.dt*self.k2_l, 0, 0, 0, 0, 0, 0],\\\n [0, 1+self.dt*self.k2_r, 0, 0, 0, 0, 0],\\\n [self.r/2, self.r/2, 0, 0, 0, 0, 0],\\\n [-self.r/self.l, self.r/self.l, 0, 0, 0, 0, 0],\\\n [0, 0, math.cos(theta)*self.dt , 0, 1, 0, -v*math.sin(theta)*self.dt],\\\n [0, 0, math.sin(theta)*self.dt , 0, 0, 1, v*math.cos(theta)*self.dt],\\\n [0, 0, 0, self.dt, 0, 0, 1]])\n \n self.current_prob_estimate = np.dot(np.dot(self.A, self.current_prob_estimate), np.transpose(self.A)) + self.Q"],"string":"[\n \"def LQRStep(n_state,\\n n_ctrl,\\n T,\\n u_lower=None,\\n u_upper=None,\\n u_zero_I=None,\\n delta_u=None,\\n linesearch_decay=0.2,\\n max_linesearch_iter=10,\\n true_cost=None,\\n true_dynamics=None,\\n delta_space=True,\\n current_x=None,\\n current_u=None,\\n verbose=0,\\n back_eps=1e-3,\\n no_op_forward=False):\\n # @profile\\n def lqr_backward(ctx, C, c, F, f):\\n n_batch = C.size(1)\\n\\n u = ctx.current_u\\n Ks = []\\n ks = []\\n prev_kt = None\\n n_total_qp_iter = 0\\n Vtp1 = vtp1 = None\\n for t in range(T-1, -1, -1):\\n if t == T-1:\\n Qt = C[t]\\n qt = c[t]\\n else:\\n Ft = F[t]\\n Ft_T = Ft.transpose(1,2)\\n Qt = C[t] + Ft_T.bmm(Vtp1).bmm(Ft)\\n if f is None or f.nelement() == 0:\\n qt = c[t] + Ft_T.bmm(vtp1.unsqueeze(2)).squeeze(2)\\n else:\\n ft = f[t]\\n qt = c[t] + Ft_T.bmm(Vtp1).bmm(ft.unsqueeze(2)).squeeze(2) + \\\\\\n Ft_T.bmm(vtp1.unsqueeze(2)).squeeze(2)\\n\\n Qt_xx = Qt[:, :n_state, :n_state]\\n Qt_xu = Qt[:, :n_state, n_state:]\\n Qt_ux = Qt[:, n_state:, :n_state]\\n Qt_uu = Qt[:, n_state:, n_state:]\\n qt_x = qt[:, :n_state]\\n qt_u = qt[:, n_state:]\\n\\n if u_lower is None:\\n if n_ctrl == 1 and u_zero_I is None:\\n Kt = -(1./Qt_uu)*Qt_ux\\n kt = -(1./Qt_uu.squeeze(2))*qt_u\\n else:\\n if u_zero_I is None:\\n Qt_uu_inv = [\\n torch.pinverse(Qt_uu[i]) for i in range(Qt_uu.shape[0])\\n ]\\n Qt_uu_inv = torch.stack(Qt_uu_inv)\\n Kt = -Qt_uu_inv.bmm(Qt_ux)\\n kt = util.bmv(-Qt_uu_inv, qt_u)\\n\\n # Qt_uu_LU = Qt_uu.lu()\\n # Kt = -Qt_ux.lu_solve(*Qt_uu_LU)\\n # kt = -qt_u.lu_solve(*Qt_uu_LU)\\n else:\\n # Solve with zero constraints on the active controls.\\n I = u_zero_I[t].float()\\n notI = 1-I\\n\\n qt_u_ = qt_u.clone()\\n qt_u_[I.bool()] = 0\\n\\n Qt_uu_ = Qt_uu.clone()\\n\\n if I.is_cuda:\\n notI_ = notI.float()\\n Qt_uu_I = (1-util.bger(notI_, notI_)).type_as(I)\\n else:\\n Qt_uu_I = 1-util.bger(notI, notI)\\n\\n Qt_uu_[Qt_uu_I.bool()] = 0.\\n Qt_uu_[util.bdiag(I).bool()] += 1e-8\\n\\n Qt_ux_ = Qt_ux.clone()\\n Qt_ux_[I.unsqueeze(2).repeat(1,1,Qt_ux.size(2)).bool()] = 0.\\n\\n if n_ctrl == 1:\\n Kt = -(1./Qt_uu_)*Qt_ux_\\n kt = -(1./Qt_uu.squeeze(2))*qt_u_\\n else:\\n Qt_uu_LU_ = Qt_uu_.lu()\\n Kt = -Qt_ux_.lu_solve(*Qt_uu_LU_)\\n kt = -qt_u_.unsqueeze(2).lu_solve(*Qt_uu_LU_).squeeze(2)\\n else:\\n assert delta_space\\n lb = get_bound('lower', t) - u[t]\\n ub = get_bound('upper', t) - u[t]\\n if delta_u is not None:\\n lb[lb < -delta_u] = -delta_u\\n ub[ub > delta_u] = delta_u\\n kt, Qt_uu_free_LU, If, n_qp_iter = pnqp(\\n Qt_uu, qt_u, lb, ub,\\n x_init=prev_kt, n_iter=20)\\n if verbose > 1:\\n print(' + n_qp_iter: ', n_qp_iter+1)\\n n_total_qp_iter += 1+n_qp_iter\\n prev_kt = kt\\n Qt_ux_ = Qt_ux.clone()\\n Qt_ux_[(1-If).unsqueeze(2).repeat(1,1,Qt_ux.size(2)).bool()] = 0\\n if n_ctrl == 1:\\n # Bad naming, Qt_uu_free_LU isn't the LU in this case.\\n Kt = -((1./Qt_uu_free_LU)*Qt_ux_)\\n else:\\n Kt = -Qt_ux_.lu_solve(*Qt_uu_free_LU)\\n\\n Kt_T = Kt.transpose(1,2)\\n\\n Ks.append(Kt)\\n ks.append(kt)\\n\\n Vtp1 = Qt_xx + Qt_xu.bmm(Kt) + Kt_T.bmm(Qt_ux) + Kt_T.bmm(Qt_uu).bmm(Kt)\\n vtp1 = qt_x + Qt_xu.bmm(kt.unsqueeze(2)).squeeze(2) + \\\\\\n Kt_T.bmm(qt_u.unsqueeze(2)).squeeze(2) + \\\\\\n Kt_T.bmm(Qt_uu).bmm(kt.unsqueeze(2)).squeeze(2)\\n\\n return Ks, ks, n_total_qp_iter\\n\\n\\n # @profile\\n def lqr_forward(ctx, x_init, C, c, F, f, Ks, ks):\\n x = ctx.current_x\\n u = ctx.current_u\\n n_batch = C.size(1)\\n\\n old_cost = util.get_cost(T, u, true_cost, true_dynamics, x=x)\\n\\n current_cost = None\\n alphas = torch.ones(n_batch).type_as(C)\\n full_du_norm = None\\n\\n i = 0\\n while (current_cost is None or \\\\\\n (old_cost is not None and \\\\\\n torch.any((current_cost > old_cost)).cpu().item() == 1)) and \\\\\\n i < max_linesearch_iter:\\n new_u = []\\n new_x = [x_init]\\n dx = [torch.zeros_like(x_init)]\\n objs = []\\n for t in range(T):\\n t_rev = T-1-t\\n Kt = Ks[t_rev]\\n kt = ks[t_rev]\\n new_xt = new_x[t]\\n xt = x[t]\\n ut = u[t]\\n dxt = dx[t]\\n new_ut = util.bmv(Kt, dxt) + ut + torch.diag(alphas).mm(kt)\\n\\n # Currently unimplemented:\\n assert not ((delta_u is not None) and (u_lower is None))\\n\\n if u_zero_I is not None:\\n new_ut[u_zero_I[t]] = 0.\\n\\n if u_lower is not None:\\n lb = get_bound('lower', t)\\n ub = get_bound('upper', t)\\n\\n if delta_u is not None:\\n lb_limit, ub_limit = lb, ub\\n lb = u[t] - delta_u\\n ub = u[t] + delta_u\\n I = lb < lb_limit\\n lb[I] = lb_limit if isinstance(lb_limit, float) else lb_limit[I]\\n I = ub > ub_limit\\n ub[I] = ub_limit if isinstance(lb_limit, float) else ub_limit[I]\\n # TODO(eugenevinitsky) why do we need to do this here?\\n new_ut = util.eclamp(new_ut, lb, ub)\\n new_u.append(new_ut)\\n\\n new_xut = torch.cat((new_xt, new_ut), dim=1)\\n if t < T-1:\\n if isinstance(true_dynamics, mpc.LinDx):\\n F, f = true_dynamics.F, true_dynamics.f\\n new_xtp1 = util.bmv(F[t], new_xut)\\n if f is not None and f.nelement() > 0:\\n new_xtp1 += f[t]\\n else:\\n new_xtp1 = true_dynamics(\\n Variable(new_xt), Variable(new_ut)).data\\n\\n new_x.append(new_xtp1)\\n dx.append(new_xtp1 - x[t+1])\\n\\n if isinstance(true_cost, mpc.QuadCost):\\n C, c = true_cost.C, true_cost.c\\n obj = 0.5*util.bquad(new_xut, C[t]) + util.bdot(new_xut, c[t])\\n else:\\n obj = true_cost(new_xut)\\n\\n objs.append(obj)\\n\\n objs = torch.stack(objs)\\n current_cost = torch.sum(objs, dim=0)\\n\\n new_u = torch.stack(new_u)\\n new_x = torch.stack(new_x)\\n if full_du_norm is None:\\n full_du_norm = (u-new_u).transpose(1,2).contiguous().view(\\n n_batch, -1).norm(2, 1)\\n\\n alphas[current_cost > old_cost] *= linesearch_decay\\n i += 1\\n\\n # If the iteration limit is hit, some alphas\\n # are one step too small.\\n alphas[current_cost > old_cost] /= linesearch_decay\\n alpha_du_norm = (u-new_u).transpose(1,2).contiguous().view(\\n n_batch, -1).norm(2, 1)\\n\\n return new_x, new_u, LqrForOut(\\n objs, full_du_norm,\\n alpha_du_norm,\\n torch.mean(alphas),\\n current_cost\\n )\\n\\n\\n def get_bound(side, t):\\n if side == 'lower':\\n v = u_lower\\n if side == 'upper':\\n v = u_upper\\n if isinstance(v, float):\\n return v\\n else:\\n return v[t]\\n\\n class LQRStepFn(Function):\\n # @profile\\n @staticmethod\\n def forward(ctx, x_init, C, c, F, f=None):\\n if no_op_forward:\\n ctx.save_for_backward(\\n x_init, C, c, F, f, current_x, current_u)\\n ctx.current_x, ctx.current_u = current_x, current_u\\n return current_x, current_u\\n\\n if delta_space:\\n # Taylor-expand the objective to do the backward pass in\\n # the delta space.\\n assert current_x is not None\\n assert current_u is not None\\n c_back = []\\n for t in range(T):\\n xt = current_x[t]\\n ut = current_u[t]\\n xut = torch.cat((xt, ut), 1)\\n c_back.append(util.bmv(C[t], xut) + c[t])\\n c_back = torch.stack(c_back)\\n f_back = None\\n else:\\n assert False\\n\\n ctx.current_x = current_x\\n ctx.current_u = current_u\\n\\n Ks, ks, n_total_qp_iter = lqr_backward(ctx, C, c_back, F, f_back)\\n new_x, new_u, for_out = lqr_forward(ctx,\\n x_init, C, c, F, f, Ks, ks)\\n ctx.save_for_backward(x_init, C, c, F, f, new_x, new_u)\\n\\n return new_x, new_u, torch.Tensor([n_total_qp_iter]), \\\\\\n for_out.costs, for_out.full_du_norm, for_out.mean_alphas\\n\\n @staticmethod\\n def backward(ctx, dl_dx, dl_du, temp=None, temp2=None):\\n start = time.time()\\n x_init, C, c, F, f, new_x, new_u = ctx.saved_tensors\\n\\n r = []\\n for t in range(T):\\n rt = torch.cat((dl_dx[t], dl_du[t]), 1)\\n r.append(rt)\\n r = torch.stack(r)\\n\\n if u_lower is None:\\n I = None\\n else:\\n I = (torch.abs(new_u - u_lower) <= 1e-8) | \\\\\\n (torch.abs(new_u - u_upper) <= 1e-8)\\n dx_init = Variable(torch.zeros_like(x_init))\\n _mpc = mpc.MPC(\\n n_state, n_ctrl, T,\\n u_zero_I=I,\\n u_init=None,\\n lqr_iter=1,\\n verbose=-1,\\n n_batch=C.size(1),\\n delta_u=None,\\n # exit_unconverged=True, # It's really bad if this doesn't converge.\\n exit_unconverged=False, # It's really bad if this doesn't converge.\\n eps=back_eps,\\n )\\n dx, du, _ = _mpc(dx_init, mpc.QuadCost(C, -r), mpc.LinDx(F, None))\\n\\n dx, du = dx.data, du.data\\n dxu = torch.cat((dx, du), 2)\\n xu = torch.cat((new_x, new_u), 2)\\n\\n dC = torch.zeros_like(C)\\n for t in range(T):\\n xut = torch.cat((new_x[t], new_u[t]), 1)\\n dxut = dxu[t]\\n dCt = -0.5*(util.bger(dxut, xut) + util.bger(xut, dxut))\\n dC[t] = dCt\\n\\n dc = -dxu\\n\\n lams = []\\n prev_lam = None\\n for t in range(T-1, -1, -1):\\n Ct_xx = C[t,:,:n_state,:n_state]\\n Ct_xu = C[t,:,:n_state,n_state:]\\n ct_x = c[t,:,:n_state]\\n xt = new_x[t]\\n ut = new_u[t]\\n lamt = util.bmv(Ct_xx, xt) + util.bmv(Ct_xu, ut) + ct_x\\n if prev_lam is not None:\\n Fxt = F[t,:,:,:n_state].transpose(1, 2)\\n lamt += util.bmv(Fxt, prev_lam)\\n lams.append(lamt)\\n prev_lam = lamt\\n lams = list(reversed(lams))\\n\\n dlams = []\\n prev_dlam = None\\n for t in range(T-1, -1, -1):\\n dCt_xx = C[t,:,:n_state,:n_state]\\n dCt_xu = C[t,:,:n_state,n_state:]\\n drt_x = -r[t,:,:n_state]\\n dxt = dx[t]\\n dut = du[t]\\n dlamt = util.bmv(dCt_xx, dxt) + util.bmv(dCt_xu, dut) + drt_x\\n if prev_dlam is not None:\\n Fxt = F[t,:,:,:n_state].transpose(1, 2)\\n dlamt += util.bmv(Fxt, prev_dlam)\\n dlams.append(dlamt)\\n prev_dlam = dlamt\\n dlams = torch.stack(list(reversed(dlams)))\\n\\n dF = torch.zeros_like(F)\\n for t in range(T-1):\\n xut = xu[t]\\n lamt = lams[t+1]\\n\\n dxut = dxu[t]\\n dlamt = dlams[t+1]\\n\\n dF[t] = -(util.bger(dlamt, xut) + util.bger(lamt, dxut))\\n\\n if f.nelement() > 0:\\n _dlams = dlams[1:]\\n assert _dlams.shape == f.shape\\n df = -_dlams\\n else:\\n df = torch.Tensor()\\n\\n dx_init = -dlams[0]\\n\\n backward_time = time.time()-start\\n return dx_init, dC, dc, dF, df\\n\\n return LQRStepFn.apply\",\n \"def lfunc(x,u):\\n return mpc.mtimes(u.T, R, u) + mpc.mtimes((x-goal).T, Q, (x-goal))\",\n \"def deriv(self, u, t, K):\\n\\n # Generate control voltages, clip at saturation voltage\\n self.v[0] = np.clip(float(-K[0]*matrix((u)).T), 0, self.params['Vsat'])\\n self.v[1] = np.clip(float(-K[1]*matrix((u)).T), 0, self.params['Vsat'])\\n self.v[2] = 0\\n\\n '''\\n Definitions:\\n x1 = q0\\n x2 = q1\\n x3 = q2\\n x4 = W rod X\\n x5 = W rod Y\\n x6 = W rod Z (not in use)\\n x7 = W wheel X\\n x8 = W wheel Y\\n x9 = W wheel Z (not in use)\\n '''\\n x1, x2, x3, x4, x5, x6, x7, x8, x9 = u\\n x1_dt = 0.5*x4\\n x2_dt = 0.5*x5\\n x3_dt = 0.5*x6\\n x4_dt = self.params['Km']*self.v[0]/self.params['Rm']/self.params['Ix'] \\\\\\n + 2*self.params['g']*self.params['lp']*self.params['Mp']/(self.params['Ix'])*x1 \\\\\\n + self.params['Bx']/(self.params['Ix'])*x4 - self.params['Bw']/(self.params['Ix'])*x7\\n x5_dt = self.params['Km']*self.v[1]/self.params['Rm']/self.params['Iy'] \\\\\\n + 2*self.params['g']*self.params['lp']*self.params['Mp']/(self.params['Iy'])*x2 \\\\\\n + self.params['By']/(self.params['Iy'])*x5 - self.params['Bw']/(self.params['Iy'])*x8\\n x6_dt = self.params['Km']*self.v[2]/self.params['Rm']/self.params['Iz'] \\\\\\n + 2*self.params['g']*self.params['Fspin_z']/(self.params['Iz'])*x3 \\\\\\n + self.params['Bz']/(self.params['Iz'])*x6 - self.params['Bw']/(self.params['Iz'])*x9\\n x7_dt = self.params['Km']*self.v[0]/self.params['Rm']/self.params['Iw'] \\\\\\n + -self.params['Bw']/self.params['Iw']*x7\\n x8_dt = self.params['Km']*self.v[1]/self.params['Rm']/self.params['Iw'] \\\\\\n + -self.params['Bw']/self.params['Iw']*x8\\n x9_dt = self.params['Km']*self.v[2]/self.params['Rm']/self.params['Iw'] \\\\\\n + -self.params['Bw']/self.params['Iw']*x9\\n\\n dxdt = [x1_dt, x2_dt, x3_dt, x4_dt, x5_dt, x6_dt, x7_dt, x8_dt, x9_dt]\\n\\n return dxdt\",\n \"def solver(self, theta):\\n\\n m = len(self.x)\\n n = len(self.t[0])\\n h = self.step_x\\n k = self.step_t\\n lamb = k / (h * h)\\n w = np.zeros(m + 1)\\n l = np.zeros(m + 1)\\n u = np.zeros(m + 1)\\n\\n uK = np.zeros(self.x.shape)\\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\\n startTime = time.clock()\\n if self.first:\\n self.uR = np.zeros(self.x.shape)\\n self.first = False\\n error = 0\\n errorCurve = np.zeros(self.x.shape)\\n z = np.zeros(m + 1)\\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\\n for i in range(1, m - 1):\\n w[i] = self.g(i * h)\\n\\n l[1] = 1 + lamb\\n u[1] = -lamb / (2 * l[1])\\n for i in range(2, m - 1):\\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\\n u[i] = -lamb / (2 * l[i])\\n\\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\\n for j in range(1, n + 1):\\n t = j * k # current t\\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\\n for i in range(2, m):\\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\\n w[m - 1] = z[m - 1]\\n for i in range(m - 2, 0, -1):\\n w[i] = z[i] - u[i] * w[i + 1]\\n\\n for i in range(0, m + 1):\\n x = i * h\\n # print(x, w[i])\\n # print('oi')\\n uK[i - 1, j - 1] = w[i]\\n self.t[i - 1, j - 1] = t\\n self.x[i - 1, j - 1] = x\\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\\n return (uK, error, errorCurve, theta)\",\n \"def solve_LF(self):\\n self.u = zeros(self.N)\\n self.u[0] = self.u0\\n self.u[1] = self.u1\\n u = self.u\\n f= self.f\\n dt = self.dt\\n t = self.t\\n N = self.N\\n for n in xrange(1,N-1):\\n u[n+1] = 2*dt*f(u[n],t[n]) + u[n-1]\\n #return t,u\",\n \"def sim(self, (K,T), (j0,x0), dt, rx, **params):\\n dt0 = dt \\n\\n k = 0\\n t = [0.]\\n j = deepcopy(j0)\\n x = [deepcopy(x0)]\\n\\n trj = dict(k=k,t=t,j=j,x=x)\\n trjs = []\\n\\n while ( trj['t'][-1] <= T # don't exceed max continuous time\\n and trj['k'] < K # don't exceed max discrete transitions\\n and not trj['j'] is None ): # don't allow discrete state is None\\n k0 = trj['k']\\n t0 = trj['t'][-1]\\n j0 = trj['j']\\n x0 = trj['x'][-1]\\n if 0: # forward Euler\\n dx = self.F((k0,t0), (j0,x0), **params)\\n else: # 4th-order Runge-Kutta \\n f = lambda t,x : self.F((k0,t), (j0,x), **params)\\n dx1 = f( t0, x0 ) * dt\\n dx2 = f( t0+.5*dt, x0+.5*dx1 ) * dt\\n dx3 = f( t0+.5*dt, x0+.5*dx2 ) * dt\\n dx4 = f( t0+dt, x0+dx3 ) * dt\\n dx = (1./6.)*( dx1 + 2*dx2 + 2*dx3 + dx4 ) / dt\\n\\n k = k0\\n j = j0\\n t = t0 + dt\\n x = x0 + dt * dx\\n g = self.G((k,t), (j,x), **params)\\n\\n # halve step size until trajectory doesn't violate guard more than rx\\n i = 0\\n imax = 50\\n while np.any(g < -rx) and (i <= imax):\\n dt = dt/2.\\n t = t0 + dt\\n x = x0 + dt * dx\\n g = self.G((k,t), (j,x), **params)\\n i += 1\\n\\n #if (i >= imax):\\n # raise RuntimeError,'(sim) guard iterations exceeded -- you probably have a buggy guard'\\n\\n # append state to trj\\n trj['t'].append(t)\\n trj['x'].append(x)\\n\\n if 0 and 'debug' in params and params['debug']:\\n print ' : (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s, dx = %s' % (k,t,j,x,dt,g,x,dx)\\n\\n # if in guard \\n if np.any(g < 0):\\n\\n # spend time in guard\\n if i >= imax:\\n t = t + rx\\n else:\\n t = t + (rx + g.min())\\n trj['t'].append(t)\\n trj['x'].append(x)\\n\\n if 'debug' in params and params['debug']:\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n\\n # append trj to trjs\\n trjs.append(trj)\\n\\n if 'Zeno' in params and params['Zeno'] and (len(trj['t']) <= 4):\\n\\n print '(sim) possible Zeno @ stepsize dt = %0.6f' % dt0\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n return trjs\\n\\n # apply reset to modify trj\\n (k,t),(j,x) = self.R((k,t), (j,x), **params)\\n trj = dict(k=k,t=[t],j=j,x=[x])\\n\\n # re-initialize step size\\n dt = dt0\\n\\n if 'debug' in params and params['debug']:\\n g = self.G((k,t), (j,x), **params)\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n\\n trjs.append(trj)\\n\\n return trjs\",\n \"def R(self, (k,t), (j,x), **params):\\n d = len(x)/2\\n q,dq = x[:d],x[d:]\\n g = self.G((k,t), (j,x), **params)\\n I = (g < 0.).nonzero()[0] # constraint indices that are activating or deactivating\\n J = deepcopy(j)\\n J[I] = np.logical_not(J[I])\\n Delta = self.Delta( (k,t), (J,q,dq), **params )\\n dq_ = util.dot( Delta, dq )\\n k_ = k+1\\n t_ = t\\n j_ = 1 * J\\n x_ = np.hstack([q,dq_])\\n return (k_,t_),(j_,x_)\",\n \"def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\\n\\n # Raise('NotImplementedError: only adjusted the arguments.')\\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\\n #precompute the expensive operation:\\n lin_penalties = 1/np.sqrt(2*eta_lin)\\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\\n #!!!!\\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\\n #!!!!\\n u_prev = u_init + 1\\n u = u_init\\n count = 0\\n obj_history = []\\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\\n start = time.time()\\n \\n u_prev = np.copy(u)\\n w_0 = w_0_update(eta_0, u, T, alpha, B) \\n w = w_update(u, H, gamma, D, C) \\n w_lin = w_lin_update(u, L_lhs, L_rhs)\\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\\n #!!!!\\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\\n #!!!!\\n count += 1 \\n if count == 10:\\n u_inf = np.copy(u)\\n w_0_inf = w_0[:]\\n w_inf = w[:]\\n w_lin_inf = w_lin[:]\\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\\n \\n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\\n obj_history.append(cur_obj)\\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\\n relaxed_obj_history.append(cur_relaxed_obj) \\n \\n stop = time.time()\\n duration = stop-start\\n \\n if count%1 == 0 and verbose: \\n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\\n print(' This iteration took: {}'.format(duration))\\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history\",\n \"def learned_RHS(t,y,q,x,desc):\\n \\n \\n Ux_mat = create_Ux_mat(x)\\n Uxx_mat = create_Uxx_mat(x)\\n\\n return (q[desc.index('u_{x}')]*Ux_mat.dot(y) + \\n q[desc.index('u_{xx}')]*Uxx_mat.dot(y) +\\n q[desc.index('u^2')]*y**2 +\\n q[desc.index('u')]*y + \\n q[desc.index('u^2u_{x}')]*(y**2)*Ux_mat.dot(y) + \\n q[desc.index('uu_{x}')]*y*Ux_mat.dot(y) + \\n q[desc.index('u^2u_{xx}')]*(y**2)*Uxx_mat.dot(y) + \\n q[desc.index('uu_{xx}')]*y*Uxx_mat.dot(y) + \\n q[desc.index('u_{x}^2')]*Ux_mat.dot(y)**2)\",\n \"def g_solving_subproblem_of_LR(self,vehicle_id):\\r\\n global_LB=-10000\\r\\n global_UB=10000\\r\\n iteration_for_RSP=20\\r\\n optimal_solution_for_RSP=None\\r\\n optimal_value_y=0\\r\\n self.multiplier_v=0.5\\r\\n\\r\\n #solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\\r\\n #obtain the variance\\r\\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB=0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\\r\\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\\r\\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\\r\\n optimal_value_y = y\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance-y!= 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB-global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\",\n \"def build_linear_system(u, dt, dx, D = 3, P = 3,time_diff = 'poly',space_diff = 'poly',lam_t = None,lam_x = None, width_x = None,width_t = None, deg_x = 5,deg_t = None,sigma = 2):\\n\\n n, m = u.shape\\n\\n if width_x == None: width_x = n/10\\n if width_t == None: width_t = m/10\\n if deg_t == None: deg_t = deg_x\\n\\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\\n if time_diff == 'poly': \\n m2 = m-2*width_t\\n offset_t = width_t\\n else: \\n m2 = m\\n offset_t = 0\\n if space_diff == 'poly': \\n n2 = n-2*width_x\\n offset_x = width_x\\n else: \\n n2 = n\\n offset_x = 0\\n\\n if lam_t == None: lam_t = 1.0/m\\n if lam_x == None: lam_x = 1.0/n\\n\\n ########################\\n # First take the time derivaitve for the left hand side of the equation\\n ########################\\n ut = np.zeros((n2,m2), dtype=u.dtype)\\n\\n if time_diff == 'FDconv':\\n Usmooth = np.zeros((n,m), dtype=u.dtype)\\n # Smooth across x cross-sections\\n for j in range(m):\\n Usmooth[:,j] = ConvSmoother(u[:,j],width_t,sigma)\\n # Now take finite differences\\n for i in range(n2):\\n ut[i,:] = FiniteDiff(Usmooth[i + offset_x,:],dt,1)\\n\\n elif time_diff == 'poly':\\n T= np.linspace(0,(m-1)*dt,m)\\n for i in range(n2):\\n ut[i,:] = PolyDiff(u[i+offset_x,:],T,diff=1,width=width_t,deg=deg_t)[:,0]\\n\\n elif time_diff == 'Tik':\\n for i in range(n2):\\n ut[i,:] = TikhonovDiff(u[i + offset_x,:], dt, lam_t)\\n\\n else:\\n for i in range(n2):\\n ut[i,:] = FiniteDiff(u[i + offset_x,:],dt,1)\\n \\n ut = np.reshape(ut, (n2*m2,1), order='F')\\n\\n ########################\\n # Now form the rhs one column at a time, and record what each one is\\n ########################\\n\\n u2 = u[offset_x:n-offset_x,offset_t:m-offset_t]\\n Theta = np.zeros((n2*m2, (D+1)*(P+1)), dtype=u.dtype)\\n ux = np.zeros((n2,m2), dtype=u.dtype)\\n rhs_description = ['' for i in range((D+1)*(P+1))]\\n\\n if space_diff == 'poly': \\n Du = {}\\n for i in range(m2):\\n Du[i] = PolyDiff(u[:,i+offset_t],np.linspace(0,(n-1)*dx,n),diff=D,width=width_x,deg=deg_x)\\n if space_diff == 'Fourier': ik = 2*np.pi*1j*np.fft.fftfreq(n, d = dx)\\n \\n for d in range(D+1):\\n\\n if d > 0:\\n for i in range(m2):\\n if space_diff == 'Tik': ux[:,i] = TikhonovDiff(u[:,i+offset_t], dx, lam_x, d=d)\\n elif space_diff == 'FDconv':\\n Usmooth = ConvSmoother(u[:,i+offset_t],width_x,sigma)\\n ux[:,i] = FiniteDiff(Usmooth,dx,d)\\n elif space_diff == 'FD': ux[:,i] = FiniteDiff(u[:,i+offset_t],dx,d)\\n elif space_diff == 'poly': ux[:,i] = Du[i][:,d-1]\\n elif space_diff == 'Fourier': ux[:,i] = np.fft.ifft(ik**d*np.fft.fft(u[:,i]))\\n else: ux = np.ones((n2,m2), dtype=u.dtype) \\n \\n for p in range(P+1):\\n Theta[:, d*(P+1)+p] = np.reshape(np.multiply(ux, np.power(u2,p)), (n2*m2), order='F')\\n\\n if p == 1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u'\\n elif p>1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u^' + str(p)\\n if d > 0: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+\\\\\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\\n\\n return ut, Theta, rhs_description\",\n \"def _call(self, x):\\n u = functional.tmp_u_prox\\n v = functional.tmp_v_prox\\n\\n # Running generalized Sinkhorn iterations\\n for j in range(functional.niter):\\n # Safe-guarded u-update, to avoid divide-by-zero error.\\n u_old = u.copy()\\n tmp1 = functional.K_op(v)\\n if np.min(tmp1) < 1e-30 or np.max(tmp1) > 1e+50:\\n print('Numerical instability, truncation in Transport prox (Kv)',\\n str(np.min(tmp1)), str(np.max(tmp1)))\\n\\n tmp = np.fmax(tmp1, 1e-30)\\n\\n\\n u = functional.mu0 / tmp\\n if np.min(u) < 1e-30 or np.max(u) > 1e+50:\\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\\n\\n # Safe-guarded v-update, to avoid divide-by-zero error.\\n v_old = v.copy()\\n\\n tmp3 = functional.K_op_adjoint(u)\\n if np.min(tmp3) < 1e-30 or np.max(tmp3) > 1e+50:\\n print('Truncation in Transport prox (KTu)',\\n str(np.min(tmp3)), str(np.max(tmp3)))\\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\\n\\n tmp4 = (self.const * tmp3 * np.exp(self.const * x))\\n\\n if np.min(tmp4) < 1e-30 or np.max(tmp4) > 1e+200:\\n print('Argument in lambdert omega (min/max)',\\n str(np.min(tmp4)), str(np.max(tmp4)))\\n\\n v = np.exp(self.const * x - lambertw_fulfix(tmp4))\\n\\n v1 = np.exp(self.const * x - scipy.special.lambertw(\\n tmp4))\\n if (v-v1).norm() > 1e-10:\\n print('diff pga ny lambderw omega funciton',\\n str((v-v1).norm()))\\n print('v (min/max)', str(np.min(v)), str(np.max(v)))\\n print('Argument in lambdert omega (min/max)',\\n str(np.min(tmp4)), str(np.max(tmp4)))\\n\\n # If the updates in both u and v are small, break the loop\\n if ((np.log(v)-np.log(v_old)).norm() < 1e-8 and\\n (np.log(u)-np.log(u_old)).norm() < 1e-8):\\n break\\n\\n # Store the u and v in the internal temporary variables of the\\n # functional\\n functional.tmp_u_prox = u\\n functional.tmp_v_prox = v\\n\\n return x - self.sigma * functional.epsilon * np.log(v)\",\n \"def LQR_cost(A, B, K, Q, R, sigma_w):\\n\\n L = A + B.dot(K)\\n if spectral_radius(L) >= 1:\\n return 1e6\\n\\n M = Q + K.T.dot(R).dot(K)\\n\\n P = solve_discrete_lyapunov(L, M)\\n\\n return (sigma_w ** 2) * np.trace(P)\",\n \"def optimize_linearized_model(self, A, B, initial_state, Q, R, target, time_horizon=10, verbose=False):\\n assert len(initial_state) == self.state_len\\n # Create variables\\n x = opt.Variable(self.state_len, time_horizon + 1, name='states')\\n u = opt.Variable(self.action_len, time_horizon, name='actions')\\n\\n # Loop through the entire time_horizon and append costs\\n cost_function = []\\n\\n for t in range(time_horizon):\\n # _cost = opt.norm(x[2, t + 1],2)*50 + opt.norm(x[3, t + 1],2)*50 + opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(u[:, t]-u[:, t-1], R*0.1)\\n _cost = opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(\\n u[:, t] - u[:, t - 1], R * 0.1)\\n _constraints = [x[:, t + 1] == A * x[:, t] + B * u[:, t],\\n u[0, t] >= MAIN_ENGINE_POWER/1.8, u[0, t] <= MAIN_ENGINE_POWER / 1.05,\\n u[1, t] >= -SIDE_ENGINE_POWER, u[1, t] <= SIDE_ENGINE_POWER,\\n u[2, t] >= -self.angle_limit, u[2, t] <= self.angle_limit,\\n opt.norm(target[:, t + 1] - x[:, t + 1], 1) <= 0.01]\\n\\n cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=_constraints))\\n\\n # Add final cost\\n problem = sum(cost_function)\\n problem.constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 0.001,\\n x[:, 0] == initial_state]\\n # Minimize Problem\\n problem.solve(verbose=verbose, solver=opt.SCS)\\n # u[0, :].value.A.flatten()\\n return x, u\",\n \"def quintic_trajectory_planning(q0, qf, qd0, qdf, qdd0, qddf, m = 100):\\n n = q0.shape[0]\\n\\n # Polynomial Parameters\\n a0 = np.copy(q0)\\n a1 = np.copy(qd0) \\n a2 = np.copy(qdd0) / 2\\n a3 = (20 * qf - 20 * q0 - 8 * qdf - 12 * qd0 - 3 * qdd0 + qddf) / 2\\n a4 = (30 * q0 - 30 * qf + 14 * qdf + 16 * qd0 + 3 * qdd0 - 2 * qddf) / 2\\n a5 = (12 * qf - 12 * q0 - 6 * qdf - 6 * qd0 - qdd0 + qddf) / 2\\n\\n timesteps = np.linspace(0, 1, num = m)\\n\\n q = np.zeros((n, m))\\n qd = np.zeros((n, m))\\n qdd = np.zeros((n, m))\\n\\n for i in range(len(timesteps)):\\n t = timesteps[i]\\n t_2 = t * t\\n t_3 = t_2 * t\\n t_4 = t_3 * t\\n t_5 = t_4 * t\\n\\n q[:, i] = (a0) + (a1 * t) + (a2 * t_2) + (a3 * t_3) + (a4 * t_4) + (a5 * t_5)\\n qd[:, i] = (a1) + (2 * a2 * t) + (3 * a3 * t_2) + (4 * a4 * t_3) + (5 * a5 * t_4)\\n qdd[:, i] = (2 * a2) + (6 * a3 * t) + (12 * a4 * t_2) + (20 * a5 * t_3)\\n\\n return q, qd, qdd\",\n \"def EstimateKFTimeStep(u1,y1,z0,Xxd,Xud,Yx,Yu,P0,Q,R):\\n \\n # estimate next step\\n z1m = Xxd.dot(z0) + Xud.dot(u1)\\n y1hat = Yx.dot(z1m) + Yu.dot(u1)\\n P1m = (Xxd.dot(P0)).dot(Xxd.T) + Q\\n \\n # Calculate Kalman gain\\n # same as Lk from [1] - And their Rtilde_k is G*P1m*G'+R\\n Kk = np.dot(P1m,Yx.T).dot( np.linalg.inv(((Yx.dot(P1m)).dot(Yx.T) + R))) \\n # update estimate with measurement\\n z1 = z1m + Kk.dot(y1 - y1hat)\\n \\n P1 = (np.eye(Xxd.shape[0]) - Kk.dot(Yx) ).dot(P1m)\\n return z1,P1,Kk\",\n \"def advance(self):\\n\\n f, n, rtol, atol, neq = \\\\\\n self.f, self.n, self.rtol, self.atol, self.neq\\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\\n dt = t_next - t_n\\n\\n first_step = dt # try one big step to next desired level\\n\\n def middle(x,y,z): # Auxilary function\\n return sorted([x,y,z])[1]\\n\\n # Extract coefficients from Butcher-tableau\\n table = self._butcher_tableau\\n k_len = table.shape[1] - 1 # number of internal stages\\n\\n # coefficients for internal stages\\n factors_u = np.asarray(table[:k_len, 1:])\\n # coefficients for t\\n factors_t = table[:k_len, 0]\\n # coefficients for u_new\\n factors_u_new = table[k_len, 1:]\\n\\n # coefficients for local error between 2 levels\\n factors_error = table[k_len+1, 1:] - factors_u_new\\n\\n u_intermediate = [u_n,]\\n t_intermediate = [t_n,]\\n u, t, h = u_n, t_n, first_step # initial values\\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\\n\\n if self.verbose > 0:\\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\\n\\n # Loop until next time point is reached\\n while (abs(t - t_n) < abs(t_next - t_n)):\\n u, t = u_intermediate[-1], t_intermediate[-1]\\n\\n # Internal steps\\n k[:, :] = 0. # initialization for next step\\n for m in range(k_len):\\n k_factors = (np.dot(factors_u, k))[m]\\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\\n u_new = u + h*(np.dot(factors_u_new, k))\\n\\n self.info['rejected'] += 1 # reduced below if accepted\\n if self.verbose > 0:\\n print ' u(t=%g)=%g: ' % (t+h, u_new),\\n\\n # local error between 2 levels\\n error = h*np.abs(np.dot(factors_error, k))\\n # Acceptable error tolerance\\n tol = rtol*np.abs(u_new) + atol\\n\\n accurate = (error <= tol).all()\\n\\n if accurate or h <= self.min_step or h >= self.max_step:\\n # Accurate enough,\\n # or the step size exceeds valid range,\\n # must accept this solution\\n u_intermediate.append(u_new)\\n t_intermediate.append(t+h)\\n if not self.disk_storage:\\n self.u_all.append(u_new)\\n self.t_all.append(t+h)\\n self.info['rejected'] -= 1\\n\\n if self.verbose > 0:\\n print 'accepted, ',\\n else:\\n if self.verbose > 0:\\n print 'rejected, ',\\n\\n if self.verbose > 0:\\n print 'err=%s, ' % str(error),\\n if hasattr(self, 'u_exact') and callable(self.u_exact):\\n print 'exact-err=%s, ' % \\\\\\n (np.asarray(self.u_exact(t+h))-u_new),\\n if h <= self.min_step:\\n print 'h=min_step!! ',\\n\\n\\n # Replace 0 values by 1e-16 since we will divide by error\\n error = np.asarray([(1e-16 if x == 0. else x) \\\\\\n for x in error])\\n\\n # Normarized error rate\\n rms = error/tol\\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\\n\\n order = float(self._method_order[0])\\n # factor to adjust the size of next step\\n # Formula is from <Numerical Methods for Engineers,\\n # Chappra & Cannle>\\n s = .8 *((1./rms_norm)**(1/order))\\n # scalar should be in range(0.1, 4.)\\n # for better accuracy and smoothness\\n s = middle(s, 0.1, 4.0)\\n h *= s\\n\\n # step size should be in range [min_step, max_step]\\n h = middle(h, self.min_step, self.max_step)\\n # adjust h to fit the last step\\n h = min(h, t_next - t_intermediate[-1])\\n\\n if self.verbose > 0:\\n print 'new h=%g' % h\\n\\n if h == 0:\\n break\\n\\n return u_new\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\n \"def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[uD]\\n \\n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\\n \\n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\\n \\n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \\n \\n return T\",\n \"def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[uD]\\n \\n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\\n \\n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\\n \\n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \\n \\n return T\",\n \"def return_quadratic_cost_function_expansion_variables(\\n X,U,dt,\\n RunningCost=\\\"Minimize Input Energy\\\"):\\n\\n if type(RunningCost)==str:\\n assert RunningCost in ['Minimize Input Energy',\\n 'Minimize time away from target angle',\\n 'Minimize time away from target angular velocity'],\\\\\\n \\\"RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'.\\\"\\n else:\\n assert type(RunningCost)==list, \\\"RunningCost must be a list of cost types.\\\"\\n for el in RunningCost:\\n assert type(el)==str, \\\"Each element of RunningCost must be a string. Not \\\" + str(type(el)) + \\\".\\\"\\n assert el in ['Minimize Input Energy',\\n 'Minimize time away from target angle',\\n 'Minimize time away from target angular velocity'],\\\\\\n \\\"Each element of RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'. '\\\" + el + \\\"' not accepted.\\\"\\n\\n # returns a list of length len(Time)-1, each element with shape (1,1), where n is the number of states.\\n l_func = return_l_func(RunningCost=RunningCost)\\n l = list(\\n map(\\n lambda X,U: l_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,1), where n is the number of states.\\n lx_func = return_lx_func(RunningCost=RunningCost)\\n lx = list(\\n map(\\n lambda X,U: lx_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,1), where n is the number of states.\\n lu_func = return_lu_func(RunningCost=RunningCost)\\n lu = list(\\n map(\\n lambda X,U: lu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,n), where m is the number of inputs and n is the number of states.\\n lux_func = return_lux_func(RunningCost=RunningCost)\\n lux = list(\\n map(\\n lambda X,U: lux_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,m), where n is the number of states and m is the number of inputs.\\n lxu_func = return_lxu_func(RunningCost=RunningCost)\\n lxu = list(\\n map(\\n lambda X,U: lxu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,m), where m is the number of inputs.\\n luu_func = return_luu_func(RunningCost=RunningCost)\\n luu = list(\\n map(\\n lambda X,U: luu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,n), where n is the number of states.\\n lxx_func = return_lxx_func(RunningCost=RunningCost)\\n lxx = list(\\n map(\\n lambda X,U: lxx_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n return(l,lx,lu,lux,lxu,luu,lxx)\",\n \"def dlqr(a, b, q, r):\\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\\n p = scipy.linalg.solve_discrete_are(a, b, q, r)\\n\\n # LQR gain\\n # k = (b.T * p * b + r)^-1 * (b.T * p * a)\\n bp = b.T.dot(p)\\n tmp1 = bp.dot(b)\\n tmp1 += r\\n tmp2 = bp.dot(a)\\n k = np.linalg.solve(tmp1, tmp2)\\n return k, p\",\n \"def trisolve(l, u, c, b):\\n n = shape(b)[0]\\n for k in range(1, n):\\n b[k] -= l[k-1]*b[k - 1]\\n b[n-1] /= u[n-1]\\n for k in range(n-2,-1,-1):\\n b[k] -= c[k]*b[k + 1]\\n b[k] /= u[k]\",\n \"def lqr(a, b, q, r):\\n a, b, q, r = map(np.atleast_2d, (a, b, q, r))\\n p = scipy.linalg.solve_continuous_are(a, b, q, r)\\n\\n # LQR gain\\n k = np.linalg.solve(r, b.T.dot(p))\\n\\n return k, p\",\n \"def time_update(self, U):\\n self.X = self.runge_kutta(self.process_model, self.X, U, self.dt)\\n \\n J = self.F.subs({'d_t': self.dt, 'v': U[0], '\\\\Theta': self.X[2]})\\n \\n self.P = J*self.P*J.T + self.Q\",\n \"def application_test():\\n # Choice of nonlinear coefficient\\n m = 2\\n\\n def q(u):\\n return (1+u)**m\\n\\n def Dq(u):\\n return m*(1+u)**(m-1)\\n\\n usage = 'manual|automatic Krylov|direct degree nx ny nz'\\n try:\\n import sys\\n J_comp = sys.argv[1]\\n linear_solver = sys.argv[2]\\n degree = int(sys.argv[3])\\n divisions = [int(arg) for arg in sys.argv[4:]]\\n except:\\n print('Usage: %s' % sys.argv[0], usage)\\n sys.exit(0)\\n\\n u = solver(q, Dq, f, divisions, degree,\\n 'pde_Newton', J_comp, linear_solver)\\n\\n # Find max error\\n u_exact = Expression(\\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\\n u_e = interpolate(u_exact, u.function_space())\\n import numpy as np\\n error = np.abs(u_e.vector().array() -\\n u.vector().array()).max()\\n print('error: %.2E' % error)\",\n \"def solver(I, f, c, U_0, U_L, L, n, dt, tstop,\\n user_action=None, version='scalar'):\\n import time\\n t0 = time.clock()\\n \\n dx = L/float(n)\\n x = linspace(0, L, n+1) # grid points in x dir\\n if dt <= 0: dt = dx/float(c) # max time step?\\n\\n u = zeros(n+1) # NumPy solution array\\n rhs = u.copy()\\n \\n # set initial condition (pointwise - allows straight if-tests):\\n t = 0.0\\n u = ic_scalar(u, x, I, U_0, U_L)\\n with_bc = False #True\\n F = WaveRHS(rhs, u, c, f, x, n, dx, version, with_bc, U_0, U_L)\\n solver = ODESolver(F, dt, u, user_action, [x])\\n solver.timeloop(tstop)\\n \\n t1 = time.clock()\\n return dt, x, t1-t0\",\n \"def j(U, Q, mesh, T, num_steps, params):\\n \\n # Define parameters for cost functional\\n alpha = params[\\\"alpha\\\"]\\n u_d = params[\\\"u_d\\\"]\\n \\n # Compute integrals with time\\n I1 = 0\\n I3 = 0\\n \\n t = 0\\n dt = T/num_steps\\n for i in range(num_steps + 1):\\n I1_int = assemble((U[i] - u_d[i])*(U[i] - u_d[i])*dx(mesh))\\n I3_int = assemble(Q[i]*Q[i]*dx(mesh))\\n \\n if i == 0 or i == num_steps:\\n I1_int *= 0.5\\n I3_int *= 0.5\\n \\n I1 += I1_int\\n I3 += I3_int\\n \\n t += dt\\n \\n \\n I1 *= dt\\n I3 *= dt*alpha/2\\n \\n # Compute end time integral\\n \\n print(\\\"Cost Functional Data\\\")\\n print(\\\"I1: {}\\\".format(I1))\\n print(\\\"I3: {}\\\".format(I3))\\n print()\\n \\n return I1 + I3\",\n \"def solve_release_time(mvi, con):\\n nd, m = mvi.nd, mvi.nc\\n\\n # If the first state is already close enough to release, step integrator back\\n # and use the state as the release state.\\n if abs(mvi.lambda1c[con.index]) < LAMBDA_TOL:\\n mvi.set_single_state(2, mvi.t1, mvi.q1, mvi.p1)\\n mvi.lambda1 = mvi.lambda0\\n return {'t': mvi.t2, 'q': mvi.q2, 'p': mvi.p2, 'lambda1': mvi.lambda1}\\n\\n set_system_state(mvi, 1)\\n Dh1T = np.transpose(Dh(mvi))\\n D2h1 = D2h(mvi)\\n\\n t_guess, q_guess = linear_interpolate_release(mvi, con.index)\\n\\n # No impacts at state 1 - solve normal release time problem.\\n if not mvi._state1_impacts:\\n\\n x0 = np.hstack((q_guess[:nd], mvi.lambda0, t_guess))\\n\\n # The root-solving problem is to find (DEL, h(qr, tr), lambda_{cont}) = 0. \\n def func(x):\\n mvi.t2 = x[-1]\\n mvi.lambda1 = x[nd:-1]\\n mvi.q2 = np.append(x[:nd], mvi.kin_config(x[-1]))\\n\\n mvi.set_midpoint()\\n f1 = mvi.p1+D1L2(mvi)+fm2(mvi)-np.dot(Dh1T,mvi.lambda1)\\n\\n set_system_state(mvi, 2)\\n f2 = h(mvi)\\n f3 = mvi.system.lambda_(constraint=con)\\n\\n return np.hstack((f1, f2, f3))\\n\\n\\n def fprime(x):\\n mvi.t2 = x[-1]\\n mvi.q2 = np.append(x[:nd], mvi.kin_config(x[-1]))\\n mvi.lambda1 = x[(nd):(nd+m)]\\n \\n mvi.set_midpoint()\\n Df11 = D2D1L2(mvi) + D2fm2(mvi)\\n Df13 = D4D1L2(mvi) + D4fm2(mvi)\\n \\n set_system_state(mvi, 2)\\n Df21 = Dh(mvi)\\n Df23 = D2h(mvi).reshape((mvi.nc, 1))\\n lam_dq = (mvi.system.lambda_dq(constraint=con)+\\n mvi.system.lambda_ddq(constraint=con)/(mvi.t2-mvi.t1))[:nd]\\n lam_dt = -1.0/(mvi.t2-mvi.t1)*np.dot(mvi.system.dq[:nd], \\n mvi.system.lambda_ddq(constraint=con)[:nd])\\n\\n Df1 = np.hstack((Df11, -Dh1T, Df13))\\n Df2 = np.hstack((Df21, np.zeros((mvi.nc, mvi.nc)), Df23))\\n Df3 = np.hstack((lam_dq, np.zeros(m), lam_dt))\\n\\n return np.vstack((Df1, Df2, Df3))\\n\\n # Impacts have occurred at state 1 - solve impact update with additional unknown \\n # release time.\\n else:\\n\\n impact_surfaces = mvi._state1_impacts\\n p = len(impact_surfaces)\\n\\n tau = mvi.tau2 # Is set by most recent impact solver.\\n\\n x0 = np.hstack((q_guess[:nd], mvi.lambda1, t_guess, np.dot(D2h1, mvi.lambda1)-tau))\\n\\n def func(x): \\n mvi.t2 = x[nd+m]\\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\\n mvi.lambda1 = x[nd:(nd+m)]\\n Ec = x[-1]\\n\\n mvi.set_midpoint()\\n f1 = mvi.p1+D1L2(mvi)+fm2(mvi)-np.dot(Dh1T,mvi.lambda1)\\n f3 = tau+D3L2(mvi)-np.dot(D2h1, mvi.lambda1)+Ec\\n\\n set_system_state(mvi, 2)\\n f2 = h(mvi)\\n f4 = mvi.system.lambda_(constraint=con)\\n \\n return np.hstack((f1, f2, f3, f4))\\n\\n def fprime(x):\\n mvi.t2 = x[nd+m]\\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\\n mvi.lambda1 = x[nd:(nd+m)]\\n Ec = x[-1]\\n \\n mvi.set_midpoint()\\n Df11 = D2D1L2(mvi) + D2fm2(mvi)\\n Df13 = D4D1L2(mvi) + D4fm2(mvi)\\n Df31 = D2D3L2(mvi)\\n Df33 = D4D3L2(mvi)\\n \\n set_system_state(mvi, 2)\\n Df21 = Dh(mvi)\\n Df23 = D2h(mvi).reshape((m, 1))\\n Df32 = -D2h(mvi)\\n Df41 = D2LAM2(mvi, con)\\n Df43 = D4LAM2(mvi, con)\\n\\n Df1 = np.hstack((Df11, -Dh1T, Df13, np.zeros((nd,1))))\\n Df2 = np.hstack((Df21, np.zeros((m, m)), Df23, np.zeros((m,1))))\\n Df3 = np.hstack((Df31, Df32, Df33, (1.0,)))\\n Df4 = np.hstack((Df41, np.zeros(m), Df43, np.zeros(1)))\\n\\n return np.vstack((Df1, Df2, Df3, Df4))\\n\\n \\n (x, infodict, ier, mesg) = scipy.optimize.fsolve(func, x0, full_output=True)\\n\\n if ier != 1:\\n print mesg\\n raise trep.ConvergenceError(\\\"Release solver failed to converge.\\\") \\n\\n mvi.t2 = x[nd+m]\\n mvi.q2 = np.append(x[:nd], mvi.kin_config(mvi.t2))\\n mvi.lambda1 = x[nd:(nd+m)]\\n mvi.set_midpoint() \\n mvi.p2 = D2L2(mvi)\\n\\n return {'t': mvi.t2, 'q': mvi.q2, 'p': mvi.p2, 'lambda1': mvi.lambda1}\",\n \"def hr_game(t0, tf, n, A, B, R, x0):\\n # t0 - Initial time\\n # tf - Final time\\n # n - Number of steps\\n # A - Adjacency matrix, np.ndarray (N,N)\\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\\n # R - Relationship or preference matrix, np.ndarray (N,N)\\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\\n\\n # Number of players\\n N = A[:, 0].size\\n # Number of strategies\\n S = x0[0, :].size\\n # Step in each iteration\\n h = (tf - t0) / n\\n # Result of each step, np.ndarray (N, S, n+1)\\n y = np.zeros([N, S, n+1], dtype='double')\\n y[:, :, 0] = x0\\n k = np.zeros([N, S])\\n # I still don't know why, but theres a problem with negative payoffs\\n B = matrixTranslate(B)\\n\\n # Fourth order Runge-Kutta\\n for t in range(n):\\n k1 = np.multiply(h, hr_egn(A, B, R, y[:, :, t]))\\n k2 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k1, 2))))\\n k3 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k2, 2))))\\n k4 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], k3)))\\n # k = (k1 + 2*k2 + 2*k3 + k4)/6\\n k = np.divide(np.add(np.add(k1, np.multiply(2, k2)), np.add(np.multiply(2, k3), k4)), 6)\\n\\n y[:, :, t+1] = np.add(y[:, :, t], k)\\n\\n # Filter results with machine epsilon\\n for v in range(N):\\n for s in range(S):\\n if y[v, s, t+1] < np.sqrt(np.finfo('double').eps):\\n y[v, s, t+1] = 0\\n elif y[v, s, t+1] > np.subtract(1, np.sqrt(np.finfo('double').eps)):\\n y[v, s, t + 1] = 1\\n\\n return y\",\n \"def integrate(self,u,x,Dt,t,bc):\\n time=t[0]\\n i=1\\n result=interfaces.State()\\n result.x=scipy.zeros((len(x),len(t)),scipy.float64)\\n result.x[:,0]=x\\n s=list(scipy.shape(u))\\n s.append(len(t))\\n result.u=scipy.zeros(s,scipy.float64)\\n result.u[:,:,0]=u\\n result.time=t\\n \\n while not scipy.allclose(time,t[-1],rtol=1e-8,atol=1e-10):\\n k1=self.estimator.estimate(u,time,x,bc)\\n\\t k2=self.estimator.estimate(u+0.5*Dt*k1,time+0.5*Dt,x,bc)\\n\\t k3=self.estimator.estimate(u+0.5*Dt*k2,time+0.5*Dt,x,bc)\\n\\t k4=self.estimator.estimate(u+Dt*k3,time+Dt,x,bc)\\n\\t u=u+Dt*(1./6.*k1+1./3.*k2+1./3.*k3+1./6.*k4)\\n time=time+Dt\\n\\t if scipy.allclose(time,t[i],rtol=1e-8,atol=1e-10):\\n \\tresult.x[:,i]=x\\n result.u[:,:,i]=u\\n \\ti+=1\\n return result\",\n \"def compute_ul_ur(self, dt):\\n\\n g = self.grid\\n # compute the piecewise linear slopes\\n # here we define the range cells considered, including 1 ghost cell\\n # on each side\\n ib = g.ng-1\\n ie = g.ng + g.N\\n\\n u = g.u\\n \\n # initialize empty arrays\\n dc = np.zeros((g.N+2*g.ng))\\n dl = np.zeros((g.N+2*g.ng))\\n dr = np.zeros((g.N+2*g.ng))\\n \\n dc[ib:ie+1] = 0.5*(u[ib+1:ie+2] - u[ib-1:ie ])\\n dl[ib:ie+1] = u[ib+1:ie+2] - u[ib :ie+1]\\n dr[ib:ie+1] = u[ib :ie+1] - u[ib-1:ie ]\\n\\n # minmod()\\n # fabs is the absolute value for real valued inputs\\n # where does np.where(condition,if true keep this value, else this)\\n # d1 = 2.0*np.where(np.fabs(dl) < np.fabs(dr), dl, dr)\\n d1 = np.zeros((len(dl)))\\n for i in range(len(dl)):\\n if np.fabs(dl[i]) < np.fabs(dr[i]):\\n d1[i] = dl[i]\\n else:\\n d1[i] = dr[i]\\n d1 = 2.0*d1\\n \\n d2 = np.zeros((len(dc)))\\n for i in range(len(dc)):\\n if np.fabs(dc[i]) < np.fabs(d1[i]):\\n d2[i] = dc[i]\\n else:\\n d2[i] = d1[i] \\n \\n # d2 = np.where(np.fabs(dc) < np.fabs(d1), dc, d1)\\n ldeltau = np.zeros((len(d2)))\\n for i in range(len(d2)):\\n if dl[i]*dr[i] > 0.0:\\n ldeltau[i] = d2[i]\\n else:\\n ldeltau[i] = 0.0\\n # ldeltau = np.where(dl*dr > 0.0, d2, 0.0)\\n\\n # interface states. \\n # Note from hydro_examples:\\n # note that there are 1 more interfaces than zones\\n ul = np.zeros((g.N+2*g.ng))\\n ur = np.zeros((g.N+2*g.ng))\\n\\n ur[ib:ie+2] = u[ib:ie+2] - \\\\\\n 0.5*(1.0 + u[ib:ie+2]*dt/self.grid.dx)*ldeltau[ib:ie+2]\\n\\n ul[ib+1:ie+2] = u[ib:ie+1] + \\\\\\n 0.5*(1.0 - u[ib:ie+1]*dt/self.grid.dx)*ldeltau[ib:ie+1]\\n\\n return ul, ur\",\n \"def drx_solver_numpy(tol, steps, factor, C, Ct, X, M, k0, l0, f0, ind_c, ind_t, P, S, B, V, refresh,\\n beams, inds, indi, indf, EIx, EIy, callback, **kwargs):\\n res = 1000 * tol\\n ts, Uo = 0, 0\\n M = factor * tile(M.reshape((-1, 1)), (1, 3))\\n\\n while (ts <= steps) and (res > tol):\\n\\n uvw, l = uvw_lengths(C, X) # noqa: E741\\n f = f0 + k0 * (l.ravel() - l0)\\n\\n if ind_t:\\n f[ind_t] *= f[ind_t] > 0\\n if ind_c:\\n f[ind_c] *= f[ind_c] < 0\\n\\n if beams:\\n S = _beam_shear(S, X, inds, indi, indf, EIx, EIy)\\n\\n q = f[:, newaxis] / l\\n qt = tile(q, (1, 3))\\n R = (P - S - Ct.dot(uvw * qt)) * B\\n res = mean(normrow(R))\\n\\n V += R / M\\n Un = sum(M * V**2)\\n if Un < Uo:\\n V *= 0\\n Uo = Un\\n\\n X += V\\n\\n if refresh:\\n if (ts % refresh == 0) or (res < tol):\\n print('Step:{0} Residual:{1:.3f}'.format(ts, res))\\n if callback:\\n callback(X, **kwargs)\\n\\n ts += 1\\n\\n return X, f, l\",\n \"def solver(u,f,n=50,m=100,t0=0,t1=1000,dt=.1,nu=1):\\n \\n u_new=[[u[i][j] for j in range(m)]for i in range(n)]\\n loopCounter=t0\\n while(loopCounter<=t1):\\n for i in xrange(1,n-1):\\n for j in xrange(1,m-1):\\n u_new[i][j]=u[i][j] + dt * (nu*u[i-1][j] + nu*u[i][j-1] - 4*nu*u[i][j] + nu*u[i][j+1] + nu*u[i+1][j] + f[i][j])\\n loopCounter+=dt\\n u=[[u_new[i][j] for j in range(m)]for i in range(n)]\\n\\n return u\",\n \"def solve(self, time_points):\\n self.t = np.asarray(time_points)\\n n = self.t.size\\n if self.neq == 1: # scalar ODEs\\n self.u = np.zeros(n)\\n else: # systems of ODEs\\n self.u = np.zeros((n, self.neq))\\n\\n # Assume self.t[0] corresponds to self.U0\\n self.u[0] = self.U0\\n\\n # Time loop\\n for k in range(n - 1):\\n self.k = k\\n self.u[k + 1] = self.advance()\\n return self.u, self.t\",\n \"def solve_step(self, bc_left=0):\\n status = 0\\n self.t += self.dt\\n\\n\\n ### Construct the RHS vector\\n # Implicit terms\\n #cff1 = 0. # Fully implicit\\n #cff2 = 0.\\n cff1 = 0.5*(1. - 2.*self.c_im)*self.dt\\n cff2 = 0.5*self.c_im*self.dt\\n RHS = cff1*self.L_rhs.dot(self.B) +\\\\\\n cff2*self.L_rhs.dot(self.B_n_m1)\\n\\n # Nonlinear (explicit) terms\\n cff3 = self.dt*(3 + self.b_ex)*0.5\\n cff4 = -self.dt*(1+2*self.b_ex)*0.5\\n cff5 = self.dt*(self.b_ex)*0.5\\n \\n RHS += cff3*self.calc_nonlinear_rhs(self.B)\\n RHS += cff4*self.calc_nonlinear_rhs(self.B_n_m1)\\n RHS += cff5*self.calc_nonlinear_rhs(self.B_n_m2)\\n\\n # Other terms from the time-derivative\\n RHS += self.B\\n\\n # Add the BCs to the RHS\\n cff0 = 0.5*(1 + self.c_im)*self.dt\\n self.add_bcs(RHS, bc_left, cff0, cff1, cff2)\\n\\n # Use the direct banded matrix solver (faster)\\n self.B_n_p1[:] = la.solve_banded( (self._j,self._j), self.L_lhs.data[::-1,:], RHS)\\n\\n # Check solutions\\n if np.any( np.isnan(self.B_n_p1)):\\n return -1\\n\\n # Update the terms last\\n self.B_n_m2[:] = self.B_n_m1\\n self.B_n_m1[:] = self.B\\n self.B[:] = self.B_n_p1\\n\\n ## Update the boundary terms in these equations\\n self.bcs[2] = self.bcs[1]\\n self.bcs[1] = self.bcs[0]\\n self.bcs[0] = bc_left\\n\\n return status\",\n \"def rhs(y, t, l, m, g):\\n # Unpack the states so you can use the variable names in the\\n # sympy.physics.mechanics equations\\n q1 = y[0]\\n q2 = y[1]\\n u1 = y[2]\\n u2 = y[3]\\n # or you can make use of python's tuple unpacking for a one liner\\n # q1, q2, u1, u2 = y\\n\\n # Initialize a vector for the derivatives.\\n dydt = zeros((len(y)))\\n\\n # Compute the derivatives, these are pasted in from the\\n # sympy.physics.mechanics results.\\n dydt[0] = u1\\n dydt[1] = u2\\n dydt[2] = (-g*sin(q1)*sin(q2)**2 + 2*g*sin(q1) -\\n g*sin(q2)*cos(q1)*cos(q2) + 2*l*u1**2*sin(q1)*cos(q1)*cos(q2)**2 -\\n l*u1**2*sin(q1)*cos(q1) - 2*l*u1**2*sin(q2)*cos(q1)**2*cos(q2) +\\n l*u1**2*sin(q2)*cos(q2) + l*u2**2*sin(q1)*cos(q2) -\\n l*u2**2*sin(q2)*cos(q1))/(l*(sin(q1)**2*sin(q2)**2 +\\n 2*sin(q1)*sin(q2)*cos(q1)*cos(q2) + cos(q1)**2*cos(q2)**2 - 2))\\n dydt[3] = (-sin(q1)*sin(q2)/2 - cos(q1)*cos(q2)/2)*(2*g*l*m*sin(q1) -\\n l**2*m*(-sin(q1)*cos(q2) +\\n sin(q2)*cos(q1))*u2**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2)) -\\n l**2*m) + (g*l*m*sin(q2) - l**2*m*(sin(q1)*cos(q2) -\\n sin(q2)*cos(q1))*u1**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2))\\n - l**2*m)\\n\\n # Return the derivatives.\\n return dydt\",\n \"def g_solving_subproblem_of_ALR(self,vehicle_id):\\r\\n global_LB = -10000\\r\\n global_UB = 10000\\r\\n iteration_for_RSP = 20\\r\\n optimal_solution_for_RSP = None\\r\\n self.multiplier_v = 0.5\\r\\n\\r\\n # solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\\r\\n\\r\\n # obtain the variance\\r\\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB = 0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\\r\\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\\r\\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance- y != 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB - global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\",\n \"def _gv_linear(self, r, t):\\n mv1t = torch.matmul(self.mv1.weight, t.T) # [k, b]\\n mv2r = torch.matmul(self.mv2.weight, r.T) # [k, b]\\n return (mv1t + mv2r + self.bv.weight).T # [b, k]\",\n \"def dlqr(A,B,Q,R):\\n #ref Bertsekas, p.151\\n \\n #first, try to solve the ricatti equation\\n X = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\\n \\n #compute the LQR gain\\n K = np.matrix(scipy.linalg.inv(B.T*X*B+R)*(B.T*X*A))\\n \\n eigVals, eigVecs = scipy.linalg.eig(A-B*K)\\n \\n return K, X, eigVals\",\n \"def T(self, q = np.zeros(1) , dq = np.zeros(1) , ddq = np.zeros(1) , R = 1 ): \\n \\n F = self.F( q , dq , ddq )\\n \\n Tl = self.Tlosses( dq , ddq )\\n \\n T = np.dot( 1. / R , F ) + np.dot( R , Tl ) \\n \\n return T\",\n \"def f(t, x, y):\\n Iq, UC, U = x # time continous state vector\\n dIq = (Uq(t) - R*Iq - UC - U) / L\\n dUC = Iq / C\\n dU = Iq / Cp\\n return array([dIq, dUC, dU])\",\n \"def dynamics(self,eta,nu,u_actual,u_control,sampleTime): \\n \\n # Current velocities\\n u_c = self.V_c * math.cos(self.beta_c - eta[5]) # current surge velocity\\n v_c = self.V_c * math.sin(self.beta_c - eta[5]) # current sway velocity \\n \\n nu_c = np.array([u_c,v_c,0,0,0,0],float) # current velocity vector\\n nu_r = nu - nu_c # relative velocity vector\\n \\n U_r = math.sqrt( nu_r[0]**2 + nu_r[1]**2 ) # relative speed\\n \\n # Rudder command and actual rudder angle\\n delta_c = u_control[0]\\n delta = u_actual[0]\\n \\n # Rudder forces and moment (Fossen 2021, Chapter 9.5.1)\\n b = 0.7 * self.T # rudder height\\n AR = b**2 / self.Lambda # aspect ratio: Lamdba = b**2/AR \\n CN = 6.13 * self.Lambda / ( self.Lambda + 2.25 ) # normal coefficient\\n t_R = 1 - 0.28 * self.Cb - 0.55\\n a_H = 0.4\\n x_R = -0.45 * self.L\\n x_H = -1.0 * self.L\\n\\n Xdd = -0.5 * ( 1 - t_R ) * self.rho * U_r**2 * AR * CN\\n Yd = -0.25 * ( 1 + a_H ) * self.rho * U_r**2 * AR * CN \\n Nd = -0.25 * ( x_R + a_H * x_H ) * self.rho * U_r**2 * AR * CN \\n \\n # Control forces and moment\\n delta_R = -delta # physical rudder angle (rad)\\n T = self.tau_X # thrust (N)\\n t_deduction = 0.1 # thrust deduction number\\n tau1 = ( 1 - t_deduction ) * T - Xdd * math.sin( delta_R )**2 \\n tau2 = -Yd * math.sin( 2 * delta_R ) \\n tau6 = -Nd * math.sin( 2 * delta_R ) \\n tau = np.array( [ tau1, tau2, tau6 ],float) \\n \\n # Linear maneuvering model\\n T_surge = self.L # approx. time constant in surge (s)\\n xg = 0 # approx. x-coordinate, CG (m) \\n \\n # 3-DOF ship model\\n [M,N] = clarke83(U_r,self.L, self.B, self.T,self.Cb,self.R66,xg,T_surge)\\n Minv = np.linalg.inv(M)\\n nu3 = np.array( [ nu_r[0], nu_r[1], nu_r[5] ]) \\n nu3_dot = np.matmul( Minv, tau - np.matmul(N,nu3) ) \\n \\n # 6-DOF ship model\\n nu_dot = np.array( [ nu3_dot[0],nu3_dot[1],0,0,0,nu3_dot[2] ]) \\n\\n # Rudder angle saturation\\n if ( abs(delta) >= self.deltaMax * math.pi / 180 ):\\n delta = np.sign(delta) * self.deltaMax * math.pi / 180\\n \\n # Rudder dynamics\\n delta_dot = (delta_c - delta) / self.T_delta \\n\\n # Forward Euler integration [k+1]\\n nu = nu + sampleTime * nu_dot\\n delta = delta + sampleTime * delta_dot\\n\\n u_actual = np.array([delta],float) \\n\\n return nu, u_actual\",\n \"def __call__(self, p, q, verbosity=1, warn=True):\\n if self.exactly_zero: return 0.0 # shortcut for trivial case\\n if self.weight == 0:\\n return _np.sum(_np.abs(q - p)) / 2\\n\\n #Set parameter values\\n self.P.value[:] = p[:]\\n self.Q.value[:] = q[:]\\n\\n treg_factor_ok = False\\n self.Treg_factor.value = self.initial_treg_factor\\n while not treg_factor_ok:\\n\\n obj1 = self._obj(self.t_params)\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1),\\n **default_cvxpy_args(self.solver))\\n\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed: # sanity check\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(_np.abs(self.T.value) - t_chk) < 1e-6)\\n\\n self.warning_msg = None\\n if failed:\\n if self.solver == \\\"SCS\\\":\\n #raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n for eps in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:\\n if REBUILD:\\n self._rebuild_problem()\\n else:\\n self._build_problem()\\n self.prob.solve(solver=remove_kicked(self.solver), verbose=(verbosity > 1), eps=eps)\\n failed = self.T.value is None # or self.resid_tvd.value is None\\n\\n if not failed:\\n t_chk = self.build_transfer_mx(self.T_params.value)\\n assert(_np.linalg.norm(self.T.value - t_chk) < 1e-6)\\n\\n if eps > 1e-4:\\n self.warning_msg = (\\\"ResidualTVD: Needed to increase eps to %g.\\\"\\n \\\" The resulting ResidualTVD values are less precise.\\\") % eps\\n if warn: print(self.warning_msg)\\n break\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n else:\\n raise ValueError(\\\"ResidualTVD: Convex optimizer failure\\\")\\n\\n #check that Treg_factor term doesn't dominate\\n\\n # Update: just leave this alone, since norm-penalty doesn't get reported - TODO later\\n treg_factor_ok = True\\n\\n # ------------------------------------------------------------------\\n #EXPERIMENTAL algorithms for updating Treg_factor ------------------\\n # ------------------------------------------------------------------\\n\\n #resid_tvd = self._obj(self.T_params.value)\\n #if resid_tvd > 10 * self.Treg_factor.value * _np.linalg.norm(self.T_params.value, 1):\\n # Treg_factor_ok = True\\n #else:\\n # self.Treg_factor.value = resid_tvd / 10 # self.Treg_factor.value / 10\\n\\n #obj2 = self._obj(self.T_params.value)\\n #if obj2 < obj1:\\n # Treg_factor_ok = True\\n #else:\\n # #maybe penalty term dominated - reduce norm(tparams) penalty term\\n # self.T_params.value[:] = self.t_params[:] #REVERT\\n # self.T.value[:, :] = _np.sum([self.t_params[ind] * self.t_basis[ind]\\n # for ind in range(self.dim)], axis=0) + _np.eye(self.n) # REVERT\\n # self.Treg_factor.value = self.Treg_factor.value / 10\\n # if self.Treg_factor.value > 1e-7:\\n # print(\\\"REDUCING treg factor to: \\\", self.Treg_factor.value)\\n # else:\\n # Treg_factor_ok = True # give up!\\n\\n if self.Treg_factor.value != self.initial_treg_factor:\\n if verbosity > 0: print(\\\"NOTE: Treg_factor was reduced to %g.\\\" % self.Treg_factor.value)\\n #_warnings.warn((\\\"Initial Treg_factor (%g) was too large, and was reduced to %g.\\\"\\n # \\\" Consider reducing the initial value to avoid repeating calculations.\\\")\\n # % (self.initial_treg_factor, self.Treg_factor.value))\\n\\n obj2 = self._obj(self.T_params.value)\\n if obj2 <= obj1:\\n self.t_params[:] = self.T_params.value[:]\\n else:\\n print_revert_msg(\\\"ResidualTVD failed to reduce objective function (%g > %g)\\\", (obj2, obj1), verbosity)\\n self.T_params.value[:] = self.t_params[:]\\n self.T.value[:, :] = self.build_transfer_mx(self.t_params)\\n\\n return self._obj(self.t_params) # not self.obj.value b/c that has additional norm regularization\",\n \"def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\\n coef2, R, b1, b2, sigmas, concomitant=False,\\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\\n max_iter_ot=20, max_iter_cd=2000,\\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\\n ot_threshold=0):\\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\\n 'stable': stable, \\\"objcd\\\": [], \\\"fot1\\\": [0.], \\\"fot2\\\": [0.],\\n 'reweighting_loss': [], \\\"n_coords\\\": [], \\\"obj\\\": 0.}\\n n_samples, n_features = Xf[0].shape\\n n_tasks = len(Xf)\\n if n_jobs == -1:\\n n_jobs = n_tasks\\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\\n\\n theta1 = coef1.copy()\\n theta2 = coef2.copy()\\n theta = theta1 - theta2\\n\\n thetaold = theta.copy()\\n\\n ot_img = True\\n if len(M) == n_features:\\n ot_img = False\\n\\n update_ot_1 = set_ot_func(stable, ot_img)\\n update_ot_2 = set_ot_func(stable, ot_img)\\n\\n xp = utils.set_module(gpu)\\n M = xp.asarray(- M / epsilon)\\n if b1 is not None:\\n b1 = xp.asarray(b1)\\n if b2 is not None:\\n b2 = xp.asarray(b2)\\n\\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 *= 0.\\n theta = theta1\\n a = n_samples * alpha * gamma\\n beta1 = n_samples * beta1\\n beta2 = n_samples * beta2\\n\\n if concomitant:\\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\\n else:\\n sigma0 = 0.\\n with Parallel(n_jobs=n_jobs, backend=\\\"threading\\\") as pll:\\n if alpha == 0.:\\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\\n Ls, marginals1,\\n sigmas, a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd,\\n positive=positive)\\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\\n theta1, theta2 = utils.get_unsigned(theta)\\n log['loss'].append(obj)\\n else:\\n for i in range(max_iter):\\n obj = 0.\\n if not positive:\\n Y1 = utils.residual(Xf, - theta2, y)\\n else:\\n Y1 = y\\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\\n Ls,\\n marginals1,\\n sigmas,\\n a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n if not positive:\\n Y2 = utils.residual(Xf, theta1, y)\\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\\n R,\\n Ls,\\n marginals2,\\n sigmas,\\n a, beta2,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n theta = theta1 - theta2\\n else:\\n theta = theta1\\n\\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\\n theta.max())\\n dx = dx.max()\\n thetaold = theta.copy()\\n if alpha:\\n if (theta1 > ot_threshold).any(0).all():\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma,\\n b=b1, tol=tol_ot,\\n max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n if fot1 is None or not theta1.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b1 = xp.log(b1 + 1e-100, out=b1)\\n stable = True\\n update_ot_1 = set_ot_func(True, ot_img)\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\\n tol=tol_ot, max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n\\n log[\\\"log_sinkhorn1\\\"].append(log_ot1)\\n thetabar1 = q1\\n log[\\\"fot1\\\"].append(fot1)\\n obj += alpha * fot1\\n if not positive and (theta2 > ot_threshold).any(0).all():\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\\n\\n if fot2 is None or not theta2.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b2 = xp.log(b2 + 1e-100, out=b2)\\n stable = True\\n update_ot_2 = set_ot_func(True, ot_img)\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot,\\n max_iter=max_iter_ot)\\n\\n log[\\\"log_sinkhorn2\\\"].append(log_ot2)\\n thetabar2 = q2\\n log[\\\"fot2\\\"].append(fot2)\\n obj += alpha * fot2\\n\\n log['loss'].append(obj)\\n log['dloss'].append(dx)\\n\\n if dx < tol:\\n break\\n if i == max_iter - 1:\\n warnings.warn('Objective did not converge.' +\\n ' You might want' +\\n ' to increase the number of iterations.' +\\n ' Fitting data with very small alpha and' +\\n ' beta may cause precision problems.',\\n ConvergenceWarning)\\n log['stable'] = stable\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 = xp.zeros_like(thetabar1)\\n try:\\n thetabar2 = thetabar2.get()\\n except AttributeError:\\n pass\\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)\",\n \"def KRC(self, ik, ipd, ipl, t):\\n idx = ik - 1\\n\\n den1 = 1 - self.delta[idx] * self.coca.PK(ik, t)\\n num1 = self.delta[idx] * self.thetak[idx]\\n ins = num1 / den1\\n\\n for l in np.arange(0, self.L):\\n pl = self.coca.PL(l, t)\\n ins += ((self.thetal[l] * self.gamma[l][idx]) / (1 - pl))\\n\\n ans = ipd * np.exp(t * ipl) * ins\\n\\n return ans\",\n \"def optimize_analytical_model(self, initial_state, previous_state, Q, R, target, time_horizon=10, time_step=1 / 60,\\n verbose=False, env=None):\\n assert len(initial_state) == self.state_len\\n # Create variables\\n m = env.lander.mass\\n J = env.lander.inertia\\n\\n x = opt.Variable(self.state_len, time_horizon + 2, name='x')\\n # mass = opt.Variable(time_horizon + 1, name='mass')\\n u = opt.Variable(self.action_len, time_horizon, name='actions')\\n\\n # Loop through the entire time_horizon and append costs\\n cost_function = []\\n # @TODO: Change to Matrix Form\\n for t in range(time_horizon):\\n _cost = opt.quad_form(target[:, t + 1] - x[:, t + 2], Q) + opt.quad_form(u[:, t], R)\\n\\n A = [(u[0, t] * (x[4, t] + u[2, t]) + u[1, t]) * (time_step ** 2) / m + 2 * x[0, t + 1] - x[0, t],\\n (u[0, t] - u[1, t] * x[4, t] - m * GRAVITY) * time_step ** 2 / m + 2 * x[1, t + 1] - x[1, t],\\n (x[0, t + 1] - x[0, t]) / time_step,\\n (x[1, t + 1] - x[1, t]) / time_step,\\n (-u[0, t] * u[2, t] * (L1 + LN) + L2 * u[1, t]) * time_step ** 2 / J + 2 * x[4, t + 1] - x[4, t],\\n (x[4, t + 1] - x[4, t]) / time_step]\\n # Dynamics\\n dynamic_constraints = [x[i, t + 2] == expr for i, expr in enumerate(A)]\\n limit_constraints = [\\n # mass[t + 1] == mass[t] - 0.007, #* opt.exp(\\n # -u[0, t] * MAIN_ENGINE_FUEL_COST - u[1, t] * SIDE_ENGINE_FUEL_COST),\\n # --------------------------------------------------------------------------------\\n # Actions\\n u[0, t] >= MAIN_ENGINE_POWER / 6, u[0, t] <= MAIN_ENGINE_POWER,\\n u[1, t] >= -SIDE_ENGINE_POWER, u[1, t] <= SIDE_ENGINE_POWER,\\n u[2, t] >= -self.angle_limit, u[2, t] <= self.angle_limit]\\n\\n _constraints = np.append(dynamic_constraints, limit_constraints)\\n cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=list(limit_constraints)))\\n\\n # Add final cost\\n problem = sum(cost_function)\\n problem.constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 10.01,\\n x[:, 0] == previous_state,\\n x[:, 1] == initial_state]\\n\\n # Minimize Problem\\n problem.solve(verbose=verbose, solver=opt.SCS)\\n # u[0, :].value.A.flatten()\\n return x[:, 2:], u\",\n \"def calc_refl(velocity, shotloc_x, shotloc_z, layer_idxs):\\n solver_dg = pykonal.EikonalSolver(coord_sys=\\\"cartesian\\\")\\n solver_dg.vv.min_coords = velocity.min_coords\\n solver_dg.vv.node_intervals = velocity.node_intervals\\n solver_dg.vv.npts = velocity.npts\\n solver_dg.vv.values = velocity.values\\n\\n #shotloc = 2.56 # km\\n src_idx = (int((shotloc_x - velocity.min_coords[0])/velocity.node_intervals[0]), int(shotloc_z/velocity.node_intervals[1]), 0)\\n solver_dg.tt.values[src_idx] = 0\\n solver_dg.unknown[src_idx] = False\\n solver_dg.trial.push(*src_idx)\\n solver_dg.solve()\\n\\n solver_ug = pykonal.EikonalSolver(coord_sys=\\\"cartesian\\\")\\n solver_ug.vv.min_coords = solver_dg.vv.min_coords\\n solver_ug.vv.node_intervals = solver_dg.vv.node_intervals\\n solver_ug.vv.npts = solver_dg.vv.npts\\n solver_ug.vv.values = solver_dg.vv.values\\n\\n for ix in range(solver_ug.tt.npts[0]):\\n #idx = (ix, solver_ug.tt.npts[1]-1, 0)\\n idx = (ix, layer_idxs[ix], 0)\\n solver_ug.tt.values[idx] = solver_dg.tt.values[idx]\\n #print(idx, solver_dg.tt.values[idx])\\n solver_ug.unknown[idx] = False\\n solver_ug.trial.push(*idx)\\n solver_ug.solve()\\n \\n return solver_ug.tt.values[:,0,0]\",\n \"def quasi_optimalityTV(f, lam_init = 2.0, q = 0.9):\\n \\n lam = lam_init\\n max_iter = 50\\n error = np.zeros(max_iter)\\n #alt_error = np.zeros(max_iter)\\n u_old = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n for i in range(1, max_iter):\\n lam = lam_init * (q ** i)\\n u_new = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n error[i] = np.linalg.norm(u_old - u_new)\\n #alt_error[i] = np.linalg.norm(u_old - u_new) /abs(lam_init*(q ** i - q ** (i-1)))\\n u_old = np.copy(u_new)\\n\\n #plt.plot(error)\\n #plt.plot(alt_error)\\n #plt.show()\\n opt_idx = np.argmin(error[error != 0.0])\\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\\n lam = lam_init * (q ** opt_idx)\\n u= ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n \\n return u, t\",\n \"def calc_control_and_trajectory(x, dw, goal, ob):\\n x_init = np.array(x)\\n\\n best_u = [0.0, 0.0]\\n best_trajectory = None\\n\\n u_samples = []\\n traj_samples = []\\n cost_samples = []\\n # evaluate all trajectory with sampled input in dynamic window\\n for v in np.arange(dw[0], dw[1], Config.v_resolution):\\n for y in np.arange(dw[2], dw[3], Config.yaw_rate_resolution):\\n\\n trajectory = predict_trajectory(x_init, v, y)\\n # calc cost\\n to_goal_cost = calc_to_goal_cost(trajectory, goal)\\n speed_cost = (Config.max_speed - trajectory[-1, 3])\\n ob_cost = calc_obstacle_cost(trajectory, ob)\\n\\n cost_samples.append([to_goal_cost,speed_cost,ob_cost])\\n u_samples.append([v, y])\\n traj_samples.append(trajectory)\\n cost_samples = np.array(cost_samples)\\n # normalization\\n def normalize_0_1(x):\\n if np.max(x)-np.min(x)>1e-4:\\n return (x-np.min(x))/(np.max(x)-np.min(x))\\n else:\\n return np.zeros_like(x)\\n\\n def normalize_div_sum(x):\\n if np.sum(x) > 1e-4:\\n return x/np.sum(x)\\n else:\\n return np.zeros_like(x)\\n\\n # for i in range(3):\\n # non_inf = cost_samples[:,i] != np.inf\\n # if np.sum(non_inf) >0:\\n # cost_samples[non_inf,i] = normalize_0_1(cost_samples[non_inf,i])\\n \\n cost_samples = Config.to_goal_cost_gain*cost_samples[:,0]+Config.speed_cost_gain*cost_samples[:,1]+Config.obstacle_cost_gain*cost_samples[:,2]\\n ind = np.argmin(cost_samples)\\n best_u = u_samples[ind]\\n best_trajectory = traj_samples[ind]\\n\\n if abs(best_u[0]) < Config.robot_stuck_flag_cons \\\\\\n and abs(x[3]) < Config.robot_stuck_flag_cons:\\n # to ensure the robot do not get stuck in\\n # [v,w] = [0,0], force the robot rotate\\n best_u[1] = -Config.max_delta_yaw_rate\\n return best_u, best_trajectory\",\n \"def dopri853core(\\n n, func, x, t, hmax, h, rtol, atol, nmax, safe, beta, fac1, fac2, pos_neg, args\\n):\\n # array to store the result\\n result = numpy.zeros((len(t), n))\\n\\n # initial preparations\\n facold = 1.0e-4\\n expo1 = 1.0 / 8.0 - beta * 0.2\\n facc1 = 1.0 / fac1\\n facc2 = 1.0 / fac2\\n\\n k1 = numpy.array(func(x, t[0], *args))\\n hmax = numpy.fabs(hmax)\\n iord = 8\\n\\n if h == 0.0: # estimate initial time step\\n h, k1, k2, k3 = hinit(func, x, t, pos_neg, k1, iord, hmax, rtol, atol, args)\\n\\n reject = 0\\n t_current = t[\\n 0\\n ] # store current integration time internally (not the current time wanted by user!!)\\n t_old = t[0]\\n finished_user_t_ii = 0 # times indices wanted by user\\n\\n result[0, :] = x\\n\\n # basic integration step\\n while (\\n finished_user_t_ii < len(t) - 1\\n ): # check if the current computed time indices less than total inices needed\\n # keep time step not too small\\n h = pos_neg * numpy.max([numpy.fabs(h), 1e3 * uround])\\n\\n # the twelve stages\\n xx1 = x + h * a21 * k1\\n k2 = numpy.array(func(xx1, t_current + c2 * h, *args))\\n\\n xx1 = x + h * (a31 * k1 + a32 * k2)\\n k3 = numpy.array(func(xx1, t_current + c3 * h, *args))\\n\\n xx1 = x + h * (a41 * k1 + a43 * k3)\\n k4 = numpy.array(func(xx1, t_current + c4 * h, *args))\\n\\n xx1 = x + h * (a51 * k1 + a53 * k3 + a54 * k4)\\n k5 = numpy.array(func(xx1, t_current + c5 * h, *args))\\n\\n xx1 = x + h * (a61 * k1 + a64 * k4 + a65 * k5)\\n k6 = numpy.array(func(xx1, t_current + c6 * h, *args))\\n\\n xx1 = x + h * (a71 * k1 + a74 * k4 + a75 * k5 + a76 * k6)\\n k7 = numpy.array(func(xx1, t_current + c7 * h, *args))\\n\\n xx1 = x + h * (a81 * k1 + a84 * k4 + a85 * k5 + a86 * k6 + a87 * k7)\\n k8 = numpy.array(func(xx1, t_current + c8 * h, *args))\\n\\n xx1 = x + h * (a91 * k1 + a94 * k4 + a95 * k5 + a96 * k6 + a97 * k7 + a98 * k8)\\n k9 = numpy.array(func(xx1, t_current + c9 * h, *args))\\n\\n xx1 = x + h * (\\n a101 * k1\\n + a104 * k4\\n + a105 * k5\\n + a106 * k6\\n + a107 * k7\\n + a108 * k8\\n + a109 * k9\\n )\\n k10 = numpy.array(func(xx1, t_current + c10 * h, *args))\\n\\n xx1 = x + h * (\\n a111 * k1\\n + a114 * k4\\n + a115 * k5\\n + a116 * k6\\n + a117 * k7\\n + a118 * k8\\n + a119 * k9\\n + a1110 * k10\\n )\\n k2 = numpy.array(func(xx1, t_current + c11 * h, *args))\\n\\n xx1 = x + h * (\\n a121 * k1\\n + a124 * k4\\n + a125 * k5\\n + a126 * k6\\n + a127 * k7\\n + a128 * k8\\n + a129 * k9\\n + a1210 * k10\\n + a1211 * k2\\n )\\n\\n t_old_older = numpy.copy(t_old)\\n t_old = numpy.copy(t_current)\\n t_current += h\\n\\n k3 = numpy.array(func(xx1, t_current, *args))\\n\\n k4 = (\\n b1 * k1\\n + b6 * k6\\n + b7 * k7\\n + b8 * k8\\n + b9 * k9\\n + b10 * k10\\n + b11 * k2\\n + b12 * k3\\n )\\n k5 = x + h * k4\\n\\n # error estimation\\n sk = atol + rtol * numpy.max([numpy.fabs(x), numpy.fabs(k5)], axis=0)\\n erri = k4 - bhh1 * k1 - bhh2 * k9 - bhh3 * k3\\n err2 = numpy.sum(numpy.square(erri / sk), axis=0)\\n erri = (\\n er1 * k1\\n + er6 * k6\\n + er7 * k7\\n + er8 * k8\\n + er9 * k9\\n + er10 * k10\\n + er11 * k2\\n + er12 * k3\\n )\\n err = numpy.sum(numpy.square(erri / sk), axis=0)\\n\\n deno = err + 0.01 * err2\\n deno = 1.0 if deno <= 0.0 else deno\\n err = numpy.fabs(h) * err * numpy.sqrt(1.0 / (deno * n))\\n\\n # computation of hnew\\n fac11 = numpy.power(err, expo1)\\n\\n # Lund-stabilization\\n fac = fac11 / pow(facold, beta)\\n\\n # we require fac1 <= hnew / h <= fac2\\n fac = numpy.max([facc2, numpy.min([facc1, fac / safe])])\\n hnew = h / fac\\n\\n if err <= 1.0:\\n # step accepted\\n facold = numpy.max([err, 1.0e-4])\\n k4 = numpy.array(func(k5, t_current, *args))\\n\\n # final preparation for dense output\\n rcont1 = numpy.copy(x)\\n xdiff = k5 - x\\n rcont2 = xdiff\\n bspl = h * k1 - xdiff\\n rcont3 = numpy.copy(bspl)\\n rcont4 = xdiff - h * k4 - bspl\\n rcont5 = (\\n d41 * k1\\n + d46 * k6\\n + d47 * k7\\n + d48 * k8\\n + d49 * k9\\n + d410 * k10\\n + d411 * k2\\n + d412 * k3\\n )\\n rcont6 = (\\n d51 * k1\\n + d56 * k6\\n + d57 * k7\\n + d58 * k8\\n + d59 * k9\\n + d510 * k10\\n + d511 * k2\\n + d512 * k3\\n )\\n rcont7 = (\\n d61 * k1\\n + d66 * k6\\n + d67 * k7\\n + d68 * k8\\n + d69 * k9\\n + d610 * k10\\n + d611 * k2\\n + d612 * k3\\n )\\n rcont8 = (\\n d71 * k1\\n + d76 * k6\\n + d77 * k7\\n + d78 * k8\\n + d79 * k9\\n + d710 * k10\\n + d711 * k2\\n + d712 * k3\\n )\\n\\n # the next three function evaluations\\n xx1 = x + h * (\\n a141 * k1\\n + a147 * k7\\n + a148 * k8\\n + a149 * k9\\n + a1410 * k10\\n + a1411 * k2\\n + a1412 * k3\\n + a1413 * k4\\n )\\n k10 = numpy.array(func(xx1, t_old + c14 * h, *args))\\n xx1 = x + h * (\\n a151 * k1\\n + a156 * k6\\n + a157 * k7\\n + a158 * k8\\n + a1511 * k2\\n + a1512 * k3\\n + a1513 * k4\\n + a1514 * k10\\n )\\n k2 = numpy.array(func(xx1, t_old + c15 * h, *args))\\n xx1 = x + h * (\\n a161 * k1\\n + a166 * k6\\n + a167 * k7\\n + a168 * k8\\n + a169 * k9\\n + a1613 * k4\\n + a1614 * k10\\n + a1615 * k2\\n )\\n k3 = numpy.array(func(xx1, t_old + c16 * h, *args))\\n\\n # final preparation\\n rcont5 = h * (rcont5 + d413 * k4 + d414 * k10 + d415 * k2 + d416 * k3)\\n rcont6 = h * (rcont6 + d513 * k4 + d514 * k10 + d515 * k2 + d516 * k3)\\n rcont7 = h * (rcont7 + d613 * k4 + d614 * k10 + d615 * k2 + d616 * k3)\\n rcont8 = h * (rcont8 + d713 * k4 + d714 * k10 + d715 * k2 + d716 * k3)\\n\\n k1 = numpy.copy(k4)\\n x = numpy.copy(k5)\\n\\n # loop for dense output in this time slot\\n while (finished_user_t_ii < len(t) - 1) and (\\n pos_neg * t[finished_user_t_ii + 1] < pos_neg * t_current\\n ):\\n result[finished_user_t_ii + 1, :] = dense_output(\\n t[finished_user_t_ii + 1],\\n t_old,\\n h,\\n [rcont1, rcont2, rcont3, rcont4, rcont5, rcont6, rcont7, rcont8],\\n )\\n finished_user_t_ii += 1\\n\\n if numpy.fabs(hnew) > hmax:\\n hnew = pos_neg * hmax\\n if reject:\\n hnew = pos_neg * numpy.min([numpy.fabs(hnew), numpy.fabs(h)])\\n\\n reject = 0\\n else:\\n # step rejected since error too big\\n hnew = h / numpy.min([facc1, fac11 / safe])\\n reject = 1\\n\\n # reverse time increment since error rejected\\n t_current = numpy.copy(t_old)\\n t_old = numpy.copy(t_old_older)\\n\\n h = numpy.copy(hnew) # current h\\n\\n return result\",\n \"def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \\n bc_surface, sigma):\\n\\n # temperatures are reported as a data frame, where each column is a step in time\\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\\n\\n # extract the necessary parameters to determine the surface heat losses\\n if bc_surface[0] == \\\"linear\\\":\\n h = bc_surface[1] + bc_surface[2]\\n hc = 0\\n emissivity = 0\\n elif bc_surface[0] == \\\"non-linear\\\":\\n h = 0\\n hc = bc_surface[1]\\n emissivity = bc_surface[2]\\n\\n # initialize temperature arrays for present and future temperatures\\n T = np.zeros_like(x_grid) + temp_initial\\n Tn = np.zeros_like(x_grid)\\n\\n # iterate over each time step\\n temperatures.iloc[:,0] = T\\n for j, t in enumerate(t_grid[:-1]):\\n \\n # create tri-diagonal matrix A\\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\\n \\n # create vector b\\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \\n emissivity = emissivity, sigma = sigma, j = j)\\n \\n # calculate value of future temperature\\n Tn = np.linalg.solve(A,b)\\n \\n # update present temperature\\n T = Tn.copy()\\n \\n # store temperature profile at this time in the data frame\\n temperatures.iloc[:, j+1] = Tn\\n \\n return temperatures\",\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def get_lqr_feedback(self, x_0=None, u_0=None):\\n q = self.wx_feedback\\n r = self.wu_feedback\\n\\n if x_0 is None:\\n x_0 = np.zeros((self.n_s, 1))\\n if u_0 is None:\\n u_0 = np.zeros((self.n_u, 1))\\n\\n if self.lin_prior:\\n a = self.a\\n b = self.b\\n\\n k_lqr, _, _ = dlqr(a, b, q, r)\\n k_fb = -k_lqr\\n else:\\n\\n raise NotImplementedError(\\n \\\"Cannot compute feed-back matrices without prior model\\\")\\n\\n return k_fb.reshape((1, self.n_s * self.n_u))\",\n \"def L_curveTV(f,lam_init = 2.0, q = 0.9):\\n lam = lam_init\\n max_iter = 50\\n residual_list = np.zeros(max_iter)\\n size_list = np.zeros(max_iter)\\n error = np.zeros(max_iter)\\n alt_error = np.zeros(max_iter)\\n \\n for i in range(max_iter): #range(max_iter):\\n u = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc=True, tol = 1.0e-5)\\n #u, _, j = projected_gradient_alt(f,lam, tau = 0.2, tol = 1.0e-4)\\n lam = lam_init * (q ** i)\\n residual_list[i] = np.linalg.norm(u - f)\\n size_list[i] = np.linalg.norm(u)\\n error[i] = np.linalg.norm(u - f) * np.linalg.norm(u)\\n #plt.loglog(residual_list,size_list)\\n #plt.show()\\n opt_idx = np.argmin(error)\\n t = 1.0 / (1.0 + lam_init * (q ** opt_idx))\\n lam = lam_init * (q ** opt_idx)\\n u = ChambollePock_denoise(f,lam, tau = 0.5, sig = 0.25, acc = True, tol = 1.0e-5)\\n return u, t\",\n \"def LinealizeCarModel(xb, u, dt, lr):\\n\\n x = xb[0]\\n y = xb[1]\\n v = xb[2]\\n theta = xb[3]\\n\\n a = u[0]\\n beta = u[1]\\n\\n t1 = -dt * v * sin(theta + beta)\\n t2 = dt * v * cos(theta + beta)\\n\\n A = np.eye(xb.shape[0])\\n A[0, 2] = dt * cos(theta + beta)\\n A[1, 2] = dt * sin(theta + beta)\\n A[3, 2] = dt * sin(beta) / lr\\n A[0, 3] = t1\\n A[1, 3] = t2\\n\\n B = np.zeros((xb.shape[0], u.shape[0]))\\n B[2, 0] = dt\\n B[0, 1] = t1\\n B[1, 1] = t2\\n B[3, 1] = dt * v * cos(beta) / lr\\n\\n tm = np.zeros((4, 1))\\n tm[0, 0] = v * cos(theta + beta) * dt\\n tm[1, 0] = v * sin(theta + beta) * dt\\n tm[2, 0] = a * dt\\n tm[3, 0] = v / lr * sin(beta) * dt\\n C = xb + tm\\n C = C - A * xb - B * u\\n\\n return A, B, C\",\n \"def Langmuir_Knudsen_mdot(D, T_p, Psat, Re, mu_g, cp_g, lambda_g, P_g, R_g, Sc_g, R_v, Yinf):\\n Pr_g = mu_g * cp_g / lambda_g # Gas Prandtl Number\\n Sh = 2.0 + 0.552 * math.sqrt(Re) * Sc_g ** (1.0/3.0) \\n Re_b = 0.0 #Blowing Reynolds number \\n Re_b0 = Re_b \\n Xseq = min(Psat / P_g, 1.0) #Molar mass fraction\\n theta2 = R_v / R_g ;\\n Yseq = min(Xseq /max(Xseq + (1.0 - Xseq) * theta2, 1e-30), 1.0) \\n yMin = min(Yseq, Yinf) \\n yMax = max(Yseq, Yinf) \\n\\n # Iterate to converge on Re_b\\n # This part could be optimized\\n Lk = computeLK(T_p,R_v,mu_g,Sc_g,P_g) \\n Re_b0 = estimate_re_b(yMin, yMax, Yinf, Sh, Sc_g)\\n \\n max_solver_iterations = 100\\n for i in range(max_solver_iterations): \\n Ysneq = computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b) \\n #Bound Ysneq so that it lies between Yseq and Yinf\\n Ysneq = max(yMin, min(yMax, Ysneq)) \\n BMneq = (Ysneq - Yinf) / max(1.0 - Ysneq, 1e-30) \\n Hm = math.log(max(1.0 + BMneq, 1e-40)) \\n Re_b0 = Re_b \\n Re_b = Hm * Sh / Sc_g \\n factor = min(0.8, 0.5 * D / Lk) #Damping factor\\n\\n if i >= max_solver_iterations:\\n print('Mdot Calculation failed to converge')\\n\\n if abs(Re_b - Re_b0) < 1.0e-6:\\n break \\n\\n #Relax update to help convergence\\n Re_b = factor * Re_b + (1.0 - factor) * Re_b0 \\n \\n #Chris debug\\n beta = 0.5 * Pr_g * Re_b ;\\n if i > -1: \\n format_string = 'i= {0:<4d} Re_b= {1:<8.4f} Ysneq= {2:<8.4f} Hm= {3:<8.4f} ' \\\\\\n 'BMneq= {4:<8.4f} Lk= {5:<8.4e} Lk/D= {6:<8.4e} factor= {7:<8.4e} beta= {8:<8.4f}'\\n print(format_string.format(i, Re_b, computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b), Hm, BMneq, Lk, Lk/D, factor, beta))\\n \\n # Back out mdot from blowing reunolds number\\n mdot = -Re_b * D * mu_g * math.pi \\n return mdot\",\n \"def forward(self):\\n R = self.LP.cost.R\\n A = self.LP.dyn.A\\n B = self.LP.dyn.B\\n\\n x = self.LP.x0\\n self.x[0] = x\\n for i in range(self.LP.N):\\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\\\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\\n if self.LP.dyn.u_dim == 1:\\n self.u[i] = float(u)\\n else:\\n self.u[i] = u\\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\\n\\n if i == 0:\\n self.J[i] = self.LP.cost.loss(x, u, i)\\n else:\\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\\n x = self.LP.dyn.next_state(x, u)\\n self.x[i+1] = x\\n\\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\\n\\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\\\\n + self.W[self.LP.N].T.dot(x)) #up to constant\",\n \"def solve_lsqr(self, b, rho=None, v=None, x_init=None, options=None):\\n\\n # Add additional linear terms for the rho terms\\n sizev = 0\\n if rho is not None:\\n vf = v.flatten() * np.sqrt(rho / 2.0)\\n sizeb = self.K.input_size\\n sizev = np.prod(v.shape)\\n b = np.hstack((b, vf))\\n\\n input_data = np.zeros(self.K.input_size)\\n output_data = np.zeros(self.K.output_size + sizev)\\n\\n def matvec(x, output_data):\\n if rho is None:\\n # Traverse compgraph\\n self.K.forward(x, output_data)\\n else:\\n # Compgraph and additional terms\\n self.K.forward(x, output_data[0:0 + sizeb])\\n np.copyto(output_data[sizeb:sizeb + sizev],\\n x * np.sqrt(rho / 2.0))\\n\\n return output_data\\n\\n def rmatvec(y, input_data):\\n if rho is None:\\n self.K.adjoint(y, input_data)\\n else:\\n self.K.adjoint(y[0:0 + sizeb], input_data)\\n input_data += y[sizeb:sizeb + sizev] * np.sqrt(rho / 2.0)\\n\\n return input_data\\n\\n # Define linear operator\\n def matvecComp(x):\\n return matvec(x, output_data)\\n\\n def rmatvecComp(y):\\n return rmatvec(y, input_data)\\n\\n K = LinearOperator((self.K.output_size + sizev, self.K.input_size),\\n matvecComp, rmatvecComp)\\n\\n # Options\\n if options is None:\\n # Default options\\n return lsqr(K, b)[0]\\n else:\\n if not isinstance(options, lsqr_options):\\n raise Exception(\\\"Invalid LSQR options.\\\")\\n return lsqr(K,\\n b,\\n atol=options.atol,\\n btol=options.btol,\\n show=options.show,\\n iter_lim=options.iter_lim)[0]\",\n \"def RHSnet(y,t,a,b0,b1,g,k,w):\\n S = y[:N]\\n E = y[N:2*N]\\n C = y[2*N:3*N]\\n b = b0 + b1*(1+np.cos(2*np.pi*t))\\n dy = np.zeros(3*N)\\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\\n return dy\",\n \"def solve(self):\\n \\n # Definition of the parameters\\n Q_pc = self.parameters.getParam(\\\"Q_pc\\\")\\n V_c = self.parameters.getParam(\\\"V_c\\\")\\n V_p = self.parameters.getParam(\\\"V_p\\\")\\n CL = self.parameters.getParam(\\\"CL\\\")\\n initial_conditions = [\\n self.parameters.getParam(\\\"q_c0\\\"),\\n self.parameters.getParam(\\\"q_p0\\\"),\\n ]\\n t_eval = np.linspace(0, self.timespan, self.nsteps)\\n\\n # Definition of the model ODEs\\n def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\\n \\\"\\\"\\\"Defines the differential equations for the PK IV model.\\n\\n Parameters:\\n :param t: time (h)\\n :param y: list of the state variables of the ODEs system, in the\\n form [q_c, q_p]\\n :param Q_pc: transition rate between central and peripheral\\n compartments (mL/h)\\n :param V_c: volume of central compartment (mL)\\n :param V_p: volume of peripheral compartment (mL)\\n :param CL: clearance/elimination rate from the central\\n compartment (mL/h)\\n\\n The parameters (except for t and y) are extracted from the\\n Parameter class, using getParam method.\\n\\n Returns list containing the differential equations, in the form:\\n [dqc_dt, dqp_dt]\\n \\\"\\\"\\\"\\n q_c, q_p = y\\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\\n dqp_dt = transfer\\n return [dqc_dt, dqp_dt]\\n\\n # Solving the model\\n sol = scipy.integrate.solve_ivp(\\n fun=lambda t, y: pk_iv_model(t, y, Q_pc, V_c, V_p, CL),\\n t_span=[t_eval[0], t_eval[-1]],\\n y0=initial_conditions,\\n t_eval=t_eval,\\n )\\n\\n # Feeding the solution line by line to solution class\\n t = sol.t\\n y = sol.y\\n N = t.shape[0]\\n columnNames = [\\\"t\\\", \\\"dose\\\", \\\"q_c\\\", \\\"q_p\\\"]\\n self.solution.begin(columnNames, N)\\n for i in range(N):\\n arr = np.zeros((len(columnNames), 1))\\n arr[0] = t[i]\\n arr[1] = self.dosefunction(t[i])\\n arr[2:, 0] = y[:, i]\\n self.solution.report(arr)\",\n \"def build_system(u, dt, dx, D=4, C=1, time_diff='FD', space_diff='FD', width_x=None,\\n width_t=None, deg_x=5, deg_t=None):\\n\\n n, m = u.shape\\n\\n if width_x == None: width_x = n / 10\\n if width_t == None: width_t = m / 10\\n if deg_t == None: deg_t = deg_x\\n\\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\\n if time_diff == 'poly':\\n m2 = m - 2 * width_t\\n offset_t = width_t\\n else:\\n m2 = m\\n offset_t = 0\\n if space_diff == 'poly':\\n n2 = n - 2 * width_x\\n offset_x = width_x\\n else:\\n n2 = n\\n offset_x = 0\\n\\n ########################\\n # First take the time derivaitve for the left hand side of the equation\\n ########################\\n ut = np.zeros((n2, m2), dtype=np.complex64)\\n\\n if time_diff == 'poly':\\n T = np.linspace(0, (m - 1) * dt, m)\\n for i in range(n2):\\n ut[i, :] = PolyDiff(u[i + offset_x, :], T, diff=1, width=width_t, deg=deg_t)[:, 0]\\n\\n else:\\n for i in range(n2):\\n ut[i, :] = FiniteDiff(u[i + offset_x, :], dt, 1)\\n\\n ut = np.reshape(ut, (n2 * m2, 1), order='F')\\n\\n ########################\\n # Now form the rhs one column at a time, and record what each one is\\n ########################\\n\\n u2 = u[offset_x:n - offset_x, offset_t:m - offset_t]\\n Theta = np.zeros((n2 * m2, (D + 1) * C), dtype=np.complex64)\\n ux = np.zeros((n2, m2), dtype=np.complex64)\\n rhs_description = ['' for i in range((D + 1) * C)]\\n\\n if space_diff == 'poly':\\n Du = {}\\n for i in range(m2):\\n Du[i] = PolyDiff(u[:, i + offset_t], np.linspace(0, (n - 1) * dx, n), diff=D, width=width_x, deg=deg_x)\\n if space_diff == 'Fourier': ik = 1j * np.fft.fftfreq(n) * n\\n\\n for d in range(D + 1):\\n # compute derivatives of d degree\\n if d > 0:\\n for i in range(m2):\\n if space_diff == 'FD':\\n ux[:, i] = FiniteDiff(u[:, i + offset_t], dx, d)\\n elif space_diff == 'poly':\\n ux[:, i] = Du[i][:, d - 1]\\n else:\\n ux = np.array(u2, dtype=np.complex64)\\n # if d == 1: print(ux)\\n\\n # compute polynomials of all terms, c used as c+1\\n for c in range(C):\\n Theta[:, d * C + c] = np.reshape(np.power(ux, c+1), (n2 * m2), order='F')\\n # print('d:{}, c:{}, mean:{}'.format(d, c, np.mean(Theta[:, d * C + c])))\\n\\n if d > 0:\\n rhs_description[d * C + c] = rhs_description[d * C + c] + \\\\\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\\n else:\\n rhs_description[d * C + c] = rhs_description[d * C + c] + 'u'\\n\\n if c > 0:\\n rhs_description[d * C + c] = rhs_description[d * C + c] + '^' + str(c+1)\\n\\n # print(rhs_description)\\n features, rhs = create_cross_features(Theta, rhs_description)\\n features = np.concatenate((Theta, features), 1)\\n rhs = np.concatenate((rhs_description, rhs), 0)\\n\\n return ut, features, rhs\",\n \"def _q_x(self):\\n lambda_r = self.latt_par['lambda_r'].value \\n return 2*np.pi*self.k/lambda_r\",\n \"def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\\n \\n # INPUTS FROM TTTW SYSTEM\\n self.b = b #buoyancy field: [Ly,N]\\n self.u = u # x-component of velocity [Ly,N]\\n self.v = v # y-component of velocity [Ly+1,N]\\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \\n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\\n self.grid_dict = grid_dict #gridded data\\n self.f = f #coriolis parameter\\n # KPP-SPECIFIC VARIABLES \\n self.hbls = np.zeros([self.b.shape[0]])\\n self.hbbl = np.zeros([self.b.shape[0]])\\n self.ustar = []\\n self.bvf = [] \\n self.kmo = []\\n self.C_h_MO = []\\n self.kbl = []\\n self.Cr = [] \\n self.Fc = []\\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\\n self.dt = dt\",\n \"def _gcl(x, r, D, Ia, Ct):\\n\\n Area = np.pi * D ** 2.0 / 4.0\\n m = 1.0 / (np.sqrt(1.0 - Ct))\\n k = np.sqrt((m + 1.0) / 2.0)\\n\\n a1 = 0.435449861 # empirically determined\\n a2 = 0.797853685\\n a3 = -0.124807893\\n a4 = 0.136821858\\n b1 = 15.6298\\n b2 = 1.0\\n R96 = a1 * (np.exp(a2 * Ct * Ct + a3 * Ct + a4)) * (b1 * Ia + b2) * D\\n\\n x0 = (9.6 * D) / ((2.0 * R96 / (k * D)) ** 3.0 - 1.0)\\n term1 = (k * D / 2.0) ** (5.0 / 2.0)\\n term2 = (105.0 / (2.0 * np.pi)) ** (-0.5)\\n term3 = (Ct * Area * x0) ** (-5.0 / 6.0)\\n c1 = term1 * term2 * term3\\n # c45=3*(c1) ** 2\\n\\n term10 = 0.1111 # * WindSpeed # U/9.0\\n term20 = (Ct * Area * (x + x0) ** (-2.0)) ** (1.0 / 3.0)\\n term310 = (r ** (3.0 / 2.0))\\n term320 = (3.0 * c1 * c1 * Ct * Area * (x + x0)) ** (-0.5)\\n term30 = term310 * term320\\n term40 = ((35.0 / (2.0 * np.pi)) ** (3.0 / 10.0)) * \\\\\\n (3.0 * c1 * c1) ** (-1.0 / 5.0)\\n DU1 = -term10 * term20 * (term30 - term40) ** 2.0\\n\\n DU = DU1 # + w2 * DU2\\n Rw = ((105 * c1 ** 2.0 / (2 * np.pi)) ** (1. / 5.)) * \\\\\\n (Ct * Area * (x + x0)) ** (1. / 3.)\\n return DU, Rw\",\n \"def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\\n auto_param_obj_history = []\\n auto_param_relaxed_obj_history = []\\n \\n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\\n eta = np.array([eta_0/len(H)]*len(H))*0.9\\n eta_lin = np.ones(L_lhs.shape[0])*0.01\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Feasibility')\\n count = 0\\n num_violated = -1\\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n count += 1\\n num_violated_prev = np.copy(num_violated)\\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\\n \\n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n # eta_lin *= eta_step\\n \\n if num_violated == num_violated_prev:\\n print('Increase enforcement')\\n if num_violated_lin > 0:\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n #eta_lin *= eta_step\\n if num_violated_oar > 0:\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n # eta_0 *= eta_step*2\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Optimality')\\n count = 0\\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\\n count += 1\\n print('Opt Iter', count)\\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\\n u_prev = np.copy(u)\\n eta_0 *= eta_step_tumor\\n print('Current eta_0:', eta_0)\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n \\n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\\n print('No improvement, increase enforcement')\\n eta_step_tumor *= 0.1\\n eta_0 *= eta_step_tumor\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # break\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\\n \\n print('Finding the correct solution:')\\n u = u_prev\\n eta_0 = eta_0/eta_step_tumor\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\\n print(\\\"OBJJJJJ:\\\", obj_u_opt_N_fixed(u, T, alpha, B))\\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history\",\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 path(self, t=10, u=None, x0=None):\\n if x0 is None:\\n x0 = np.zeros(3)\\n\\n def dynamics(t, x, vehicle, u):\\n # u = vehicle.control(demand, x)\\n \\n return vehicle.deriv(x, u)\\n\\n if base.isscalar(t):\\n t_span = (0, t)\\n t_eval = np.linspace(0, t, 100)\\n elif isinstance(t, np.ndarray):\\n t_span = (t[0], t[-1])\\n t_eval = t\\n else:\\n raise ValueError('bad time argument')\\n sol = integrate.solve_ivp(dynamics, t_span, x0, t_eval=t_eval, method=\\\"RK45\\\", args=(self, u))\\n\\n return (sol.t, sol.y.T)\",\n \"def run(self):\\n self.errList = []\\n self.initialize()\\n\\n for i in range(self.maxiter):\\n # update U\\n for k in range(self.K):\\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\\n full_matrices=False)\\n self.U[k] = q.T.dot(p.T)\\n self.U[k] = self.U[k].real\\n\\n # calculate temporal variable y\\n y = np.zeros([self.rank, self.L, self.K])\\n for k in range(self.K):\\n y[:, :, k] = self.U[k].T.dot(self.X[k])\\n\\n # get H, V, and temps by running a single iteration of CP_ALS\\n if i == 0:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1, printitn=0)\\n else:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1,\\n init=[self.H, self.V, temps], printitn=0)\\n self.H = cp.Us[0]\\n self.V = cp.Us[1]\\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\\n\\n # update S\\n for k in range(self.K):\\n self.S[:, :, k] = np.diag(temps[k, :])\\n\\n # checking the stop criteria\\n # error = 0\\n for k in range(self.K):\\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\\n\\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\\n self.errList.append(error)\\n if (i + 1) % self.printitn == 0:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n elif error < self.tol:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n\\n if error < self.tol:\\n break\\n else:\\n self.sigma_old = self.sigma_new\\n self.sigma_new = 0\\n\\n for k in range(self.K):\\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\",\n \"def ft_ll(m, t, y, x, x_kernel, x_kernel_params, t_kernel, t_kernel_params):\\n # Take copies of everything - this is a function\\n m = copy.deepcopy(m)\\n t = copy.deepcopy(t)\\n y = copy.deepcopy(y)\\n x = copy.deepcopy(x)\\n\\n K_x = x_kernel(x, x, **x_kernel_params)\\n N = len(y)\\n\\n lambd = np.zeros((N, 1))\\n gamma = np.zeros((N, 1))\\n\\n K_t = [None] * N\\n\\n for n in range(N):\\n K_t[n] = t_kernel(t[n], t[n], **t_kernel_params)\\n lambd[n] = np.dot(np.ones((1, len(t[n]))), np.linalg.solve(K_t[n], np.ones((len(t[n]), 1))))\\n # Making sure y[n] is a column vector\\n y[n] = np.array(y[n], ndmin=2)\\n if y[n].shape[0] == 1:\\n y[n] = y[n].T\\n gamma[n] = np.dot(np.ones((1, len(t[n]))), np.linalg.solve(K_t[n], y[n] - m[n] * np.ones(y[n].shape)))\\n\\n Lambd = np.diag(lambd.ravel())\\n\\n ll = 0\\n\\n # Terms relating to individual curves\\n for n in range(N):\\n ll += - 0.5 * np.dot((y[n] - m[n] * np.ones(y[n].shape)).T,\\n np.linalg.solve(K_t[n], y[n] - m[n] * np.ones(y[n].shape)))\\n ll += - 0.5 * np.log(np.linalg.det(K_t[n]))\\n\\n # Terms relating to K_x\\n ll += + 0.5 * np.dot(gamma.T, np.linalg.solve(np.linalg.inv(K_x) + Lambd, gamma))\\n ll += - 0.5 * np.log(np.linalg.det(np.linalg.inv(K_x) + Lambd))\\n ll += - 0.5 * np.log(np.linalg.det(K_x))\\n\\n return ll\",\n \"def f_model(self, X_f=None):\\n # M*D2q + k = q + B*u\\n # y = [q1; q2; dq1_dt; dq2_dt]\\n\\n if X_f is None:\\n t = self.t\\n x0 = self.x0\\n u = self.u\\n else:\\n t = self.tensor(X_f[:, 0:1])\\n x0 = self.tensor(X_f[:, 1:5])\\n u = self.tensor(X_f[:, 5:7])\\n\\n i_PR90 = tf.ones(len(t), dtype=tf.float64) * 161\\n\\n with tf.GradientTape(persistent=True) as tape:\\n tape.watch(t)\\n y_pred = self.model(tf.concat([t, x0, u], axis=1))\\n\\n q1 = y_pred[:, 0:1]\\n q2 = y_pred[:, 1:2]\\n dq1_dt = y_pred[:, 2:3]\\n dq2_dt = y_pred[:, 3:4]\\n dq_dt = tf.stack([dq1_dt, dq2_dt], axis=1)\\n\\n dq1_dt_tf = tape.gradient(q1, t)[:, 0]\\n dq2_dt_tf = tape.gradient(q2, t)[:, 0]\\n dq_dt_tf = tf.stack([dq1_dt_tf, dq2_dt_tf], axis=1)\\n\\n d2q1_dt_tf = tape.gradient(dq1_dt, t)[:, 0]\\n d2q2_dt_tf = tape.gradient(dq2_dt, t)[:, 0]\\n d2q_dt_tf = tf.stack([d2q1_dt_tf, d2q2_dt_tf], axis=1)\\n\\n M_tf = M_tensor(q2[:, 0], i_PR90)\\n k_tf = k_tensor(dq1_dt_tf, q2[:, 0], dq2_dt_tf)\\n q_tf = q_tensor(q1[:, 0], dq1_dt_tf, q2[:, 0], dq2_dt_tf)\\n B_tf = B_tensor(i_PR90)\\n\\n f_pred = tf.concat([dq_dt_tf - dq_dt[:, :, 0],\\n tf.linalg.matvec(M_tf, d2q_dt_tf) + k_tf - q_tf - tf.linalg.matvec(B_tf, u)], axis=1)\\n\\n return f_pred\",\n \"def PDE_RHS_FKPP(t,y,q,x,description=None):\\n \\n \\n D_mat = create_Uxx_mat(x)\\n\\n return (q[0]*D_mat.dot(y) + \\n q[1]*y*(1-y))\",\n \"def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\\n\\n # def Q_gen(I, R):\\n # w = I * I * R\\n # return w\\n\\n # def Q_rad_in(I_sun, A_s, a_s):\\n # w = I_sun * D * a_s\\n # return w\\n\\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\\n # w = htcoeff * A_s * (T_line - T_amb)\\n # return w\\n\\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\\n # return w\\n\\n def reynolds(V, D, v, Mair=1.103):\\n r = V * D / v\\n return r\\n\\n def nusselt(Re, Pr):\\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\\n c = (Re / 282000) ** (5.0/8.0)\\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\\n return n\\n\\n def air_prop(T_amb):\\n # temp v k Pr\\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\\n [250, 11.44e-6, 22.3e-3, 0.720],\\n [300, 15.89e-6, 26.3e-3, 0.707],\\n [350, 20.92e-6, 30.0e-3, 0.700],\\n [400, 26.41e-6, 33.8e-3, 0.690],\\n [450, 32.39e-6, 37.3e-3, 0.686],\\n [500, 38.79e-6, 40.7e-3, 0.684],\\n [550, 45.57e-6, 43.9e-3, 0.683],\\n [600, 52.69e-6, 46.9e-3, 0.685]])\\n\\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\\n 0, air_prop[:,1:])\\n return v, k, Pr\\n\\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\\n if 273 <= T_line <= 323:\\n R = ((R_lo + \\n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\\n *(T_line - T_range[0]))/N_cond)\\n elif T_line > 323:\\n R = ((R_mid + \\n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\\n *(T_line - T_range[1]))/N_cond)\\n else:\\n R = R_lo\\n print('Out of bounds')\\n return R\\n\\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\\n temp_factor = 1\\n wind_factor = 1\\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\\n\\n T_amb = T_amb*temp_factor\\n V = V*wind_factor\\n\\n v, k, Pr = air_prop(T_amb)\\n Re = reynolds(V, D, v)\\n htcoeff = nusselt(Re, Pr) * k / D\\n\\n def T_line(T_init):\\n \\n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\\n print R\\n\\n C4 = e_s * sigma * D * math.pi\\n C3 = 0.0\\n C2 = 0.0\\n C1 = htcoeff * D * math.pi\\n C0 = - ( I ** 2 * R\\n + I_sun * a_s * D\\n + htcoeff * D * math.pi * T_amb\\n + e_s * D * math.pi * sigma * (T_amb ** 4))\\n\\n return np.roots([C4, C3, C2, C1, C0])\\n\\n T_c = T_amb\\n \\n for i in range(n_iter):\\n T_arr = T_line(T_c)\\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\\n print T_c\\n\\n return T_c\",\n \"def dynstall_mhh_dxdt_simple(t, x, U, U_dot, omega, alpha_34, p):\\n # States\\n x1=x[0] # Downwash memory term 1\\n x2=x[1] # Downwash memory term 2\\n x3=x[2] # Clp', Lift coefficient with a time lag to the attached lift coeff\\n x4=x[3] # f'' , Final separation point function\\n # Parameters\\n alpha0 = p['alpha0']\\n Cla = p['Cla']\\n c = p['chord']\\n A1 = p['A1']\\n A2 = p['A2']\\n b1 = p['b1']\\n b2 = p['b2']\\n F_st = p['F_st']\\n # Variables derived from inputs\\n U = max(U, 0.01)\\n Tu = max(c/(2*U), 1e-4) # Eq. 23\\n Tf = p['Tf0']*Tu # OLD was twice: Tf = p['Tf0']*c/U\\n Tp = p['Tp0']*Tu # OLD was twice: Tp = p['Tp0']*c/U\\n # Variables derived from states\\n if p['alpha0_in_x1x2']:\\n alphaE = alpha_34*(1-A1-A2)+ x1 + x2 # Eq. 12\\n else:\\n alphaE = (alpha_34-alpha0)*(1-A1-A2)+ x1 + x2 + alpha0 # Eq. 12\\n\\n# alphaE = u['alphaE'](t) # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< HACK HACK TODO TODO TODO TODO TODO\\n\\n Clp = Cla * (alphaE-alpha0) + np.pi * Tu * omega # Eq. 13\\n alphaF = x3/Cla+alpha0 # p. 13\\n fs_aF = F_st(alphaF) # p. 13\\n if(fs_aF<0):\\n print('Problematic fs:',fs_aF)\\n x4 = np.clip(x4, 1e-16, 1.0) # Constraining x4 between 0 and 1 increases numerical stability\\n # State equation\\n xdot = [0]*4\\n if p['alpha0_in_x1x2']:\\n xdot[0] = -1/Tu * (b1 + c * U_dot/(2*U**2)) * x1 + b1 * A1 / Tu * alpha_34\\n xdot[1] = -1/Tu * (b2 + c * U_dot/(2*U**2)) * x2 + b2 * A2 / Tu * alpha_34\\n else:\\n xdot[0] = -1/Tu * (b1 + c * U_dot/(2*U**2)) * x1 + b1 * A1 / Tu * (alpha_34-alpha0)\\n xdot[1] = -1/Tu * (b2 + c * U_dot/(2*U**2)) * x2 + b2 * A2 / Tu * (alpha_34-alpha0)\\n xdot[2] = -1/Tp * x3 + 1/Tp * Clp\\n xdot[3] = -1/Tf * x4 + 1/Tf * fs_aF\\n return xdot\",\n \"def test_solver():\\n # Choice of nonlinear coefficient\\n m = 2\\n\\n def q(u):\\n return (1+u)**m\\n\\n def Dq(u):\\n return m*(1+u)**(m-1)\\n\\n u_exact = Expression(\\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\\n linear_solver = 'direct'\\n errors = []\\n for method in 'alg_Newton', 'pde_Newton':\\n for J_comp in 'manual', 'automatic':\\n for degree in 1, 2, 3:\\n error_prev = -1\\n for divisions in [(10, 10), (20, 20), (40, 40)]:\\n u = solver(\\n q, Dq, f, divisions, degree,\\n method, J_comp,\\n linear_solver,\\n abs_tol_Krylov=1E-10,\\n rel_tol_Krylov=1E-10,\\n abs_tol_Newton=1E-10,\\n rel_tol_Newton=1E-10)\\n\\n # Find max error\\n u_e = interpolate(u_exact, u.function_space())\\n import numpy as np\\n error = np.abs(u_e.vector().array() -\\n u.vector().array()).max()\\n # Expect convergence as h**(degree+1)\\n if error_prev > 0:\\n frac = abs(error - error_prev/2**(degree+1))\\n errors.append(frac)\\n error_prev = error\\n tol = 4E-5\\n for error_reduction in errors:\\n assert error_reduction < tol, error_reduction\",\n \"def run_main(sst, ft_qv, use_NT):\\n\\n dtout=10. #minutes\\n end_time=8*24. #hours\\n del_time=dtout*60. #seconds\\n end_time=end_time*3600. #seconds\\n #sst=297\\n D=5.e-6 #s-1\\n U=7 #m/s\\n psfc=100. #kPa\\n qsfc=tf.qs_tp(sst,psfc)\\n ft_intercept = 292 #K\\n ft_gamma = 6.e-3 #K/m\\n #ft_qv = 2.e-3\\n k=0.2 #entrainment efficiency\\n Cd = 1.e-3 #drag coefficient\\n tspan = np.arange(0.,end_time,del_time)\\n vars_init=[285.,400.,8.e-3] #theta (K), height (m) qv (kg/kg) to start\\n the_tup=dict(D=D,U=U,sst=sst,ft_intercept=ft_intercept,ft_gamma=ft_gamma,\\n qsfc=qsfc,ft_qv=ft_qv,k=k,Cd=Cd,radcool=30.,use_NT=use_NT) # include use_NT\\n the_tup=make_tuple(the_tup,'coeffs')\\n output=integrate.odeint(dmixed_vars, vars_init, tspan,(the_tup,))\\n result=pd.DataFrame.from_records(output,columns=['theta','h','qv'])\\n\\n # save time/computation by only doing calculations for the last timestep (equilibrium)\\n result['time']=tspan[-1]/3600./24. #days\\n result['deltheta'] = theta_ft(result['h'].values[-1],ft_intercept,ft_gamma) - result['theta'].iloc[-1]\\n result['delqv'] = ft_qv - result['qv'].iloc[-1]\\n result['LCL'] = calc_lcl(result.iloc[-1], psfc)\\n result['q_flux_0']=calc_sfc_qvap_flux(result.iloc[-1],the_tup)\\n result['T_flux_0']=calc_sfc_theta_flux(result.iloc[-1],the_tup)\\n result['entflux_theta']=calc_entflux_theta(result.iloc[-1],the_tup)\\n \\n # decide how to calculate entrainment\\n the_vars = [result['theta'].iloc[-1],result['h'].iloc[-1],result['qv'].iloc[-1]]\\n if use_NT:\\n result['went']=calc_went_NT(the_vars, the_tup, result['deltheta'].iloc[-1], \\n result['T_flux_0'].iloc[-1], result['q_flux_0'].iloc[-1])\\n else:\\n result['went']=calc_went(result.iloc[-1],the_tup)\\n\\n result['entflux_qv']=calc_entflux_qv(result.iloc[-1],the_tup)\\n\\n with open('dumpmodel.csv','w') as f:\\n result.to_csv(f,index=False)\\n \\n return None\",\n \"def reconstruct_solution(spikes,sol,uval,twin,ics,tau,variable,**kwargs):\\n\\n # Model parameters\\n pars = {'dt' : 1e-3}\\n pars = gu.varargin(pars,**kwargs)\\n\\n # Generate time vector\\n time = np.arange(twin[0],twin[-1],pars['dt'])\\n time = np.sort(np.r_[time,spikes])\\n # Generate spike vector\\n tspk = np.copy(time)\\n for i in range(1,len(spikes)):\\n tspk[np.where(np.logical_and(time>=spikes[i-1],time<spikes[i]))[0]] = spikes[i-1]\\n tspk[np.where(time >= spikes[len(spikes)-1])[0]] = spikes[len(spikes)-1]\\n tspk[np.where(time < spikes[0])[0]] = 0\\n # Generate general solution vector\\n vsol = np.ones(time.size)\\n if (variable=='x') and isscalar(uval):\\n uval = uval * np.ones(sol.size)\\n if variable=='x':\\n for i in range(1, len(spikes)):\\n # x must be given at x(t_i^+) according to xsol\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]*(1-uval[i-1])\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]*(1-uval[len(spikes)-1])\\n else:\\n for i in range(1, len(spikes)):\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]\\n vsol[np.where(time < spikes[0])[0]] = ics\\n # Compute effective solution\\n solution = np.zeros((2, time.size))\\n solution[0] = time\\n\\n if variable=='x':\\n # Assumes that the first ICs is x(0)\\n solution[1] = xsol(vsol,time-tspk,tau)\\n else:\\n solution[1] = usol(vsol,time-tspk,tau)\\n\\n return solution\",\n \"def leastsquares(A,b,qr=qrfact.qri_mgs_piv,alpha=0.5):\\n \\n\\n A = numpy.array(A, dtype=float)\\n m,n = A.shape\\n z = numpy.zeros( n )\\n a = numpy.zeros( n )\\n x = numpy.zeros( n )\\n b = numpy.transpose(b)[0]\\n\\n # do the QR factorization\\n try:\\n Q,R = qr(A)[:2] # Some QR routines return a third permutation P solving AP=QR.\\n PA = A\\n except TypeError:\\n Q,R,P = qr(A,alpha)[:3] # Some QR routines return a third permutation P solving AP=QR.\\n AP = numpy.dot( A, P )\\n\\n # Step 1'': orthogonalization of b against Q\\n u = b\\n for j in range( 0, n ) :\\n # print \\\"Qj = \\\", Q[:,j]\\n # print \\\"u = \\\", u\\n # print \\\"dot = \\\", numpy.dot( Q[:,j], u )\\n z[j] = numpy.dot( Q[:,j], u )\\n u = u - z[j] * Q[:,j]\\n\\n # Step 2'': iterative orthogonalization of u\\n ul2norm = numpy.linalg.norm( u )\\n ii = 0\\n while True : # iterate\\n for j in range( 0, n ) :\\n a[j] = numpy.dot( Q[:,j], u )\\n z[j] = z[j] + a[j]\\n u = u - a[j] * Q[:,j]\\n\\n ii = ii + 1\\n ulnorm = ul2norm\\n ul2norm = numpy.linalg.norm( u )\\n\\n #print ul2norm, ulnorm\\n \\n if (ul2norm > alpha * ulnorm) or ul2norm == 0 :\\n # print \\\"used\\\", ii, \\\"orthogonalizations\\\"\\n break\\n\\n #print z\\n #print R\\n\\n # Step 3'': use back substitution to solve Rx = z\\n for i in range( n-1, -1, -1 ) :\\n x[i] = z[i]\\n for j in range( i+1, n ) :\\n x[i] = x[i] - R[i,j] * x[j]\\n x[i] = x[i] / R[i,i]\\n #print x\\n\\n #need to permute x according to permutation matrix P\\n \\n return numpy.dot( P, x )\",\n \"def solveFluNet(T,Ntime,a,b0,b1,g,k,w,y0,P,N,RHS=3):\\n #I have added the variables P the transport matrix \\n #and N the network size because they are needed\\n #in the RHS.\\n #I have added the variable RHS to be able to \\n #choose which RHS method we want to use when running\\n #solveFluNet\\n \\n #add input variables to RHS functions if needed\\n def RHSnet(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\\"\\\"\\\"\\n S = y[:N]\\n E = y[N:2*N]\\n C = y[2*N:3*N]\\n b = b0 + b1*(1+np.cos(2*np.pi*t))\\n dy = np.zeros(3*N)\\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\\n return dy\\n \\n def RHSnetF(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\\"\\n Calculations carried out by fn.rhs\\n \\\"\\\"\\\"\\n dy = fn.rhs(P,y,t,a,b0,b1,g,k,w)\\n return dy\\n \\n def RHSnetFomp(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\n Calculations carried out by fn.rhs_omp\\n \\\"\\\"\\\"\\n dy = fn.rhs_omp(P,y,t,a,b0,b1,g,k,w,2)\\n return dy\\n\\n #Add code here and to RHS functions above to simulate network flu model\\n t = np.linspace(0,T,Ntime)\\n if (RHS==1):\\n sol = odeint(RHSnet,y0,t,args=(a,b0,b1,g,k,w))\\n if (RHS==2):\\n sol = odeint(RHSnetF,y0,t,args=(a,b0,b1,g,k,w))\\n if (RHS==3):\\n sol = odeint(RHSnetFomp,y0,t,args=(a,b0,b1,g,k,w))\\n S = sol[:,:N]\\n E = sol[:,N:2*N]\\n C = sol[:,2*N:3*N]\\n return t,S,E,C\",\n \"def MyGRRK3_step(f, t, qn, dt, r, e, w):\\r\\n assert((not np.any(np.isnan(t))) and np.all(np.isfinite(t)) and\\r\\n np.all(np.isreal(t))), \\\\\\r\\n \\\"t must be real, finite and not NaN\\\"\\r\\n assert((not np.any(np.isnan(dt))) and np.all(np.isfinite(dt)) and\\r\\n np.all(np.isreal(dt))), \\\\\\r\\n \\\"dt must be real, finite and not NaN\\\"\\r\\n assert(len(qn) == 2), \\\"qn must have length 2\\\"\\r\\n assert(hasattr(f, '__call__')), \\\\\\r\\n \\\"f must be a callable function\\\"\\r\\n assert((not np.any(np.isnan(r))) and np.all(np.isfinite(r)) and\\r\\n np.all(np.isreal(r))), \\\\\\r\\n \\\"r must be real, finite and not NaN\\\"\\r\\n assert((not np.any(np.isnan(e))) and np.all(np.isfinite(e)) and\\r\\n np.all(np.isreal(e))), \\\\\\r\\n \\\"e must be real, finite and not NaN\\\"\\r\\n assert((not np.any(np.isnan(w))) and np.all(np.isfinite(w)) and\\r\\n np.all(np.isreal(w))), \\\\\\r\\n \\\"w must be real, finite and not NaN\\\"\\r\\n\\r\\n def F(k0):\\r\\n \\\"\\\"\\\"\\r\\n Function defines the set of nonlinear equations describing k1 and k2\\r\\n of the third order explicit Runge-Kutta algorithm\\r\\n\\r\\n Parameters\\r\\n ----------\\r\\n\\r\\n k0 : vector\\r\\n intial guess for roots of the problem\\r\\n\\r\\n Returns\\r\\n -------\\r\\n\\r\\n f3 : vector\\r\\n set of nonlinear equations of k1 and k2\\r\\n \\\"\\\"\\\"\\r\\n assert((not np.any(np.isnan(k0))) and np.all(np.isfinite(k0)) and\\r\\n np.all(np.isreal(k0))),\\\\\\r\\n \\\"k0 must be real, finite and not NaN\\\"\\r\\n assert(len(k0) == 4), \\\"K must have length 4\\\"\\r\\n assert(hasattr(F, '__call__')), \\\\\\r\\n \\\"F must be a callable function\\\"\\r\\n k1 = np.array([k0[0], k0[1]])\\r\\n k2 = np.array([k0[2], k0[3]])\\r\\n f1 = k1 - np.array([f(t + dt / 3,\\r\\n qn + (dt / 12) * (5 * k1 - k2), r, e, w)])\\r\\n f2 = k2 - np.array([f(t + dt,\\r\\n qn + (dt / 4) * (3 * k1 + k2), r, e, w)])\\r\\n f3 = np.reshape(np.array([f1, f2]), (4,))\\r\\n return f3\\r\\n\\r\\n k0 = np.reshape(np.array([f(t + dt / 3, qn, r, e, w),\\r\\n f(t + dt, qn, r, e, w)]), (4,))\\r\\n k = fsolve(F, k0)\\r\\n k1 = np.array([k[0], k[1]])\\r\\n k2 = np.array([k[2], k[3]])\\r\\n qnpG1 = qn + (dt / 4) * (3 * k1 + k2)\\r\\n return qnpG1\",\n \"def solver(\\n kappa, f, u_D, Nx, Ny, degree=1,\\n linear_solver='Krylov', # Alternative: 'direct'\\n abs_tol=1E-5, # Absolute tolerance in Krylov solver\\n rel_tol=1E-3, # Relative tolerance in Krylov solver\\n max_iter=1000, # Max no of iterations in Krylov solver\\n log_level=PROGRESS, # Amount of solver output\\n dump_parameters=False, # Write out parameter database?\\n ):\\n # Create mesh and define function space\\n mesh = UnitSquareMesh(Nx, Ny)\\n V = FunctionSpace(mesh, 'P', degree)\\n\\n def boundary(x, on_boundary):\\n return on_boundary\\n\\n bc = DirichletBC(V, u_D, boundary)\\n\\n # Define variational problem\\n u = TrialFunction(V)\\n v = TestFunction(V)\\n a = kappa*dot(grad(u), grad(v))*dx\\n L = f*v*dx\\n\\n # Compute solution\\n u = Function(V)\\n\\n if linear_solver == 'Krylov':\\n prm = parameters['krylov_solver'] # short form\\n prm['absolute_tolerance'] = abs_tol\\n prm['relative_tolerance'] = rel_tol\\n prm['maximum_iterations'] = max_iter\\n print(parameters['linear_algebra_backend'])\\n set_log_level(log_level)\\n if dump_parameters:\\n info(parameters, True)\\n solver_parameters = {'linear_solver': 'gmres',\\n 'preconditioner': 'ilu'}\\n else:\\n solver_parameters = {'linear_solver': 'lu'}\\n\\n solve(a == L, u, bc, solver_parameters=solver_parameters)\\n return u\",\n \"def Lq(self):\\n if not self.isVaild():\\n pass\\n temp = ((self.r()**self.C)*self.Rho()) / \\\\\\n (math.factorial(self.C)*((1 - self.Rho())**2))\\n return temp*self.P0()\",\n \"def ers(self, qL, qR, A, xt):\\n hL, hR, uL, uR, cL, cR = self.get_param(qL, qR)\\n fL = self.flux(qL)\\n fR = self.flux(qR)\\n # Find starting value for Newton-Rhapson iterative method\\n hS = self.start_exact(hL, hR, cL, cR, uL, uR)\\n h0 = hS\\n # Start iteration\\n for _ in range(self.n_iter):\\n fL, fld = self.geofun(hS, hL, cL)\\n fR, frd = self.geofun(hS, hR, cR)\\n hS = hS - (fL + fR + uR - uL)/(fld + frd)\\n if abs(hS - h0) / (0.5 * (hS + h0) ) <= self.tol: break\\n if hS < 0.: hS = self.tol\\n h0 = hS\\n # Check if converged or not\\n if _ == self.n_iter and abs(hS - h0) / (0.5 * (hS + h0) ) > self.tol:\\n raise 'Solution not converged, try to increase n_iter value'\\n else:\\n # Converged solution for depth hS in Star Region.\\n # Compute velocity uS in Star Region\\n uS = 0.5*(uL + uR) + 0.5*(fR - fL);\\n cS = math.sqrt(9.81*hS);\\n # Sample solution\\n h, u = self.samwet(hL, hR, hS, uL, uR, uS, cL, cR, cS, xt)\\n return h, h*u\",\n \"def u_t(self):\\n\\t\\tdim = self.dim \\n\\t\\ttim_all = self.tim_all\\n\\t\\t#ctrl = self.ctrl\\n\\t\\tH0 = self.H0\\n\\t\\tHctrl = self.Hctrl\\n\\n\\t\\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\\n\\t\\tu_all[0,:,:] = np.eye(dim)\\n\\n\\t\\tfor tim in xrange(tim_all):\\n\\t\\t\\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\\n\\t\\t\\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\\n\\n\\n\\t\\treturn u_all\",\n \"def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[ int(uD) ]\\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \\n \\n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\\n \\n dJ_a = self.jacobian_actuators_diff( q , dq )\\n \\n C = self.C( q , dq )\\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\\n \\n D = self.D( q , dq )\\n Da = np.dot( B , np.dot( self.Da , B.T ) )\\n \\n CD_all = C + D + Ca + Da\\n \\n G = self.G( q )\\n \\n # External forces\\n J_e = self.jacobian_endeffector( q )\\n f_e = self.F_ext( q , dq )\\n \\n # Disturbance force\\n f_d = self.F_dist( t )\\n \\n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\\n \\n return ddq\",\n \"def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[ int(uD) ]\\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \\n \\n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\\n \\n dJ_a = self.jacobian_actuators_diff( q , dq )\\n \\n C = self.C( q , dq )\\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\\n \\n D = self.D( q , dq )\\n Da = np.dot( B , np.dot( self.Da , B.T ) )\\n \\n CD_all = C + D + Ca + Da\\n \\n G = self.G( q )\\n \\n # External forces\\n J_e = self.jacobian_endeffector( q )\\n f_e = self.F_ext( q , dq )\\n \\n # Disturbance force\\n f_d = self.F_dist( t )\\n \\n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\\n \\n return ddq\",\n \"def sys(self, t, x, u):\\n xk = fft(x)\\n\\n # 4/3 truncation rule\\n # dealiasing due to triple nonlinearity\\n # note: you could do zero-padding to improve memory\\n # efficiency\\n xk[self.n_states // 4 : 3 * self.n_states // 4] = 0j\\n x = ifft(xk)\\n\\n yk = (-self.k**2 * xk.ravel() / 2) * 1j\\n y = ifft(yk) + 1j * abs(x) ** 2 * x + u\\n return y\",\n \"def quintic_polynomials_planner(sx, sy, syaw, sv, sa, gx, gy, gyaw, gv, ga,\\n max_accel, max_jerk, dt):\\n\\n vxs = sv * math.cos(syaw)\\n vys = sv * math.sin(syaw)\\n vxg = gv * math.cos(gyaw)\\n vyg = gv * math.sin(gyaw)\\n\\n axs = sa * math.cos(syaw)\\n ays = sa * math.sin(syaw)\\n axg = ga * math.cos(gyaw)\\n ayg = ga * math.sin(gyaw)\\n\\n time, rx, ry, ryaw, rv, ra, rj = [], [], [], [], [], [], []\\n\\n for T in np.arange(MIN_T, MAX_T, MIN_T):\\n xqp = QuinticPolynomial(sx, vxs, axs, gx, vxg, axg, T)\\n yqp = QuinticPolynomial(sy, vys, ays, gy, vyg, ayg, T)\\n\\n time, rx, ry, ryaw, rv, ra, rj = [], [], [], [], [], [], []\\n\\n for t in np.arange(0.0, T + dt, dt):\\n time.append(t)\\n rx.append(xqp.calc_point(t))\\n ry.append(yqp.calc_point(t))\\n\\n vx = xqp.calc_first_derivative(t)\\n vy = yqp.calc_first_derivative(t)\\n v = np.hypot(vx, vy)\\n yaw = math.atan2(vy, vx)\\n rv.append(v)\\n ryaw.append(yaw)\\n\\n ax = xqp.calc_second_derivative(t)\\n ay = yqp.calc_second_derivative(t)\\n a = np.hypot(ax, ay)\\n if len(rv) >= 2 and rv[-1] - rv[-2] < 0.0:\\n a *= -1\\n ra.append(a)\\n\\n jx = xqp.calc_third_derivative(t)\\n jy = yqp.calc_third_derivative(t)\\n j = np.hypot(jx, jy)\\n if len(ra) >= 2 and ra[-1] - ra[-2] < 0.0:\\n j *= -1\\n rj.append(j)\\n\\n if max([abs(i) for i in ra]) <= max_accel and \\\\\\n max([abs(i) for i in rj]) <= max_jerk:\\n print(\\\"find path!!\\\")\\n break\\n\\n return time, rx, ry, ryaw, rv, ra, rj\",\n \"def solve_rocket_equations():\\n # initial data\\n u0 = numpy.array([h0,v0,mp0])\\n t = [0.0] # The array of times\\n u = [u0] # The array of evolved solutions\\n # Evolve!\\n while u[-1][0] >= 0.0:\\n t.append(t[-1]+dt)\\n u.append(euler_step(u[-1],t[-1],rhs,dt))\\n return numpy.array(t),numpy.array(u)\",\n \"def pk_iv_model(t, y, Q_pc, V_c, V_p, CL):\\n q_c, q_p = y\\n transfer = Q_pc * (q_c / V_c - q_p / V_p)\\n dqc_dt = self.dosefunction(t) - q_c / V_c * CL - transfer\\n dqp_dt = transfer\\n return [dqc_dt, dqp_dt]\",\n \"def step(self, u=None, dt=None):\\n\\n dt = dt if dt is not None else self.dt\\n u = u if u is not None else np.zeros(self.n_dofs)\\n\\n qdd = np.linalg.inv(self.M) @ (u - self.C - self.B @ self.qd).T\\n self.qd += np.array(qdd).flatten() * dt\\n self.q += self.qd * dt\\n self.t += dt\",\n \"def __call__(self, u, t):\\n S, I, R = u\\n return [-self.beta(t)*S*I, self.beta(t)*S*I - self.nu(t)*I, self.nu(t)*I]\",\n \"def a(self, x, t0):\\n dummy = 0.0 * t0\\n x_1 = x[0]\\n x_2 = x[1]\\n x_3 = x[2]\\n x_4 = x[3]\\n x_5 = x[4]\\n x_6 = x[5]\\n x_7 = x[6]\\n # Load parameters.\\n e_1_tilde = self.e_1_tilde\\n e_2_tilde = self.e_2_tilde\\n r = self.rr\\n z_1 = self.z_1\\n z_1_tilde = self.z_1_tilde\\n z_2_tilde = self.z_2_tilde\\n alpha_1 = self.alpha_1\\n alpha_2 = self.alpha_2\\n alpha_2_tilde = self.alpha_2_tilde\\n alpha_11_tilde = self.alpha_11_tilde\\n alpha_12_tilde = self.alpha_12_tilde\\n mu_H_tilde = self.mu_H_tilde\\n mu_1_tilde = self.mu_1_tilde\\n mu_2_tilde = self.mu_2_tilde\\n sigma_H = self.sigma_H\\n sigma_1_tilde = self.sigma_1_tilde\\n sigma_2_tilde = self.sigma_2_tilde\\n sigma_11 = self.sigma_11\\n sigma_12 = self.sigma_12\\n #\\n # Right hand side of model.\\n #\\n f_1 = z_1 * alpha_1 * x_3 * (1.0 - x_1) - mu_H_tilde * x_1\\n f_2 = (1.0 - x_2) * (\\n x_3 * (z_1_tilde * alpha_11_tilde + z_2_tilde * alpha_12_tilde)\\n + z_1_tilde * alpha_2_tilde * x_6) - mu_1_tilde * x_2\\n f_3 = (z_1 * sigma_H * x_1 +\\n (z_1_tilde * sigma_11 + z_2_tilde * sigma_12) * x_2) \\\\\\n * (x_4 - x_3) - (e_1_tilde + x_4) * x_3\\n f_4 = x_4 * (1 - x_4)\\n f_5 = z_2_tilde * alpha_2 * x_6 * (1.0 - x_5) - mu_2_tilde * x_5\\n f_6 = (z_1_tilde * sigma_1_tilde * x_2\\n + z_2_tilde * sigma_2_tilde * x_5) * (x_7 - x_6) \\\\\\n - (e_2_tilde + r * x_7) * x_6\\n f_7 = r * x_7 * (1.0 - x_7)\\n r = np.array([f_1, f_2, f_3, f_4, f_5, f_6, f_7])\\n return r\",\n \"def refit_pll_opt(model,data):\\n data = toPM(data);\\n import scipy.optimize\\n from scipy.sparse import triu\\n def to_vector(L,h):\\n return np.hstack((h,triu(L,k=1).tocoo().data))\\n def from_vector(x):\\n h = x[:len(model.h)];\\n tmp = triu(model.L,k=1).tocoo();\\n L = csr((x[len(model.h):],(tmp.row,tmp.col)),shape=model.L.shape)\\n return L+L.T,h\\n def f0(x0):\\n L,h = from_vector(x0)\\n return -__pll(L,h,data).mean()\\n def jac(x0):\\n L,h = from_vector(x0)\\n return -to_vector(*__dpll(L,h,data))\\n\\n x0 = to_vector(model.L,model.h)\\n res = scipy.optimize.minimize(f0,x0, method='BFGS',jac=jac)\\n #print(\\\"Success? \\\",res.success)\\n model.L,model.h = from_vector(res.x)\\n return res\",\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def test_lu_forward_sub():\\t\\n\\t# test 1\\n\\tL = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\n\\tb = np.array([4, -8, 9, 6])\\n\\n\\ty = lu_forward_sub(L, b) \\t\\t\\n\\ty_soln = np.array([4,0,5,8])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y - y_soln) < 1.e-10\\n\\n\\t# test 2\\n\\tL2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\n\\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\\n\\n\\ty2 = lu_forward_sub(L2, b2) \\t\\t\\n\\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y2 - y_soln2) < 1.e-10\",\n \"def main(init_state, end_state, Q, R, sys_params, curr_time_str, results_dir,render=False):\\n # initialize environment\\n\\n env = gym.make('cp-custom-v0')\\n if render:\\n video_path = results_dir + '/vid.mp4'\\n vid = video_recorder.VideoRecorder(env, path=video_path)\\n env.seed(1) # seed for reproducibility\\n\\n obs = env.reset(init_state=init_state,\\n end_state=end_state,\\n action_noise_std=sys_params[4],\\n obs_noise_std=sys_params[5]\\n )\\n\\n n_states = obs.shape[0]\\n x_OUT = np.zeros((n_states, 1))\\n u_OUT = np.zeros((1))\\n done = False\\n step_count = 0\\n max_steps = 1000\\n\\n A, B, C, D = get_model_matrix_lqr()\\n lqr = LQR(A, B, C, D, Q, R)\\n controller_time = []\\n while True:\\n if render:\\n env.render()\\n vid.capture_frame()\\n\\n # check if bar is near the top \\\"stable\\\" region\\n theta_std = standardize_angle(obs[2])\\n\\n # uncomment if you want to do a swing up\\n \\\"\\\"\\\"\\n if (-0.5 < theta_std < 0.5):\\n # action = mpc_control(obs, Q, R, sys_params)\\n _, action = lqr.apply_state_controller(lqr.K, obs)\\n else:\\n action = energy_shaping_control(obs, sys_params)\\n \\\"\\\"\\\"\\n\\n start_time = time.time()\\n action = mpc_control(obs, Q, R, sys_params)\\n # _, action = lqr.apply_state_controller(lqr.K, obs)\\n controller_time.append(time.time() - start_time)\\n\\n # if step_count % 100 == 0:\\n # print(step_count)\\n\\n # apply action\\n obs, reward, done, end_state_reached, _ = env.step(action)\\n x_OUT = np.append(x_OUT, obs, axis=1)\\n u_OUT = np.append(u_OUT, action)\\n step_count += 1\\n\\n if (done) or (step_count >= max_steps):\\n # print(f'Terminated after {step_count+1} iterations \\\\n Final State: {obs}\\\\n Target State: {xf}')\\n # print(np.mean(controller_time))\\n break\\n\\n env.close()\\n return x_OUT[:, 1:], u_OUT[1:], end_state_reached, step_count+1\",\n \"def update_nodes(self):\\n\\n L = self.level\\n P = L.prob\\n\\n # only if the level has been touched before\\n assert L.status.unlocked\\n\\n # get number of collocation nodes for easier access\\n M = self.coll.num_nodes\\n\\n # gather all terms which are known already (e.g. from the previous iteration)\\n # this corresponds to u0 + QF(u^k) - QdF(u^k) + tau\\n\\n # get QF(u^k)\\n integral = self.integrate()\\n for m in range(M):\\n # get -QdF(u^k)_m\\n for j in range(1, M + 1):\\n integral[m] -= L.dt * self.QI[m + 1, j] * L.f[j]\\n\\n # add initial value\\n integral[m] += L.u[0]\\n # add tau if associated\\n if L.tau[m] is not None:\\n integral[m] += L.tau[m]\\n\\n # do the sweep\\n for m in range(0, M):\\n # build rhs, consisting of the known values from above and new values from previous nodes (at k+1)\\n rhs = P.dtype_u(integral[m])\\n for j in range(1, m + 1):\\n rhs += L.dt * self.QI[m + 1, j] * L.f[j]\\n\\n # implicit solve with prefactor stemming from the diagonal of Qd\\n L.u[m + 1] = P.solve_system(\\n rhs, L.dt * self.QI[m + 1, m + 1], L.u[m + 1], L.time + L.dt * self.coll.nodes[m]\\n )\\n # update function values\\n L.f[m + 1] = P.eval_f(L.u[m + 1], L.time + L.dt * self.coll.nodes[m])\\n\\n # indicate presence of new values at this level\\n L.status.updated = True\\n\\n return None\",\n \"def solve_rossler(alpha = 1.0, beta = 1.0, gamma = 1.0, max_time = 10, N = 5):\\n resolution = 72\\n \\n fig1 = plt.figure(dpi = resolution)\\n ax1, ax2, ax3 = fig1.subplots(3, 1)\\n\\n fig = plt.figure()\\n ax = fig.add_axes([0, 0, 1, 1], projection='3d')\\n # ax.axis('off')\\n \\n def rossler_deriv(xi, t0, alpha=alpha, beta = beta, gamma = gamma):\\n \\\"\\\"\\\"Compute the time-derivative of a Lorenz system.\\\"\\\"\\\"\\n \\n xi1, xi2, xi3 = xi\\n \\n xi1_dot = -xi1 - exp(xi3)\\n xi2_dot = xi1 + alpha * xi2\\n xi3_dot = gamma * exp(-xi3) + xi1 - beta\\n \\n return [xi1_dot, xi2_dot, xi3_dot]\\n\\n # Choose random starting points, uniformly distributed from -15 to 15\\n np.random.seed(1)\\n xi0 = -15 + 30 * np.random.random((N, 3))\\n xi0[:,2] = np.log(abs(xi0[:,2]))\\n\\n # Solve for the trajectories\\n t = np.linspace(0, max_time, int(250*max_time))\\n xi_t = np.asarray([integrate.odeint(rossler_deriv, xi0i, t)\\n for xi0i in xi0])\\n \\n # choose a different color for each trajectory\\n colors = plt.cm.viridis(np.linspace(0, 1, N))\\n\\n for i in range(N):\\n xi1, xi2, xi3= xi_t[i,:,:].T\\n \\n ax1.plot(t, xi1, '-', c=colors[i])\\n ax1.set_title('xi1')\\n \\n ax2.plot(t, xi2, '-', c=colors[i])\\n ax2.set_title('xi2')\\n \\n ax3.plot(t, xi3, '-', c=colors[i])\\n ax3.set_title('xi3')\\n \\n lines = ax.plot(xi1, xi2, xi3, '-', c=colors[i])\\n plt.setp(lines, linewidth=2)\\n angle = 104\\n ax.view_init(30, angle)\\n plt.show()\\n\\n return t, xi_t\",\n \"def solve_model(self): \\n \\n t0 = time.time() #start the clock\\n \\n # a. benchmark case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(1)\\n \\n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(self.tau_benchmark) #set tax system\\n \\n #iii. benchmark equilibrium\\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\\\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Benchmark Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\")\\n print(f\\\"ss output = {self.Yss_b:.2f}\\\")\\n print(f\\\"ss capital = {self.Kss_b:.2f}\\\")\\n print(f\\\"ss tfp = {self.TFPss_b:.2f}\\\")\\n print(f\\\"ss wage = {self.w_ss_b:.2f}\\\")\\n print(f\\\"entry mass = {self.E_star_b:.3f}\\\")\\n print(f\\\"avg. firm size = {self.average_firm_size_b:.2f}\\\")\\n \\n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\\n \\n if self.plott:\\n #i. initialize\\n employed = [4.99, 49.99]\\n firm_size_by_employee = np.zeros(len(employed)+1)\\n share_employment = np.zeros(len(employed)+1)\\n \\n \\n #i. percentage of firms that employ employed\\n \\n for i_e in range(len(employed)):\\n summ = np.sum(firm_size_by_employee)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\\n firm_size_by_employee[i_e] = interpolate - summ\\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\\n \\n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Size of Firms by Firm Size (Number of Employees)')\\n plt.savefig('firm_size_rr08.pdf')\\n plt.show()\\n \\n \\n #ii. employment percentage by firm size\\n for i_e in range(len(employed)):\\n summ = np.sum(share_employment)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\\n share_employment[i_e] = interpolate - summ\\n share_employment[-1] = 1 - np.sum(share_employment)\\n \\n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Employment Share by Firm Size (Number of Employees)')\\n plt.savefig('employment_by_firm_size_rr08.pdf')\\n plt.show()\\n \\n #iii. productivity cdf and employment cdf\\n plt.plot(self.grid_s, self.cdf_stationary_b)\\n plt.plot(self.grid_s, self.cdf_emp_b)\\n plt.title('Stationary CDF' )\\n plt.xlabel('Productivity level')\\n plt.ylabel('Cumulative Sum')\\n plt.legend(['Firms by Productivity Level','Share of Employment'])\\n plt.savefig('cdf_rr08.pdf')\\n plt.show()\\n \\n \\n \\n #c. distortion case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(0)\\n \\n #ii. compute stationary economy for each tau\\n \\n for idx, tau in enumerate(self.tau_vector):\\n \\n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\\n self.tau_s[idx] = self.find_subsidy_rate(tau)\\n \\n # set tax system with newly found tau_s and given tau\\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv) #set tax system\\n \\n #v. distorted stationary equilibrium\\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\\\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\\\\n _, _ = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Distorted Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n if self.distortion_case == 1:\\n print(\\\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(low productivity firms recieve subsidy, high productivity taxed)\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Positively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(high productivity firms recieve subsidy, low productivity taxed)\\\\n\\\")\\n if self.policy_type == 1 :\\n print(\\\"Tax Type: Tax on output\\\\n\\\")\\n elif self.policy_type == 2 :\\n print(\\\"Tax Type: Tax on capital\\\\n\\\")\\n elif self.policy_type == 3 :\\n print(\\\"Tax Type: Tax on labor\\\\n\\\")\\n print(f\\\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\\\")\\n print(f\\\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\\\")\\n print(f\\\"fraction of firms excempt = {self.excempt_frac:.2f}\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n \\n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \\n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\\n [], \\n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \\n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \\n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \\n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \\\"Tax = \\\"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\\n \\n\\n t1 = time.time()\\n print(f'\\\\nTotal Run Time: {t1-t0:.2f} seconds')\",\n \"def predict(self, u):\\n\\n dtheta_l = self.current_state_estimate[0,0]\\n dtheta_r = self.current_state_estimate[1,0]\\n v = self.current_state_estimate[2,0]\\n w = self.current_state_estimate[3,0]\\n x = self.current_state_estimate[4,0]\\n y = self.current_state_estimate[5,0]\\n theta = self.current_state_estimate[6,0]\\n vl = u[0,0]\\n vr = u[1,0]\\n \\n # Vary noise with input voltage\\n if abs(self.current_state_estimate[0,0]) < .03:\\n self.Q[0,0] = .0000001\\n dtheta_l = 0\\n\\n else:\\n self.Q[0,0] = abs(vl)*.03/3000+.03\\n\\n if abs(self.current_state_estimate[1,0]) < .03:\\n self.Q[1,1] = .0000001\\n dtheta_r = 0\\n else:\\n self.Q[1,1] = abs(vr)*.03/3000+.03\\n\\n ## TRANSITION ESTIMATE\\n self.current_state_estimate[0] += self.dt*(self.k2_l*dtheta_l + self.k1_l*vl)\\n self.current_state_estimate[1] += self.dt*(self.k2_r*dtheta_r + self.k1_r*vr)\\n self.current_state_estimate[2] = self.r/2 * (self.current_state_estimate[0] + self.current_state_estimate[1])\\n self.current_state_estimate[3] = self.r/self.l * (self.current_state_estimate[1] - self.current_state_estimate[0])\\n self.current_state_estimate[4] += (self.dt)*self.current_state_estimate[2]*math.cos(theta)\\n self.current_state_estimate[5] += (self.dt)*self.current_state_estimate[2]*math.sin(theta)\\n self.current_state_estimate[6] += (self.dt)*self.current_state_estimate[3]\\n \\n ## TRANISTION PROBABILITY\\n # only propogate the things that can move\\n self.A[0:7, 0:7] = np.array([[1+self.dt*self.k2_l, 0, 0, 0, 0, 0, 0],\\\\\\n [0, 1+self.dt*self.k2_r, 0, 0, 0, 0, 0],\\\\\\n [self.r/2, self.r/2, 0, 0, 0, 0, 0],\\\\\\n [-self.r/self.l, self.r/self.l, 0, 0, 0, 0, 0],\\\\\\n [0, 0, math.cos(theta)*self.dt , 0, 1, 0, -v*math.sin(theta)*self.dt],\\\\\\n [0, 0, math.sin(theta)*self.dt , 0, 0, 1, v*math.cos(theta)*self.dt],\\\\\\n [0, 0, 0, self.dt, 0, 0, 1]])\\n \\n self.current_prob_estimate = np.dot(np.dot(self.A, self.current_prob_estimate), np.transpose(self.A)) + self.Q\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6856822","0.67716205","0.6512035","0.63664174","0.6199675","0.6168004","0.6133567","0.6129773","0.6099672","0.6093726","0.6058491","0.5990289","0.59402376","0.58544946","0.58435804","0.58374304","0.58292556","0.58270043","0.58121234","0.58121234","0.5810242","0.5803487","0.5789584","0.5729127","0.57248974","0.5722042","0.5709363","0.5702375","0.5701264","0.569653","0.5692678","0.5685922","0.5677445","0.5651125","0.56364226","0.5634874","0.5634082","0.56338537","0.5618305","0.5610045","0.5608234","0.560721","0.5590966","0.55839837","0.5581314","0.5574638","0.5573767","0.55722606","0.55613124","0.5558616","0.555848","0.55556107","0.555056","0.5544906","0.5544578","0.5541188","0.55363417","0.5534121","0.55335116","0.5531546","0.55291474","0.55253017","0.5524167","0.551787","0.55089855","0.5508899","0.5482443","0.5480462","0.5474583","0.5466005","0.5463009","0.5462588","0.5462473","0.5462461","0.5459666","0.5452245","0.5450926","0.5448337","0.54458517","0.54363054","0.54264206","0.54240686","0.5420568","0.5418056","0.54125595","0.54125595","0.5410575","0.5410056","0.5409935","0.54071724","0.5404912","0.54024327","0.5399731","0.5395057","0.53920364","0.53916746","0.53882736","0.5379055","0.53739953","0.5360407","0.5357583"],"string":"[\n \"0.6856822\",\n \"0.67716205\",\n \"0.6512035\",\n \"0.63664174\",\n \"0.6199675\",\n \"0.6168004\",\n \"0.6133567\",\n \"0.6129773\",\n \"0.6099672\",\n \"0.6093726\",\n \"0.6058491\",\n \"0.5990289\",\n \"0.59402376\",\n \"0.58544946\",\n \"0.58435804\",\n \"0.58374304\",\n \"0.58292556\",\n \"0.58270043\",\n \"0.58121234\",\n \"0.58121234\",\n \"0.5810242\",\n \"0.5803487\",\n \"0.5789584\",\n \"0.5729127\",\n \"0.57248974\",\n \"0.5722042\",\n \"0.5709363\",\n \"0.5702375\",\n \"0.5701264\",\n \"0.569653\",\n \"0.5692678\",\n \"0.5685922\",\n \"0.5677445\",\n \"0.5651125\",\n \"0.56364226\",\n \"0.5634874\",\n \"0.5634082\",\n \"0.56338537\",\n \"0.5618305\",\n \"0.5610045\",\n \"0.5608234\",\n \"0.560721\",\n \"0.5590966\",\n \"0.55839837\",\n \"0.5581314\",\n \"0.5574638\",\n \"0.5573767\",\n \"0.55722606\",\n \"0.55613124\",\n \"0.5558616\",\n \"0.555848\",\n \"0.55556107\",\n \"0.555056\",\n \"0.5544906\",\n \"0.5544578\",\n \"0.5541188\",\n \"0.55363417\",\n \"0.5534121\",\n \"0.55335116\",\n \"0.5531546\",\n \"0.55291474\",\n \"0.55253017\",\n \"0.5524167\",\n \"0.551787\",\n \"0.55089855\",\n \"0.5508899\",\n \"0.5482443\",\n \"0.5480462\",\n \"0.5474583\",\n \"0.5466005\",\n \"0.5463009\",\n \"0.5462588\",\n \"0.5462473\",\n \"0.5462461\",\n \"0.5459666\",\n \"0.5452245\",\n \"0.5450926\",\n \"0.5448337\",\n \"0.54458517\",\n \"0.54363054\",\n \"0.54264206\",\n \"0.54240686\",\n \"0.5420568\",\n \"0.5418056\",\n \"0.54125595\",\n \"0.54125595\",\n \"0.5410575\",\n \"0.5410056\",\n \"0.5409935\",\n \"0.54071724\",\n \"0.5404912\",\n \"0.54024327\",\n \"0.5399731\",\n \"0.5395057\",\n \"0.53920364\",\n \"0.53916746\",\n \"0.53882736\",\n \"0.5379055\",\n \"0.53739953\",\n \"0.5360407\",\n \"0.5357583\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89497,"cells":{"query":{"kind":"string","value":"Check that the observability matrix is full rank. We check this by using the standard condition that [C CA CA^2 . . . CA^{n1}] is full rank"},"document":{"kind":"string","value":"def check_observability(A, C):\n assert len(A.shape) == 2\n dim = A.shape[0]\n stack = []\n for i in range(dim):\n term = C @ np.linalg.matrix_power(A, i)\n stack.append(term)\n obs_grammian = np.vstack(stack)\n return np.linalg.matrix_rank(obs_grammian) == dim"},"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 fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()","def is_full_row_rank(G):\n assert len(G.shape) == 2, \"should be a 2d numpy arrayp\"\n rows = G.shape[0]\n rank = np.linalg.matrix_rank(G)\n return rank >= rows","def check_k_matrix_stability(self):\r\n K = self.make_k_matrix()\r\n vals, vects = scipy_sparse_eigens(K)\r\n principal_val = vals.max()\r\n print(\"ht3_solver:\\t'Stiffness' matrix principal eigenvalue was \"\r\n + str(principal_val))\r\n if principal_val > 1:\r\n print(\"##########################################################\")\r\n print(\"ht3_solver:\\tWARNING\")\r\n print(\"ht3_solver:\\tPrincipal eigenvalue is more than one.\")\r\n print(\"ht3_solver:\\tThe analysis will be unstable.\")\r\n print(\"ht3_solver:\\tIf this is OK, just go and modify the code \"\r\n + \"or something.\")\r\n print(\"##########################################################\")\r\n raise(AssertionError)","def is_solvable(self):\n for row, col in np.ndindex(9, 9):\n if len(self.possible_values[row][col]) < 1 and self.final_values[row][col] == 0:\n return False\n return True","def _only_one_type(self):\n num_larger_than_1 = 0\n for symb, indices in self.atoms_indx.items():\n if len(indices) > 0:\n num_larger_than_1 += 1\n return num_larger_than_1 <= 1","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def valid(self, col, rank):\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0","def valid(self, col, rank):\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0","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 test_basic_cardinality(self):\n dim = Real(\"yolo\", \"reciprocal\", 0.043, 2.3, precision=2)\n order_0012 = np.arange(43, 99 + 1)\n order_010 = np.arange(10, 99 + 1)\n order_23 = np.arange(10, 23 + 1)\n assert dim.cardinality == sum(map(len, [order_0012, order_010, order_23]))","def healthy_test(obj: np.ndarray) -> bool:\n nb_rows, nb_cols = obj.shape\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))","def part1c_0():\n xs = exampleInput\n T = submission.computeEdgeMarginals(simpleCRF, xs)\n for t in T:\n grader.requireIsEqual( 1.0, sum(t.values()) )","def test_estimateFullRichness(self):\r\n # Verified with iNEXT.\r\n\r\n # f2 > 0\r\n obs = self.estimator3.estimateFullRichness()\r\n assert_almost_equal(obs, 5.5)\r\n\r\n # f2 == 0\r\n obs = self.estimator4.estimateFullRichness()\r\n assert_almost_equal(obs, 4)","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 checkNumNeighbors():","def test00(self):\n a = np.arange(self.N)\n ac = bcolz.arange(self.N, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def check_free(self, arr):\n cell_location = self.cartesian_to_cell(arr)\n cell = self.occ_matrix[cell_location[0], cell_location[1]]\n return cell == 0","def test_reduce_null_matrix_is_empty(self):\n original = pd.read_csv(NULL_FILENAME, index_col=0, header=0)\n full_reduced = entropy_reduce_position_matrix(\n original,\n 1,\n trivial_metric\n )\n self.assertEqual(full_reduced.shape[0], original.shape[0])\n self.assertEqual(full_reduced.shape[1], 0)","def isbra(qob):\n return qob.shape[0] == 1 and qob.shape[1] > 1 # Row vector check","def is_board_full(board):\n return not any(0 in val for val in board)","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_fulldim(polyreg, abs_tol=ABS_TOL):\n # logger.debug('is_fulldim')\n if polyreg.fulldim is not None:\n return polyreg.fulldim\n lenP = len(polyreg)\n if lenP == 0:\n rc, xc = cheby_ball(polyreg)\n status = rc > abs_tol\n else:\n status = np.zeros(lenP)\n for ii in range(lenP):\n rc, xc = cheby_ball(polyreg.list_poly[ii])\n status[ii] = rc > abs_tol\n status = np.sum(status)\n status = status > 0\n polyreg.fulldim = status\n return status","def check_controllability(A, B):\n assert len(A.shape) == 2\n dim = A.shape[0]\n stack = []\n for i in range(dim):\n term = B @ np.linalg.matrix_power(A, i)\n stack.append(term)\n grammian = np.hstack(stack)\n return np.linalg.matrix_rank(grammian) == dim","def _is_absolutely_monotonic(self,r,tol):\n s=len(self)\n K=np.vstack([self.A.astype(float),self.b.astype(float)])\n K=np.hstack([K,np.zeros([s+1,1])])\n X=np.eye(s+1)+r*K\n if abs(np.linalg.det(X))<tol: return 0\n beta_r=np.linalg.solve(X,K)\n v_r_sum = np.dot(np.eye(s+1)-r*beta_r,np.ones([s+1,1]))\n if beta_r.min()<-tol or v_r_sum.min()<-tol:\n return 0\n else:\n return 1\n # Need an exception here if rhi==rmax","def is_full(board):\r\n return False","def is_fullp(self):\n front = (self.front + 1) % self.length\n return front == self.rear","def is_full(self, row, col):\n self._validate_indexes(row, col)\n return self._uf.connected(self._top_idx, row * self._n + col)","def isFullConf(triols, rThreshold = 0.2):\n for i in range(2,len(triols),3):\n if triols[i] < rThreshold:\n return False\n return True","def is_full(self) -> bool:\n return self._array[0].all()","def solved(self):\n return all(cell == 1 for row in self.faces for cell in row) or all(cell == 0 for row in self.faces for cell in row)","def test01(self):\n a = np.arange(3, self.N)\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","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 _test_obssize(t):\n return t.shape[0] != len(t.ids(axis='observation'))","def has_straight(self):\n res = []\n self.suit_hist()\n for val in self.ranks.keys():\n res.append(val)\n res.sort()\n self.is_sequence(res, 3)","def test_board_full(self):\n actual = self.controller.check_tie()\n self.assertTrue(actual)","def _is_legal_state(self, observation):\n servers_used_mem = np.zeros(len(self.servers_mem))\n for i, _ in enumerate(servers_used_mem):\n servers_used_mem[i] = np.sum(self.services_mem[observation==i])\n return np.alltrue(np.array(self.servers_mem) >= servers_used_mem)","def isFull(self) -> bool:\n return (self.rear + 1) % self.capacity == self.front","def bornoff(self, board):\n res = False\n if (self.player):\n if (reduce(lambda x, y: x+y, board.p1vec) < reduce(lambda x, y: x+y, self.board.p1vec)):\n res = True\n else:\n if (reduce(lambda x, y: x+y, board.p2vec) < reduce(lambda x, y: x+y, self.board.p2vec)):\n res = True\n return res","def is_compact(self):\n return self.n_rays()==0 and self.n_lines()==0","def check(m) :\n #find Connected-component\n lst = find_c(m)\n for e in lst :\n # verify len , 3 is the len of large boat\n if len(e) > 3 :\n return False\n if not is_vert(e) and not is_hori(e):\n return False\n return True","def __bool__(self):\n return self.fam.c_nonzero(self)","def isFull(self) -> bool:\n return self._elems == self._k","def is_pos_unate(self, vs=None):\n vs = self._expect_vars(vs)\n basis = self.support - set(vs)\n mincov = [PC_ZERO] * (1 << len(basis))\n # Test whether table entries are monotonically increasing\n for cf in self.iter_cofactors(vs):\n for i, item in enumerate(cf.pcdata):\n if mincov[i] == PC_ONE and item == PC_ZERO:\n return False\n mincov[i] = item\n return True","def is_1DNN(self):\n if not self.dims == 1:\n return False\n if not set(self.__m__.keys()) <= set(((0,),(1,),(-1,))):\n return False\n\n return True","def is_algebraically_stable(self):\n import numpy as np\n\n if np.any(self.b < 0):\n return False\n\n # Check the eigenvalues for positive definiteness.\n #\n # We could also check whether the Cholesky factorization fails (=> not pos. def.).\n # However, since we are interested in positive SEMIdefinite matrices, we have to\n # regularize M by adding a small multiple of the identity matrix. Since \"small\"\n # depends on the floating point type and this is probably not a bottleneck, using\n # the eigenvalues seems to be fine.\n rk = self.__num__()\n B = np.diag(rk.b)\n M = B.dot(rk.A) + rk.A.T.dot(B) - np.outer(rk.b, rk.b)\n isposdef = np.all(np.linalg.eigvals(M) >= -10 * np.finfo(M.dtype).eps)\n\n return isposdef","def _validate_cardinality(self, columns):\n cards = [len(c.data) for c in columns]\n c = np.unique(cards)\n assert len(c) == 1, c\n return c[0]","def _is_vessel_full(self):\n return np.size(np.where(self.end_of_lanes + (np.ones(self.lanes) * self.minimal_package) <= self.rows)) == 0","def is_full_dimensional(self):\n\n return self.affine_dimension() == self.space_dimension()","def testrescorr():\n tau = np.zeros((2,50))\n tau[0,25] = 2\n tau[1,23] = 3\n tau2 = spec_utils.res_corr(tau, 2, 8)\n #Check flux conserved\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\n #Check expanded by expected amount\n for i in (0,1):\n assert np.size(np.where(tau2[i,:]> 0)) == 15","def invertible(self):\n a = self._data\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]","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 is_full(board):\n return False","def test_rank_centrality():\n for case in iter_testcases('pairwise'):\n n_items = case[\"n_items\"]\n data = case[\"data\"]\n assert np.allclose(\n case[\"rc_est\"], rank_centrality(n_items, data),\n atol=ATOL, rtol=RTOL)","def test_trivial_reduce_entropy_full_reduce(self):\n original = pd.read_csv(MATRIX_1_FILENAME, index_col=0, header=0)\n full_reduced = entropy_reduce_position_matrix(\n original,\n 1,\n trivial_metric\n )\n self.assertEqual(full_reduced.shape[0], original.shape[0])\n self.assertEqual(full_reduced.shape[1], 1)","def _test_obsdup(t):\n return t.shape[0] != len(set(t.ids(axis='observation')))","def check_if_full(self):\n pass","def test02(self):\n a = np.arange(3, self.N, 4)\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def check_matrix_converge(self):\n # If all of the running window changes are to the same value, then we stop learning\n test = list(map(lambda x: int(\n x.split(\"->\")[0]) == int(float(x.split(\"->\")[1])), self.running_update_window))\n is_converged = np.count_nonzero(test) == self.running_update_window_len\n return is_converged","def square_check(self):\n return len(self.matrix) == len(self.matrix[0])","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 __bool__(self):\n return len(self.atoms) >= 1","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_trivial(self):\n return self.dims == 0","def check_if_column_full(self, board, x):\n for y in reversed(range(self.height // 80)):\n if board[x, 0] != 0:\n return True\n elif board[(x, y)] == 0:\n return False\n else:\n y -= y\n continue","def has_fullhouse(self):\n if self.has_pair() & self.has_three_of_a_kind():\n self.rank_per_hand['5'] = \"full house\"\n return True\n return False","def check_lin_independence(vectors):\n if len(vectors) == 1:\n return True\n M = np.zeros([len(vectors), len(vectors[0])], dtype=np.complex_)\n for i in range(len(vectors)):\n M[i] = vectors[i].T\n pl, u = lu(M, permute_l=True)\n if any([np.count_nonzero(M[i]) == 0 for i in range(len(vectors))]):\n return False #M must be full rank for linear independence\n return True","def single_roidb(entry):\n gt_boxes = entry['boxes']\n return gt_boxes.shape[0] <= 1","def empty(self):\n return self.numba_rtree._bounds_tree.shape[0] == 0","def is_full(self):\n\n return self.count == len(self.array)","def is_full(self):","def part1b_0():\n xs = exampleInput\n _, forward = submission.computeForward(simpleCRF, xs)\n for i in xrange(len(xs)):\n grader.requireIsEqual( 1.0, sum( forward[i].values() ) )","def check_matrix(self, matrix):\n for i in range(self.size):\n if (matrix[0][i] + matrix[-1][i] == i % 2 or matrix[0][i] + matrix[-1][i] == (i + 1) % 2) and (\n matrix[i][0] + matrix[i][-1] == i % 2 or matrix[i][0] + matrix[i][-1] == (i + 1) % 2):\n pass\n else:\n logging.debug(\"Matrix detection failed. Matrix passed to function \" + str(matrix))\n return False\n for i in range(self.size):\n for j in range(self.size):\n if matrix[i][j] > 1:\n logging.debug(\"Matrix detection failed. Matrix passed to function \" + str(matrix))\n return False\n logging.info(\"Matrix detected : \" + str(matrix))\n return True","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 has_straight_flush(self):\n res = []\n self.suit_hist()\n for card in self.cards:\n if self.suits[card.suit] >= 5:\n res.append(card.rank)\n self.is_sequence(res, 7)","def __getStableConcepts(weight_matrix: Union[np.ndarray, pd.DataFrame]) -> np.ndarray:\n stables = []\n for i in range(len(weight_matrix)):\n if np.all(weight_matrix[i] == 0):\n stables.append(i)\n\n return stables","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) -> bool:","def test02b(self):\n a = np.ones(self.N, dtype='i4')\n ac = bcolz.ones(self.N, dtype='i4', rootdir=self.rootdir)\n self.assertTrue(a.dtype == ac.dtype)\n self.assertTrue(np.all(a == ac[:]))","def check_condor(self):\n\n self.cluster=self.info['mw_run']['1']\n self.norm_with_cross=self.info['mw_run']['4']\n self.condor_req=self.info['mw_run']['11']\n\n #type is automaticaly updated now\n #self.cluster=int(condor)\n #if norm_with_cross==\"F\":\n # self.norm_with_cross=0\n #else:\n # self.norm_with_cross=1","def test_continuity():\n dc = cs[:,0:Nr-1]-cs[:,1:Nr]\n assert dc.any < cmax","def check_matrix(solver,matrix):\n model_validated = True\n #To check that the negation of the given formula is UNSAT under the clauses \n #in the solver we check if the negation of each clause is UNSAT under these clauses.\n for clause in matrix:\n negated_claus=[-l for l in clause]\n model_validated = not solver.solve(negated_claus)\n if not model_validated:\n print(\"Falsified Clause: {}\".format(clause))\n return False\n return True","def test_rosenbrock(self):\n fun = get_problem('rosenbrock', self.dimension)\n self.assertEqual(fun(self.array2), 0.0)","def test_is_99_1SpaceConnected(self):\n self.assertEqual(self.hand.oneSpaceConnectedInd, 0)\n self.assertEqual(self.hand.suitedInd, 0)\n self.assertEqual(self.hand.premInd, 0)\n self.assertEqual(self.hand.connectedInd, 0)\n self.assertEqual(self.hand.PPInd, 1)\n self.assertEqual(self.hand.PPCard, 9)","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_full(self):\n return len(self.walls) == 4","def test03(self):\n a = np.arange(self.N, dtype=\"i1\")\n ac = bcolz.arange(self.N, dtype=\"i1\", rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","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 test00(self):\n a = np.arange(1, 11) > 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def _IsActuatorMessageAllValid(mode, node_labels, node_label_helper,\n max_no_update_count, *attributes):\n if mode == common.SPARSE_COMMS_MODE:\n # Check the `valid` variable for TetherDown.\n if attributes[1]:\n for label in node_labels:\n idx = node_label_helper.Value(label)\n if attributes[0][idx].no_update_count > max_no_update_count:\n return False\n return True\n return False\n elif mode == common.FULL_COMMS_MODE:\n for attribute in attributes:\n if not struct_tree.IsValidElement(attribute):\n return False\n return True\n else:\n assert False","def recip_rank(recs, truth):\n good = recs['item'].isin(truth.index)\n npz, = np.nonzero(good)\n if len(npz):\n return 1.0 / (npz[0] + 1.0)\n else:\n return 0.0","def is_full(self):\n return self.idx == self.len","def is_full(self):\n return len(self.keys) == self.order","def is_full(self):\n return set(self._parent.letters()) == set(self.winners())","def part_one():\n return len(numpy.where(grid > 1)[0])","def is_full(self):\n return self.top == self.size - 1","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"],"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 fullGrid(state):\\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()\",\n \"def is_full_row_rank(G):\\n assert len(G.shape) == 2, \\\"should be a 2d numpy arrayp\\\"\\n rows = G.shape[0]\\n rank = np.linalg.matrix_rank(G)\\n return rank >= rows\",\n \"def check_k_matrix_stability(self):\\r\\n K = self.make_k_matrix()\\r\\n vals, vects = scipy_sparse_eigens(K)\\r\\n principal_val = vals.max()\\r\\n print(\\\"ht3_solver:\\\\t'Stiffness' matrix principal eigenvalue was \\\"\\r\\n + str(principal_val))\\r\\n if principal_val > 1:\\r\\n print(\\\"##########################################################\\\")\\r\\n print(\\\"ht3_solver:\\\\tWARNING\\\")\\r\\n print(\\\"ht3_solver:\\\\tPrincipal eigenvalue is more than one.\\\")\\r\\n print(\\\"ht3_solver:\\\\tThe analysis will be unstable.\\\")\\r\\n print(\\\"ht3_solver:\\\\tIf this is OK, just go and modify the code \\\"\\r\\n + \\\"or something.\\\")\\r\\n print(\\\"##########################################################\\\")\\r\\n raise(AssertionError)\",\n \"def is_solvable(self):\\n for row, col in np.ndindex(9, 9):\\n if len(self.possible_values[row][col]) < 1 and self.final_values[row][col] == 0:\\n return False\\n return True\",\n \"def _only_one_type(self):\\n num_larger_than_1 = 0\\n for symb, indices in self.atoms_indx.items():\\n if len(indices) > 0:\\n num_larger_than_1 += 1\\n return num_larger_than_1 <= 1\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def valid(self, col, rank):\\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0\",\n \"def valid(self, col, rank):\\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0\",\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 test_basic_cardinality(self):\\n dim = Real(\\\"yolo\\\", \\\"reciprocal\\\", 0.043, 2.3, precision=2)\\n order_0012 = np.arange(43, 99 + 1)\\n order_010 = np.arange(10, 99 + 1)\\n order_23 = np.arange(10, 23 + 1)\\n assert dim.cardinality == sum(map(len, [order_0012, order_010, order_23]))\",\n \"def healthy_test(obj: np.ndarray) -> bool:\\n nb_rows, nb_cols = obj.shape\\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))\",\n \"def part1c_0():\\n xs = exampleInput\\n T = submission.computeEdgeMarginals(simpleCRF, xs)\\n for t in T:\\n grader.requireIsEqual( 1.0, sum(t.values()) )\",\n \"def test_estimateFullRichness(self):\\r\\n # Verified with iNEXT.\\r\\n\\r\\n # f2 > 0\\r\\n obs = self.estimator3.estimateFullRichness()\\r\\n assert_almost_equal(obs, 5.5)\\r\\n\\r\\n # f2 == 0\\r\\n obs = self.estimator4.estimateFullRichness()\\r\\n assert_almost_equal(obs, 4)\",\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 checkNumNeighbors():\",\n \"def test00(self):\\n a = np.arange(self.N)\\n ac = bcolz.arange(self.N, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def check_free(self, arr):\\n cell_location = self.cartesian_to_cell(arr)\\n cell = self.occ_matrix[cell_location[0], cell_location[1]]\\n return cell == 0\",\n \"def test_reduce_null_matrix_is_empty(self):\\n original = pd.read_csv(NULL_FILENAME, index_col=0, header=0)\\n full_reduced = entropy_reduce_position_matrix(\\n original,\\n 1,\\n trivial_metric\\n )\\n self.assertEqual(full_reduced.shape[0], original.shape[0])\\n self.assertEqual(full_reduced.shape[1], 0)\",\n \"def isbra(qob):\\n return qob.shape[0] == 1 and qob.shape[1] > 1 # Row vector check\",\n \"def is_board_full(board):\\n return not any(0 in val for val in board)\",\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_fulldim(polyreg, abs_tol=ABS_TOL):\\n # logger.debug('is_fulldim')\\n if polyreg.fulldim is not None:\\n return polyreg.fulldim\\n lenP = len(polyreg)\\n if lenP == 0:\\n rc, xc = cheby_ball(polyreg)\\n status = rc > abs_tol\\n else:\\n status = np.zeros(lenP)\\n for ii in range(lenP):\\n rc, xc = cheby_ball(polyreg.list_poly[ii])\\n status[ii] = rc > abs_tol\\n status = np.sum(status)\\n status = status > 0\\n polyreg.fulldim = status\\n return status\",\n \"def check_controllability(A, B):\\n assert len(A.shape) == 2\\n dim = A.shape[0]\\n stack = []\\n for i in range(dim):\\n term = B @ np.linalg.matrix_power(A, i)\\n stack.append(term)\\n grammian = np.hstack(stack)\\n return np.linalg.matrix_rank(grammian) == dim\",\n \"def _is_absolutely_monotonic(self,r,tol):\\n s=len(self)\\n K=np.vstack([self.A.astype(float),self.b.astype(float)])\\n K=np.hstack([K,np.zeros([s+1,1])])\\n X=np.eye(s+1)+r*K\\n if abs(np.linalg.det(X))<tol: return 0\\n beta_r=np.linalg.solve(X,K)\\n v_r_sum = np.dot(np.eye(s+1)-r*beta_r,np.ones([s+1,1]))\\n if beta_r.min()<-tol or v_r_sum.min()<-tol:\\n return 0\\n else:\\n return 1\\n # Need an exception here if rhi==rmax\",\n \"def is_full(board):\\r\\n return False\",\n \"def is_fullp(self):\\n front = (self.front + 1) % self.length\\n return front == self.rear\",\n \"def is_full(self, row, col):\\n self._validate_indexes(row, col)\\n return self._uf.connected(self._top_idx, row * self._n + col)\",\n \"def isFullConf(triols, rThreshold = 0.2):\\n for i in range(2,len(triols),3):\\n if triols[i] < rThreshold:\\n return False\\n return True\",\n \"def is_full(self) -> bool:\\n return self._array[0].all()\",\n \"def solved(self):\\n return all(cell == 1 for row in self.faces for cell in row) or all(cell == 0 for row in self.faces for cell in row)\",\n \"def test01(self):\\n a = np.arange(3, self.N)\\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\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 _test_obssize(t):\\n return t.shape[0] != len(t.ids(axis='observation'))\",\n \"def has_straight(self):\\n res = []\\n self.suit_hist()\\n for val in self.ranks.keys():\\n res.append(val)\\n res.sort()\\n self.is_sequence(res, 3)\",\n \"def test_board_full(self):\\n actual = self.controller.check_tie()\\n self.assertTrue(actual)\",\n \"def _is_legal_state(self, observation):\\n servers_used_mem = np.zeros(len(self.servers_mem))\\n for i, _ in enumerate(servers_used_mem):\\n servers_used_mem[i] = np.sum(self.services_mem[observation==i])\\n return np.alltrue(np.array(self.servers_mem) >= servers_used_mem)\",\n \"def isFull(self) -> bool:\\n return (self.rear + 1) % self.capacity == self.front\",\n \"def bornoff(self, board):\\n res = False\\n if (self.player):\\n if (reduce(lambda x, y: x+y, board.p1vec) < reduce(lambda x, y: x+y, self.board.p1vec)):\\n res = True\\n else:\\n if (reduce(lambda x, y: x+y, board.p2vec) < reduce(lambda x, y: x+y, self.board.p2vec)):\\n res = True\\n return res\",\n \"def is_compact(self):\\n return self.n_rays()==0 and self.n_lines()==0\",\n \"def check(m) :\\n #find Connected-component\\n lst = find_c(m)\\n for e in lst :\\n # verify len , 3 is the len of large boat\\n if len(e) > 3 :\\n return False\\n if not is_vert(e) and not is_hori(e):\\n return False\\n return True\",\n \"def __bool__(self):\\n return self.fam.c_nonzero(self)\",\n \"def isFull(self) -> bool:\\n return self._elems == self._k\",\n \"def is_pos_unate(self, vs=None):\\n vs = self._expect_vars(vs)\\n basis = self.support - set(vs)\\n mincov = [PC_ZERO] * (1 << len(basis))\\n # Test whether table entries are monotonically increasing\\n for cf in self.iter_cofactors(vs):\\n for i, item in enumerate(cf.pcdata):\\n if mincov[i] == PC_ONE and item == PC_ZERO:\\n return False\\n mincov[i] = item\\n return True\",\n \"def is_1DNN(self):\\n if not self.dims == 1:\\n return False\\n if not set(self.__m__.keys()) <= set(((0,),(1,),(-1,))):\\n return False\\n\\n return True\",\n \"def is_algebraically_stable(self):\\n import numpy as np\\n\\n if np.any(self.b < 0):\\n return False\\n\\n # Check the eigenvalues for positive definiteness.\\n #\\n # We could also check whether the Cholesky factorization fails (=> not pos. def.).\\n # However, since we are interested in positive SEMIdefinite matrices, we have to\\n # regularize M by adding a small multiple of the identity matrix. Since \\\"small\\\"\\n # depends on the floating point type and this is probably not a bottleneck, using\\n # the eigenvalues seems to be fine.\\n rk = self.__num__()\\n B = np.diag(rk.b)\\n M = B.dot(rk.A) + rk.A.T.dot(B) - np.outer(rk.b, rk.b)\\n isposdef = np.all(np.linalg.eigvals(M) >= -10 * np.finfo(M.dtype).eps)\\n\\n return isposdef\",\n \"def _validate_cardinality(self, columns):\\n cards = [len(c.data) for c in columns]\\n c = np.unique(cards)\\n assert len(c) == 1, c\\n return c[0]\",\n \"def _is_vessel_full(self):\\n return np.size(np.where(self.end_of_lanes + (np.ones(self.lanes) * self.minimal_package) <= self.rows)) == 0\",\n \"def is_full_dimensional(self):\\n\\n return self.affine_dimension() == self.space_dimension()\",\n \"def testrescorr():\\n tau = np.zeros((2,50))\\n tau[0,25] = 2\\n tau[1,23] = 3\\n tau2 = spec_utils.res_corr(tau, 2, 8)\\n #Check flux conserved\\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\\n #Check expanded by expected amount\\n for i in (0,1):\\n assert np.size(np.where(tau2[i,:]> 0)) == 15\",\n \"def invertible(self):\\n a = self._data\\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]\",\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 is_full(board):\\n return False\",\n \"def test_rank_centrality():\\n for case in iter_testcases('pairwise'):\\n n_items = case[\\\"n_items\\\"]\\n data = case[\\\"data\\\"]\\n assert np.allclose(\\n case[\\\"rc_est\\\"], rank_centrality(n_items, data),\\n atol=ATOL, rtol=RTOL)\",\n \"def test_trivial_reduce_entropy_full_reduce(self):\\n original = pd.read_csv(MATRIX_1_FILENAME, index_col=0, header=0)\\n full_reduced = entropy_reduce_position_matrix(\\n original,\\n 1,\\n trivial_metric\\n )\\n self.assertEqual(full_reduced.shape[0], original.shape[0])\\n self.assertEqual(full_reduced.shape[1], 1)\",\n \"def _test_obsdup(t):\\n return t.shape[0] != len(set(t.ids(axis='observation')))\",\n \"def check_if_full(self):\\n pass\",\n \"def test02(self):\\n a = np.arange(3, self.N, 4)\\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def check_matrix_converge(self):\\n # If all of the running window changes are to the same value, then we stop learning\\n test = list(map(lambda x: int(\\n x.split(\\\"->\\\")[0]) == int(float(x.split(\\\"->\\\")[1])), self.running_update_window))\\n is_converged = np.count_nonzero(test) == self.running_update_window_len\\n return is_converged\",\n \"def square_check(self):\\n return len(self.matrix) == len(self.matrix[0])\",\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 __bool__(self):\\n return len(self.atoms) >= 1\",\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_trivial(self):\\n return self.dims == 0\",\n \"def check_if_column_full(self, board, x):\\n for y in reversed(range(self.height // 80)):\\n if board[x, 0] != 0:\\n return True\\n elif board[(x, y)] == 0:\\n return False\\n else:\\n y -= y\\n continue\",\n \"def has_fullhouse(self):\\n if self.has_pair() & self.has_three_of_a_kind():\\n self.rank_per_hand['5'] = \\\"full house\\\"\\n return True\\n return False\",\n \"def check_lin_independence(vectors):\\n if len(vectors) == 1:\\n return True\\n M = np.zeros([len(vectors), len(vectors[0])], dtype=np.complex_)\\n for i in range(len(vectors)):\\n M[i] = vectors[i].T\\n pl, u = lu(M, permute_l=True)\\n if any([np.count_nonzero(M[i]) == 0 for i in range(len(vectors))]):\\n return False #M must be full rank for linear independence\\n return True\",\n \"def single_roidb(entry):\\n gt_boxes = entry['boxes']\\n return gt_boxes.shape[0] <= 1\",\n \"def empty(self):\\n return self.numba_rtree._bounds_tree.shape[0] == 0\",\n \"def is_full(self):\\n\\n return self.count == len(self.array)\",\n \"def is_full(self):\",\n \"def part1b_0():\\n xs = exampleInput\\n _, forward = submission.computeForward(simpleCRF, xs)\\n for i in xrange(len(xs)):\\n grader.requireIsEqual( 1.0, sum( forward[i].values() ) )\",\n \"def check_matrix(self, matrix):\\n for i in range(self.size):\\n if (matrix[0][i] + matrix[-1][i] == i % 2 or matrix[0][i] + matrix[-1][i] == (i + 1) % 2) and (\\n matrix[i][0] + matrix[i][-1] == i % 2 or matrix[i][0] + matrix[i][-1] == (i + 1) % 2):\\n pass\\n else:\\n logging.debug(\\\"Matrix detection failed. Matrix passed to function \\\" + str(matrix))\\n return False\\n for i in range(self.size):\\n for j in range(self.size):\\n if matrix[i][j] > 1:\\n logging.debug(\\\"Matrix detection failed. Matrix passed to function \\\" + str(matrix))\\n return False\\n logging.info(\\\"Matrix detected : \\\" + str(matrix))\\n return True\",\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 has_straight_flush(self):\\n res = []\\n self.suit_hist()\\n for card in self.cards:\\n if self.suits[card.suit] >= 5:\\n res.append(card.rank)\\n self.is_sequence(res, 7)\",\n \"def __getStableConcepts(weight_matrix: Union[np.ndarray, pd.DataFrame]) -> np.ndarray:\\n stables = []\\n for i in range(len(weight_matrix)):\\n if np.all(weight_matrix[i] == 0):\\n stables.append(i)\\n\\n return stables\",\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) -> bool:\",\n \"def test02b(self):\\n a = np.ones(self.N, dtype='i4')\\n ac = bcolz.ones(self.N, dtype='i4', rootdir=self.rootdir)\\n self.assertTrue(a.dtype == ac.dtype)\\n self.assertTrue(np.all(a == ac[:]))\",\n \"def check_condor(self):\\n\\n self.cluster=self.info['mw_run']['1']\\n self.norm_with_cross=self.info['mw_run']['4']\\n self.condor_req=self.info['mw_run']['11']\\n\\n #type is automaticaly updated now\\n #self.cluster=int(condor)\\n #if norm_with_cross==\\\"F\\\":\\n # self.norm_with_cross=0\\n #else:\\n # self.norm_with_cross=1\",\n \"def test_continuity():\\n dc = cs[:,0:Nr-1]-cs[:,1:Nr]\\n assert dc.any < cmax\",\n \"def check_matrix(solver,matrix):\\n model_validated = True\\n #To check that the negation of the given formula is UNSAT under the clauses \\n #in the solver we check if the negation of each clause is UNSAT under these clauses.\\n for clause in matrix:\\n negated_claus=[-l for l in clause]\\n model_validated = not solver.solve(negated_claus)\\n if not model_validated:\\n print(\\\"Falsified Clause: {}\\\".format(clause))\\n return False\\n return True\",\n \"def test_rosenbrock(self):\\n fun = get_problem('rosenbrock', self.dimension)\\n self.assertEqual(fun(self.array2), 0.0)\",\n \"def test_is_99_1SpaceConnected(self):\\n self.assertEqual(self.hand.oneSpaceConnectedInd, 0)\\n self.assertEqual(self.hand.suitedInd, 0)\\n self.assertEqual(self.hand.premInd, 0)\\n self.assertEqual(self.hand.connectedInd, 0)\\n self.assertEqual(self.hand.PPInd, 1)\\n self.assertEqual(self.hand.PPCard, 9)\",\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_full(self):\\n return len(self.walls) == 4\",\n \"def test03(self):\\n a = np.arange(self.N, dtype=\\\"i1\\\")\\n ac = bcolz.arange(self.N, dtype=\\\"i1\\\", rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\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 test00(self):\\n a = np.arange(1, 11) > 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def _IsActuatorMessageAllValid(mode, node_labels, node_label_helper,\\n max_no_update_count, *attributes):\\n if mode == common.SPARSE_COMMS_MODE:\\n # Check the `valid` variable for TetherDown.\\n if attributes[1]:\\n for label in node_labels:\\n idx = node_label_helper.Value(label)\\n if attributes[0][idx].no_update_count > max_no_update_count:\\n return False\\n return True\\n return False\\n elif mode == common.FULL_COMMS_MODE:\\n for attribute in attributes:\\n if not struct_tree.IsValidElement(attribute):\\n return False\\n return True\\n else:\\n assert False\",\n \"def recip_rank(recs, truth):\\n good = recs['item'].isin(truth.index)\\n npz, = np.nonzero(good)\\n if len(npz):\\n return 1.0 / (npz[0] + 1.0)\\n else:\\n return 0.0\",\n \"def is_full(self):\\n return self.idx == self.len\",\n \"def is_full(self):\\n return len(self.keys) == self.order\",\n \"def is_full(self):\\n return set(self._parent.letters()) == set(self.winners())\",\n \"def part_one():\\n return len(numpy.where(grid > 1)[0])\",\n \"def is_full(self):\\n return self.top == self.size - 1\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58528364","0.575484","0.570392","0.5627623","0.5623395","0.5601164","0.5532206","0.5532206","0.5532206","0.5532206","0.5505377","0.5505377","0.5463339","0.54319173","0.542496","0.5393358","0.53866196","0.5373487","0.5358698","0.535044","0.53352785","0.53322196","0.533204","0.5299368","0.52977735","0.52902675","0.5285593","0.5280277","0.52762866","0.5275167","0.5272456","0.5266084","0.5261433","0.52592796","0.52588385","0.5257643","0.52571595","0.52522606","0.52456164","0.5241366","0.52405477","0.5240175","0.5238374","0.523679","0.52362704","0.52328104","0.5230974","0.52295876","0.52279216","0.5217233","0.5193984","0.51938504","0.51937896","0.5191646","0.5184615","0.5183726","0.5178751","0.51746464","0.51738095","0.5161561","0.5160389","0.5158924","0.5157158","0.515497","0.5154453","0.5153327","0.51498187","0.5148937","0.5147374","0.5138997","0.5137382","0.51304305","0.51272476","0.51203513","0.5119629","0.5117596","0.5115448","0.51140296","0.51122206","0.5111208","0.5111007","0.5106627","0.5106546","0.5100364","0.5095346","0.50931305","0.5092104","0.50736207","0.5073399","0.5070614","0.5066587","0.50649506","0.5063265","0.5062712","0.5059589","0.5059349","0.50587195","0.5058121","0.5055729","0.5048694"],"string":"[\n \"0.58528364\",\n \"0.575484\",\n \"0.570392\",\n \"0.5627623\",\n \"0.5623395\",\n \"0.5601164\",\n \"0.5532206\",\n \"0.5532206\",\n \"0.5532206\",\n \"0.5532206\",\n \"0.5505377\",\n \"0.5505377\",\n \"0.5463339\",\n \"0.54319173\",\n \"0.542496\",\n \"0.5393358\",\n \"0.53866196\",\n \"0.5373487\",\n \"0.5358698\",\n \"0.535044\",\n \"0.53352785\",\n \"0.53322196\",\n \"0.533204\",\n \"0.5299368\",\n \"0.52977735\",\n \"0.52902675\",\n \"0.5285593\",\n \"0.5280277\",\n \"0.52762866\",\n \"0.5275167\",\n \"0.5272456\",\n \"0.5266084\",\n \"0.5261433\",\n \"0.52592796\",\n \"0.52588385\",\n \"0.5257643\",\n \"0.52571595\",\n \"0.52522606\",\n \"0.52456164\",\n \"0.5241366\",\n \"0.52405477\",\n \"0.5240175\",\n \"0.5238374\",\n \"0.523679\",\n \"0.52362704\",\n \"0.52328104\",\n \"0.5230974\",\n \"0.52295876\",\n \"0.52279216\",\n \"0.5217233\",\n \"0.5193984\",\n \"0.51938504\",\n \"0.51937896\",\n \"0.5191646\",\n \"0.5184615\",\n \"0.5183726\",\n \"0.5178751\",\n \"0.51746464\",\n \"0.51738095\",\n \"0.5161561\",\n \"0.5160389\",\n \"0.5158924\",\n \"0.5157158\",\n \"0.515497\",\n \"0.5154453\",\n \"0.5153327\",\n \"0.51498187\",\n \"0.5148937\",\n \"0.5147374\",\n \"0.5138997\",\n \"0.5137382\",\n \"0.51304305\",\n \"0.51272476\",\n \"0.51203513\",\n \"0.5119629\",\n \"0.5117596\",\n \"0.5115448\",\n \"0.51140296\",\n \"0.51122206\",\n \"0.5111208\",\n \"0.5111007\",\n \"0.5106627\",\n \"0.5106546\",\n \"0.5100364\",\n \"0.5095346\",\n \"0.50931305\",\n \"0.5092104\",\n \"0.50736207\",\n \"0.5073399\",\n \"0.5070614\",\n \"0.5066587\",\n \"0.50649506\",\n \"0.5063265\",\n \"0.5062712\",\n \"0.5059589\",\n \"0.5059349\",\n \"0.50587195\",\n \"0.5058121\",\n \"0.5055729\",\n \"0.5048694\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62513566"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89498,"cells":{"query":{"kind":"string","value":"Check that the controllability matrix [B, BA, ..., BA^{n1}] is full rank"},"document":{"kind":"string","value":"def check_controllability(A, B):\n assert len(A.shape) == 2\n dim = A.shape[0]\n stack = []\n for i in range(dim):\n term = B @ np.linalg.matrix_power(A, i)\n stack.append(term)\n grammian = np.hstack(stack)\n return np.linalg.matrix_rank(grammian) == dim"},"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 fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()","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_board_full(board):\n return not any(0 in val for val in board)","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_board_full(self):\n for position in self.positions:\n if self.is_position_availible(position):\n return False\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 is_solvable(self):\n for row, col in np.ndindex(9, 9):\n if len(self.possible_values[row][col]) < 1 and self.final_values[row][col] == 0:\n return False\n return True","def is_full_row_rank(G):\n assert len(G.shape) == 2, \"should be a 2d numpy arrayp\"\n rows = G.shape[0]\n rank = np.linalg.matrix_rank(G)\n return rank >= rows","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 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 empty(self):\n return self.numba_rtree._bounds_tree.shape[0] == 0","def valid(self, col, rank):\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0","def valid(self, col, rank):\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0","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_full(board):\r\n return False","def valid_attempt(board):\n for i in range(n):\n if [] in board[i]:\n return 0\n return 1","def is_full(board):\n return False","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 test00(self):\n a = np.arange(self.N)\n ac = bcolz.arange(self.N, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","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 check_observability(A, C):\n assert len(A.shape) == 2\n dim = A.shape[0]\n stack = []\n for i in range(dim):\n term = C @ np.linalg.matrix_power(A, i)\n stack.append(term)\n obs_grammian = np.vstack(stack)\n return np.linalg.matrix_rank(obs_grammian) == dim","def test_overFill(self):\r\n high = 15\r\n for _ in range(high):\r\n self.nb.add(_)\r\n\r\n self.assertFalse(self.nb.isEmpty())\r\n self.assertTrue(self.nb.isFull())\r\n self.assertEqual(5, len(self.nb))\r\n\r\n # check all are still present\r\n for _ in range(high-1, high - SIZE-1, -1):\r\n self.assertTrue(_ in self.nb)","def checkNumNeighbors():","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_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 sudoku_isready(A):\r\n x = isqrt(len(A))\r\n if x*x == len(A):\r\n return True\r\n return False","def has_remained_B(N, cur):\n for n in range(N):\n ## cardinality of B_n\n card = get_parameter(cur, par=(\"card_B%d\" % n))\n if card > 0:\n return True\n return False","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 test_nullspace_blocked(input_matrix):\n mat = sp.Matrix(input_matrix)\n assert sorted(mat.nullspace()) == sorted(nullspace_blocked(mat))","def check_if_column_full(self, board, x):\n for y in reversed(range(self.height // 80)):\n if board[x, 0] != 0:\n return True\n elif board[(x, y)] == 0:\n return False\n else:\n y -= y\n continue","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_validate_complete_board_all_filled_all_zeroes(self):\n players_scoreboard = {'ones': 0, 'twos': 0, 'threes': 0, 'fours': 0, 'fives': 0,\n 'sixes': 0, 'three of a kind': 0, 'four of a kind': 0, 'full house': 0,\n 'small straight': 0, 'large straight': 0, 'chance': 0, 'yahtzee': 0}\n actual = validate_complete_board(players_scoreboard)\n expected = True\n self.assertEqual(expected, actual)","def isbra(qob):\n return qob.shape[0] == 1 and qob.shape[1] > 1 # Row vector check","def _check_nmant(np_type, nmant):\n np_type = np.dtype(np_type).type\n max_contig = np_type(2 ** (nmant + 1)) # maximum of contiguous integers\n tests = max_contig + np.array([-2, -1, 0, 1, 2], dtype=np_type)\n return np.all(tests - max_contig == [-2, -1, 0, 0, 2])","def check_constraints ( A, S, complete ) :\n\t\n\tok = True\n\t\n\tfor i in range(len(complete)) :\n\t\tif complete[i] :\n\t\t\tif not (dot(A[i],S) == 0) :\n\t\t\t\tok = False\n\t\t\t\tprint '\\n'\n\t\t\t\tprint '*** warning *** constraint %d not verified' % (i)\n\t\t\t\tvars_inds = (where(abs(A[i]) == 1))[0]\n\t\t\t\tprint 'variables involved:', vars_inds\n\t\t\t\tprint 'displacements:', S[vars_inds]\n\t\t\t\tprint\n\t\t\t\t#programPause = raw_input(\"Press the <ENTER> key to continue...\")\n\t\t\t\t\n\treturn ok","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 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 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_fullp(self):\n front = (self.front + 1) % self.length\n return front == self.rear","def test01(self):\n a = np.arange(3, self.N)\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def test02b(self):\n a = np.ones(self.N, dtype='i4')\n ac = bcolz.ones(self.N, dtype='i4', rootdir=self.rootdir)\n self.assertTrue(a.dtype == ac.dtype)\n self.assertTrue(np.all(a == ac[:]))","def is_full(self):\n return self.top == self.size - 1","def test_board_full(self):\n actual = self.controller.check_tie()\n self.assertTrue(actual)","def isFull(self) -> bool:\n return (self.rear + 1) % self.capacity == self.front","def test_caller_is_not_full(self):\n partially_filled = TruthTable('A xor B', fill_all=False)\n partially_filled.fill(A=0)\n\n with self.assertRaises(RequiresFullTableError):\n partially_filled.equivalent_to('B xor A')","def solve(board):\n find = find_blank(board)\n \n if not find:\n return True\n #will loop through untill the blanks are filled\n\n\n\n else:\n row, col = find\n\n for i in range(1, 10):\n if valid(board, i, (row, col)):\n board[row][col] = i\n\n if solve(board):\n return True\n board[row][col] = 0\n return False","def _only_one_type(self):\n num_larger_than_1 = 0\n for symb, indices in self.atoms_indx.items():\n if len(indices) > 0:\n num_larger_than_1 += 1\n return num_larger_than_1 <= 1","def isFull(self) -> bool:\n return self._elems == self._k","def solve(bo):\n find = find_empty(bo)\n\n if find:\n row, col = find\n else:\n return True\n\n for i in range(1,10):\n if valid(bo, (row, col), i):\n bo[row][col] = i\n\n if solve(bo):\n return True\n\n bo[row][col] = 0\n\n return False","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 validate(self):\n if self.isEmpty(): return False\n\n sum = 0\n for item in self.mask:\n sum += item.prob\n return sum == 1","def checkvalid(self,borad,row,col,n):\n # check the above column has 'Q'\n i=0\n while i!=row:\n if borad[i][col]=='Q':\n return False\n i+=1\n # check the left-top 135 and right-top 45\n i,j=row-1,col-1\n while i>=0 and j>=0:\n if borad[i][j]=='Q':\n return False\n i-=1\n j-=1\n \n i,j=row-1,col+1\n while i>=0 and j<n:\n if borad[i][j]=='Q':\n return False\n i-=1\n j+=1\n \n return True","def test_basic_cardinality(self):\n dim = Real(\"yolo\", \"reciprocal\", 0.043, 2.3, precision=2)\n order_0012 = np.arange(43, 99 + 1)\n order_010 = np.arange(10, 99 + 1)\n order_23 = np.arange(10, 23 + 1)\n assert dim.cardinality == sum(map(len, [order_0012, order_010, order_23]))","def isFull(T):\r\n return len(T.data) >= T.max_data","def check_net_finality(self):\n for place in self.P:\n if place.M > 0 and not self.check_place_finality(place):\n return False\n return True","def test02(self):\n a = np.arange(3, self.N, 4)\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def invertible(self):\n a = self._data\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]","def valid(n, board, row, col):\n for i in range(col):\n if board[row][i] == 1:\n return False\n x = row\n y = col\n while x >= 0 and y >= 0:\n if board[x][y] == 1:\n return False\n x -= 1\n y -= 1\n x = row\n y = col\n while x < n and y >= 0:\n if board[x][y] == 1:\n return False\n x += 1\n y -= 1\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 test_board_not_full(self):\n\n self.controller.model.board[0][0] = '-'\n actual = self.controller.check_tie()\n self.assertFalse(actual)","def is_full_board(board):\n return config.NO_PLAYER not in board","def check_if_full(self):\n pass","def is_complete(matrix,size):\n for _,row in matrix.items():\n if len(row) < size:\n return False\n return True","def illegal(self):\r\n ## First checks for integer value\r\n if type(self.blockList) is int: return 1\r\n ## Then checks for 6 rows\r\n if len(self.blockList) > 6: return 1\r\n for row in self.blockList:\r\n ## Then checks that each row has 6 columns\r\n if len(self.blockList[row]) > 6: return 1\r\n for column in self.blockList[row]:\r\n ## 18 blocks is the maximum number of blocks that can be on the board\r\n if block < 0 or block > 18: return 1\r\n return 0","def single_roidb(entry):\n gt_boxes = entry['boxes']\n return gt_boxes.shape[0] <= 1","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","def checkMatrix(i,j):\n # print(i,j)\n counter = Counter([grid[di][dj] for di in range(i,i+3) for dj in range(j,j+3)])\n for k in range(1,10):\n if counter[k] != 1:\n return False\n\n rows_sum = [sum(grid[k][j:j+3]) for k in range(i,i+3)]\n # print(rows_sum)\n if not all(m == 15 for m in rows_sum):\n return False\n cols_sum = [sum(grid[q][k] for q in range(i,i+3)) for k in range(j,j+3)]\n # print(cols_sum)\n if not all(m == 15 for m in cols_sum):\n return False\n dgl_sum = sum(grid[i+k][j+k] for k in range(3))\n anti_dgl_sum = sum(grid[i+k][j+2-k] for k in range(3))\n # print(dgl_sum, anti_dgl_sum)\n if dgl_sum != 15 or anti_dgl_sum != 15:\n return False\n return True","def goal_test(state): \n size = len(state)\n for i in range (size):\n for j in range (size):\n if state[i][j] != i*size + j:\n return False \n return True","def is_board_valid(bd):\n return is_rows_valid(bd) and is_cols_valid(bd) and is_sqrs_valid(bd)","def is_complete(self):\n is_complete = True\n \n if (type(self.N) is not IntType) or self.N < 2:\n warnings.warn('N not set up properly.')\n is_complete = False\n \n if self.m is None or len(self.m) != self.N:\n warnings.warn('m not set up properly.')\n is_complete = False\n \n if self.R is None or len(self.R) != self.N:\n warnings.warn('R not set up properly.')\n is_complete = False\n \n if self.a is None or len(self.a) != self.N - 1:\n warnings.warn('a not set up properly.')\n is_complete = False\n \n if self.force is None or len(self.force) != self.N:\n warnings.warn('force not set up properly.')\n is_complete = False\n \n if self.Delta is None or len(self.Delta) != self.N - 1:\n warnings.warn('Delta not set up properly.')\n is_complete = False\n \n if self.n is None or len(self.n) != self.N - 1:\n warnings.warn('n not set up properly.')\n is_complete = False\n \n if self.beta < 0.0:\n warnings.warn('beta not set up properly.')\n is_complete = False\n \n if self.m0 < 0.0:\n warnings.warn('m0 not set up properly.')\n is_complete = False\n \n if self.mu < 0.0:\n warnings.warn('mu not set up properly.')\n is_complete = False\n \n return is_complete","def test03(self):\n a = np.arange(self.N, dtype=\"i1\")\n ac = bcolz.arange(self.N, dtype=\"i1\", rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def check_grid(grid: List):\n for row in range(9):\n for col in range(9):\n if grid[row][col] == 0:\n return False\n return True","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 isSafe(board, row, col, n):\n\n \"\"\" veriying the row on left side \"\"\"\n for i in range(col):\n if board[row][i] == 1:\n return False\n\n \"\"\" veriying upper diagonal on left side \"\"\"\n for i,j in zip(range(row,-1,-1), range(col,-1,-1)):\n if board[i][j] == 1:\n return False\n\n \"\"\" veriying upper diagonal on left side \"\"\"\n for i,j in zip(range(row, n, 1), range(col,-1,-1)):\n if board[i][j] == 1:\n return False\n\n return True","def check_matrix(self, matrix):\n for i in range(self.size):\n if (matrix[0][i] + matrix[-1][i] == i % 2 or matrix[0][i] + matrix[-1][i] == (i + 1) % 2) and (\n matrix[i][0] + matrix[i][-1] == i % 2 or matrix[i][0] + matrix[i][-1] == (i + 1) % 2):\n pass\n else:\n logging.debug(\"Matrix detection failed. Matrix passed to function \" + str(matrix))\n return False\n for i in range(self.size):\n for j in range(self.size):\n if matrix[i][j] > 1:\n logging.debug(\"Matrix detection failed. Matrix passed to function \" + str(matrix))\n return False\n logging.info(\"Matrix detected : \" + str(matrix))\n return True","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 check_grid(self) -> None:\n if not len(self.grid) == 81:\n raise ValueError(\"Grid does not have 81 elements. Aborting\")","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 checkBoardValid(self):\n for i in range(9):\n for j in range(9):\n if self.board[i, j] == 0:\n continue\n\n if not self.isPossibleAssign((i, j), self.board[i, j]):\n return False\n\n return True","def goal_test(self, state):\n return state.board==range(self.N*self.N)","def _check_satisfied_neighborhood(\n recursive_counter: int, stop_recursive: int, matrix_size: int\n) -> bool:\n return recursive_counter >= stop_recursive * (matrix_size ** 2)","def on_board(self):\n if -1 < self._rank < 8 and \\\n -1 < self._file < 8:\n return True\n\n return False","def test_nbands_vrt_array(self):\n self.assertEqual(_test_array(landsat_vrt).shape[0], 2)","def test_fill_nnz(seed, shape):\n # Generate 4 matrices of 100x100 pixls with random density between 0 and 10%\n mats = gen_mats(seed, shape)\n nnz_union = pap.get_nnz_union(mats)\n # Check if all matrices have been filled to the sparsity of nnz_union\n for mat in mats:\n filled = pap.fill_nnz(mat, nnz_union)\n assert filled.nnz == nnz_union.shape[0]","def check(m) :\n #find Connected-component\n lst = find_c(m)\n for e in lst :\n # verify len , 3 is the len of large boat\n if len(e) > 3 :\n return False\n if not is_vert(e) and not is_hori(e):\n return False\n return True","def test_fill(self):\r\n for _ in range(SIZE):\r\n self.nb.add(_)\r\n\r\n self.assertFalse(self.nb.isEmpty())\r\n self.assertTrue(self.nb.isFull())\r\n self.assertEqual(5, len(self.nb))","def square_check(self):\n return len(self.matrix) == len(self.matrix[0])","def check_neighbours(self):\n for p in self.targetCell.possibilities:\n if p != 0:\n if p not in self.targetCell.row_neighbour_possibilities:\n self.targetCell.solve(p)\n return True\n elif p not in self.targetCell.column_neighbour_possibilities:\n self.targetCell.solve(p)\n return True\n elif p not in self.targetCell.box_neighbour_possibilities:\n self.targetCell.solve(p)\n return True\n return False","def checkEmpty(grid):\n for x in range(len(grid.board)):\n for y in range(len(grid.board[0])):\n if grid.board[x][y] == 0:\n return True\n return False","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_free(self, arr):\n cell_location = self.cartesian_to_cell(arr)\n cell = self.occ_matrix[cell_location[0], cell_location[1]]\n return cell == 0","def is_full(self, row, col):\n self._validate_indexes(row, col)\n return self._uf.connected(self._top_idx, row * self._n + col)","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):","def isEmpty(self):\n return self._N == 0","def validate_empty_branches(nanowire, min_free_branch, msg):\n score = 0\n valid = False\n\n for intersection in nanowire:\n free_b = 0\n for branch in intersection:\n min_free_pos = len(branch)\n free_p = 0\n for tup in branch:\n if not isinstance(tup, dict):\n continue\n if list(tup.values())[0] == 0:\n free_p += 1\n else:\n free_p = 0\n if free_p>=min_free_pos:\n free_b += 1\n if free_b>=min_free_branch:\n valid = True\n\n if valid:\n score += 1\n # if score==0:\n # raise exception.NoEmptyBranchException(msg)\n return score","def is_full(self):\n\n return self.count == len(self.array)","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 is_full(self) -> bool:"],"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 fullGrid(state):\\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()\",\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_board_full(board):\\n return not any(0 in val for val in board)\",\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_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_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 is_solvable(self):\\n for row, col in np.ndindex(9, 9):\\n if len(self.possible_values[row][col]) < 1 and self.final_values[row][col] == 0:\\n return False\\n return True\",\n \"def is_full_row_rank(G):\\n assert len(G.shape) == 2, \\\"should be a 2d numpy arrayp\\\"\\n rows = G.shape[0]\\n rank = np.linalg.matrix_rank(G)\\n return rank >= rows\",\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 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 empty(self):\\n return self.numba_rtree._bounds_tree.shape[0] == 0\",\n \"def valid(self, col, rank):\\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0\",\n \"def valid(self, col, rank):\\n return rank <= 8 and rank > 0 and self.getColIdx(col) < 8 and self.getColIdx(col) >= 0\",\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_full(board):\\r\\n return False\",\n \"def valid_attempt(board):\\n for i in range(n):\\n if [] in board[i]:\\n return 0\\n return 1\",\n \"def is_full(board):\\n return False\",\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 test00(self):\\n a = np.arange(self.N)\\n ac = bcolz.arange(self.N, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\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 check_observability(A, C):\\n assert len(A.shape) == 2\\n dim = A.shape[0]\\n stack = []\\n for i in range(dim):\\n term = C @ np.linalg.matrix_power(A, i)\\n stack.append(term)\\n obs_grammian = np.vstack(stack)\\n return np.linalg.matrix_rank(obs_grammian) == dim\",\n \"def test_overFill(self):\\r\\n high = 15\\r\\n for _ in range(high):\\r\\n self.nb.add(_)\\r\\n\\r\\n self.assertFalse(self.nb.isEmpty())\\r\\n self.assertTrue(self.nb.isFull())\\r\\n self.assertEqual(5, len(self.nb))\\r\\n\\r\\n # check all are still present\\r\\n for _ in range(high-1, high - SIZE-1, -1):\\r\\n self.assertTrue(_ in self.nb)\",\n \"def checkNumNeighbors():\",\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_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 sudoku_isready(A):\\r\\n x = isqrt(len(A))\\r\\n if x*x == len(A):\\r\\n return True\\r\\n return False\",\n \"def has_remained_B(N, cur):\\n for n in range(N):\\n ## cardinality of B_n\\n card = get_parameter(cur, par=(\\\"card_B%d\\\" % n))\\n if card > 0:\\n return True\\n return False\",\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 test_nullspace_blocked(input_matrix):\\n mat = sp.Matrix(input_matrix)\\n assert sorted(mat.nullspace()) == sorted(nullspace_blocked(mat))\",\n \"def check_if_column_full(self, board, x):\\n for y in reversed(range(self.height // 80)):\\n if board[x, 0] != 0:\\n return True\\n elif board[(x, y)] == 0:\\n return False\\n else:\\n y -= y\\n continue\",\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_validate_complete_board_all_filled_all_zeroes(self):\\n players_scoreboard = {'ones': 0, 'twos': 0, 'threes': 0, 'fours': 0, 'fives': 0,\\n 'sixes': 0, 'three of a kind': 0, 'four of a kind': 0, 'full house': 0,\\n 'small straight': 0, 'large straight': 0, 'chance': 0, 'yahtzee': 0}\\n actual = validate_complete_board(players_scoreboard)\\n expected = True\\n self.assertEqual(expected, actual)\",\n \"def isbra(qob):\\n return qob.shape[0] == 1 and qob.shape[1] > 1 # Row vector check\",\n \"def _check_nmant(np_type, nmant):\\n np_type = np.dtype(np_type).type\\n max_contig = np_type(2 ** (nmant + 1)) # maximum of contiguous integers\\n tests = max_contig + np.array([-2, -1, 0, 1, 2], dtype=np_type)\\n return np.all(tests - max_contig == [-2, -1, 0, 0, 2])\",\n \"def check_constraints ( A, S, complete ) :\\n\\t\\n\\tok = True\\n\\t\\n\\tfor i in range(len(complete)) :\\n\\t\\tif complete[i] :\\n\\t\\t\\tif not (dot(A[i],S) == 0) :\\n\\t\\t\\t\\tok = False\\n\\t\\t\\t\\tprint '\\\\n'\\n\\t\\t\\t\\tprint '*** warning *** constraint %d not verified' % (i)\\n\\t\\t\\t\\tvars_inds = (where(abs(A[i]) == 1))[0]\\n\\t\\t\\t\\tprint 'variables involved:', vars_inds\\n\\t\\t\\t\\tprint 'displacements:', S[vars_inds]\\n\\t\\t\\t\\tprint\\n\\t\\t\\t\\t#programPause = raw_input(\\\"Press the <ENTER> key to continue...\\\")\\n\\t\\t\\t\\t\\n\\treturn ok\",\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 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 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_fullp(self):\\n front = (self.front + 1) % self.length\\n return front == self.rear\",\n \"def test01(self):\\n a = np.arange(3, self.N)\\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def test02b(self):\\n a = np.ones(self.N, dtype='i4')\\n ac = bcolz.ones(self.N, dtype='i4', rootdir=self.rootdir)\\n self.assertTrue(a.dtype == ac.dtype)\\n self.assertTrue(np.all(a == ac[:]))\",\n \"def is_full(self):\\n return self.top == self.size - 1\",\n \"def test_board_full(self):\\n actual = self.controller.check_tie()\\n self.assertTrue(actual)\",\n \"def isFull(self) -> bool:\\n return (self.rear + 1) % self.capacity == self.front\",\n \"def test_caller_is_not_full(self):\\n partially_filled = TruthTable('A xor B', fill_all=False)\\n partially_filled.fill(A=0)\\n\\n with self.assertRaises(RequiresFullTableError):\\n partially_filled.equivalent_to('B xor A')\",\n \"def solve(board):\\n find = find_blank(board)\\n \\n if not find:\\n return True\\n #will loop through untill the blanks are filled\\n\\n\\n\\n else:\\n row, col = find\\n\\n for i in range(1, 10):\\n if valid(board, i, (row, col)):\\n board[row][col] = i\\n\\n if solve(board):\\n return True\\n board[row][col] = 0\\n return False\",\n \"def _only_one_type(self):\\n num_larger_than_1 = 0\\n for symb, indices in self.atoms_indx.items():\\n if len(indices) > 0:\\n num_larger_than_1 += 1\\n return num_larger_than_1 <= 1\",\n \"def isFull(self) -> bool:\\n return self._elems == self._k\",\n \"def solve(bo):\\n find = find_empty(bo)\\n\\n if find:\\n row, col = find\\n else:\\n return True\\n\\n for i in range(1,10):\\n if valid(bo, (row, col), i):\\n bo[row][col] = i\\n\\n if solve(bo):\\n return True\\n\\n bo[row][col] = 0\\n\\n return False\",\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 validate(self):\\n if self.isEmpty(): return False\\n\\n sum = 0\\n for item in self.mask:\\n sum += item.prob\\n return sum == 1\",\n \"def checkvalid(self,borad,row,col,n):\\n # check the above column has 'Q'\\n i=0\\n while i!=row:\\n if borad[i][col]=='Q':\\n return False\\n i+=1\\n # check the left-top 135 and right-top 45\\n i,j=row-1,col-1\\n while i>=0 and j>=0:\\n if borad[i][j]=='Q':\\n return False\\n i-=1\\n j-=1\\n \\n i,j=row-1,col+1\\n while i>=0 and j<n:\\n if borad[i][j]=='Q':\\n return False\\n i-=1\\n j+=1\\n \\n return True\",\n \"def test_basic_cardinality(self):\\n dim = Real(\\\"yolo\\\", \\\"reciprocal\\\", 0.043, 2.3, precision=2)\\n order_0012 = np.arange(43, 99 + 1)\\n order_010 = np.arange(10, 99 + 1)\\n order_23 = np.arange(10, 23 + 1)\\n assert dim.cardinality == sum(map(len, [order_0012, order_010, order_23]))\",\n \"def isFull(T):\\r\\n return len(T.data) >= T.max_data\",\n \"def check_net_finality(self):\\n for place in self.P:\\n if place.M > 0 and not self.check_place_finality(place):\\n return False\\n return True\",\n \"def test02(self):\\n a = np.arange(3, self.N, 4)\\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def invertible(self):\\n a = self._data\\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]\",\n \"def valid(n, board, row, col):\\n for i in range(col):\\n if board[row][i] == 1:\\n return False\\n x = row\\n y = col\\n while x >= 0 and y >= 0:\\n if board[x][y] == 1:\\n return False\\n x -= 1\\n y -= 1\\n x = row\\n y = col\\n while x < n and y >= 0:\\n if board[x][y] == 1:\\n return False\\n x += 1\\n y -= 1\\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 test_board_not_full(self):\\n\\n self.controller.model.board[0][0] = '-'\\n actual = self.controller.check_tie()\\n self.assertFalse(actual)\",\n \"def is_full_board(board):\\n return config.NO_PLAYER not in board\",\n \"def check_if_full(self):\\n pass\",\n \"def is_complete(matrix,size):\\n for _,row in matrix.items():\\n if len(row) < size:\\n return False\\n return True\",\n \"def illegal(self):\\r\\n ## First checks for integer value\\r\\n if type(self.blockList) is int: return 1\\r\\n ## Then checks for 6 rows\\r\\n if len(self.blockList) > 6: return 1\\r\\n for row in self.blockList:\\r\\n ## Then checks that each row has 6 columns\\r\\n if len(self.blockList[row]) > 6: return 1\\r\\n for column in self.blockList[row]:\\r\\n ## 18 blocks is the maximum number of blocks that can be on the board\\r\\n if block < 0 or block > 18: return 1\\r\\n return 0\",\n \"def single_roidb(entry):\\n gt_boxes = entry['boxes']\\n return gt_boxes.shape[0] <= 1\",\n \"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\",\n \"def checkMatrix(i,j):\\n # print(i,j)\\n counter = Counter([grid[di][dj] for di in range(i,i+3) for dj in range(j,j+3)])\\n for k in range(1,10):\\n if counter[k] != 1:\\n return False\\n\\n rows_sum = [sum(grid[k][j:j+3]) for k in range(i,i+3)]\\n # print(rows_sum)\\n if not all(m == 15 for m in rows_sum):\\n return False\\n cols_sum = [sum(grid[q][k] for q in range(i,i+3)) for k in range(j,j+3)]\\n # print(cols_sum)\\n if not all(m == 15 for m in cols_sum):\\n return False\\n dgl_sum = sum(grid[i+k][j+k] for k in range(3))\\n anti_dgl_sum = sum(grid[i+k][j+2-k] for k in range(3))\\n # print(dgl_sum, anti_dgl_sum)\\n if dgl_sum != 15 or anti_dgl_sum != 15:\\n return False\\n return True\",\n \"def goal_test(state): \\n size = len(state)\\n for i in range (size):\\n for j in range (size):\\n if state[i][j] != i*size + j:\\n return False \\n return True\",\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_complete(self):\\n is_complete = True\\n \\n if (type(self.N) is not IntType) or self.N < 2:\\n warnings.warn('N not set up properly.')\\n is_complete = False\\n \\n if self.m is None or len(self.m) != self.N:\\n warnings.warn('m not set up properly.')\\n is_complete = False\\n \\n if self.R is None or len(self.R) != self.N:\\n warnings.warn('R not set up properly.')\\n is_complete = False\\n \\n if self.a is None or len(self.a) != self.N - 1:\\n warnings.warn('a not set up properly.')\\n is_complete = False\\n \\n if self.force is None or len(self.force) != self.N:\\n warnings.warn('force not set up properly.')\\n is_complete = False\\n \\n if self.Delta is None or len(self.Delta) != self.N - 1:\\n warnings.warn('Delta not set up properly.')\\n is_complete = False\\n \\n if self.n is None or len(self.n) != self.N - 1:\\n warnings.warn('n not set up properly.')\\n is_complete = False\\n \\n if self.beta < 0.0:\\n warnings.warn('beta not set up properly.')\\n is_complete = False\\n \\n if self.m0 < 0.0:\\n warnings.warn('m0 not set up properly.')\\n is_complete = False\\n \\n if self.mu < 0.0:\\n warnings.warn('mu not set up properly.')\\n is_complete = False\\n \\n return is_complete\",\n \"def test03(self):\\n a = np.arange(self.N, dtype=\\\"i1\\\")\\n ac = bcolz.arange(self.N, dtype=\\\"i1\\\", rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def check_grid(grid: List):\\n for row in range(9):\\n for col in range(9):\\n if grid[row][col] == 0:\\n return False\\n return True\",\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 isSafe(board, row, col, n):\\n\\n \\\"\\\"\\\" veriying the row on left side \\\"\\\"\\\"\\n for i in range(col):\\n if board[row][i] == 1:\\n return False\\n\\n \\\"\\\"\\\" veriying upper diagonal on left side \\\"\\\"\\\"\\n for i,j in zip(range(row,-1,-1), range(col,-1,-1)):\\n if board[i][j] == 1:\\n return False\\n\\n \\\"\\\"\\\" veriying upper diagonal on left side \\\"\\\"\\\"\\n for i,j in zip(range(row, n, 1), range(col,-1,-1)):\\n if board[i][j] == 1:\\n return False\\n\\n return True\",\n \"def check_matrix(self, matrix):\\n for i in range(self.size):\\n if (matrix[0][i] + matrix[-1][i] == i % 2 or matrix[0][i] + matrix[-1][i] == (i + 1) % 2) and (\\n matrix[i][0] + matrix[i][-1] == i % 2 or matrix[i][0] + matrix[i][-1] == (i + 1) % 2):\\n pass\\n else:\\n logging.debug(\\\"Matrix detection failed. Matrix passed to function \\\" + str(matrix))\\n return False\\n for i in range(self.size):\\n for j in range(self.size):\\n if matrix[i][j] > 1:\\n logging.debug(\\\"Matrix detection failed. Matrix passed to function \\\" + str(matrix))\\n return False\\n logging.info(\\\"Matrix detected : \\\" + str(matrix))\\n return True\",\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 check_grid(self) -> None:\\n if not len(self.grid) == 81:\\n raise ValueError(\\\"Grid does not have 81 elements. Aborting\\\")\",\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 checkBoardValid(self):\\n for i in range(9):\\n for j in range(9):\\n if self.board[i, j] == 0:\\n continue\\n\\n if not self.isPossibleAssign((i, j), self.board[i, j]):\\n return False\\n\\n return True\",\n \"def goal_test(self, state):\\n return state.board==range(self.N*self.N)\",\n \"def _check_satisfied_neighborhood(\\n recursive_counter: int, stop_recursive: int, matrix_size: int\\n) -> bool:\\n return recursive_counter >= stop_recursive * (matrix_size ** 2)\",\n \"def on_board(self):\\n if -1 < self._rank < 8 and \\\\\\n -1 < self._file < 8:\\n return True\\n\\n return False\",\n \"def test_nbands_vrt_array(self):\\n self.assertEqual(_test_array(landsat_vrt).shape[0], 2)\",\n \"def test_fill_nnz(seed, shape):\\n # Generate 4 matrices of 100x100 pixls with random density between 0 and 10%\\n mats = gen_mats(seed, shape)\\n nnz_union = pap.get_nnz_union(mats)\\n # Check if all matrices have been filled to the sparsity of nnz_union\\n for mat in mats:\\n filled = pap.fill_nnz(mat, nnz_union)\\n assert filled.nnz == nnz_union.shape[0]\",\n \"def check(m) :\\n #find Connected-component\\n lst = find_c(m)\\n for e in lst :\\n # verify len , 3 is the len of large boat\\n if len(e) > 3 :\\n return False\\n if not is_vert(e) and not is_hori(e):\\n return False\\n return True\",\n \"def test_fill(self):\\r\\n for _ in range(SIZE):\\r\\n self.nb.add(_)\\r\\n\\r\\n self.assertFalse(self.nb.isEmpty())\\r\\n self.assertTrue(self.nb.isFull())\\r\\n self.assertEqual(5, len(self.nb))\",\n \"def square_check(self):\\n return len(self.matrix) == len(self.matrix[0])\",\n \"def check_neighbours(self):\\n for p in self.targetCell.possibilities:\\n if p != 0:\\n if p not in self.targetCell.row_neighbour_possibilities:\\n self.targetCell.solve(p)\\n return True\\n elif p not in self.targetCell.column_neighbour_possibilities:\\n self.targetCell.solve(p)\\n return True\\n elif p not in self.targetCell.box_neighbour_possibilities:\\n self.targetCell.solve(p)\\n return True\\n return False\",\n \"def checkEmpty(grid):\\n for x in range(len(grid.board)):\\n for y in range(len(grid.board[0])):\\n if grid.board[x][y] == 0:\\n return True\\n return False\",\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_free(self, arr):\\n cell_location = self.cartesian_to_cell(arr)\\n cell = self.occ_matrix[cell_location[0], cell_location[1]]\\n return cell == 0\",\n \"def is_full(self, row, col):\\n self._validate_indexes(row, col)\\n return self._uf.connected(self._top_idx, row * self._n + col)\",\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):\",\n \"def isEmpty(self):\\n return self._N == 0\",\n \"def validate_empty_branches(nanowire, min_free_branch, msg):\\n score = 0\\n valid = False\\n\\n for intersection in nanowire:\\n free_b = 0\\n for branch in intersection:\\n min_free_pos = len(branch)\\n free_p = 0\\n for tup in branch:\\n if not isinstance(tup, dict):\\n continue\\n if list(tup.values())[0] == 0:\\n free_p += 1\\n else:\\n free_p = 0\\n if free_p>=min_free_pos:\\n free_b += 1\\n if free_b>=min_free_branch:\\n valid = True\\n\\n if valid:\\n score += 1\\n # if score==0:\\n # raise exception.NoEmptyBranchException(msg)\\n return score\",\n \"def is_full(self):\\n\\n return self.count == len(self.array)\",\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 is_full(self) -> bool:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64367396","0.6185774","0.61180735","0.6107293","0.61059","0.6050762","0.6046627","0.6046486","0.59971195","0.5967931","0.59551543","0.5925763","0.59230703","0.59230703","0.59198326","0.5916389","0.58971936","0.5856238","0.5807457","0.58016616","0.5795885","0.57787955","0.57589513","0.57584155","0.57475436","0.5731747","0.57290274","0.57214993","0.5705409","0.5704529","0.56980073","0.5691773","0.5689011","0.5685105","0.56744003","0.5672892","0.567053","0.5662962","0.5659654","0.5641461","0.5633469","0.5628796","0.5625341","0.56161755","0.5611573","0.5604842","0.56035274","0.56016","0.5597494","0.55939484","0.5581862","0.5575196","0.5567006","0.5562776","0.5555176","0.55408055","0.5538228","0.5534009","0.5532401","0.5528831","0.55238855","0.5513431","0.5511542","0.5507137","0.54996866","0.549735","0.5495161","0.5490796","0.5490601","0.5485183","0.5481534","0.5480604","0.5475136","0.54713273","0.5471323","0.54701567","0.5468558","0.5452436","0.54426885","0.543501","0.5433341","0.5432836","0.54307806","0.54306984","0.54200816","0.54170483","0.54055196","0.54050905","0.5399014","0.53965116","0.53949064","0.539477","0.5383872","0.5380919","0.5380092","0.5374609","0.53724325","0.5370665","0.53672636","0.5362668"],"string":"[\n \"0.64367396\",\n \"0.6185774\",\n \"0.61180735\",\n \"0.6107293\",\n \"0.61059\",\n \"0.6050762\",\n \"0.6046627\",\n \"0.6046486\",\n \"0.59971195\",\n \"0.5967931\",\n \"0.59551543\",\n \"0.5925763\",\n \"0.59230703\",\n \"0.59230703\",\n \"0.59198326\",\n \"0.5916389\",\n \"0.58971936\",\n \"0.5856238\",\n \"0.5807457\",\n \"0.58016616\",\n \"0.5795885\",\n \"0.57787955\",\n \"0.57589513\",\n \"0.57584155\",\n \"0.57475436\",\n \"0.5731747\",\n \"0.57290274\",\n \"0.57214993\",\n \"0.5705409\",\n \"0.5704529\",\n \"0.56980073\",\n \"0.5691773\",\n \"0.5689011\",\n \"0.5685105\",\n \"0.56744003\",\n \"0.5672892\",\n \"0.567053\",\n \"0.5662962\",\n \"0.5659654\",\n \"0.5641461\",\n \"0.5633469\",\n \"0.5628796\",\n \"0.5625341\",\n \"0.56161755\",\n \"0.5611573\",\n \"0.5604842\",\n \"0.56035274\",\n \"0.56016\",\n \"0.5597494\",\n \"0.55939484\",\n \"0.5581862\",\n \"0.5575196\",\n \"0.5567006\",\n \"0.5562776\",\n \"0.5555176\",\n \"0.55408055\",\n \"0.5538228\",\n \"0.5534009\",\n \"0.5532401\",\n \"0.5528831\",\n \"0.55238855\",\n \"0.5513431\",\n \"0.5511542\",\n \"0.5507137\",\n \"0.54996866\",\n \"0.549735\",\n \"0.5495161\",\n \"0.5490796\",\n \"0.5490601\",\n \"0.5485183\",\n \"0.5481534\",\n \"0.5480604\",\n \"0.5475136\",\n \"0.54713273\",\n \"0.5471323\",\n \"0.54701567\",\n \"0.5468558\",\n \"0.5452436\",\n \"0.54426885\",\n \"0.543501\",\n \"0.5433341\",\n \"0.5432836\",\n \"0.54307806\",\n \"0.54306984\",\n \"0.54200816\",\n \"0.54170483\",\n \"0.54055196\",\n \"0.54050905\",\n \"0.5399014\",\n \"0.53965116\",\n \"0.53949064\",\n \"0.539477\",\n \"0.5383872\",\n \"0.5380919\",\n \"0.5380092\",\n \"0.5374609\",\n \"0.53724325\",\n \"0.5370665\",\n \"0.53672636\",\n \"0.5362668\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67005306"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89499,"cells":{"query":{"kind":"string","value":"Returns a random dim x dim matrix with top eigenvalue bounded by bound dim"},"document":{"kind":"string","value":"def sample_matrix(dim, bound):\n return np.random.uniform(low=-bound, high=bound, size=(dim, dim))"},"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 calculate_biggest_eigenvalue(cls, covariance_matrix):\n timer = TimerHandler()\n timer.start(\"eigen2\")\n eigvals = scipy.linalg.eigh(covariance_matrix, \n eigvals_only = True, \n eigvals = (covariance_matrix.shape[0] -1,covariance_matrix.shape[0]-1), \n overwrite_a = True)\n return eigvals[0]","def check(mat, otp):\n prd = mat*otp\n eigval = prd[0]/otp[0]\n print 'computed eigenvalue :' , eigval\n [eigs, vecs] = np.linalg.eig(mat)\n abseigs = list(abs(eigs))\n ind = abseigs.index(max(abseigs))\n print ' largest eigenvalue :', eigs[ind]","def eigen(M):\n values, vectors = np.linalg.eig(M)\n return values, vectors","def eigen(X):\n\n symmetric = np.alltrue(np.isclose(X - X.T, np.zeros(n)))\n small = max(X.shape) <= 11\n\n if symmetric:\n return jacobi(X)\n elif small:\n maxiter = 10 ** max(*X.shape, 4)\n return qrm3(X, maxiter=maxiter)\n else:\n maxiter = 10 ** max(*X.shape, 4)\n return qrm2(X, maxiter=maxiter)","def right_eigenvalues(matrix, nvals=None):\n matrix = np.asarray(matrix)\n return _eigenvalues(matrix, nvals)","def geteigenspinors(spinorsize):\n\n e = ()\n myl = 1/2\n # loop-and-a-half (TM)\n while True:\n for m in np.arange(1/2, myl+1, 1):\n for ms in [1, -1]:\n for s in [-1, 1]:\n e += ((myl, m*ms, s),)\n myl += 1\n if len(e) >= spinorsize:\n break\n\n e = e[:spinorsize]\n eigenspinors = sorted(e, key=itemgetter(2, 0, 1))\n return eigenspinors","def generate(\n matsize: int,\n kind: MatrixKind = MatrixKind.GOE,\n seed: Optional[int] = None,\n log_time: bool = False,\n use_tridiagonal: bool = True,\n ) -> Eigenvalues:\n kind = MatrixKind.validate(kind)\n if kind == MatrixKind.Poisson:\n np.random.seed(seed)\n # eigenvalues of diagonal are just the entries\n return Eigenvalues(np.sort(np.random.standard_normal(matsize)), kind=kind)\n elif kind == MatrixKind.Uniform:\n raise NotImplementedError(\"Uniform random matrices not implemeted.\")\n elif kind == MatrixKind.GUE:\n size = [matsize, matsize]\n if seed is not None:\n np.random.seed(seed)\n A = np.random.standard_normal(size) + 1j * np.random.standard_normal(size)\n M: fArr = (A + A.conjugate().T) / 2 # type: ignore\n elif kind == MatrixKind.GOE:\n if matsize > 500 and use_tridiagonal:\n M = _generate_GOE_tridiagonal(size=matsize, seed=seed)\n else:\n M = _generate_GOE_matrix(matsize, seed=seed)\n else:\n kinds = [e.value for e in MatrixKind] # type: ignore[unreachable]\n raise ValueError(f\"`kind` must be one of {kinds}\")\n\n if log_time:\n print(f\"\\n{strftime('%H:%M:%S (%b%d)')} -- computing eigenvalues...\")\n eigs: fArr = np.linalg.eigvalsh(M)\n if log_time:\n print(f\"{strftime('%H:%M:%S (%b%d)')} -- computed eigenvalues.\")\n return Eigenvalues(eigs, kind=kind)","def compute_largest_eigenvalue(A, num_simulations):\n b_k = power_iteration(A, num_simulations)\n return b_k.dot(A).dot(b_k) / (b_k.dot(b_k))","def _init_eigenmatrix(self, P):\n self._.d = nrows(P) - 1\n assert all(len(r) == self._.d + 1 for r in P), \\\n \"parameter length mismatch\"\n P = Matrix(SR, P)\n for i, x in enumerate(P[0]):\n P[0, i] = integralize(x)\n self._.n = sum(P[0])\n return P","def best_x0(self, G):\n N = G.number_of_nodes()\n return np.random.randint(0,2, size=(N,))","def test_eigen_multiple_neighborhoods(self):\n # vectorized version\n t0 = time.time()\n extract_vect = EigenValueVectorizeFeatureExtractor()\n eigvals_vect = extract_vect.extract(self.point_cloud, self.neigh, None, None, None)\n print('Timing Vectorize : {}'.format((time.time() - t0)))\n eigvals_vect = np.vstack(eigvals_vect[:3]).T\n\n # serial version\n eigvals = []\n t0 = time.time()\n for n in self.neigh:\n extract = EigenValueSerial()\n eigvals.append(extract.extract(self.point_cloud, n, None, None, None))\n print('Timing Serial : {}'.format((time.time() - t0)))\n eigvals = np.array(eigvals)\n\n np.testing.assert_allclose(eigvals_vect, eigvals)","def get_eigen_value(A, v):\n Av = np.dot(A, v)\n print(\"Mag v, should be 1:\", mag(v))\n lmb = mag(Av) / mag(v)\n return lmb","def P(self):\n self.eigenmatrix()","def test_eigenvalues_of_too_few_points_results_in_0():\n a = np.array([5])\n pc = create_point_cloud(a, a, a)\n\n compute_features(pc, [[0]], pc, [\"eigenv_1\", \"eigenv_2\", \"eigenv_3\"], InfiniteCylinder(5))\n\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\n assert not np.any(np.isnan(eigen_val_123))\n assert not np.any(np.isinf(eigen_val_123))","def MakeEigenVectors( self ): \n sqrt2 = np.sqrt(2)\n Isqrt2 = 1.0 / sqrt2\n EVectors = np.asarray( [ [ Isqrt2 , Isqrt2 , 0 ] ,\n [ Isqrt2 ,-Isqrt2 , 0 ] , \n [ 0 , 0 , 1 ] ] )\n for i in range( self.NQ ):\n for j in range( self.Nbranches ):\n self.EigenVectors[ i , j , 0 , : ] = EVectors[ j , : ]","def left_eigenvalues(matrix, nvals=None):\n matrix = np.asarray(matrix)\n return _eigenvalues(np.transpose(matrix), nvals)","def matrix_generate(n):\n a = np.eye(n)\n max = 0\n for i in range(n):\n for j in range(n):\n a[i][j] = random.randint(0,50)\n a[j][i] = a[i][j]\n if a[i][j] > max:\n max = a[i][j]\n for i in range(n):\n a[i][i] = max * n + random.randint(20,40)\n return np.array(a)","def numpy_eigenvalues(A):\n import numpy\n A = numpy.array(A)\n E = numpy.linalg.eigenvalues(A)\n import Numeric\n E = Numeric.array(E)\n return E","def get_eigenvalues(self):\n return self.eigenValues","def _gershgorin_eigval_bound(K):\n return np.max(np.sum(np.abs(K), axis=1))","def generate_matrix(size) -> np.ndarray:\n np.random.seed(1)\n return np.random.rand(size, size) - 0.5","def Q(self):\n self.dualEigenmatrix()","def eigenCheat( Ja, Jf, truncNum = scipy.inf ):\n H = glueEmH( Ja, Jf, truncNum )\n \n return scipy.linalg.eigh( H )","def rand(self):\n return np.random.rand(self.nx)","def random_matrix(rows, cols):\n return np.random.randn(rows, cols)","def test_eigen_basis_non_orthogonal():\n\n basis = [HarmonicOscillator(n=i, center=0.25) for i in range(2)] + [\n HarmonicOscillator(n=i, center=-0.25) for i in range(2)\n ]\n\n S = pairwise_array_from_func(basis, Overlap())\n H = pairwise_array_from_func(basis, Hamiltonian(Harmonic(center=0.0)))\n eigb = EigenBasis.from_basis(basis, H, S)\n\n # check the first 3 energy levels, we won't have converged\n # the higher ones wrt basis set size\n expected_energies = [(n + 0.5) for n in range(3)]\n\n diffs = [e1 - e2 for e1, e2 in zip(sorted(eigb.energies), expected_energies)]\n\n # a little lenient due to convergence of basis to keep test fast\n assert all(math.isclose(d, 0.0, abs_tol=1e-3) for d in diffs)","def dominant_eigenvector(A: numpy.ndarray) -> numpy.ndarray:\n # dimension of A\n dims = A.shape\n # diagonalize A\n eValues, eVectors = numpy.linalg.eigh(A)\n # find the position of the largest eigenvalue\n idx = numpy.argmax(eValues)\n # retrive the dominant eigenvector and reshape it to a column vector\n dom = numpy.reshape(eVectors[:, idx], (dims[0], 1))\n return dom","def analytical_eig(A):\n n = len(A)\n h = 1/float(n)\n d = 2/float(h)**2\n a = -1/float(h)**2\n eigenval = np.empty(n)\n for j in range(1,n+1):\n eigenval[j-1] = d + 2*a*np.cos((j*np.pi)/(float(n)+1)) # Analytic solution\n \n return eigenval","def get_eigen_values_and_vectors(matrix, num_values):\n (w, v) = eigen_decomp(matrix)\n eigen_values = []\n eigen_vectors = []\n ### YOUR CODE HERE\n max_indexs=np.argpartition(w, -num_values)\n max_indexs=max_indexs[-num_values:]\n ids=np.argsort(w[max_indexs])\n sort_index=max_indexs[ids]\n eigen_values=w[sort_index]\n eigen_vectors=v[:,sort_index]\n ### END YOUR CODE\n return eigen_values, eigen_vectors","def _make_random_matrix(self, n_components, n_features):\n #random_state = check_random_state(self.random_state)\n return _gaussian_random_matrix(\n n_components, n_features, random_state=self.random_state\n )","def applyCornerValues(matrix, roughness):\n maxIndex = matrix.shape[0] -1 \n #print \"maxIndex = \", maxIndex\n \n matrix[0, 0, 0] = random.random() * roughness\n matrix[0, maxIndex, 0 ] = random.random() * roughness\n matrix[maxIndex, 0, 0] = random.random() * roughness\n matrix[maxIndex, maxIndex, 0] = random.random() * roughness\n \n matrix[0, 0, maxIndex] = random.random() * roughness\n matrix[0, maxIndex, maxIndex] = random.random() * roughness\n matrix[maxIndex, 0, maxIndex] = random.random() * roughness\n matrix[maxIndex, maxIndex, maxIndex] = random.random() * roughness\n # for debugging","def posdef_eig(mat):\n return posdef_eig_functions[POSDEF_EIG_METHOD](mat)","def asm_eigenpro_fn(samples, map_fn, top_q, bs_gpu, alpha, min_q=5, seed=1):\n\n np.random.seed(seed) # set random seed for subsamples\n start = time.time()\n n_sample, _ = samples.shape\n\n if top_q is None:\n svd_q = min(n_sample - 1, 1000)\n else:\n svd_q = top_q\n\n eigvals, eigvecs, beta = svd.nystrom_kernel_svd(samples, map_fn, svd_q)\n\n # Choose k such that the batch size is bounded by\n # the subsample size and the memory size.\n # Keep the original k if it is pre-specified.\n if top_q is None:\n max_bs = min(max(n_sample / 5, bs_gpu), n_sample)\n top_q = np.sum(np.power(1 / eigvals, alpha) < max_bs) - 1\n top_q = max(top_q, min_q)\n\n eigvals, tail_eigval = eigvals[:top_q - 1], eigvals[top_q - 1]\n eigvecs = eigvecs[:, :top_q - 1]\n\n device = samples.device\n eigvals_t = torch.tensor(eigvals.copy()).to(device)\n eigvecs_t = torch.tensor(eigvecs).to(device)\n tail_eigval_t = torch.tensor(tail_eigval, dtype=torch.float).to(device)\n\n scale = utils.float_x(np.power(eigvals[0] / tail_eigval, alpha))\n diag_t = (1 - torch.pow(tail_eigval_t / eigvals_t, alpha)) / eigvals_t\n\n def eigenpro_fn(grad, kmat):\n '''Function to apply EigenPro preconditioner.'''\n return torch.mm(eigvecs_t * diag_t,\n torch.t(torch.mm(torch.mm(torch.t(grad),\n kmat),\n eigvecs_t)))\n\n print(\"SVD time: %.2f, top_q: %d, top_eigval: %.2f, new top_eigval: %.2e\" %\n (time.time() - start, top_q, eigvals[0], eigvals[0] / scale))\n\n\n return eigenpro_fn, scale, eigvals[0], beta","def explore_eigenvalues(self, X_train, X_test) :\r\n\r\n # scaler = StandardScaler()\r\n # X_train = scaler.fit_transform(X_train)\r\n # X_test = scaler.transform(X_test)\r\n\r\n print (\"Train feature shape:\", X_train.shape)\r\n print(\"Train feature shape:\", X_test.shape)\r\n \r\n\r\n mean_vec = np.mean(X_test, axis=0)\r\n cov_mat = (X_test - mean_vec).T.dot((X_test - mean_vec)) / (X_test.shape[0]-1)\r\n print('Covariance matrix \\n%s' %cov_mat)\r\n print('NumPy covariance matrix: \\n%s' %np.cov(X_test.T))\r\n eig_vals, eig_vecs = np.linalg.eig(cov_mat)\r\n print('Eigenvectors \\n%s' %eig_vecs)\r\n print(\"---------------------------------\")\r\n print('\\nEigenvalues \\n%s' %eig_vals)\r\n # Make a list of (eigenvalue, eigenvector) tuples\r\n eig_pairs = [(np.abs(eig_vals[i]), eig_vecs[:,i]) for i in range(len(eig_vals))]\r\n\r\n # Sort the (eigenvalue, eigenvector) tuples from high to low\r\n eig_pairs.sort(key=lambda x: x[0], reverse=True)\r\n\r\n # Visually confirm that the list is correctly sorted by decreasing eigenvalues\r\n print(\"---------------------------------\")\r\n print('Eigenvalues in descending order:')\r\n for i in eig_pairs:\r\n print(i[0])\r\n # tot = sum(eig_vals)\r\n # var_exp = [(i / tot)*100 for i in sorted(eig_vals, reverse=True)]\r\n # print(\"Explained variance : \\n{}\".format(var_exp))\r\n \r\n\r\n return X_train, X_test","def random_triangular_matrix(size: int, lower: bool = True) -> np.ndarray:\n\n a = np.random.uniform(0, 1, (size, size))\n if lower:\n ind = np.triu_indices(5, 1)\n else:\n ind = np.tril_indices(5, 1)\n a[ind] = 0\n\n return a","def partial_eigs(self, level, node=None):\n if level >= self._max_level:\n raise ValueError(\n 'The level input parameter ({}) has to be less than the'\n 'max_level ({}). Remember that the starting index is 0'.format(\n level, self._max_level))\n if node:\n return self.operator.eigenvalues[self._index_list(level, node)]\n\n indeces = [self._index_list(level, i) for i in range(2**level)]\n return np.concatenate([self.operator.eigenvalues[idx] for idx in indeces])","def generate_pos_def_all_pos(n):\n A = np.random.uniform(size=(n,n))\n A += A.T\n # Add just enough of an identity matrix to make all eigenvalues positive\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\n return A","def posdef_inv_eig(tensor, identity, damping):\n eigenvalues, eigenvectors = tf.self_adjoint_eig(tensor + damping * identity)\n return tf.matmul(eigenvectors / eigenvalues, eigenvectors, transpose_b=True)","def minimum_eigen_vector(x, num_steps, learning_rate, vector_prod_fn):\n x = tf.nn.l2_normalize(x)\n for _ in range(num_steps):\n x = eig_one_step(x, learning_rate, vector_prod_fn)\n return x","def eigen_vector_i(self, i):\n return self._eig_vec[:,i]","def get_sigmaz(self):\n\n try:\n out = np.diag(self.eigen_x)\n except AttributeError:\n self.get_eigen()\n out = np.diag(self.eigen_x)\n return out","def get_random_k(matrix, k):\n assert k <= matrix.shape[1]\n col_inds = np.array([np.random.choice(matrix.shape[1],k) for _ in range(matrix.shape[0])]).flatten()\n row_inds = np.repeat(range(matrix.shape[0]),k)\n\n vals = matrix[row_inds, col_inds]\n\n return vals, col_inds","def eig(self,manifold_num):\n num_sites = len(self.energies[manifold_num])\n ham = self.manifold_hamiltonian(manifold_num).toarray()\n eigvals, eigvecs = eigh(ham)\n # Force degenerate eigenvectors to be orthogonal\n if self.qr_flag:\n eigvecs, r = np.linalg.qr(eigvecs,mode='reduced')\n if self.check_eigenvectors:\n HV = ham.dot(eigvecs)\n D = eigvecs.T.dot(HV)\n if np.allclose(D,np.diag(eigvals),rtol=1E-11,atol=1E-11):\n pass\n else:\n # warnings.warn('Eigenvalues altered by QR factorization, max absolute change in diagonal matrix of {}'.format(np.max(D-np.diag(eigvals))))\n warnings.warn('Using eigenvectors to diagonalize hamiltonian does not result in the expected diagonal matrix to tolerance, largest deviation is {}'.format(np.max(np.abs(D - np.diag(eigvals)))))\n \n sort_indices = eigvals.argsort()\n eigvals.sort()\n eigvecs = eigvecs[:,sort_indices]\n if self.qr_flag:\n r = r[:,sort_indices]\n self.r_mats.append(r)\n # I choose to pick the phase of my eigenvectors such that the state which has the\n # largest overlap has a positive overlap. For sufficiently small d, and alpha close\n # to 1, this will be the overlap between the same excited and ground states.\n for i in range(eigvals.size):\n max_index = np.argmax(np.abs(eigvecs[:,i]))\n if eigvecs[max_index,i] < 0:\n eigvecs[:,i] *= -1\n\n return eigvals, eigvecs","def get_eigen(self, predictor=True):\n\n if predictor is True:\n vec_ = range(1, self.npred + 1)\n fctr_ = self.gamma\n else:\n vec_ = range(1, self.nresp + 1)\n fctr_ = self.eta\n eigen = np.exp([-fctr_ * float(p_) for p_ in vec_]) / np.exp(-fctr_)\n return eigen","def GetEigenvalues(self):\n\t\treturn self.Solver.GetEigenvalues().real.copy()","def structure_tensor_eigenvalues(A_elems):\n return _symmetric_compute_eigenvalues(A_elems)","def initialize_variational_parameters(num_rows_of_image, num_cols_of_image, K):\n q = np.random.random((num_rows_of_image, num_cols_of_image, K))\n for row_num in range(num_rows_of_image):\n for col_num in range(num_cols_of_image):\n q[row_num, col_num, :] = q[row_num, col_num, :]/sum(q[row_num ,col_num, :])\n return q","def calc_J():\n return np.random.normal(loc=0, scale=1) #loc means - mean, scale -std","def dual_eigenspace(self, B=None):\n N = self.conductor()\n H = self._S.ambient()\n V = H.vector_space()\n if B is None:\n # TODO: This is a heuristic guess at a \"Sturm bound\"; it's the same\n # formula as the one over QQ for Gamma_0(N). I have no idea if this\n # is correct or not yet. It is probably much too large. -- William Stein\n from sage.modular.all import Gamma0\n B = Gamma0(N.norm()).index()//6 + 1\n for P in primes_of_bounded_norm(B+1):\n P = P.sage_ideal()\n if V.dimension() == 1:\n return V\n if not P.divides(N):\n T = H.hecke_matrix(P).transpose()\n V = (T - self.ap(P)).kernel_on(V)\n raise RuntimeError, \"unable to isolate 1-dimensional space\"","def eigs(self):\n return np.concatenate(self.operator.eigenvalues)","def test_kernel_matrix(kernel, sample):\n sample = [ele for ele in sample] # consumed several times\n\n potato = KernelMethod(kernel)\n mat = potato.matrix(sample)\n assert np.all(np.linalg.eigvals(mat) > 0) or np.isclose(\n [np.min(np.linalg.eigvals(mat))], [0]\n )","def unscaled_eigen_prob(Q, lam_inv, a, centres, batch_size):\n d, _ = _shape(Q)\n distances, true_exp = _eigen_distances_squared(Q, lam_inv, a, centres, batch_size)\n exponentials = tf.exp(-0.5 * distances)\n return tf.reduce_mean(exponentials, axis=1)","def get_i_eigen_function(i, X, K, times_bigger_than_machine_epsilon=1.0):\n la, v = linalg.eigh(K) # eigh uses the knowledge that K is symmetric p.s.d\n cutoff = times_bigger_than_machine_epsilon * np.finfo(float).eps\n # Get the index of the first element greater than cutoff\n cutoff_i = np.arange(la.shape[0])[la > cutoff][0]\n i_ = max(cutoff_i, i)\n f = create_f(x_is=X, alpha_is=v[i_, :])\n return f","def remove_random_edges(self):\n # Make rand edges an inf.\n for x in range(self.rank * 10):\n i, j = rnd.randint(0, self.rank - 1), rnd.randint(0, self.rank - 1)\n self.matrix[(i, j), (j, i)] = inf","def run_numpy(self):\n return np.linalg.eigh(self.mat)","def generate_x(number_dimensions, T_train, T_test, mu, feature_model):\n number_training_obeservations = T_train.shape[0]\n number_testing_obeservations = T_test.shape[0]\n\n X_train = np.zeros((number_training_obeservations,number_dimensions))\n X_test = np.zeros((number_testing_obeservations,number_dimensions))\n\n mixture_indicator_train = generate_mixture_indicator(number_training_obeservations)\n mixture_indicator_test = generate_mixture_indicator(number_testing_obeservations)\n\n G = np.random.normal(0,1,(number_dimensions,number_dimensions))\n q, r = np.linalg.qr(G)\n\n mu1 = mu*np.ones(number_dimensions)\n mu2 = -mu*np.ones(number_dimensions)\n\n if feature_model == \"A\":\n eigenvalues1 = np.random.uniform(0,1,(number_dimensions,1))\n eigenvalues1 = np.sort(eigenvalues1, axis = 0)/np.sum(eigenvalues1)\n lambda1 = np.identity(number_dimensions)\n np.fill_diagonal(lambda1,eigenvalues1)\n cov1 = q@lambda1@q.T\n\n for i in range(number_training_obeservations):\n if T_train[i] == 0:\n X_train[i,:] = np.random.multivariate_normal(mu1,cov1,1)\n else:\n X_train[i,:] = np.random.multivariate_normal(mu2,cov1,1)\n \n for i in range(number_testing_obeservations):\n if T_test[i] == 0:\n X_test[i,:] = np.random.multivariate_normal(mu1,cov1,1)\n else:\n X_test[i,:] = np.random.multivariate_normal(mu2,cov1,1)\n\n\n elif feature_model == \"B\":\n eigenvalues1 = np.random.uniform(0,1,(number_dimensions,1))\n eigenvalues1 = np.sort(eigenvalues1, axis = 0)/np.sum(eigenvalues1)\n lambda1 = np.identity(number_dimensions)\n np.fill_diagonal(lambda1,eigenvalues1)\n cov1 = q@lambda1@q.T\n\n eigenvalues2 = np.random.uniform(0,1,(number_dimensions,1))\n eigenvalues2 = np.sort(eigenvalues2, axis = 0)[::-1]/np.sum(eigenvalues2)\n lambda2 = np.identity(number_dimensions)\n np.fill_diagonal(lambda2,eigenvalues2)\n cov2 = q@lambda2@q.T\n\n\n for i in range(number_training_obeservations):\n if T_train[i] == 0:\n if mixture_indicator_train[i] == 0:\n X_train[i,:] = np.random.multivariate_normal(mu1,cov1,1)\n else:\n X_train[i,:] = np.random.multivariate_normal(mu1,cov2,1)\n else:\n if mixture_indicator_train[i] == 0:\n X_train[i,:] = np.random.multivariate_normal(mu2,cov1,1)\n else:\n X_train[i,:] = np.random.multivariate_normal(mu2,cov2,1)\n \n for i in range(number_testing_obeservations):\n if T_test[i] == 0:\n if mixture_indicator_test[i] == 0:\n X_test[i,:] = np.random.multivariate_normal(mu1,cov1,1)\n else:\n X_test[i,:] = np.random.multivariate_normal(mu1,cov2,1)\n else:\n if mixture_indicator_test[i] == 0:\n X_test[i,:] = np.random.multivariate_normal(mu2,cov1,1)\n else:\n X_test[i,:] = np.random.multivariate_normal(mu2,cov2,1)\n\n train_mean = np.mean(X_train, axis = 0)\n train_std = np.std(X_train, axis = 0)\n X_train = (X_train - train_mean)/train_std\n X_test = (X_test - train_mean)/train_std\n \n return X_train, X_test","def eigen_decomposition(self):\n w, V = linalg.eigh(self.K)\n c = w[::-1]\n if isinstance(self.num_xi, float):\n percent_energy = np.cumsum(c) / np.sum(c)\n self.num_xi = np.arange(c.shape[0])[percent_energy < self.num_xi][-1] # num_xi changes\n self.Lambda = w[::-1][:self.num_xi]\n self.V = V[:, ::-1][:, :self.num_xi]","def _solve_eigen(self, X, y):\n self.means_, self.neighbor_means_ = _class_means_and_neighbor_means(\n X, y, self.within_between_ratio, self.nearest_neighbor_ratio)\n \n Sw = _class_cov(X, y) # within class cov\n Sb = _local_pairwise_cov(self.means_, self.neighbor_means_)\n \n evals, evecs = linalg.eigh(Sb, Sw)\n evecs = evecs[:, np.argsort(evals)[::-1]] # sort eigenvectors\n self.scalings_ = np.asarray(evecs)","def eigen_vector_i_all(self):\n return self._eig_vec","def rand(self):\n q = pinocchio.randomConfiguration(self.model)\n v = np.random.rand(self.model.nv) * 2 - 1\n return np.concatenate([q.flat, v])","def gen_rand_mat(dim=3):\n tmp = npr.uniform(-1, 1, (dim,dim))\n\n # make matrix symmetric\n for i in range(dim):\n for j in range(i+1, dim):\n tmp[i,j] = tmp[j,i]\n\n return tmp","def _make_random_matrix(self, n_components, n_features):","def test_rescale_eigenvalues(self):\n\t\t\n\t\tevals = self.watcher.get_ESD(layer=self.fc2_layer)\n\t\trescaled_evals, Wscale = RMT_Util.rescale_eigenvalues(evals)\n\t\tun_rescaled_evals = RMT_Util.un_rescale_eigenvalues(rescaled_evals, Wscale)\n\n\t\tactual = np.max(evals)\n\t\texpected = np.max(un_rescaled_evals)\n\t\tself.assertAlmostEqual(actual, expected)","def get_sigmazinv(self):\n\n try:\n out = np.diag(1 / self.eigen_x)\n except AttributeError:\n self.get_eigen(predictor=True)\n out = np.diag(1 / self.eigen_x)\n return out","def eigenv2tensor(axis):\n vec = np.ones((3, 3))\n vecval = np.ones((3, 3))\n for i in xrange(len(axis)):\n vmag = np.linalg.norm(axis[i])\n v = axis[i] / vmag\n #print v\n vec[:, i] = v\n vecval[:, i] = axis[i]\n adp = np.linalg.solve(vec, vecval)\n return adp","def poweig(A, x0, maxiter = 100, ztol= 1.0e-5, mode= 0, teststeps=1):\n m = len(A)\n xi = x0[:] \n \n for n in range(maxiter):\n # matrix vector multiplication.\n xim1 = xi[:]\n for i in range(m):\n xi[i] = 0.0\n for j in range(m):\n xi[i] += A[i][j] * xim1[j]\n print n, xi\n if mode == 0:\n vlen = sqrt(sum([xi[k]**2 for k in range(m)]))\n xi = [xi[k] /vlen for k in range(m)]\n elif mode == 1:\n for k in range(m-1, -1, -1):\n c = abs(xi[k])\n if c > 1.0e-5:\n xi = [xi[k] /c for k in range(m)]\n break\n # early termination test.\n if n % teststeps == 0:\n S = sum([xi[k]-xim1[k] for k in range(m)])\n if abs(S) < ztol:\n break\n #print n, xi\n # Compute Rayleigh quotient.\n numer = sum([xi[k] * xim1[k] for k in range(m)])\n denom = sum([xim1[k]**2 for k in range(m)])\n xlambda = numer/denom\n return xlambda, xi","def _gaussian_random_matrix(n_components, n_features, random_state=None):\n _check_input_size(n_components, n_features)\n #rng = check_random_state(random_state)\n #components = rng.normal(\n #loc=0.0, scale=1.0 / np.sqrt(n_components), size=(n_components, n_features)\n #)\n\n if random_state and not isinstance(random_state, np.random.RandomState):\n af.random.set_seed(random_state)\n if random_state is None or random_state is np.random:\n pass #use default rng\n #af.random.set_seed(random_state)\n if isinstance(random_state, numbers.Integral):\n af.random.set_seed(random_state)\n if isinstance(random_state, np.random.RandomState):\n pass #use default rng\n\n scale = 1.0 / np.sqrt(n_components)\n components_af = af.randn(n_components, n_features) * scale\n #tmp?\n #components = components_af.to_ndarray()\n components = components_af\n\n return components","def compute_limit_matrix(gamma, adjacency, n_states):\n num_states = n_states\n identity = np.eye(num_states)\n return np.linalg.inv(identity - gamma * adjacency / 6)","def H(self) -> BaseMatrix:","def H(self) -> BaseMatrix:","def uncertainty_sampling(nn_main, sess_main, X, pool_size=None):\n\n temp = find_k_most_uncertain(nn_main, sess_main, X, k=1,\n pool_size=pool_size)\n\n return temp[0]","def assert_valid_eigen_recurse(M, w, v, **kw):\n if len(M.shape) > 2:\n for i in range(M.shape[0]):\n assert_valid_eigen_recurse(M[i], w[i], v[i], **kw)\n else:\n if len(M.shape) == 2:\n assert_valid_eigen_no_broadcast(M, w, v, **kw)\n else:\n raise AssertionError('Not enough dimensions')","def construct_random_initial(self):\n x = np.random.random((self._crv_size, self._bound))\n return x","def posdef_eig_svd(mat):\n evals, evecs, _ = tf.svd(mat)\n\n return evals, evecs","def randomGrid(N):\n grid = np.zeros((N,N), dtype=int)\n for i in range(N): \n for j in range(N): \n if np.random.uniform() < 0.2:\n # cell alive\n grid[i,j] = int(np.random.uniform(low=1, high=(256*256*256)-1))\n return grid","def getEigenVectors(X_new, elambda):\n X_cov = X_new.T.dot(X_new)\n eigenvalues, eigenvectors = np.linalg.eig(X_cov)\n eigen_sorted_ind = eigenvalues.argsort()[::-1]\n eigenvalues = eigenvalues / eigenvalues.sum()\n eigenvalues_sum = 0\n eigenvectors_selected = eigenvectors\n for i in xrange(len(eigen_sorted_ind)):\n eigenvalues_sum += eigenvalues[eigen_sorted_ind[i]]\n if eigenvalues_sum >= elambda:\n eigenvectors_selected = eigenvectors[:, eigen_sorted_ind[0:i]]\n break\n return eigenvectors_selected","def generate_matrix(rows, cols):\n matrix_random = np.random.rand(rows, cols)\n return matrix_random","def rand_TE(num_topics=5, k=20):\n W = np.random.uniform(-0.25,0.25,(num_topics,k)) \n return W","def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\n npars = len(bl)\n x = np.zeros((nrows,npars))\n bound = bu-bl\n for i in range(nrows):\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\n x[i,:]= bl + np.random.rand(1,npars)*bound\n return x","def kinetic_energy_per_mode(proj_vel,eigvals): #,check=False): \n return 0.5 * ( np.square(proj_vel).T * eigvals ).T #, 0.5 * ( proj_vel * eigvals ) * identity @ ( eigvals * proj_vel )","def eigenvalue_sensitivity(T, k):\n\n eValues, rightEigenvectors = numpy.linalg.eig(T)\n leftEigenvectors = numpy.linalg.inv(rightEigenvectors)\n\n perm = numpy.argsort(eValues)[::-1]\n\n rightEigenvectors = rightEigenvectors[:, perm]\n leftEigenvectors = leftEigenvectors[perm]\n\n sensitivity = numpy.outer(leftEigenvectors[k], rightEigenvectors[:, k])\n\n return sensitivity","def Ham_eigvals(self,kx,ky):\n tHam=self.Ham_gen(kx,ky)\n eigval=np.linalg.eigvals(tHam)\n sidc=eigval.argsort()\n eigval=eigval[sidc]\n return eigval.real","def hessian_matrix_eigvals(H_elems):\n return _symmetric_compute_eigenvalues(H_elems)","def eig(self, q):\n q1, q2 = q.T\n c = np.sqrt(9.81*q1)\n lambda1 = q2/q1 - c\n lambda2 = q2/q1 + c\n return np.array([lambda1, lambda2])","def matrixOfEigenvec(A):\n eigenvals, eigenvecs = la.eig(A)\n return eigenvecs","def _random_not_singular(N):\n data = np.zeros((1, 1))\n while np.linalg.det(data) == 0:\n data = np.random.random((N, N)) + \\\n 1j * np.random.random((N, N)) - (0.5 + 0.5j)\n return data","def get_E(J,k):\n E = -2 * J * np.cos(k) # energyeigenvalue \n return E","def test_eigsum_non_interacting(self, size):\n t_nn = 1.2\n idx = np.arange(size)\n g0_inv_full = np.zeros((size, size), dtype=complex)\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\n for g0 in self.g0_loc_inv:\n g0_inv_full[idx, idx] = g0\n _, h, _ = gt.matrix.decompose_gf(g0_inv_full)\n assert_allclose(np.sum(h), np.trace(g0_inv_full))","def generate_pos_def(n):\n A = np.random.normal(size=(n,n)) + 1j * np.random.normal(size=(n,n))\n A += np.conjugate(A).T\n # Add just enough of an identity matrix to make all eigenvalues positive\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\n return A","def boot_matrix(z, B):\n z = np.array(z).flatten()\n n = len(z) # sample size\n idz = np.random.randint(0, n, size=(B, n)) # indices to pick for all boostrap samples\n return z[idz]","def calc_eigen(self, left=False, **parameter_overrides):\n A, B = self.form_state_space_matrices(**parameter_overrides)\n\n if len(A.shape) == 3: # array version\n evals = np.zeros(A.shape[:2], dtype='complex128')\n evecs = np.zeros(A.shape, dtype='complex128')\n for i, Ai in enumerate(A):\n if left:\n Ai = np.transpose(Ai)\n evals[i], evecs[i] = np.linalg.eig(Ai)\n return evals, evecs\n else:\n if left:\n A = np.transpose(A)\n return np.linalg.eig(A)","def call_eigenValues(self, input_value):\n eigValues, eigVectors = self.getEigen(input_value)\n return tf.reverse(eigVectors, [-1]), tf.reverse(eigValues, [-1])","def T(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def initialize_dense(input_size, output_size):\n # TODO: replace the initialization constant 0.01 in a more systematic approach\n return np.random.randn(output_size, input_size) * 0.01","def max_KLT(data):\n\n eigs = []\n p = 64\n N = 64\n for sig in data:\n cov_matrix = autocorr_matrix(sig)\n eigv = np.real(scipy.linalg.eigvalsh(cov_matrix)[::-1])\n eigv = eigv/np.mean(eigv)\n eigs.append(max(eigv))\n\n return eigs","def exactEig( gen, Jf, Ja):\n H = makeH( gen, Jf, Ja )\n return scipy.linalg.eigh( H.toarray() )","def getProjectionMatrix(sorted_eigvecs):\n matrix_w = np.vstack(sorted_eigvecs).transpose()\n return matrix_w","def initial_x():\n\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\n\n return np.array(temp, dtype=np.float_)","def test_gauss_kernel():\n\n gauss = gauss_kernel(2, 5)\n\n assert gauss.shape == (5, 5)\n assert gauss[2, 2] == 0.039788735772973836"],"string":"[\n \"def calculate_biggest_eigenvalue(cls, covariance_matrix):\\n timer = TimerHandler()\\n timer.start(\\\"eigen2\\\")\\n eigvals = scipy.linalg.eigh(covariance_matrix, \\n eigvals_only = True, \\n eigvals = (covariance_matrix.shape[0] -1,covariance_matrix.shape[0]-1), \\n overwrite_a = True)\\n return eigvals[0]\",\n \"def check(mat, otp):\\n prd = mat*otp\\n eigval = prd[0]/otp[0]\\n print 'computed eigenvalue :' , eigval\\n [eigs, vecs] = np.linalg.eig(mat)\\n abseigs = list(abs(eigs))\\n ind = abseigs.index(max(abseigs))\\n print ' largest eigenvalue :', eigs[ind]\",\n \"def eigen(M):\\n values, vectors = np.linalg.eig(M)\\n return values, vectors\",\n \"def eigen(X):\\n\\n symmetric = np.alltrue(np.isclose(X - X.T, np.zeros(n)))\\n small = max(X.shape) <= 11\\n\\n if symmetric:\\n return jacobi(X)\\n elif small:\\n maxiter = 10 ** max(*X.shape, 4)\\n return qrm3(X, maxiter=maxiter)\\n else:\\n maxiter = 10 ** max(*X.shape, 4)\\n return qrm2(X, maxiter=maxiter)\",\n \"def right_eigenvalues(matrix, nvals=None):\\n matrix = np.asarray(matrix)\\n return _eigenvalues(matrix, nvals)\",\n \"def geteigenspinors(spinorsize):\\n\\n e = ()\\n myl = 1/2\\n # loop-and-a-half (TM)\\n while True:\\n for m in np.arange(1/2, myl+1, 1):\\n for ms in [1, -1]:\\n for s in [-1, 1]:\\n e += ((myl, m*ms, s),)\\n myl += 1\\n if len(e) >= spinorsize:\\n break\\n\\n e = e[:spinorsize]\\n eigenspinors = sorted(e, key=itemgetter(2, 0, 1))\\n return eigenspinors\",\n \"def generate(\\n matsize: int,\\n kind: MatrixKind = MatrixKind.GOE,\\n seed: Optional[int] = None,\\n log_time: bool = False,\\n use_tridiagonal: bool = True,\\n ) -> Eigenvalues:\\n kind = MatrixKind.validate(kind)\\n if kind == MatrixKind.Poisson:\\n np.random.seed(seed)\\n # eigenvalues of diagonal are just the entries\\n return Eigenvalues(np.sort(np.random.standard_normal(matsize)), kind=kind)\\n elif kind == MatrixKind.Uniform:\\n raise NotImplementedError(\\\"Uniform random matrices not implemeted.\\\")\\n elif kind == MatrixKind.GUE:\\n size = [matsize, matsize]\\n if seed is not None:\\n np.random.seed(seed)\\n A = np.random.standard_normal(size) + 1j * np.random.standard_normal(size)\\n M: fArr = (A + A.conjugate().T) / 2 # type: ignore\\n elif kind == MatrixKind.GOE:\\n if matsize > 500 and use_tridiagonal:\\n M = _generate_GOE_tridiagonal(size=matsize, seed=seed)\\n else:\\n M = _generate_GOE_matrix(matsize, seed=seed)\\n else:\\n kinds = [e.value for e in MatrixKind] # type: ignore[unreachable]\\n raise ValueError(f\\\"`kind` must be one of {kinds}\\\")\\n\\n if log_time:\\n print(f\\\"\\\\n{strftime('%H:%M:%S (%b%d)')} -- computing eigenvalues...\\\")\\n eigs: fArr = np.linalg.eigvalsh(M)\\n if log_time:\\n print(f\\\"{strftime('%H:%M:%S (%b%d)')} -- computed eigenvalues.\\\")\\n return Eigenvalues(eigs, kind=kind)\",\n \"def compute_largest_eigenvalue(A, num_simulations):\\n b_k = power_iteration(A, num_simulations)\\n return b_k.dot(A).dot(b_k) / (b_k.dot(b_k))\",\n \"def _init_eigenmatrix(self, P):\\n self._.d = nrows(P) - 1\\n assert all(len(r) == self._.d + 1 for r in P), \\\\\\n \\\"parameter length mismatch\\\"\\n P = Matrix(SR, P)\\n for i, x in enumerate(P[0]):\\n P[0, i] = integralize(x)\\n self._.n = sum(P[0])\\n return P\",\n \"def best_x0(self, G):\\n N = G.number_of_nodes()\\n return np.random.randint(0,2, size=(N,))\",\n \"def test_eigen_multiple_neighborhoods(self):\\n # vectorized version\\n t0 = time.time()\\n extract_vect = EigenValueVectorizeFeatureExtractor()\\n eigvals_vect = extract_vect.extract(self.point_cloud, self.neigh, None, None, None)\\n print('Timing Vectorize : {}'.format((time.time() - t0)))\\n eigvals_vect = np.vstack(eigvals_vect[:3]).T\\n\\n # serial version\\n eigvals = []\\n t0 = time.time()\\n for n in self.neigh:\\n extract = EigenValueSerial()\\n eigvals.append(extract.extract(self.point_cloud, n, None, None, None))\\n print('Timing Serial : {}'.format((time.time() - t0)))\\n eigvals = np.array(eigvals)\\n\\n np.testing.assert_allclose(eigvals_vect, eigvals)\",\n \"def get_eigen_value(A, v):\\n Av = np.dot(A, v)\\n print(\\\"Mag v, should be 1:\\\", mag(v))\\n lmb = mag(Av) / mag(v)\\n return lmb\",\n \"def P(self):\\n self.eigenmatrix()\",\n \"def test_eigenvalues_of_too_few_points_results_in_0():\\n a = np.array([5])\\n pc = create_point_cloud(a, a, a)\\n\\n compute_features(pc, [[0]], pc, [\\\"eigenv_1\\\", \\\"eigenv_2\\\", \\\"eigenv_3\\\"], InfiniteCylinder(5))\\n\\n eigen_val_123 = np.array([pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])\\n assert not np.any(np.isnan(eigen_val_123))\\n assert not np.any(np.isinf(eigen_val_123))\",\n \"def MakeEigenVectors( self ): \\n sqrt2 = np.sqrt(2)\\n Isqrt2 = 1.0 / sqrt2\\n EVectors = np.asarray( [ [ Isqrt2 , Isqrt2 , 0 ] ,\\n [ Isqrt2 ,-Isqrt2 , 0 ] , \\n [ 0 , 0 , 1 ] ] )\\n for i in range( self.NQ ):\\n for j in range( self.Nbranches ):\\n self.EigenVectors[ i , j , 0 , : ] = EVectors[ j , : ]\",\n \"def left_eigenvalues(matrix, nvals=None):\\n matrix = np.asarray(matrix)\\n return _eigenvalues(np.transpose(matrix), nvals)\",\n \"def matrix_generate(n):\\n a = np.eye(n)\\n max = 0\\n for i in range(n):\\n for j in range(n):\\n a[i][j] = random.randint(0,50)\\n a[j][i] = a[i][j]\\n if a[i][j] > max:\\n max = a[i][j]\\n for i in range(n):\\n a[i][i] = max * n + random.randint(20,40)\\n return np.array(a)\",\n \"def numpy_eigenvalues(A):\\n import numpy\\n A = numpy.array(A)\\n E = numpy.linalg.eigenvalues(A)\\n import Numeric\\n E = Numeric.array(E)\\n return E\",\n \"def get_eigenvalues(self):\\n return self.eigenValues\",\n \"def _gershgorin_eigval_bound(K):\\n return np.max(np.sum(np.abs(K), axis=1))\",\n \"def generate_matrix(size) -> np.ndarray:\\n np.random.seed(1)\\n return np.random.rand(size, size) - 0.5\",\n \"def Q(self):\\n self.dualEigenmatrix()\",\n \"def eigenCheat( Ja, Jf, truncNum = scipy.inf ):\\n H = glueEmH( Ja, Jf, truncNum )\\n \\n return scipy.linalg.eigh( H )\",\n \"def rand(self):\\n return np.random.rand(self.nx)\",\n \"def random_matrix(rows, cols):\\n return np.random.randn(rows, cols)\",\n \"def test_eigen_basis_non_orthogonal():\\n\\n basis = [HarmonicOscillator(n=i, center=0.25) for i in range(2)] + [\\n HarmonicOscillator(n=i, center=-0.25) for i in range(2)\\n ]\\n\\n S = pairwise_array_from_func(basis, Overlap())\\n H = pairwise_array_from_func(basis, Hamiltonian(Harmonic(center=0.0)))\\n eigb = EigenBasis.from_basis(basis, H, S)\\n\\n # check the first 3 energy levels, we won't have converged\\n # the higher ones wrt basis set size\\n expected_energies = [(n + 0.5) for n in range(3)]\\n\\n diffs = [e1 - e2 for e1, e2 in zip(sorted(eigb.energies), expected_energies)]\\n\\n # a little lenient due to convergence of basis to keep test fast\\n assert all(math.isclose(d, 0.0, abs_tol=1e-3) for d in diffs)\",\n \"def dominant_eigenvector(A: numpy.ndarray) -> numpy.ndarray:\\n # dimension of A\\n dims = A.shape\\n # diagonalize A\\n eValues, eVectors = numpy.linalg.eigh(A)\\n # find the position of the largest eigenvalue\\n idx = numpy.argmax(eValues)\\n # retrive the dominant eigenvector and reshape it to a column vector\\n dom = numpy.reshape(eVectors[:, idx], (dims[0], 1))\\n return dom\",\n \"def analytical_eig(A):\\n n = len(A)\\n h = 1/float(n)\\n d = 2/float(h)**2\\n a = -1/float(h)**2\\n eigenval = np.empty(n)\\n for j in range(1,n+1):\\n eigenval[j-1] = d + 2*a*np.cos((j*np.pi)/(float(n)+1)) # Analytic solution\\n \\n return eigenval\",\n \"def get_eigen_values_and_vectors(matrix, num_values):\\n (w, v) = eigen_decomp(matrix)\\n eigen_values = []\\n eigen_vectors = []\\n ### YOUR CODE HERE\\n max_indexs=np.argpartition(w, -num_values)\\n max_indexs=max_indexs[-num_values:]\\n ids=np.argsort(w[max_indexs])\\n sort_index=max_indexs[ids]\\n eigen_values=w[sort_index]\\n eigen_vectors=v[:,sort_index]\\n ### END YOUR CODE\\n return eigen_values, eigen_vectors\",\n \"def _make_random_matrix(self, n_components, n_features):\\n #random_state = check_random_state(self.random_state)\\n return _gaussian_random_matrix(\\n n_components, n_features, random_state=self.random_state\\n )\",\n \"def applyCornerValues(matrix, roughness):\\n maxIndex = matrix.shape[0] -1 \\n #print \\\"maxIndex = \\\", maxIndex\\n \\n matrix[0, 0, 0] = random.random() * roughness\\n matrix[0, maxIndex, 0 ] = random.random() * roughness\\n matrix[maxIndex, 0, 0] = random.random() * roughness\\n matrix[maxIndex, maxIndex, 0] = random.random() * roughness\\n \\n matrix[0, 0, maxIndex] = random.random() * roughness\\n matrix[0, maxIndex, maxIndex] = random.random() * roughness\\n matrix[maxIndex, 0, maxIndex] = random.random() * roughness\\n matrix[maxIndex, maxIndex, maxIndex] = random.random() * roughness\\n # for debugging\",\n \"def posdef_eig(mat):\\n return posdef_eig_functions[POSDEF_EIG_METHOD](mat)\",\n \"def asm_eigenpro_fn(samples, map_fn, top_q, bs_gpu, alpha, min_q=5, seed=1):\\n\\n np.random.seed(seed) # set random seed for subsamples\\n start = time.time()\\n n_sample, _ = samples.shape\\n\\n if top_q is None:\\n svd_q = min(n_sample - 1, 1000)\\n else:\\n svd_q = top_q\\n\\n eigvals, eigvecs, beta = svd.nystrom_kernel_svd(samples, map_fn, svd_q)\\n\\n # Choose k such that the batch size is bounded by\\n # the subsample size and the memory size.\\n # Keep the original k if it is pre-specified.\\n if top_q is None:\\n max_bs = min(max(n_sample / 5, bs_gpu), n_sample)\\n top_q = np.sum(np.power(1 / eigvals, alpha) < max_bs) - 1\\n top_q = max(top_q, min_q)\\n\\n eigvals, tail_eigval = eigvals[:top_q - 1], eigvals[top_q - 1]\\n eigvecs = eigvecs[:, :top_q - 1]\\n\\n device = samples.device\\n eigvals_t = torch.tensor(eigvals.copy()).to(device)\\n eigvecs_t = torch.tensor(eigvecs).to(device)\\n tail_eigval_t = torch.tensor(tail_eigval, dtype=torch.float).to(device)\\n\\n scale = utils.float_x(np.power(eigvals[0] / tail_eigval, alpha))\\n diag_t = (1 - torch.pow(tail_eigval_t / eigvals_t, alpha)) / eigvals_t\\n\\n def eigenpro_fn(grad, kmat):\\n '''Function to apply EigenPro preconditioner.'''\\n return torch.mm(eigvecs_t * diag_t,\\n torch.t(torch.mm(torch.mm(torch.t(grad),\\n kmat),\\n eigvecs_t)))\\n\\n print(\\\"SVD time: %.2f, top_q: %d, top_eigval: %.2f, new top_eigval: %.2e\\\" %\\n (time.time() - start, top_q, eigvals[0], eigvals[0] / scale))\\n\\n\\n return eigenpro_fn, scale, eigvals[0], beta\",\n \"def explore_eigenvalues(self, X_train, X_test) :\\r\\n\\r\\n # scaler = StandardScaler()\\r\\n # X_train = scaler.fit_transform(X_train)\\r\\n # X_test = scaler.transform(X_test)\\r\\n\\r\\n print (\\\"Train feature shape:\\\", X_train.shape)\\r\\n print(\\\"Train feature shape:\\\", X_test.shape)\\r\\n \\r\\n\\r\\n mean_vec = np.mean(X_test, axis=0)\\r\\n cov_mat = (X_test - mean_vec).T.dot((X_test - mean_vec)) / (X_test.shape[0]-1)\\r\\n print('Covariance matrix \\\\n%s' %cov_mat)\\r\\n print('NumPy covariance matrix: \\\\n%s' %np.cov(X_test.T))\\r\\n eig_vals, eig_vecs = np.linalg.eig(cov_mat)\\r\\n print('Eigenvectors \\\\n%s' %eig_vecs)\\r\\n print(\\\"---------------------------------\\\")\\r\\n print('\\\\nEigenvalues \\\\n%s' %eig_vals)\\r\\n # Make a list of (eigenvalue, eigenvector) tuples\\r\\n eig_pairs = [(np.abs(eig_vals[i]), eig_vecs[:,i]) for i in range(len(eig_vals))]\\r\\n\\r\\n # Sort the (eigenvalue, eigenvector) tuples from high to low\\r\\n eig_pairs.sort(key=lambda x: x[0], reverse=True)\\r\\n\\r\\n # Visually confirm that the list is correctly sorted by decreasing eigenvalues\\r\\n print(\\\"---------------------------------\\\")\\r\\n print('Eigenvalues in descending order:')\\r\\n for i in eig_pairs:\\r\\n print(i[0])\\r\\n # tot = sum(eig_vals)\\r\\n # var_exp = [(i / tot)*100 for i in sorted(eig_vals, reverse=True)]\\r\\n # print(\\\"Explained variance : \\\\n{}\\\".format(var_exp))\\r\\n \\r\\n\\r\\n return X_train, X_test\",\n \"def random_triangular_matrix(size: int, lower: bool = True) -> np.ndarray:\\n\\n a = np.random.uniform(0, 1, (size, size))\\n if lower:\\n ind = np.triu_indices(5, 1)\\n else:\\n ind = np.tril_indices(5, 1)\\n a[ind] = 0\\n\\n return a\",\n \"def partial_eigs(self, level, node=None):\\n if level >= self._max_level:\\n raise ValueError(\\n 'The level input parameter ({}) has to be less than the'\\n 'max_level ({}). Remember that the starting index is 0'.format(\\n level, self._max_level))\\n if node:\\n return self.operator.eigenvalues[self._index_list(level, node)]\\n\\n indeces = [self._index_list(level, i) for i in range(2**level)]\\n return np.concatenate([self.operator.eigenvalues[idx] for idx in indeces])\",\n \"def generate_pos_def_all_pos(n):\\n A = np.random.uniform(size=(n,n))\\n A += A.T\\n # Add just enough of an identity matrix to make all eigenvalues positive\\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\\n return A\",\n \"def posdef_inv_eig(tensor, identity, damping):\\n eigenvalues, eigenvectors = tf.self_adjoint_eig(tensor + damping * identity)\\n return tf.matmul(eigenvectors / eigenvalues, eigenvectors, transpose_b=True)\",\n \"def minimum_eigen_vector(x, num_steps, learning_rate, vector_prod_fn):\\n x = tf.nn.l2_normalize(x)\\n for _ in range(num_steps):\\n x = eig_one_step(x, learning_rate, vector_prod_fn)\\n return x\",\n \"def eigen_vector_i(self, i):\\n return self._eig_vec[:,i]\",\n \"def get_sigmaz(self):\\n\\n try:\\n out = np.diag(self.eigen_x)\\n except AttributeError:\\n self.get_eigen()\\n out = np.diag(self.eigen_x)\\n return out\",\n \"def get_random_k(matrix, k):\\n assert k <= matrix.shape[1]\\n col_inds = np.array([np.random.choice(matrix.shape[1],k) for _ in range(matrix.shape[0])]).flatten()\\n row_inds = np.repeat(range(matrix.shape[0]),k)\\n\\n vals = matrix[row_inds, col_inds]\\n\\n return vals, col_inds\",\n \"def eig(self,manifold_num):\\n num_sites = len(self.energies[manifold_num])\\n ham = self.manifold_hamiltonian(manifold_num).toarray()\\n eigvals, eigvecs = eigh(ham)\\n # Force degenerate eigenvectors to be orthogonal\\n if self.qr_flag:\\n eigvecs, r = np.linalg.qr(eigvecs,mode='reduced')\\n if self.check_eigenvectors:\\n HV = ham.dot(eigvecs)\\n D = eigvecs.T.dot(HV)\\n if np.allclose(D,np.diag(eigvals),rtol=1E-11,atol=1E-11):\\n pass\\n else:\\n # warnings.warn('Eigenvalues altered by QR factorization, max absolute change in diagonal matrix of {}'.format(np.max(D-np.diag(eigvals))))\\n warnings.warn('Using eigenvectors to diagonalize hamiltonian does not result in the expected diagonal matrix to tolerance, largest deviation is {}'.format(np.max(np.abs(D - np.diag(eigvals)))))\\n \\n sort_indices = eigvals.argsort()\\n eigvals.sort()\\n eigvecs = eigvecs[:,sort_indices]\\n if self.qr_flag:\\n r = r[:,sort_indices]\\n self.r_mats.append(r)\\n # I choose to pick the phase of my eigenvectors such that the state which has the\\n # largest overlap has a positive overlap. For sufficiently small d, and alpha close\\n # to 1, this will be the overlap between the same excited and ground states.\\n for i in range(eigvals.size):\\n max_index = np.argmax(np.abs(eigvecs[:,i]))\\n if eigvecs[max_index,i] < 0:\\n eigvecs[:,i] *= -1\\n\\n return eigvals, eigvecs\",\n \"def get_eigen(self, predictor=True):\\n\\n if predictor is True:\\n vec_ = range(1, self.npred + 1)\\n fctr_ = self.gamma\\n else:\\n vec_ = range(1, self.nresp + 1)\\n fctr_ = self.eta\\n eigen = np.exp([-fctr_ * float(p_) for p_ in vec_]) / np.exp(-fctr_)\\n return eigen\",\n \"def GetEigenvalues(self):\\n\\t\\treturn self.Solver.GetEigenvalues().real.copy()\",\n \"def structure_tensor_eigenvalues(A_elems):\\n return _symmetric_compute_eigenvalues(A_elems)\",\n \"def initialize_variational_parameters(num_rows_of_image, num_cols_of_image, K):\\n q = np.random.random((num_rows_of_image, num_cols_of_image, K))\\n for row_num in range(num_rows_of_image):\\n for col_num in range(num_cols_of_image):\\n q[row_num, col_num, :] = q[row_num, col_num, :]/sum(q[row_num ,col_num, :])\\n return q\",\n \"def calc_J():\\n return np.random.normal(loc=0, scale=1) #loc means - mean, scale -std\",\n \"def dual_eigenspace(self, B=None):\\n N = self.conductor()\\n H = self._S.ambient()\\n V = H.vector_space()\\n if B is None:\\n # TODO: This is a heuristic guess at a \\\"Sturm bound\\\"; it's the same\\n # formula as the one over QQ for Gamma_0(N). I have no idea if this\\n # is correct or not yet. It is probably much too large. -- William Stein\\n from sage.modular.all import Gamma0\\n B = Gamma0(N.norm()).index()//6 + 1\\n for P in primes_of_bounded_norm(B+1):\\n P = P.sage_ideal()\\n if V.dimension() == 1:\\n return V\\n if not P.divides(N):\\n T = H.hecke_matrix(P).transpose()\\n V = (T - self.ap(P)).kernel_on(V)\\n raise RuntimeError, \\\"unable to isolate 1-dimensional space\\\"\",\n \"def eigs(self):\\n return np.concatenate(self.operator.eigenvalues)\",\n \"def test_kernel_matrix(kernel, sample):\\n sample = [ele for ele in sample] # consumed several times\\n\\n potato = KernelMethod(kernel)\\n mat = potato.matrix(sample)\\n assert np.all(np.linalg.eigvals(mat) > 0) or np.isclose(\\n [np.min(np.linalg.eigvals(mat))], [0]\\n )\",\n \"def unscaled_eigen_prob(Q, lam_inv, a, centres, batch_size):\\n d, _ = _shape(Q)\\n distances, true_exp = _eigen_distances_squared(Q, lam_inv, a, centres, batch_size)\\n exponentials = tf.exp(-0.5 * distances)\\n return tf.reduce_mean(exponentials, axis=1)\",\n \"def get_i_eigen_function(i, X, K, times_bigger_than_machine_epsilon=1.0):\\n la, v = linalg.eigh(K) # eigh uses the knowledge that K is symmetric p.s.d\\n cutoff = times_bigger_than_machine_epsilon * np.finfo(float).eps\\n # Get the index of the first element greater than cutoff\\n cutoff_i = np.arange(la.shape[0])[la > cutoff][0]\\n i_ = max(cutoff_i, i)\\n f = create_f(x_is=X, alpha_is=v[i_, :])\\n return f\",\n \"def remove_random_edges(self):\\n # Make rand edges an inf.\\n for x in range(self.rank * 10):\\n i, j = rnd.randint(0, self.rank - 1), rnd.randint(0, self.rank - 1)\\n self.matrix[(i, j), (j, i)] = inf\",\n \"def run_numpy(self):\\n return np.linalg.eigh(self.mat)\",\n \"def generate_x(number_dimensions, T_train, T_test, mu, feature_model):\\n number_training_obeservations = T_train.shape[0]\\n number_testing_obeservations = T_test.shape[0]\\n\\n X_train = np.zeros((number_training_obeservations,number_dimensions))\\n X_test = np.zeros((number_testing_obeservations,number_dimensions))\\n\\n mixture_indicator_train = generate_mixture_indicator(number_training_obeservations)\\n mixture_indicator_test = generate_mixture_indicator(number_testing_obeservations)\\n\\n G = np.random.normal(0,1,(number_dimensions,number_dimensions))\\n q, r = np.linalg.qr(G)\\n\\n mu1 = mu*np.ones(number_dimensions)\\n mu2 = -mu*np.ones(number_dimensions)\\n\\n if feature_model == \\\"A\\\":\\n eigenvalues1 = np.random.uniform(0,1,(number_dimensions,1))\\n eigenvalues1 = np.sort(eigenvalues1, axis = 0)/np.sum(eigenvalues1)\\n lambda1 = np.identity(number_dimensions)\\n np.fill_diagonal(lambda1,eigenvalues1)\\n cov1 = q@lambda1@q.T\\n\\n for i in range(number_training_obeservations):\\n if T_train[i] == 0:\\n X_train[i,:] = np.random.multivariate_normal(mu1,cov1,1)\\n else:\\n X_train[i,:] = np.random.multivariate_normal(mu2,cov1,1)\\n \\n for i in range(number_testing_obeservations):\\n if T_test[i] == 0:\\n X_test[i,:] = np.random.multivariate_normal(mu1,cov1,1)\\n else:\\n X_test[i,:] = np.random.multivariate_normal(mu2,cov1,1)\\n\\n\\n elif feature_model == \\\"B\\\":\\n eigenvalues1 = np.random.uniform(0,1,(number_dimensions,1))\\n eigenvalues1 = np.sort(eigenvalues1, axis = 0)/np.sum(eigenvalues1)\\n lambda1 = np.identity(number_dimensions)\\n np.fill_diagonal(lambda1,eigenvalues1)\\n cov1 = q@lambda1@q.T\\n\\n eigenvalues2 = np.random.uniform(0,1,(number_dimensions,1))\\n eigenvalues2 = np.sort(eigenvalues2, axis = 0)[::-1]/np.sum(eigenvalues2)\\n lambda2 = np.identity(number_dimensions)\\n np.fill_diagonal(lambda2,eigenvalues2)\\n cov2 = q@lambda2@q.T\\n\\n\\n for i in range(number_training_obeservations):\\n if T_train[i] == 0:\\n if mixture_indicator_train[i] == 0:\\n X_train[i,:] = np.random.multivariate_normal(mu1,cov1,1)\\n else:\\n X_train[i,:] = np.random.multivariate_normal(mu1,cov2,1)\\n else:\\n if mixture_indicator_train[i] == 0:\\n X_train[i,:] = np.random.multivariate_normal(mu2,cov1,1)\\n else:\\n X_train[i,:] = np.random.multivariate_normal(mu2,cov2,1)\\n \\n for i in range(number_testing_obeservations):\\n if T_test[i] == 0:\\n if mixture_indicator_test[i] == 0:\\n X_test[i,:] = np.random.multivariate_normal(mu1,cov1,1)\\n else:\\n X_test[i,:] = np.random.multivariate_normal(mu1,cov2,1)\\n else:\\n if mixture_indicator_test[i] == 0:\\n X_test[i,:] = np.random.multivariate_normal(mu2,cov1,1)\\n else:\\n X_test[i,:] = np.random.multivariate_normal(mu2,cov2,1)\\n\\n train_mean = np.mean(X_train, axis = 0)\\n train_std = np.std(X_train, axis = 0)\\n X_train = (X_train - train_mean)/train_std\\n X_test = (X_test - train_mean)/train_std\\n \\n return X_train, X_test\",\n \"def eigen_decomposition(self):\\n w, V = linalg.eigh(self.K)\\n c = w[::-1]\\n if isinstance(self.num_xi, float):\\n percent_energy = np.cumsum(c) / np.sum(c)\\n self.num_xi = np.arange(c.shape[0])[percent_energy < self.num_xi][-1] # num_xi changes\\n self.Lambda = w[::-1][:self.num_xi]\\n self.V = V[:, ::-1][:, :self.num_xi]\",\n \"def _solve_eigen(self, X, y):\\n self.means_, self.neighbor_means_ = _class_means_and_neighbor_means(\\n X, y, self.within_between_ratio, self.nearest_neighbor_ratio)\\n \\n Sw = _class_cov(X, y) # within class cov\\n Sb = _local_pairwise_cov(self.means_, self.neighbor_means_)\\n \\n evals, evecs = linalg.eigh(Sb, Sw)\\n evecs = evecs[:, np.argsort(evals)[::-1]] # sort eigenvectors\\n self.scalings_ = np.asarray(evecs)\",\n \"def eigen_vector_i_all(self):\\n return self._eig_vec\",\n \"def rand(self):\\n q = pinocchio.randomConfiguration(self.model)\\n v = np.random.rand(self.model.nv) * 2 - 1\\n return np.concatenate([q.flat, v])\",\n \"def gen_rand_mat(dim=3):\\n tmp = npr.uniform(-1, 1, (dim,dim))\\n\\n # make matrix symmetric\\n for i in range(dim):\\n for j in range(i+1, dim):\\n tmp[i,j] = tmp[j,i]\\n\\n return tmp\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def test_rescale_eigenvalues(self):\\n\\t\\t\\n\\t\\tevals = self.watcher.get_ESD(layer=self.fc2_layer)\\n\\t\\trescaled_evals, Wscale = RMT_Util.rescale_eigenvalues(evals)\\n\\t\\tun_rescaled_evals = RMT_Util.un_rescale_eigenvalues(rescaled_evals, Wscale)\\n\\n\\t\\tactual = np.max(evals)\\n\\t\\texpected = np.max(un_rescaled_evals)\\n\\t\\tself.assertAlmostEqual(actual, expected)\",\n \"def get_sigmazinv(self):\\n\\n try:\\n out = np.diag(1 / self.eigen_x)\\n except AttributeError:\\n self.get_eigen(predictor=True)\\n out = np.diag(1 / self.eigen_x)\\n return out\",\n \"def eigenv2tensor(axis):\\n vec = np.ones((3, 3))\\n vecval = np.ones((3, 3))\\n for i in xrange(len(axis)):\\n vmag = np.linalg.norm(axis[i])\\n v = axis[i] / vmag\\n #print v\\n vec[:, i] = v\\n vecval[:, i] = axis[i]\\n adp = np.linalg.solve(vec, vecval)\\n return adp\",\n \"def poweig(A, x0, maxiter = 100, ztol= 1.0e-5, mode= 0, teststeps=1):\\n m = len(A)\\n xi = x0[:] \\n \\n for n in range(maxiter):\\n # matrix vector multiplication.\\n xim1 = xi[:]\\n for i in range(m):\\n xi[i] = 0.0\\n for j in range(m):\\n xi[i] += A[i][j] * xim1[j]\\n print n, xi\\n if mode == 0:\\n vlen = sqrt(sum([xi[k]**2 for k in range(m)]))\\n xi = [xi[k] /vlen for k in range(m)]\\n elif mode == 1:\\n for k in range(m-1, -1, -1):\\n c = abs(xi[k])\\n if c > 1.0e-5:\\n xi = [xi[k] /c for k in range(m)]\\n break\\n # early termination test.\\n if n % teststeps == 0:\\n S = sum([xi[k]-xim1[k] for k in range(m)])\\n if abs(S) < ztol:\\n break\\n #print n, xi\\n # Compute Rayleigh quotient.\\n numer = sum([xi[k] * xim1[k] for k in range(m)])\\n denom = sum([xim1[k]**2 for k in range(m)])\\n xlambda = numer/denom\\n return xlambda, xi\",\n \"def _gaussian_random_matrix(n_components, n_features, random_state=None):\\n _check_input_size(n_components, n_features)\\n #rng = check_random_state(random_state)\\n #components = rng.normal(\\n #loc=0.0, scale=1.0 / np.sqrt(n_components), size=(n_components, n_features)\\n #)\\n\\n if random_state and not isinstance(random_state, np.random.RandomState):\\n af.random.set_seed(random_state)\\n if random_state is None or random_state is np.random:\\n pass #use default rng\\n #af.random.set_seed(random_state)\\n if isinstance(random_state, numbers.Integral):\\n af.random.set_seed(random_state)\\n if isinstance(random_state, np.random.RandomState):\\n pass #use default rng\\n\\n scale = 1.0 / np.sqrt(n_components)\\n components_af = af.randn(n_components, n_features) * scale\\n #tmp?\\n #components = components_af.to_ndarray()\\n components = components_af\\n\\n return components\",\n \"def compute_limit_matrix(gamma, adjacency, n_states):\\n num_states = n_states\\n identity = np.eye(num_states)\\n return np.linalg.inv(identity - gamma * adjacency / 6)\",\n \"def H(self) -> BaseMatrix:\",\n \"def H(self) -> BaseMatrix:\",\n \"def uncertainty_sampling(nn_main, sess_main, X, pool_size=None):\\n\\n temp = find_k_most_uncertain(nn_main, sess_main, X, k=1,\\n pool_size=pool_size)\\n\\n return temp[0]\",\n \"def assert_valid_eigen_recurse(M, w, v, **kw):\\n if len(M.shape) > 2:\\n for i in range(M.shape[0]):\\n assert_valid_eigen_recurse(M[i], w[i], v[i], **kw)\\n else:\\n if len(M.shape) == 2:\\n assert_valid_eigen_no_broadcast(M, w, v, **kw)\\n else:\\n raise AssertionError('Not enough dimensions')\",\n \"def construct_random_initial(self):\\n x = np.random.random((self._crv_size, self._bound))\\n return x\",\n \"def posdef_eig_svd(mat):\\n evals, evecs, _ = tf.svd(mat)\\n\\n return evals, evecs\",\n \"def randomGrid(N):\\n grid = np.zeros((N,N), dtype=int)\\n for i in range(N): \\n for j in range(N): \\n if np.random.uniform() < 0.2:\\n # cell alive\\n grid[i,j] = int(np.random.uniform(low=1, high=(256*256*256)-1))\\n return grid\",\n \"def getEigenVectors(X_new, elambda):\\n X_cov = X_new.T.dot(X_new)\\n eigenvalues, eigenvectors = np.linalg.eig(X_cov)\\n eigen_sorted_ind = eigenvalues.argsort()[::-1]\\n eigenvalues = eigenvalues / eigenvalues.sum()\\n eigenvalues_sum = 0\\n eigenvectors_selected = eigenvectors\\n for i in xrange(len(eigen_sorted_ind)):\\n eigenvalues_sum += eigenvalues[eigen_sorted_ind[i]]\\n if eigenvalues_sum >= elambda:\\n eigenvectors_selected = eigenvectors[:, eigen_sorted_ind[0:i]]\\n break\\n return eigenvectors_selected\",\n \"def generate_matrix(rows, cols):\\n matrix_random = np.random.rand(rows, cols)\\n return matrix_random\",\n \"def rand_TE(num_topics=5, k=20):\\n W = np.random.uniform(-0.25,0.25,(num_topics,k)) \\n return W\",\n \"def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\\n npars = len(bl)\\n x = np.zeros((nrows,npars))\\n bound = bu-bl\\n for i in range(nrows):\\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\\n x[i,:]= bl + np.random.rand(1,npars)*bound\\n return x\",\n \"def kinetic_energy_per_mode(proj_vel,eigvals): #,check=False): \\n return 0.5 * ( np.square(proj_vel).T * eigvals ).T #, 0.5 * ( proj_vel * eigvals ) * identity @ ( eigvals * proj_vel )\",\n \"def eigenvalue_sensitivity(T, k):\\n\\n eValues, rightEigenvectors = numpy.linalg.eig(T)\\n leftEigenvectors = numpy.linalg.inv(rightEigenvectors)\\n\\n perm = numpy.argsort(eValues)[::-1]\\n\\n rightEigenvectors = rightEigenvectors[:, perm]\\n leftEigenvectors = leftEigenvectors[perm]\\n\\n sensitivity = numpy.outer(leftEigenvectors[k], rightEigenvectors[:, k])\\n\\n return sensitivity\",\n \"def Ham_eigvals(self,kx,ky):\\n tHam=self.Ham_gen(kx,ky)\\n eigval=np.linalg.eigvals(tHam)\\n sidc=eigval.argsort()\\n eigval=eigval[sidc]\\n return eigval.real\",\n \"def hessian_matrix_eigvals(H_elems):\\n return _symmetric_compute_eigenvalues(H_elems)\",\n \"def eig(self, q):\\n q1, q2 = q.T\\n c = np.sqrt(9.81*q1)\\n lambda1 = q2/q1 - c\\n lambda2 = q2/q1 + c\\n return np.array([lambda1, lambda2])\",\n \"def matrixOfEigenvec(A):\\n eigenvals, eigenvecs = la.eig(A)\\n return eigenvecs\",\n \"def _random_not_singular(N):\\n data = np.zeros((1, 1))\\n while np.linalg.det(data) == 0:\\n data = np.random.random((N, N)) + \\\\\\n 1j * np.random.random((N, N)) - (0.5 + 0.5j)\\n return data\",\n \"def get_E(J,k):\\n E = -2 * J * np.cos(k) # energyeigenvalue \\n return E\",\n \"def test_eigsum_non_interacting(self, size):\\n t_nn = 1.2\\n idx = np.arange(size)\\n g0_inv_full = np.zeros((size, size), dtype=complex)\\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\\n for g0 in self.g0_loc_inv:\\n g0_inv_full[idx, idx] = g0\\n _, h, _ = gt.matrix.decompose_gf(g0_inv_full)\\n assert_allclose(np.sum(h), np.trace(g0_inv_full))\",\n \"def generate_pos_def(n):\\n A = np.random.normal(size=(n,n)) + 1j * np.random.normal(size=(n,n))\\n A += np.conjugate(A).T\\n # Add just enough of an identity matrix to make all eigenvalues positive\\n A += -1.01*np.min(np.linalg.eigvalsh(A))*np.identity(n)\\n return A\",\n \"def boot_matrix(z, B):\\n z = np.array(z).flatten()\\n n = len(z) # sample size\\n idz = np.random.randint(0, n, size=(B, n)) # indices to pick for all boostrap samples\\n return z[idz]\",\n \"def calc_eigen(self, left=False, **parameter_overrides):\\n A, B = self.form_state_space_matrices(**parameter_overrides)\\n\\n if len(A.shape) == 3: # array version\\n evals = np.zeros(A.shape[:2], dtype='complex128')\\n evecs = np.zeros(A.shape, dtype='complex128')\\n for i, Ai in enumerate(A):\\n if left:\\n Ai = np.transpose(Ai)\\n evals[i], evecs[i] = np.linalg.eig(Ai)\\n return evals, evecs\\n else:\\n if left:\\n A = np.transpose(A)\\n return np.linalg.eig(A)\",\n \"def call_eigenValues(self, input_value):\\n eigValues, eigVectors = self.getEigen(input_value)\\n return tf.reverse(eigVectors, [-1]), tf.reverse(eigValues, [-1])\",\n \"def T(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def initialize_dense(input_size, output_size):\\n # TODO: replace the initialization constant 0.01 in a more systematic approach\\n return np.random.randn(output_size, input_size) * 0.01\",\n \"def max_KLT(data):\\n\\n eigs = []\\n p = 64\\n N = 64\\n for sig in data:\\n cov_matrix = autocorr_matrix(sig)\\n eigv = np.real(scipy.linalg.eigvalsh(cov_matrix)[::-1])\\n eigv = eigv/np.mean(eigv)\\n eigs.append(max(eigv))\\n\\n return eigs\",\n \"def exactEig( gen, Jf, Ja):\\n H = makeH( gen, Jf, Ja )\\n return scipy.linalg.eigh( H.toarray() )\",\n \"def getProjectionMatrix(sorted_eigvecs):\\n matrix_w = np.vstack(sorted_eigvecs).transpose()\\n return matrix_w\",\n \"def initial_x():\\n\\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\\n\\n return np.array(temp, dtype=np.float_)\",\n \"def test_gauss_kernel():\\n\\n gauss = gauss_kernel(2, 5)\\n\\n assert gauss.shape == (5, 5)\\n assert gauss[2, 2] == 0.039788735772973836\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5875326","0.5783161","0.5597876","0.5518314","0.54774606","0.53589374","0.53341335","0.52804285","0.52785826","0.52338797","0.52313197","0.52312946","0.52151245","0.5212694","0.5212556","0.5212227","0.5209878","0.52093714","0.52040935","0.5180018","0.5166742","0.51590127","0.51397514","0.5107752","0.50965077","0.5093474","0.5049126","0.5029399","0.5020037","0.5004687","0.49744424","0.49650344","0.4942264","0.49396408","0.49308345","0.49287322","0.4919588","0.49168453","0.49159566","0.49044684","0.49024147","0.48994094","0.4894759","0.48900807","0.48890406","0.48866716","0.4886173","0.4879982","0.48656183","0.48574203","0.48538598","0.48534957","0.4851399","0.48489362","0.484015","0.48337823","0.48210484","0.48180503","0.48082682","0.48028773","0.47983193","0.47964656","0.47937652","0.47890228","0.4785813","0.4784454","0.47819772","0.47812888","0.4781258","0.4781258","0.4779773","0.47791284","0.4775055","0.47655147","0.47597963","0.47559136","0.4754552","0.47481743","0.47427744","0.47352368","0.47328523","0.47327036","0.4731955","0.47241625","0.47234228","0.47214717","0.4720858","0.47207654","0.47155493","0.47127494","0.4709487","0.47041163","0.4702113","0.4702113","0.4700791","0.47000432","0.46995488","0.46976605","0.46971953","0.46934736"],"string":"[\n \"0.5875326\",\n \"0.5783161\",\n \"0.5597876\",\n \"0.5518314\",\n \"0.54774606\",\n \"0.53589374\",\n \"0.53341335\",\n \"0.52804285\",\n \"0.52785826\",\n \"0.52338797\",\n \"0.52313197\",\n \"0.52312946\",\n \"0.52151245\",\n \"0.5212694\",\n \"0.5212556\",\n \"0.5212227\",\n \"0.5209878\",\n \"0.52093714\",\n \"0.52040935\",\n \"0.5180018\",\n \"0.5166742\",\n \"0.51590127\",\n \"0.51397514\",\n \"0.5107752\",\n \"0.50965077\",\n \"0.5093474\",\n \"0.5049126\",\n \"0.5029399\",\n \"0.5020037\",\n \"0.5004687\",\n \"0.49744424\",\n \"0.49650344\",\n \"0.4942264\",\n \"0.49396408\",\n \"0.49308345\",\n \"0.49287322\",\n \"0.4919588\",\n \"0.49168453\",\n \"0.49159566\",\n \"0.49044684\",\n \"0.49024147\",\n \"0.48994094\",\n \"0.4894759\",\n \"0.48900807\",\n \"0.48890406\",\n \"0.48866716\",\n \"0.4886173\",\n \"0.4879982\",\n \"0.48656183\",\n \"0.48574203\",\n \"0.48538598\",\n \"0.48534957\",\n \"0.4851399\",\n \"0.48489362\",\n \"0.484015\",\n \"0.48337823\",\n \"0.48210484\",\n \"0.48180503\",\n \"0.48082682\",\n \"0.48028773\",\n \"0.47983193\",\n \"0.47964656\",\n \"0.47937652\",\n \"0.47890228\",\n \"0.4785813\",\n \"0.4784454\",\n \"0.47819772\",\n \"0.47812888\",\n \"0.4781258\",\n \"0.4781258\",\n \"0.4779773\",\n \"0.47791284\",\n \"0.4775055\",\n \"0.47655147\",\n \"0.47597963\",\n \"0.47559136\",\n \"0.4754552\",\n \"0.47481743\",\n \"0.47427744\",\n \"0.47352368\",\n \"0.47328523\",\n \"0.47327036\",\n \"0.4731955\",\n \"0.47241625\",\n \"0.47234228\",\n \"0.47214717\",\n \"0.4720858\",\n \"0.47207654\",\n \"0.47155493\",\n \"0.47127494\",\n \"0.4709487\",\n \"0.47041163\",\n \"0.4702113\",\n \"0.4702113\",\n \"0.4700791\",\n \"0.47000432\",\n \"0.46995488\",\n \"0.46976605\",\n \"0.46971953\",\n \"0.46934736\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59177387"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":894,"numItemsPerPage":100,"numTotalItems":95772,"offset":89400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTc3MjkxMywianRpIjoiNzBlNjE4NjUtY2NhZS00ZTk2LTkyNGEtZDZkZTY4NmQ5NTAwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU3NzY1MTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.SPdsBycFn8ljKNQYiSU2CFepk1WwCY8-Pl2ry1Zqjq2SFAKQw7PmPIlOlPl-hhS0LlZmQbjlohlH9QQbfZ3YDA","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 |
|---|---|---|---|---|---|---|
Make a dataset for training or evaluating SMURF. | def make_dataset(self,
path,
mode,
height=None,
width=None):
# Split up the possibly comma seperated directories.
if ',' in path:
l = path.split(',')
d = '/'.join(l[0].split('/')[:-1])
l[0] = l[0].split('/')[-1]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataset(dataset_type, soruce, opts): \n\n p = PreProcessor(dataset_type, opts)\n\n # If we are NOT running \"implementation.py\", we read the data from file\n if dataset_type == \"train\" or dataset_type == \"dev\" or dataset_type == \"test\":\n path_to_data = soruce\n p.read_labe... | [
"0.71976507",
"0.7156453",
"0.6980805",
"0.6959531",
"0.688197",
"0.68500346",
"0.6844109",
"0.6841355",
"0.68199223",
"0.6816855",
"0.6813762",
"0.68059635",
"0.67992455",
"0.67547446",
"0.6730391",
"0.6708142",
"0.6706259",
"0.66852164",
"0.6672077",
"0.6619019",
"0.6602753... | 0.0 | -1 |
Return a prettified taxon name. | def pname(name):
ranks = list(reversed(name.split(';')))
for i, rank in enumerate(ranks):
if rank in ['Others', 'Unassigned']:
return rank
if rank == '__':
continue
if rank.split('__')[1] is '':
return ranks[i+1] + ';' + rank
return rank | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def taxonParser(taxon):\r\n parser = TaxonParser(taxon)\r\n scientific_name = \"\"\r\n\r\n try:\r\n parsed_name = parser.parse()\r\n if parsed_name.isBinomial() is True:\r\n scientific_name = str(parsed_name.genus) + \" \" + str(parsed_name.specificEpithet)\r\n if str(p... | [
"0.64729476",
"0.63083935",
"0.62381494",
"0.62266713",
"0.61525995",
"0.6145447",
"0.6030031",
"0.59031326",
"0.58614546",
"0.58417225",
"0.58398944",
"0.5793541",
"0.57750577",
"0.5752416",
"0.57239914",
"0.5706593",
"0.56737465",
"0.56687945",
"0.56369525",
"0.5615086",
"0... | 0.0 | -1 |
Default action if no subcommand is passed. | def _default(self):
self.app.render(infoNetwork.all()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_handler(self, _: argparse.Namespace) -> int:\n print(\"No command specified!\")\n self.parser.print_usage()\n return 1",
"def run(self):\n if self.subcommand_parser is None:\n self.exit(1, 'Command defines no subcommands')\n\n args = self.parse_args()\n ... | [
"0.7499549",
"0.6950549",
"0.68918645",
"0.6662167",
"0.65991306",
"0.6514817",
"0.650766",
"0.6461696",
"0.64330965",
"0.6416854",
"0.6334393",
"0.6319114",
"0.63075733",
"0.6286679",
"0.6237047",
"0.6179591",
"0.61773044",
"0.61754835",
"0.6156815",
"0.61317736",
"0.6086994... | 0.0 | -1 |
Returns the current training instance. | def getTrainInstance(self): #NOTE: Probably faster way of doing this than additional 'if' statement every learning iteration
return [self.currentTrainState, self.currentTrainPhenotype] #Return unadulterated training data
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTrainInstance(self):\n self.train_inst_condition = self.format_data.trainFormatted[self.data_ref][0]\n self.train_inst_phenotype = self.format_data.trainFormatted[self.data_ref][1]\n if self.data_ref < (self.format_data.numTrainphenotypes - 1):\n self.data_ref += 1\n e... | [
"0.6745298",
"0.65309036",
"0.652377",
"0.64405304",
"0.64387655",
"0.63725954",
"0.63721037",
"0.6339007",
"0.633087",
"0.6328472",
"0.6328472",
"0.631136",
"0.62620455",
"0.6256982",
"0.6194044",
"0.61931723",
"0.61446357",
"0.61241245",
"0.6090343",
"0.6074379",
"0.6053777... | 0.7190633 | 0 |
Returns the current training instance. | def getTestInstance(self):
return [self.currentTestState, self.currentTestPhenotype] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTrainInstance(self): #NOTE: Probably faster way of doing this than additional 'if' statement every learning iteration\r\n return [self.currentTrainState, self.currentTrainPhenotype] #Return unadulterated training data\r",
"def getTrainInstance(self):\n self.train_inst_condition = self.forma... | [
"0.71910805",
"0.6746282",
"0.65304893",
"0.6523471",
"0.6442107",
"0.64365894",
"0.6372113",
"0.637159",
"0.63391674",
"0.633235",
"0.63296",
"0.63296",
"0.63115346",
"0.6262467",
"0.6256379",
"0.61942786",
"0.6191379",
"0.61420786",
"0.612376",
"0.6089886",
"0.6073037",
"... | 0.0 | -1 |
Shifts the environment to the next instance in the data. | def newInstance(self, isTraining):
#-------------------------------------------------------
# Training Data
#-------------------------------------------------------
if isTraining:
if self.dataRef < (self.formatData.numTrainInstances-1):
self.dataRef += ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def advance(self):\n self._state = self._next_state",
"def step(self, env):\n self.loc = env.look_and_move(self.loc, self.vision)\n self.sugar += env.harvest(self.loc) - self.metabolism\n self.age += 1",
"def advance(self):\n self.last = self.next\n self.next = {}",
... | [
"0.6054279",
"0.60246956",
"0.5994793",
"0.5764017",
"0.5736582",
"0.5727876",
"0.5688803",
"0.5682906",
"0.568099",
"0.5655789",
"0.562545",
"0.5563428",
"0.5542813",
"0.5464575",
"0.5454749",
"0.5453741",
"0.54400635",
"0.54220384",
"0.53969413",
"0.5393709",
"0.5387718",
... | 0.0 | -1 |
Resets the iteration count through the current data set. | def resetDataRef(self, isTraining):
self.dataRef = 0
if isTraining:
self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]
self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]
else:
self.currentTestState = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n self.reset_count += 1\n self._init_data()",
"def reset(self):\n self.__sets = []\n self._computed = False",
"def reset(self):\n self._idx = 0",
"def reset(self):\n self.counter = 0",
"def reset (self):\n self.counter = 0",
"def restart(s... | [
"0.76493454",
"0.7592407",
"0.75396395",
"0.7494579",
"0.7469788",
"0.74186695",
"0.7362823",
"0.72185916",
"0.7206081",
"0.7201951",
"0.7198221",
"0.7198221",
"0.7175789",
"0.71727675",
"0.71725744",
"0.71486783",
"0.7148364",
"0.7142279",
"0.7115226",
"0.7083241",
"0.703967... | 0.0 | -1 |
Turns on evaluation mode. Saves the instance we left off in the training data. Also important when using RAIN. | def startEvaluationMode(self):
self.storeDataRef = self.dataRef | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self):\n self.training = False",
"def eval(self):\n self.train(mode=False)",
"def startEvaluationMode(self):\n self.saved_dat_ref = self.data_ref",
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def test(self):\n ... | [
"0.77029514",
"0.7351376",
"0.6970109",
"0.69243413",
"0.67273355",
"0.6641681",
"0.6606844",
"0.65508974",
"0.65234417",
"0.6444228",
"0.6444228",
"0.63508517",
"0.63474333",
"0.6293147",
"0.6250714",
"0.6239057",
"0.62286705",
"0.62021804",
"0.6135565",
"0.61062217",
"0.608... | 0.6623913 | 6 |
Turns off evaluation mode. Reestablishes place in dataset. | def stopEvaluationMode(self):
self.dataRef = self.storeDataRef | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stopEvaluationMode(self):\n self.data_ref = self.saved_dat_ref",
"def eval(self):\n self.train(mode=False)",
"def evaluate(self):\n self.training = False",
"def startEvaluationMode(self):\n self.saved_dat_ref = self.data_ref",
"def startEvaluationMode(self):\r\n self.... | [
"0.7714545",
"0.7181543",
"0.71166897",
"0.7048885",
"0.6880281",
"0.6681234",
"0.6602843",
"0.6505008",
"0.64479685",
"0.6384801",
"0.622787",
"0.61700326",
"0.6166375",
"0.61271054",
"0.612519",
"0.6065476",
"0.5972313",
"0.59697014",
"0.5949517",
"0.58708465",
"0.5826638",... | 0.77148956 | 0 |
Return True if password is valid for user, else False | def check_password(self, password):
if self.password_expire_epoch != 0 and \
time.time() > self.password_expire_epoch:
lg.debug("Password invalid for user '%s': user password is expired"\
%self.name)
return False
if self.password_hash is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_password_valid(password):\n #TODO : This should also be handled by the front_end\n pass",
"def get_has_password(self, user):\n return True if user.password else False",
"def check_password(self, password):\n return self.password == password",
"def verify_password(self, pass... | [
"0.8181345",
"0.80773896",
"0.80308294",
"0.79664797",
"0.78895646",
"0.78841513",
"0.7839702",
"0.78388",
"0.7825555",
"0.7808887",
"0.775599",
"0.775599",
"0.77107185",
"0.77031857",
"0.7691626",
"0.7690411",
"0.7689362",
"0.76876014",
"0.7684381",
"0.76713455",
"0.7656842"... | 0.7833034 | 8 |
Return deferred returning User object if auth successful, else None | def simple_auth(self, name, password, user=None):
if not self._is_initialized():
return self._not_initialized_deferred()
def _do_auth(res=None, state="entry", user=None):
if state == 'entry':
d = self.get_user_record(name)
d.addCallback(_do_auth, s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auth(session, db):\n\tif (session.auth != None) and db(db.User.id == session.auth).count() == 1:\n\t\treturn User(session.auth, db)\n\telse:\n\t\treturn None",
"def get_user(self, token: str) -> Optional[User]:",
"def get_user(self, token: str) -> Optional[User]:",
"def getUser():\n username = pos... | [
"0.7104391",
"0.69574493",
"0.69574493",
"0.68695545",
"0.6855984",
"0.67873764",
"0.6775833",
"0.6756567",
"0.6676308",
"0.6669874",
"0.6645674",
"0.66192853",
"0.66097975",
"0.65966207",
"0.656263",
"0.65613914",
"0.6555194",
"0.65526843",
"0.6551315",
"0.65439045",
"0.6524... | 0.0 | -1 |
Return a brief description of how to use this command, by default from the attribute ``self.help``. | def usage(self, subcommand):
if subcommand == self.run_alias:
return self.usage_alias(subcommand)
return """
./manage.py alias
./manage.py alias name
./manage.py alias name[=value]
./manage.py unalias name
Save commands and parameters as shortcuts.
Aliases are stored... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def help(self) -> str:\n raise NotImplementedError",
"def help(self) -> str:\n\t\treturn None",
"def help_help(self):\n print(\"List commands or print details about a command\")",
"def help_description():\n pass",
"def help(self):\r\n self._short_help(None, None, None, None)",
"de... | [
"0.86134076",
"0.8328481",
"0.83243597",
"0.82085884",
"0.8195443",
"0.81407374",
"0.81246716",
"0.8114379",
"0.8072708",
"0.790892",
"0.7887833",
"0.7887833",
"0.7855178",
"0.78480136",
"0.7847862",
"0.77800506",
"0.77442",
"0.773133",
"0.7728289",
"0.7712405",
"0.76743376",... | 0.0 | -1 |
PLots the features in a 3d plot including the hyperplane that separates the data | def plot_3d_plot(self, features, headers, labels):
self.master_plot.scatter(features[:, 0], features[:, 1], features[:, 2], c=labels)
self.master_plot.set_xlabel(headers[0])
self.master_plot.set_ylabel(headers[1])
self.master_plot.set_zlabel(headers[2])
plot_hyperplane(self.clf,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot3d(self):\n plot_rupture_wire3d(self)",
"def svm_add_3d_hyperplane(model, ax, plotted_points):\n SPACE_SAMPLING_POINTS = 70\n X_MIN = np.min(plotted_points[:, 0])\n X_MAX = np.max(plotted_points[:, 0])\n Y_MIN = np.min(plotted_points[:, 1])\n Y_MAX = np.max(plotted_points[:, 1])\n ... | [
"0.7302647",
"0.7106038",
"0.7101418",
"0.69293755",
"0.6890816",
"0.6856431",
"0.6853505",
"0.6824226",
"0.67982167",
"0.6775323",
"0.67729586",
"0.67109203",
"0.67087954",
"0.6701973",
"0.66566586",
"0.6629957",
"0.66192967",
"0.6613964",
"0.66003513",
"0.6584965",
"0.65722... | 0.75784415 | 0 |
Graphs the features from the log file. Creates a 3D graph with time, average power to motors and velocity as axises. It also decomposes the dimensions into individual 2D graphs. | def graph(self, file_data):
self.file_data = file_data
self.features, self.headers = get_features(file_data)
# FIXME make it so that the outliers can be visualized as well
self.new_scaled_features, self.features = manipulate_features(self.features, file_data)
# features = scale... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logplot(in_dir, fname, xlim, ylim, title):\n\n with open(in_dir + fname,'r') as logfile:\n lf_lines = logfile.readlines()\n\n traj_x = []\n traj_y = []\n\n for row in lf_lines:\n if row[:4] == 'pose':\n #print(float(row[10:-2]))\n tup = row[7:]\n sep_p... | [
"0.5589732",
"0.5531616",
"0.54918617",
"0.54734266",
"0.5443798",
"0.5409416",
"0.5401678",
"0.5318455",
"0.5291172",
"0.5280342",
"0.52708125",
"0.52629036",
"0.5238679",
"0.5226329",
"0.5199443",
"0.5171123",
"0.5170337",
"0.51116526",
"0.50877655",
"0.5086324",
"0.5083493... | 0.5361183 | 7 |
Clears all the axes | def clear_graphs(self):
for ax in (self.master_plot, self.time_velocity, self.time_power, self.power_velocity):
ax.cla() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\n\n # Clear\n self.axes.cla()\n try:\n self.figure.clf()\n except KeyError:\n FlatCAMApp.App.log.warning(\"KeyError in MPL figure.clf()\")\n\n # Re-build\n self.figure.add_axes(self.axes)\n self.axes.set_aspect(1)\n self... | [
"0.82477164",
"0.7836058",
"0.7796212",
"0.77853906",
"0.7656969",
"0.7641738",
"0.7476974",
"0.74030435",
"0.738647",
"0.7372803",
"0.7297088",
"0.7183157",
"0.7169569",
"0.71616346",
"0.71613884",
"0.70750993",
"0.70736307",
"0.6969796",
"0.69636786",
"0.69146824",
"0.68999... | 0.80753964 | 1 |
Shows the grids for the major ticks in the plot. | def show_grid(self):
for ax in (self.time_velocity, self.time_power, self.power_velocity):
ax.grid(True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nicegrid():\n pl.grid(b=True, which='major', color='black', linestyle='-')\n\n pl.grid(b=True, which='minor', color='silver', linestyle=':')",
"def show_grid(frame, episode_nr):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xticks(np.arange(0.5, 10, 1))\n ax.set_yticks(np.arange(0.5, 10, 1))\n... | [
"0.68624645",
"0.67270374",
"0.66225463",
"0.6502822",
"0.6419999",
"0.6419999",
"0.6344717",
"0.63419735",
"0.62765646",
"0.6247754",
"0.6218179",
"0.6216362",
"0.61837363",
"0.6176579",
"0.6159757",
"0.6152556",
"0.6152556",
"0.61514324",
"0.61219585",
"0.6111579",
"0.60773... | 0.7353925 | 0 |
Creates an addition figure that will display the a graph with the constants on it and also the lines of best fit of the accelerating portion of it, the decelerating portion of it and the average of both of those lines | def show_constants_graph(self, features, file_data, labels, c=None):
if is_straight_line(file_data):
easygui.msgbox("It was determined that the robot was trying to go straight. "
"As an ongoing feature the program will be able detect kLag, etc... "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_graph(self):\r\n A = self.a_grid ; V = self.V1 ; Pol = self.Pol\r\n A_opt = A[Pol.astype(int)]\r\n \r\n fig = plt.subplots(figsize = (8,5))\r\n ax = [None,None]\r\n pltgrid = (1,2)\r\n \r\n ax[0] = plt.subplot2grid(pltgrid, (0,0))\r\n ax[1] = ... | [
"0.67043483",
"0.66094536",
"0.6536485",
"0.6489944",
"0.6460383",
"0.6324786",
"0.63169456",
"0.63111645",
"0.62606317",
"0.62522936",
"0.6246969",
"0.61507666",
"0.61484957",
"0.6146962",
"0.61454314",
"0.6120756",
"0.6114009",
"0.61120445",
"0.607397",
"0.6066781",
"0.6062... | 0.6149567 | 12 |
This is the main loop which runs until the user no selects any file. Retrieves the saved model for separating the data. | def find_constants(open_path):
if not os.path.exists(MODEL_FILE):
easygui.msgbox("There are no models to use to classify the data. Please train algorithm first.")
return
clf = joblib.load(MODEL_FILE)
if is_empty_model(clf):
easygui.msgbox("The model has not been fitted yet. Please... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\r\n # Close any open models\r\n self.cleanUp()\r\n # Dynamically select file to preview\r\n self.selectTrial() \r\n # Add adjusted COM (RRA/CMC) model\r\n self.loadAdjustedModel()\r\n # Hide the markers from view\r\n self.hideModelMarker... | [
"0.69089055",
"0.6218082",
"0.6208536",
"0.61605316",
"0.60690135",
"0.5954537",
"0.5932205",
"0.59236944",
"0.5921074",
"0.5898295",
"0.5871303",
"0.5865246",
"0.58392626",
"0.5826997",
"0.58248043",
"0.5769699",
"0.5768321",
"0.57621425",
"0.5759154",
"0.57176274",
"0.57117... | 0.0 | -1 |
Creates and initializes a card | def __init__(self, suit: str, rank: str) -> None:
self.suit = suit
self.rank = rank
self.value = Card.values[rank]
self.hidden = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createCard(self,id,name):\n card = Card(id,name)\n self.cards[id] = card\n print('Created Card:'+id)",
"def define_card(card):\n try:\n value = define_card_value(card[0])\n color = define_card_color(card[1])\n return Card(value, color)\n except AttributeError:\... | [
"0.7489538",
"0.74147695",
"0.73503184",
"0.7285862",
"0.7285862",
"0.7158202",
"0.71478814",
"0.71125865",
"0.70091987",
"0.6920996",
"0.6901048",
"0.6856007",
"0.681001",
"0.67669064",
"0.67593235",
"0.6752542",
"0.6734627",
"0.6703586",
"0.66528183",
"0.66227216",
"0.66011... | 0.6388992 | 45 |
both threads will call this function to try to acquire the lock | def try_lock_acquire(lock):
logging.debug('Starting')
for i in range(2):
time.sleep(0.5)
logging.debug('Trying to acquire')
""".acqire() returns false if the timeout passed in has elapsed."""
have_it = lock.acquire(0)
try:
if have_it:
""" only one thread will acquire the lock each iteration """
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def acquire_lock(self):\n self._multistore._lock()",
"def acquire_lock(self):\n if self.lock:\n self.lock.acquire()",
"def lock(self):\n self.mtx.acquire()",
"def lock(self):\n raise NotImplementedError",
"def acquire_lock (self):\n\n self._exec (self.selec... | [
"0.8146044",
"0.80489576",
"0.7777038",
"0.76436627",
"0.7439585",
"0.7301035",
"0.7277469",
"0.7263061",
"0.7245742",
"0.72069293",
"0.718976",
"0.7181839",
"0.71141493",
"0.70146245",
"0.7011094",
"0.6964797",
"0.69139475",
"0.68795747",
"0.6869598",
"0.68481034",
"0.684688... | 0.68544126 | 19 |
Return all the matching commands. Only for the submode which is passed in. Be sensitive to features, be sensitive to the prefix. For commands which have a first keyword which is a pattern, use the command description's completio | def commands_for_submode(prefix):
candidates = _lookup_command_candidates(prefix, command_registry)
# print type(candidates), [x['self'] for x in candidates]
# print [x.get('all-help') for x in candidates]
if debug.cli():
# print 'commands_for_submode:', sorted(dict([[x['name']['title'] if type(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matching_commands(self, command_word, is_no_command, command_list):\n candidates = []\n current_mode = bigsh.run.finder.mode_stack.current_mode()\n command_word_lower = command_word.lower()\n\n try:\n for command in command_list:\n # If this command is ... | [
"0.66676307",
"0.6511643",
"0.6412278",
"0.63640773",
"0.6297366",
"0.62761074",
"0.6274068",
"0.6131544",
"0.6130938",
"0.60968447",
"0.6082013",
"0.6057049",
"0.5983618",
"0.5955035",
"0.5952809",
"0.58883524",
"0.58177805",
"0.5813151",
"0.5804144",
"0.5801285",
"0.5795904... | 0.8093101 | 0 |
Save some state about the version/module | def add_command_module_name(version, module):
if version not in command_syntax_version:
command_syntax_version[version] = [module]
else:
command_syntax_version[version].append(module) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_state(self):\n pass",
"def save_state(self):\r\n state = {\r\n 'next_student_module_id': self.next_student_module_id,\r\n }\r\n with open(self.STATE_FILE, \"w\") as state_file:\r\n json.dump(state, state_file)\r\n self.say(\"Saved state: {}\".form... | [
"0.67257243",
"0.65780526",
"0.64473563",
"0.6440833",
"0.64254165",
"0.621508",
"0.6183765",
"0.61343235",
"0.611661",
"0.610986",
"0.604875",
"0.6012745",
"0.60035145",
"0.5991767",
"0.5912925",
"0.58604914",
"0.5834747",
"0.5828542",
"0.5822429",
"0.57592875",
"0.57477856"... | 0.0 | -1 |
Returns whether or not the given value is a valid boundary value. Valid values are integers or the special strings 'min' or 'max' (caseinsensitive) | def _is_range_boundary(boundary):
return (isinstance(boundary, numbers.Integral) or
(_is_string(boundary) and (boundary.lower() in ('min','max')))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self, value: Union[int, float]) -> bool:\n if self.left_boundary['open']:\n if self.left_boundary['value'] >= value:\n return False\n else:\n if self.left_boundary['value'] > value:\n return False\n if self.right_boundary['open']... | [
"0.7001806",
"0.69449776",
"0.69125473",
"0.6847961",
"0.6784564",
"0.6771291",
"0.6754776",
"0.671932",
"0.67118704",
"0.6632516",
"0.6568673",
"0.6539237",
"0.65292275",
"0.6448011",
"0.6417884",
"0.64089316",
"0.6399697",
"0.6356775",
"0.6352202",
"0.63023275",
"0.6292374"... | 0.8070116 | 0 |
Converts the given boundary value to an appropriate integral boundary value. This is used to handle the special "min' and 'max' string values. The test_value argument should be the value which is being tested for whether or not it's in a range. Since long integral values have an unlimited precision there is no actual M... | def _convert_range_boundary(boundary, test_value):
if _is_string(boundary):
if boundary.lower() == 'min':
boundary = test_value - 1
elif boundary.lower() == 'max':
boundary = test_value + 1
else:
raise error.CommandDescriptionError('Invalid range boundary ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_range_boundary(boundary):\n return (isinstance(boundary, numbers.Integral) or\n (_is_string(boundary) and (boundary.lower() in ('min','max'))))",
"def clean_int(\n i: int,\n ub: int,\n lb: int = 0,\n ) -> int: \n\n # Initialisations\n i_temp = i\n\n # Check if the in... | [
"0.6226162",
"0.6110354",
"0.5956353",
"0.5869911",
"0.5851052",
"0.5840057",
"0.58316064",
"0.5831372",
"0.5728684",
"0.569103",
"0.56804085",
"0.56803036",
"0.5654331",
"0.56315446",
"0.55944073",
"0.5495219",
"0.5494189",
"0.5409632",
"0.5409632",
"0.539477",
"0.5389832",
... | 0.7728433 | 0 |
Returns whether or not the argument is a valid single range. A valid range is either a single integral value or else a sequence (tuple or list) with 2 elements, each of which is a valid range boundary value. | def _is_single_range(r):
return (isinstance(r, numbers.Integral) or
(isinstance(r, collections.Sequence) and (len(r) == 2) and
_is_range_boundary(r[0]) and _is_range_boundary(r[1]))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_one_range(r):\n if not _is_single_range(r):\n raise error.RangeSyntaxError(str(r))",
"def acceptsArgument(self):\n range = self.validateRange(self.range)\n return not(not(range[1]))",
"def isRangeValid(self) -> bool:\n ...",
"def _is_range(cls, rng):\n match = re.... | [
"0.7808903",
"0.7591454",
"0.7182697",
"0.71769637",
"0.7123997",
"0.7108595",
"0.6981113",
"0.69550073",
"0.6891303",
"0.688228",
"0.686025",
"0.6788622",
"0.6352424",
"0.63459134",
"0.63131315",
"0.62641954",
"0.6227245",
"0.6194634",
"0.61821723",
"0.6179093",
"0.6149241",... | 0.86027473 | 0 |
Checks that the argument is a valid single range as determined by _is_single_range. If it is, then the function returns None. It it's not, then a RangeSyntaxError exception is raised. | def _check_one_range(r):
if not _is_single_range(r):
raise error.RangeSyntaxError(str(r)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_single_range(r):\n return (isinstance(r, numbers.Integral) or\n (isinstance(r, collections.Sequence) and (len(r) == 2) and\n _is_range_boundary(r[0]) and _is_range_boundary(r[1])))",
"def _check_range(r): \n if _is_single_range(r):\n _check_one_range(r)\n elif isin... | [
"0.71708286",
"0.6784762",
"0.6421671",
"0.63540816",
"0.6278021",
"0.6267585",
"0.61784256",
"0.5972375",
"0.5945648",
"0.5697895",
"0.5589983",
"0.5469726",
"0.53853506",
"0.533863",
"0.531605",
"0.5294728",
"0.52871644",
"0.528131",
"0.5274676",
"0.5242175",
"0.51893365",
... | 0.81059533 | 0 |
Checks that the argument is a valid range. If it is, then the function returns None. It it's not, then a RangeSyntaxError exception is raised. | def _check_range(r):
if _is_single_range(r):
_check_one_range(r)
elif isinstance(r, collections.Sequence):
for r2 in r:
_check_one_range(r2)
else:
raise error.RangeSyntaxError(str(r)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_range(parser, arg, minimum=0, maximum=100):\n if arg < minimum:\n parser.error(\"%s < %s\", arg, minimum)\n else:\n if arg > maximum:\n parser.error(\"%s > %s\", arg, maximum)\n\n return arg",
"def _check_one_range(r):\n if not _is_single_range(r):\n raise... | [
"0.77003306",
"0.7608936",
"0.7103421",
"0.68035877",
"0.6748383",
"0.67366076",
"0.673641",
"0.6694982",
"0.64401865",
"0.64094526",
"0.6375695",
"0.63503134",
"0.6252607",
"0.6230385",
"0.6222785",
"0.61698633",
"0.61226755",
"0.60937774",
"0.6084571",
"0.6073749",
"0.60656... | 0.7267727 | 2 |
Look up the given name in a typedef. If it's not found in the given typedef it recursively searches for the value in the base typedefs. Returns None if the value is not found. | def _lookup_typedef_value(typedef, name):
assert typedef is not None
assert name is not None
# Check if the typedef has the attribute
value = typedef.get(name)
if value:
return value
# Otherwise, see if it's defined in the base type(s)
base_type_name = typedef.get('base-typ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkLookup(self, name):\n if not self.symbols.has_key(name):\n # we don't care\n return None\n # is it one we really care about\n t = self.symbols[name].getType()\n if t == \"typedef\":\n t = self.symbols[name].getAliasType()\n if t == \"... | [
"0.62882066",
"0.6006309",
"0.5985091",
"0.58943266",
"0.5891234",
"0.58053267",
"0.57933515",
"0.5666294",
"0.5659589",
"0.556779",
"0.5549444",
"0.5516995",
"0.5516995",
"0.54696757",
"0.5459081",
"0.5456446",
"0.5453206",
"0.5431234",
"0.5415231",
"0.5371446",
"0.53526515"... | 0.8076759 | 0 |
Called when an argument doesn't match the expected type. Raises an ArgumentValidationError exception. The message for the exception can be customized by specifying a error format string in the type definition. The format string is called ' validationerrorformat'. | def _raise_argument_validation_exception(typedef, value, detail, expected_tokens=None):
typedef_name = typedef.get('help-name')
if typedef_name is None:
typedef_name = typedef.get('name')
if typedef_name is None:
typedef_name = typedef.get('field')
if typedef_name is None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_incorrect_arg_type(self):\n\n with pytest.raises(TypeError) as exc_info:\n upper_incomplete_gamma(a='A', z=0.3)\n\n expected_error_msg = (\n 'type of argument \"a\" must be one of (int, float); got str instead'\n )\n assert str(exc_info.value) == expected_... | [
"0.69686395",
"0.66745853",
"0.6643091",
"0.6587547",
"0.6579584",
"0.646052",
"0.6447449",
"0.64430845",
"0.6376854",
"0.63049024",
"0.63008493",
"0.62791383",
"0.6219893",
"0.61986107",
"0.61303514",
"0.6127861",
"0.6121139",
"0.6109378",
"0.6102843",
"0.60939085",
"0.60928... | 0.7721112 | 0 |
Gets the args item from the given item. The item may be a command or subcommand description or a nested arg list inside a 'choice' argument. If there's no item names "args", then it returns None. If the args item is a single argument, then it's converted into a tuple containing that single argument, so that the caller ... | def _get_args(item):
args = item.get('args')
if args and not isinstance(args, collections.Sequence):
args = (args,)
return args | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _item_or_tuple(self, seq):\n t = tuple(seq)\n if self._is_multi:\n return t\n else:\n return t[0]",
"def _item_or_tuple(self, seq):\n t = tuple(seq)\n if self._is_multi:\n return t\n else:\n return t[0]",
"def _item_or_tuple(self, seq):\n ... | [
"0.60065734",
"0.5978255",
"0.5978255",
"0.57647127",
"0.5749274",
"0.5505375",
"0.5469559",
"0.5410199",
"0.53327376",
"0.5265627",
"0.52116334",
"0.5186901",
"0.51850796",
"0.5178818",
"0.5167262",
"0.5139123",
"0.5139123",
"0.51254106",
"0.50968003",
"0.5068587",
"0.506782... | 0.7316674 | 0 |
Get the syntax help string for an argument list. | def _get_command_args_syntax_help_string(command, is_no_command, args):
syntax_string = ''
if args:
for i, arg in enumerate(args):
if i > 0:
syntax_string += ' '
if _is_string(arg):
syntax_string += arg
continue
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmd_help(args):",
"def help():\n return statement(help_text)",
"def help_list(self):\n help_str = \"\"\"Lists command(s) from history in a flexible/searchable way.\n\n Usage: list [arg]\n\n Where arg is:\n no arg -> list most recent command\n arg is inte... | [
"0.66476196",
"0.6568818",
"0.6546846",
"0.64866126",
"0.64727557",
"0.64497846",
"0.64382064",
"0.633312",
"0.6330669",
"0.63208956",
"0.6274658",
"0.6242831",
"0.62242854",
"0.6200293",
"0.6198663",
"0.61940193",
"0.6166287",
"0.60947055",
"0.6091308",
"0.60767895",
"0.6057... | 0.63734406 | 7 |
Predicate to provide some indication of whether or not the command allows the 'no' prefix | def is_no_command_supported(command):
command_type = command.get('command-type')
if command_type:
if command_type in ['display-table','display-rest', 'show']:
return False
no_supported = command.get('no-supported', True)
if no_supported == False:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_skip(self, value):\n return value.startswith(self.flag_prefix) or value == '--'",
"def possible_negation_prefix(text: str) -> bool:\n prefixes = (\"de\", \"dis\", \"im\", \"in\", \"ir\", \"il\", \"non\", \"un\", \"mis\")\n # Length is mentioned to limit wrong prefix recongnition such as \... | [
"0.6331741",
"0.6209631",
"0.6140443",
"0.61398494",
"0.6138786",
"0.6078261",
"0.6060077",
"0.6056548",
"0.60399204",
"0.596429",
"0.5939109",
"0.5934993",
"0.58885604",
"0.5875812",
"0.58206064",
"0.5796699",
"0.57939255",
"0.57747096",
"0.57518256",
"0.57354045",
"0.571539... | 0.58597386 | 14 |
Returns the list of matching command candidates from the command list. | def get_matching_commands(self, command_word, is_no_command, command_list):
candidates = []
current_mode = bigsh.run.finder.mode_stack.current_mode()
command_word_lower = command_word.lower()
try:
for command in command_list:
# If this command is tied to a fe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _lookup_command_candidates(command_prefix, command_list):\n candidates = []\n current_mode = bigsh.run.finder.mode_stack.current_mode()\n try:\n for command in command_list:\n modes = _get_applicable_modes(command)\n if _match_current_modes(command, current_mode, modes):\n... | [
"0.78405523",
"0.6468865",
"0.63149947",
"0.62614846",
"0.6214467",
"0.6194494",
"0.6165398",
"0.6153341",
"0.6145241",
"0.61329925",
"0.5982471",
"0.59805346",
"0.5973649",
"0.5963104",
"0.59585357",
"0.5950532",
"0.5916563",
"0.59144855",
"0.5905247",
"0.5900076",
"0.589186... | 0.71730745 | 1 |
Parse the given args from the given command words. | def parse_arguments(self, args, words, start_word_index, scopes,
arg_data, fields, actions, prefix_matches, command):
if len(args) == 0:
return [[0, [], scopes, arg_data, fields, actions]]
parse_results = []
arg = args[0]
if _is_string(arg):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args(args):\n parser = argparse.ArgumentParser(\n description=\"Command line bot application, e.g. bot how do you work?\")\n parser.add_argument(\n '--version',\n action='version',\n version='nlpia_bot {ver}'.format(ver=__version__))\n ... | [
"0.73245573",
"0.7055901",
"0.66049635",
"0.6526766",
"0.652343",
"0.650238",
"0.6472132",
"0.64673615",
"0.6459616",
"0.6401424",
"0.6397366",
"0.638948",
"0.63884",
"0.6379766",
"0.6367825",
"0.63568634",
"0.63269633",
"0.631822",
"0.6295588",
"0.6281215",
"0.6237192",
"0... | 0.705395 | 2 |
Select the most appropriate localized text to associate with the completionreason for some completiontext | def complete_help(self, arg_scopes):
c_help = _lookup_in_scopes('conpletion-text', arg_scopes)
if c_help:
return c_help
c_help = _lookup_in_scopes('syntax-help', arg_scopes)
if c_help:
return c_help
c_help = _lookup_in_scopes('all-help', arg_scopes)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def completion_set(self, completions, text, reason):\n if completions == None:\n completions = {text : reason}\n return\n current_text = completions.get(text)\n # current_text could possibly be None from the lookup\n if current_text != None and current_text[0] == '... | [
"0.6259234",
"0.61822283",
"0.59109974",
"0.57965857",
"0.5733555",
"0.56752014",
"0.5584407",
"0.5546678",
"0.5533903",
"0.5503533",
"0.5498424",
"0.54351395",
"0.5376525",
"0.5369051",
"0.5360784",
"0.53588665",
"0.5344191",
"0.531261",
"0.53013414",
"0.5272706",
"0.5260305... | 0.55057406 | 9 |
In situations where multiple commands match for some completion text, the last commanditeratedover will populate the text for the completion dictionary. Use the first character of the completion string for this command to identify when the text represents the most "base" variant of the command to display for completion... | def completion_set(self, completions, text, reason):
if completions == None:
completions = {text : reason}
return
current_text = completions.get(text)
# current_text could possibly be None from the lookup
if current_text != None and current_text[0] == '!':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complete_help(self, arg_scopes):\n c_help = _lookup_in_scopes('conpletion-text', arg_scopes)\n if c_help:\n return c_help\n c_help = _lookup_in_scopes('syntax-help', arg_scopes)\n if c_help:\n return c_help\n c_help = _lookup_in_scopes('all-help', arg_sc... | [
"0.6587769",
"0.6476927",
"0.64444095",
"0.62364894",
"0.610779",
"0.6104665",
"0.60427445",
"0.5979768",
"0.5978135",
"0.59669816",
"0.5960604",
"0.5933637",
"0.5852868",
"0.58415747",
"0.5825542",
"0.5779125",
"0.57398105",
"0.5697792",
"0.5675063",
"0.56458724",
"0.5634846... | 0.0 | -1 |
Print the completions ourselves in sorted multiple column format. We use this when the completions are are pseudo/help completions that aren't real tokens that we want readline to use for completions. | def print_completions(self, completions):
meta_completions = [completion[0] if isinstance(completion, tuple)
else completion for completion in completions]
meta_completions.sort()
bigsh.print_completion_help(bigsh.choices_text_builder(meta_completions)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cli_completions(self) -> str:\n completions = []\n for cmd_name in self.cli_parser.cmd_names:\n completions.append(cmd_name)\n for plugin_name in self.name_to_plugin_class:\n completions.append(plugin_name)\n\n return \",\".join(completions)",
"def displaySor... | [
"0.60223293",
"0.5749722",
"0.57289875",
"0.5696492",
"0.56638753",
"0.55966675",
"0.5560439",
"0.5553174",
"0.5548504",
"0.55221015",
"0.5500452",
"0.5498528",
"0.5395442",
"0.5389106",
"0.53512865",
"0.5325396",
"0.530939",
"0.53022945",
"0.5282126",
"0.5232109",
"0.5226291... | 0.7565795 | 0 |
The canonical (i.e. most general) representation of a validation result is a list of 2item tuples where the first item in the tuple is the validated value that should be used to update the arg_data and the second item is the actual token that was matched, which may not be the same as the word in the command. For exampl... | def _canonicalize_validation_result(result):
if result is None:
result = []
elif _is_list(result):
if len(result) > 0 and not _is_list(result[0]):
result = [result]
else:
matching_token = result if _is_string(result) else str(result)
result = [(result, matching_to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process_validator_results(ret, level, object_data, obj):\n\n # The first object in the tuple is the one being validated\n if isinstance(obj, tuple):\n real_obj = obj[0]\n else:\n real_obj = obj\n\n if not ret:\n is_valid = True\n return i... | [
"0.5750961",
"0.55248684",
"0.5506295",
"0.54921216",
"0.5306934",
"0.5261992",
"0.5246164",
"0.52409977",
"0.51459575",
"0.5136628",
"0.51328367",
"0.5111515",
"0.50920993",
"0.5087317",
"0.5069478",
"0.5063956",
"0.5053605",
"0.5051444",
"0.50409806",
"0.5040384",
"0.502853... | 0.7486084 | 0 |
Validate that the specified value matches the validation in the specified type definition and any inherited type definitions | def validate_type(type_name, value, arg_data, scopes, command):
# Look up the type definition and perform any validation specified there
typedef = typedef_registry.get(type_name)
if not typedef:
raise error.CommandDescriptionError('Unknown type: %s' % type_name)
type_result = None
validatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkType(self, value):\n pass",
"def validate(self, value):\n value = super(Type,self).validate(value)\n if self.type is None:\n return value\n if value is not None and not isinstance(value,self.type):\n try:\n if isinstance(value, list) or is... | [
"0.71427083",
"0.6972905",
"0.6835837",
"0.67700577",
"0.671566",
"0.6649001",
"0.6594712",
"0.65906966",
"0.65582323",
"0.6530636",
"0.6525814",
"0.6501799",
"0.6471414",
"0.6450656",
"0.6442439",
"0.6424564",
"0.6416181",
"0.64132726",
"0.6408936",
"0.64036417",
"0.6397485"... | 0.6791413 | 3 |
Build output lines from the passed in text. If the text has leading spaces, then leave the spaces intact (starting at the indent). | def dumb_formatter(out, text, left, right = None):
if right == None:
(right, line_length) = bigsh.pp.get_terminal_size()
if right - 20 > left: # XXX needs work
right = right - 20
right = min(right, 120)
left_indent = ' ' * left
out_len = left
out_line = left_indent
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __indent_text_block(text):\n lines = text.splitlines()\n if len(lines) > 1:\n out = lines[0] + \"\\r\\n\"\n for i in range(1, len(lines)-1):\n out = out + \" \" + lines[i] + \"\\r\\n\"\n out = out + \" \" + lines[-1]\n return out\n return text",
"... | [
"0.73112255",
"0.66962504",
"0.6664648",
"0.66639674",
"0.6600784",
"0.6528203",
"0.6523025",
"0.6511936",
"0.6481735",
"0.6391032",
"0.6383207",
"0.6354279",
"0.6329117",
"0.63085085",
"0.6291374",
"0.6235841",
"0.6215798",
"0.61852205",
"0.61840844",
"0.6153983",
"0.6147103... | 0.6057945 | 24 |
qualify Generate qualify version of the permutations field_values Generate instance of command using these fields | def __init__(self, qualify = False, field_values = None):
super(CommandPermutor, self).__init__()
self.commands = []
self.collect = []
# intended to be boolean, but any predicate type will do.
self.qualify = qualify
# field_values is intended to be a dictionary of name:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def field_to_generator(self, field, field_values):\n if self.qualify:\n # Many of the fields are actually fields in\n # the named obj-type. Take a shot at seeing if that's\n # the case, and call a sample value collector\n\n if self.path_other:\n # ... | [
"0.59003377",
"0.5237725",
"0.5203437",
"0.5165361",
"0.50387293",
"0.50179744",
"0.4940163",
"0.49088612",
"0.48980182",
"0.48827323",
"0.48454884",
"0.48104414",
"0.4796751",
"0.4788122",
"0.47654617",
"0.47645807",
"0.47437337",
"0.47381946",
"0.47369894",
"0.47285095",
"0... | 0.60619706 | 0 |
Convert the field name to a text field. When 'qualify' is set, replace the field name with a likely procedure to call instead | def field_to_generator(self, field, field_values):
if self.qualify:
# Many of the fields are actually fields in
# the named obj-type. Take a shot at seeing if that's
# the case, and call a sample value collector
if self.path_other:
# These are ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_field(identifier: str) -> str:\n return identifier.lower()",
"def __call__(self, field_name):\n try:\n return getattr(self, field_name)\n except Exception:\n return self._encoded_fields[field_name]",
"def capnp_field_name(self, field):\n name = field.name\n return as_ide... | [
"0.59077346",
"0.57926226",
"0.55189836",
"0.54694974",
"0.5461919",
"0.5446574",
"0.5430781",
"0.5419817",
"0.5418746",
"0.5403276",
"0.5351895",
"0.5326152",
"0.52837604",
"0.5249325",
"0.5220029",
"0.5216379",
"0.5213939",
"0.5204398",
"0.51758146",
"0.5173832",
"0.5161701... | 0.4900808 | 54 |
Permute command for a submode, takes the command, finds all the related submodesmodes, permutes all the commands in the submode, then a recursive call to any submodes found within this one. submode_command command dictionary of the submode command. Can be set to None as an indication of "root" qualify boolean, describe... | def permute_single_submode(submode_command, qualify):
permuted = []
permute_submodes = []
if submode_command == None:
mode = 'login'
else:
# first, the submode. There ought to be only one permutation.
permute = CommandPermutor(qualify)
permuted.append(permute.permute_co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def permute_command(words, qualify):\n if len(words) == 0:\n return permute_single_submode(None, qualify)\n else:\n permute = CommandPermutor(qualify)\n return permute.handle_command(words)",
"def commands_for_submode(prefix):\n candidates = _lookup_command_candidates(prefix, comman... | [
"0.6088499",
"0.5510981",
"0.5013558",
"0.4904283",
"0.48374233",
"0.47861892",
"0.47663242",
"0.4672153",
"0.4592035",
"0.45495653",
"0.45457467",
"0.4542132",
"0.4524321",
"0.45221865",
"0.44939885",
"0.4493422",
"0.4463644",
"0.44468173",
"0.4442733",
"0.44194564",
"0.4403... | 0.78541815 | 0 |
Permute all the commands (with no parameters), or a sigle command. The command is named via the name | def permute_command(words, qualify):
if len(words) == 0:
return permute_single_submode(None, qualify)
else:
permute = CommandPermutor(qualify)
return permute.handle_command(words) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call_command_direct(self, name, args=None, kwargs=None):\n comm,_=self._commands[name]\n return comm(*(args or []),**(kwargs or {}))",
"def _transform_command(self) -> None:\n self.command = None if self.command == [] else self.command",
"def __call__(self, cmd):\n cmdname = cmd... | [
"0.5660321",
"0.55383295",
"0.54060173",
"0.539535",
"0.5362111",
"0.5255111",
"0.5249829",
"0.524142",
"0.5200568",
"0.5195856",
"0.51837564",
"0.51559633",
"0.51405185",
"0.5124075",
"0.51221806",
"0.5109466",
"0.50891364",
"0.50802135",
"0.5072316",
"0.5067867",
"0.503808"... | 0.69490945 | 0 |
Returns whether or not the argument is a string (either a "str" or "unicode") | def _is_string(arg):
return isinstance(arg, types.StringTypes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def typeIsString(obj):\n return type(obj) is str or _haveTypeUnicode and type(obj) is unicode",
"def is_string(atype):\n if atype == str:\n return True\n elif PY2:\n if atype == unicode:\n return True\n return False",
"def is_string(value):\n return isinstanc... | [
"0.85439533",
"0.8531232",
"0.85032046",
"0.8458424",
"0.8457038",
"0.8448985",
"0.84387064",
"0.84377694",
"0.84271085",
"0.82765406",
"0.82513785",
"0.8241974",
"0.8218465",
"0.81970197",
"0.81306636",
"0.81137633",
"0.8081129",
"0.80713755",
"0.7998069",
"0.7932523",
"0.78... | 0.9257119 | 0 |
Returns whether or not the argument is a list. This means that it's an instance of a sequence, but not including the string types | def _is_list(arg):
return isinstance(arg, collections.Sequence) and not _is_string(arg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_list ( self, s ):\r\n\t\treturn isinstance ( s, type( list () ) )",
"def is_list_of(seq, expected_type):\n return is_seq_of(seq, expected_type, seq_type=list)",
"def _is_list(item):\n return isinstance(item, list)",
"def _is_list(val):\n\n return isinstance(val, list)",
"def is_sequence_o... | [
"0.83214027",
"0.81061",
"0.8065349",
"0.79083794",
"0.7902992",
"0.78376174",
"0.78361946",
"0.78166515",
"0.7780776",
"0.7772325",
"0.7759591",
"0.77538717",
"0.7664642",
"0.7664073",
"0.7621871",
"0.7563922",
"0.75465405",
"0.7468648",
"0.73699504",
"0.73252976",
"0.728769... | 0.90609455 | 0 |
Look up the given name in the given list of scopes. Returns the default value if the name is not defined in any of the scopes. | def _lookup_in_scopes(name, scopes, default=None):
assert name
assert scopes is not None
# We iterate over the items in the scope (rather than using 'get')
# so we can do a case-insensitive lookup.
name_lower = name.lower()
for scope in scopes:
for key, value in scope.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup(scopes, name):\n # type: (Scopes[T], str) -> Optional[T]\n\n for scope in scopes:\n for key, val in scope:\n if key == name:\n return val\n return None",
"def get_by_name(self, name):\n scopes = self._client.get_all()\n result = [x for x in scope... | [
"0.79767394",
"0.71245885",
"0.6058012",
"0.6011732",
"0.59649855",
"0.5573654",
"0.5547338",
"0.55172366",
"0.54739946",
"0.53942615",
"0.53553236",
"0.53401506",
"0.53022784",
"0.52925473",
"0.52719605",
"0.5179497",
"0.51721185",
"0.5171616",
"0.5151544",
"0.5137249",
"0.5... | 0.8805875 | 0 |
Helper function for _get_applicable_modes to add any modes for this command | def _add_applicable_modes(command, mode_dict):
description_feature = command.get('feature')
if description_feature:
if not feature.feature_enabled(description_feature):
return
mode = command.get('mode')
if mode:
if type(mode) == list:
for m in mode:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_applicable_modes(command):\n mode_dict = {}\n _add_applicable_modes(command, mode_dict)\n return mode_dict.keys()",
"def append_modes(self,modes):\n self.modes = np.append(self.modes,np.array(modes,dtype=modetype))",
"def apply_mode_command(self, channel, command):\n direction, ... | [
"0.753973",
"0.71372646",
"0.6752454",
"0.6620678",
"0.6579078",
"0.65712893",
"0.6447186",
"0.6447186",
"0.64453655",
"0.64104617",
"0.64058155",
"0.63210326",
"0.6265792",
"0.61772203",
"0.61080694",
"0.6099957",
"0.6079826",
"0.607896",
"0.60186535",
"0.6015669",
"0.600954... | 0.87255466 | 0 |
Returns a list of all of the modes that are specified for this command | def _get_applicable_modes(command):
mode_dict = {}
_add_applicable_modes(command, mode_dict)
return mode_dict.keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modes(self) -> List[str]:\n return [m.name for m in self._modes]",
"def _get_modes(self):\n return self.__modes",
"def get_modes(self):\n return self.circuit.get_modes()",
"def modes(self):\n return np.hstack(tuple(self.operator.modes))",
"def get_modes(self):\n return [i... | [
"0.8445033",
"0.82154745",
"0.80214876",
"0.7829724",
"0.78250915",
"0.7822188",
"0.7747393",
"0.7696896",
"0.7645572",
"0.75551045",
"0.75231206",
"0.745426",
"0.7388421",
"0.73145664",
"0.72621864",
"0.7185098",
"0.71638507",
"0.71492827",
"0.7133864",
"0.7105226",
"0.70994... | 0.82162344 | 1 |
Return True when this command_mode is an exact match for this current mode (used to partition list of commands into two groups, one exact level, and for for related mode matches) | def _exact_mode_match(current_mode, command_modes):
if not type(command_modes) == list:
command_modes = [command_modes]
for mode in command_modes:
if mode == current_mode:
return True
if mode.endswith('*') and mode[:-1] == current_mode:
return True
return Fals... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _match_current_modes(command, current_mode, modes):\n if current_mode in modes:\n return True\n #\n # if the modes is enable, this works everywhere\n #\n if 'login' in modes:\n return True\n #\n # if the modes is login, and the mode is anything but login,\n # then this is ... | [
"0.7462347",
"0.60965776",
"0.5913109",
"0.57950515",
"0.5736853",
"0.5670262",
"0.5664345",
"0.5632514",
"0.5624758",
"0.5591398",
"0.5580854",
"0.5562407",
"0.5527055",
"0.5523893",
"0.54978305",
"0.5474427",
"0.5451625",
"0.54250956",
"0.5420091",
"0.54136974",
"0.5408295"... | 0.81015956 | 0 |
Even when the current mode isn't in the list of modes, there's a few modes in the mode list which are intended to | def _match_current_modes(command, current_mode, modes):
if current_mode in modes:
return True
#
# if the modes is enable, this works everywhere
#
if 'login' in modes:
return True
#
# if the modes is login, and the mode is anything but login,
# then this is true
#
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_modes(self):\n return self.__modes",
"def mode(self):\r\n pass",
"def mode(self) -> Mode:\n ...",
"def __check_mode(self):\n self.mode[\"auto_mode\"] = self.communications.get_mode()",
"def mode(self, mode: Optional[int] = None) -> Optional[int]:\n ...",
"def cmd_m... | [
"0.74098396",
"0.7371424",
"0.7287743",
"0.70694387",
"0.7034376",
"0.69173056",
"0.6859695",
"0.6854071",
"0.68327373",
"0.68093693",
"0.68080527",
"0.68073785",
"0.6804063",
"0.6792828",
"0.67795384",
"0.6770016",
"0.67179525",
"0.6708704",
"0.6704747",
"0.66946924",
"0.668... | 0.6675021 | 21 |
Returns the list of command candidates from the given command list. A candidate must have a 'mode' value that matches the current mode, and its name must begin with the given command prefix. | def _lookup_command_candidates(command_prefix, command_list):
candidates = []
current_mode = bigsh.run.finder.mode_stack.current_mode()
try:
for command in command_list:
modes = _get_applicable_modes(command)
if _match_current_modes(command, current_mode, modes):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matching_commands(self, command_word, is_no_command, command_list):\n candidates = []\n current_mode = bigsh.run.finder.mode_stack.current_mode()\n command_word_lower = command_word.lower()\n\n try:\n for command in command_list:\n # If this command is ... | [
"0.6808836",
"0.6215403",
"0.60658646",
"0.59883577",
"0.5964308",
"0.59415025",
"0.58491945",
"0.584738",
"0.57828355",
"0.57461345",
"0.5679819",
"0.5637294",
"0.56194764",
"0.56044847",
"0.5591293",
"0.5573114",
"0.55270916",
"0.5516119",
"0.5515833",
"0.55114114",
"0.5507... | 0.86891496 | 0 |
Opens a new database connection if there is none yet for the current application context. | def get_db():
top = _app_ctx_stack.top
if not hasattr(top, 'sqlite_db'):
top.sqlite_db = sqlite3.connect(app.config['DATABASE'])
top.sqlite_db.row_factory = sqlite3.Row
return top.sqlite_db | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_open():\n if not hasattr(g, 'sqlite_db'):\n g.sqlite_db = db_connect()\n return g.sqlite_db",
"def open_database(self):\n if self._conn is None:\n self._conn = sqlite3.connect(self._db_path)",
"def open_db(db_name: str = DB_NAME) -> DBConnection:\n return sqlite3.connec... | [
"0.7738929",
"0.7583458",
"0.7317899",
"0.7169646",
"0.70223415",
"0.69680053",
"0.6955745",
"0.6949704",
"0.68988895",
"0.6843065",
"0.6830136",
"0.68184245",
"0.68068093",
"0.6795719",
"0.6770086",
"0.67619467",
"0.67508566",
"0.6747435",
"0.6732536",
"0.67013234",
"0.66885... | 0.6672212 | 26 |
Closes the database again at the end of the request. | def close_database(exception):
top = _app_ctx_stack.top
if hasattr(top, 'sqlite_db'):
top.sqlite_db.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_request():\n db.close()",
"def close(self):\n\t\tself.db.close()",
"def close(self):\n self.db.close()",
"def close(self):\n if getattr(self, \"_db\", None):\n self._db.close()\n self._db = None",
"def close(self):\n self._flush()\n self.databa... | [
"0.82172483",
"0.8109686",
"0.7960271",
"0.7959435",
"0.79532206",
"0.79365206",
"0.79365206",
"0.79365206",
"0.78534675",
"0.7839457",
"0.78294516",
"0.77948606",
"0.7794269",
"0.76857483",
"0.766378",
"0.76578975",
"0.7632097",
"0.7593259",
"0.7591888",
"0.7591824",
"0.7581... | 0.0 | -1 |
Creates the database tables. | def init_db():
with app.app_context():
db = get_db()
with app.open_resource('schema.sql', mode='r') as f:
db.cursor().executescript(f.read())
db.commit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_db_tables():\n\n try:\n webapp.dbsql.create_all()\n webapp.dbsql.session.commit()\n except Exception as e:\n # TODO: melhorar o ... | [
"0.91241604",
"0.91241604",
"0.8920711",
"0.8715738",
"0.8659642",
"0.8593035",
"0.85459346",
"0.84720796",
"0.8466383",
"0.8454938",
"0.84451497",
"0.8281925",
"0.82708716",
"0.8220735",
"0.82034945",
"0.81462497",
"0.8125565",
"0.8086544",
"0.80096585",
"0.79545003",
"0.790... | 0.0 | -1 |
Queries the database and returns a list of dictionaries. | def query_db(query, args=(), one=False):
cur = get_db().execute(query, args)
rv = cur.fetchall()
return (rv[0] if rv else None) if one else rv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict_query(self) -> list:\n return [row.to_dict() for row in self.all()]",
"def get_query(query):\n global database\n res = database.conn.execute(query)\n out = res.fetchall()\n return [dict(zip(i.keys(), i)) for i in out]",
"async def db_query(self, *args, **kwargs):\n rows = []\n... | [
"0.740623",
"0.73176324",
"0.7065287",
"0.70045894",
"0.6963166",
"0.6914262",
"0.6902726",
"0.68810415",
"0.68354386",
"0.6817908",
"0.67895174",
"0.67873615",
"0.6780232",
"0.67508334",
"0.6716449",
"0.6702382",
"0.6694209",
"0.6687523",
"0.6651072",
"0.6647847",
"0.6639653... | 0.0 | -1 |
Convenience method to look up the id for a username. | def get_user_id(username):
rv = query_db('select user_id from user where username = ?',
[username], one=True)
return rv[0] if rv else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_id(self, username):\n\n users_list = self.get_list()\n for user_info in users_list:\n if user_info['username'] == username:\n return user_info['id']\n # return None\n raise UserNotFoundException(\"User {0} not found\".format(username))",
"def user_id_... | [
"0.83481854",
"0.79321814",
"0.7773568",
"0.7773353",
"0.7484976",
"0.7484976",
"0.7484976",
"0.7456012",
"0.7427511",
"0.7414133",
"0.7376001",
"0.73518324",
"0.73131895",
"0.7263178",
"0.71839017",
"0.7131035",
"0.7069776",
"0.70134205",
"0.70006573",
"0.692825",
"0.6890176... | 0.73150337 | 13 |
Format a timestamp for display. | def format_datetime(timestamp):
return datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d @ %H:%M') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _format_ts(cls, timestamp):\n return localtime(timestamp).strftime('%Y-%m-%d %H:%M:%S')",
"def formatTimestamp(self, timestamp):\n return time.strftime('%Y%m%d-%H%M%S-%Z', time.localtime(timestamp))",
"def render_timestamp(timestamp):\n return datetime.fromtimestamp(timestamp).strftime(\"%... | [
"0.83113927",
"0.8024185",
"0.78500414",
"0.7596884",
"0.7578498",
"0.7574983",
"0.7447329",
"0.743664",
"0.7395809",
"0.73817986",
"0.727902",
"0.71649474",
"0.7120334",
"0.70975757",
"0.70693433",
"0.7055185",
"0.698",
"0.698",
"0.6962262",
"0.6930938",
"0.69197065",
"0.6... | 0.7109238 | 15 |
Shows a users leaderboard for modeling contest. If not logged in then forward user to contest description. | def defaultlanding():
#send user to description page if not logged in
if not g.user:
return redirect(url_for('description'))
#display leaderboard for competition if logged in
return redirect(url_for('leaderboard')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def leaderboard():\n # Get leaderboard and user information\n leaderboard, current_user_info = gdb.getleaderboard(current_user.userID)\n # Get top gainer leaderboards\n weektopgainers, monthtopgainers = gdb.gettopgainers()\n # Render template\n return render_template('leaderboard.html',\n ... | [
"0.7132831",
"0.6990279",
"0.698829",
"0.6592735",
"0.6456158",
"0.63978505",
"0.63156646",
"0.62179524",
"0.61793965",
"0.61651367",
"0.6143687",
"0.6069071",
"0.6069068",
"0.6031999",
"0.60070384",
"0.5922585",
"0.5920286",
"0.5916132",
"0.5897987",
"0.5893534",
"0.5756729"... | 0.6577176 | 4 |
Displays a markdown doc describing the predictive modeling contest. Note ./content/contest/.md must be modified for contest. | def description():
#rule = request.url_rule
#print(rule)
file = open('./contest/content/description.md', 'r')
rawText = file.read()
file.close()
content = Markup(markdown(rawText,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.tables']))
return render_template('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markov_story():\n return render_template(\"markovstory.html\")",
"def evaluation():\n file = open('./contest/content/evaluation.md', 'r')\n rawText = file.read()\n file.close()\n content = Markup(markdown(rawText, \n extensions=['markdown.extensions.fenced_code', 'markdown.extensions.ta... | [
"0.6716274",
"0.61918634",
"0.61094517",
"0.6046048",
"0.5814884",
"0.57651407",
"0.5678175",
"0.56608206",
"0.56433624",
"0.5626179",
"0.56228733",
"0.5610109",
"0.5568798",
"0.5550789",
"0.5529062",
"0.55206585",
"0.54883075",
"0.546363",
"0.54536027",
"0.54217476",
"0.5419... | 0.6056569 | 3 |
Displays a markdown doc describing the predictive modeling contest. Note ./content/contest/.md must be modified for contest. | def evaluation():
file = open('./contest/content/evaluation.md', 'r')
rawText = file.read()
file.close()
content = Markup(markdown(rawText,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.tables']))
return render_template('markdowntemplate.html',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markov_story():\n return render_template(\"markovstory.html\")",
"def show_story():\n print(story)\n ans = request.args\n mad_story = story.generate(ans)\n return render_template(\"story.html\", story=mad_story)",
"def description():\n #rule = request.url_rule\n #print(rule)\n file ... | [
"0.6715872",
"0.6109959",
"0.605513",
"0.60453767",
"0.58141357",
"0.5764724",
"0.56801903",
"0.56615716",
"0.564484",
"0.5626134",
"0.56238323",
"0.560941",
"0.5568852",
"0.55506897",
"0.55294514",
"0.552025",
"0.54897755",
"0.54637724",
"0.54536664",
"0.54208964",
"0.541954... | 0.6191105 | 1 |
Displays a markdown doc describing the predictive modeling contest. Note ./content/contest/.md must be modified for contest. | def rules():
file = open('./contest/content/rules.md', 'r')
rawText = file.read()
file.close()
content = Markup(markdown(rawText,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.tables']))
return render_template('markdowntemplate.html',
title=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markov_story():\n return render_template(\"markovstory.html\")",
"def evaluation():\n file = open('./contest/content/evaluation.md', 'r')\n rawText = file.read()\n file.close()\n content = Markup(markdown(rawText, \n extensions=['markdown.extensions.fenced_code', 'markdown.extensions.ta... | [
"0.6716376",
"0.61918926",
"0.61108327",
"0.60579824",
"0.6045585",
"0.581355",
"0.57638925",
"0.5676026",
"0.56627285",
"0.5643063",
"0.56268203",
"0.562448",
"0.5607453",
"0.55694515",
"0.5551792",
"0.5530864",
"0.5521991",
"0.54890364",
"0.5463644",
"0.5454346",
"0.5422025... | 0.5060308 | 51 |
Displays a markdown doc describing the predictive modeling contest. Note ./content/contest/.md must be modified for contest. | def data():
file = open('./contest/content/data.md', 'r')
rawText = file.read()
file.close()
content = Markup(markdown(rawText,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.tables']))
return render_template('markdowntemplate.html',
title='D... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markov_story():\n return render_template(\"markovstory.html\")",
"def evaluation():\n file = open('./contest/content/evaluation.md', 'r')\n rawText = file.read()\n file.close()\n content = Markup(markdown(rawText, \n extensions=['markdown.extensions.fenced_code', 'markdown.extensions.ta... | [
"0.67163235",
"0.61921257",
"0.6109971",
"0.60564226",
"0.60465986",
"0.5814859",
"0.576513",
"0.5678197",
"0.56455314",
"0.5626489",
"0.56233984",
"0.56087315",
"0.5568962",
"0.5550528",
"0.55295354",
"0.55203474",
"0.5489993",
"0.54648334",
"0.54543287",
"0.5421151",
"0.541... | 0.5661878 | 8 |
Displays a markdown doc describing the predictive modeling contest. Note ./content/contest/.md must be modified for contest. | def prizes():
file = open('./contest/content/prizes.md', 'r')
rawText = file.read()
file.close()
content = Markup(markdown(rawText,
extensions=['markdown.extensions.fenced_code', 'markdown.extensions.tables']))
return render_template('markdowntemplate.html',
titl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def markov_story():\n return render_template(\"markovstory.html\")",
"def evaluation():\n file = open('./contest/content/evaluation.md', 'r')\n rawText = file.read()\n file.close()\n content = Markup(markdown(rawText, \n extensions=['markdown.extensions.fenced_code', 'markdown.extensions.ta... | [
"0.6716274",
"0.61918634",
"0.61094517",
"0.6056569",
"0.6046048",
"0.5814884",
"0.57651407",
"0.5678175",
"0.56608206",
"0.56433624",
"0.5626179",
"0.56228733",
"0.5610109",
"0.5568798",
"0.5550789",
"0.5529062",
"0.55206585",
"0.54883075",
"0.546363",
"0.54536027",
"0.54217... | 0.0 | -1 |
Allow user to select the upload they'd like to use for submission Default selection should be most recent submissions | def select_model():
try:
#check if contest has ended
if contestEndBool():
flash("Error: contest has ended")
raise Exception("contest has ended")
input = request.form
print(str(input))
for count, x in enumerate(input): print(count, x)
if len(inp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_file_upload_method():\n\n if not Settings.prompt(\"upload files\"): \n return \"unset\"\n Settings.print(\"Select an upload source\")\n sources = Settings.get_source_options()\n question = {\n 'type': 'list',\n 'name': 'upload',\n '... | [
"0.5997314",
"0.5983872",
"0.589526",
"0.576531",
"0.5642785",
"0.5381244",
"0.5381244",
"0.5363477",
"0.5341594",
"0.5295605",
"0.5283472",
"0.5279332",
"0.5256086",
"0.5177524",
"0.5163761",
"0.5152573",
"0.5134435",
"0.51217484",
"0.5096993",
"0.50757486",
"0.5058516",
"... | 0.6039245 | 0 |
Allow users to upload submissions to modeling contest Users must be logged in. | def upload_file():
#query the db and render the table used to display the leaderboard to users
userBoard = query_db('''
select submission_id, submit_date, public_score
from submission sub
where user_id = '%s'
order by public_score %s''' % (session['user_id'], orderBy))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_allowed_to_submit(request):\n return not settings.REQUIRE_LOGIN or request.user.is_authenticated()",
"def test_access_cartography_upload_form(self):\n\t\tc = Client()\n\t\tUser.objects.create_superuser('bobby', 'bobby@foo.com', 'bob')\n\t\tlog = c.login(username='bobby', password='bob')\n\t\tself.asser... | [
"0.6346095",
"0.6128161",
"0.60236895",
"0.5991602",
"0.59610605",
"0.58730686",
"0.57726794",
"0.57536113",
"0.573331",
"0.5728953",
"0.5707575",
"0.56958395",
"0.5684615",
"0.5650055",
"0.56336886",
"0.562404",
"0.5591402",
"0.55805683",
"0.5559244",
"0.5558897",
"0.5550839... | 0.5735105 | 8 |
Displays the latest messages of all users. | def public_timeline():
return render_template('timeline.html', messages=query_db('''
select message.*, user.* from message, user
where message.author_id = user.user_id
order by message.pub_date desc limit ?''', [PER_PAGE])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list(request):\r\n usermessages = request.user.profile.recent_messages()\r\n d = {\r\n 'form': NewMessageForm(),\r\n 'usermessages': usermessages,\r\n 'title': 'Messages',\r\n }\r\n return render_to_response('usermessages/list.html', d, \r\n context_instance=RequestConte... | [
"0.7695993",
"0.7487634",
"0.6752437",
"0.67180043",
"0.6717233",
"0.6611216",
"0.6601907",
"0.6523693",
"0.6414698",
"0.6396658",
"0.6388416",
"0.63542783",
"0.63322663",
"0.6324767",
"0.6306849",
"0.63036233",
"0.6260323",
"0.62598145",
"0.6252585",
"0.6237499",
"0.621526",... | 0.68704623 | 3 |
Logs the user in. | def login():
if g.user:
return redirect(url_for('leaderboard'))
error = None
if request.method == 'POST':
user = query_db('''select * from user where
username = ?''', [request.form['username']], one=True)
if user is None:
error = 'Invalid username'
eli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_in(self):\n\t\tpass",
"def log_in(self):\n print('-=' * 12 + \" Log in \" + '-=' * 12)\n mob_num, password = self._input_mob_num('Mobile Number :'), input(\"Password: \")\n self._user = self.auth.log_in(mob_num, password)\n if self._user:\n print(\"you are logged in... | [
"0.79675275",
"0.7852267",
"0.7533633",
"0.7426753",
"0.74120265",
"0.73694736",
"0.73554826",
"0.7352218",
"0.73194534",
"0.73194534",
"0.72863114",
"0.72628456",
"0.71599513",
"0.7111777",
"0.70810497",
"0.70796275",
"0.7071781",
"0.70487857",
"0.70274097",
"0.7014469",
"0.... | 0.0 | -1 |
Logs the user out. | def logout():
flash('You were logged out')
session.pop('user_id', None)
return redirect(url_for('leaderboard')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_out_user(self):\n flask_login.logout_user()",
"def sign_out(self):\n self.auth.log_out(self._user)\n self._user = None\n print(\"Signed out successfully\")\n return self.logging_page()",
"def logOut(self):\n self.client.logout()",
"def logout_user():\n pas... | [
"0.85989505",
"0.8412849",
"0.8397216",
"0.8393396",
"0.82630706",
"0.8261279",
"0.82022554",
"0.81415004",
"0.81156605",
"0.80973995",
"0.80543846",
"0.8053196",
"0.804197",
"0.79746354",
"0.79651797",
"0.7959803",
"0.789355",
"0.78747684",
"0.78555274",
"0.78462565",
"0.783... | 0.7539114 | 55 |
Find the minimum number of edits required to convert str_1 to str_2 | def edit_distance(str_1, str_2):
return edit_distance_dp(str_1, len(str_1), str_2, len(str_2)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def editing_distance(str1: str, str2: str) -> int:\r\n if not str1 and not str2:\r\n return 0\r\n if not str1:\r\n return len(str2)\r\n if not str2:\r\n return len(str1)\r\n if str1[0] == str2[0]:\r\n return min(editing_distance(str1[1::], str2[1::]), 1 + editing_distance(st... | [
"0.78606004",
"0.7667521",
"0.7666502",
"0.7485708",
"0.7342039",
"0.7078117",
"0.7051589",
"0.7030334",
"0.7002312",
"0.6992367",
"0.68882006",
"0.68589854",
"0.68285865",
"0.6781553",
"0.67763644",
"0.6762268",
"0.6755266",
"0.66761094",
"0.66730696",
"0.665412",
"0.663446"... | 0.7184663 | 5 |
Find the minimum number of edits required to convert str_1 to str_2 | def edit_distance_dp(str_1, m, str_2, n):
# table for storing sub-problems
sub = [[0 for i in range(n + 1)] for j in range(m + 1)] # padded for empty cases
# fill table
for i in range(m + 1):
for j in range(n + 1):
if i == 0:
# str_1 is empty, or we have not selecte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def editing_distance(str1: str, str2: str) -> int:\r\n if not str1 and not str2:\r\n return 0\r\n if not str1:\r\n return len(str2)\r\n if not str2:\r\n return len(str1)\r\n if str1[0] == str2[0]:\r\n return min(editing_distance(str1[1::], str2[1::]), 1 + editing_distance(st... | [
"0.78606004",
"0.7667521",
"0.7666502",
"0.7485708",
"0.7342039",
"0.7184663",
"0.7078117",
"0.7051589",
"0.7030334",
"0.7002312",
"0.6992367",
"0.68882006",
"0.68589854",
"0.68285865",
"0.67763644",
"0.6762268",
"0.6755266",
"0.66761094",
"0.66730696",
"0.665412",
"0.663446"... | 0.6781553 | 14 |
Collapses input of dim TNH to (TN)H, and applies to a module. Allows handling of variable sequence lengths and minibatch sizes. | def __init__(self, module):
super(SequenceWise, self).__init__()
self.module = module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def H_layer(nqubits):\n for idx in range(nqubits):\n qml.Hadamard(wires=idx)",
"def H_layer(self, nqubits):\n for idx in range(nqubits):\n qml.Hadamard(wires=idx)",
"def build_model(hype_space):\n print(\"Hyperspace:\")\n print(hype_space)\n\n input = Input(shape=(MAXLEN_SE... | [
"0.5513121",
"0.5469915",
"0.52214915",
"0.521163",
"0.5186334",
"0.5182777",
"0.51315635",
"0.49392486",
"0.4894024",
"0.48866612",
"0.48558587",
"0.4839549",
"0.48389077",
"0.4814754",
"0.48115247",
"0.47978458",
"0.47978264",
"0.47797433",
"0.47725466",
"0.47584283",
"0.47... | 0.0 | -1 |
Splice multiple frames. Helpful for implementing Time Delayed Neural Network (TDNN). | def __init__(self,
context,
full_context=False,
batch_first=True,
keep_dims=False):
super(Splice, self).__init__()
self.check_valid_context(context)
self.context = self.normalize_context(context, full_context)
self.batc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delace(self):\n if not self.isdelaced:\n newframes = []\n self.frame_dt /= 2\n for i, frame in enumerate(self.frames):\n newframes.append(\n Frame(\n frame.data[1::2, :],\n self.starttime\n ... | [
"0.6003755",
"0.5650122",
"0.55415636",
"0.5539786",
"0.55298394",
"0.5410173",
"0.52612764",
"0.5251893",
"0.52402836",
"0.5198621",
"0.517389",
"0.5163097",
"0.512419",
"0.51004255",
"0.5084766",
"0.50782037",
"0.5070901",
"0.50673556",
"0.50505686",
"0.5041725",
"0.5038684... | 0.49631998 | 25 |
Download Reistijden GeoJSON and save it to the database. | def download_and_update():
with tempfile.TemporaryDirectory(dir=TEMP_DOWNLOAD_DIR) as temp_dir:
reistijden_jsonfile = os.path.join(temp_dir, 'reistijdenAmsterdam.geojson')
r = requests.get(REISTIJDEN_TARGET_URL)
with open(reistijden_jsonfile, 'w') as f:
f.write(r.text)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_geojson():\n\n # check the file was already downloaded\n global GEOJSON\n if GEOJSON: return GEOJSON\n\n conn = None\n cur = None\n try:\n\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\n cur = conn.cursor()\n cur.execute( \"\"\"SELECT row_to_json(fc) FROM... | [
"0.65090847",
"0.6401234",
"0.629521",
"0.62839437",
"0.6232702",
"0.61436486",
"0.6100601",
"0.60972625",
"0.5967515",
"0.5946081",
"0.5935013",
"0.5935013",
"0.58112276",
"0.5717537",
"0.5706458",
"0.5656695",
"0.5588673",
"0.55623233",
"0.55592436",
"0.55287975",
"0.552224... | 0.751995 | 0 |
Parse source GeoJSON with travel times. | def _parse_and_store_geojson(filename):
ds = DataSource(filename)
_sanity_check_datasource(ds)
logger.info('Data file %s was opened', ds.name)
lm = LayerMapping(WegStuk, ds, MAPPING)
with transaction.atomic():
WegStuk.objects.all().delete()
lm.save(strict=True, verbose=False)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(res):\n res=res[0]\n steps = []\n if not isinstance(res, dict):\n return {}\n\n for step in res[\"legs\"][0][\"steps\"]:\n instruction = re.sub('<[^<]+?>', '', step[\"html_instructions\"])\n distance = step[\"distance\"][\"text\"]\n duration = step[\"duration\"][\"... | [
"0.5746532",
"0.54747635",
"0.5376057",
"0.53146565",
"0.52925307",
"0.5279979",
"0.52677",
"0.5224246",
"0.5183527",
"0.51704335",
"0.5142615",
"0.51053476",
"0.5066675",
"0.5046991",
"0.5043811",
"0.50331575",
"0.502856",
"0.5015569",
"0.50040835",
"0.49954006",
"0.49932897... | 0.5041001 | 15 |
Hardcoded sanity checks, assumes input GeoJSON does not change. | def _sanity_check_datasource(ds):
if len(ds) != 1:
raise SanityCheckError('GeoJSON should have only 1 layer.')
# TODO: add more checks | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_geojson(data):\n \"\"\"Enforces camelcasing of properties\"\"\"\n if 'id' in data:\n del data['id']\n try:\n data['type'] = data['type'] if 'type' in data else \"Feature\"\n data['geometry'] = data['geometry'] if 'geometry' in data else None\n if 'properties' not in ... | [
"0.7562509",
"0.7042181",
"0.66670763",
"0.6600149",
"0.64749795",
"0.64165884",
"0.6416432",
"0.6386212",
"0.6275836",
"0.61825293",
"0.61635286",
"0.6162776",
"0.609787",
"0.6077802",
"0.60744584",
"0.5965066",
"0.5861117",
"0.58045316",
"0.580073",
"0.57666594",
"0.5733157... | 0.69514114 | 2 |
At this point it is completely built and ready to be fired; it is "prepared". However pay attention at the formatting used in this function because it is programmed to be pretty printed and may differ from the actual request. | def pretty_print_POST(req):
print('{}\n{}\n{}\n\n{}'.format(
'-----------START-----------',
req.method + ' ' + req.url,
'\n'.join('{}: {}'.format(k, v) for k, v in req.headers.items()),
req.body,
)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare(self, request):\n pass",
"def prepare(self):\n\t\treturn self.api.prepare_request(self)",
"def _prepare(self):",
"def _prepare(self):",
"def prepare(self):",
"def prepare(self):\n pass",
"def prepare(self):\n pass",
"def prepare(self):\n pass",
"async def pre... | [
"0.66846484",
"0.6565005",
"0.6478224",
"0.6478224",
"0.6324114",
"0.60384876",
"0.60384876",
"0.60384876",
"0.6034071",
"0.5947664",
"0.5901407",
"0.5881416",
"0.58444005",
"0.5784762",
"0.5779519",
"0.57518095",
"0.5715669",
"0.5696821",
"0.5693568",
"0.5689683",
"0.5686989... | 0.0 | -1 |
Scrieti o functie care returneaza numarul de cuvinte din string. Cuvintele sunt separate de spatii, semne de punctuatie (, ;, ? ! . ). | def nrWords(text):
list = text.replace(',', ' ').replace('.', ' ').replace(';', ' ')
list = list.replace('!', ' ').replace('?', ' ').split()
return len(list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_punct(self,text):",
"def get_nummeric_only(text):\n\n nummeric_string =\"\"\n \n for character in text:\n if character.isnumeric():\n \n nummeric_string+=character\n \n return nummeric_string",
"def remove_punctuation(string):\n return NON_AL... | [
"0.62161505",
"0.61967057",
"0.6113026",
"0.60086334",
"0.59861207",
"0.5784456",
"0.57690686",
"0.57293624",
"0.5693772",
"0.56806844",
"0.56788987",
"0.56788987",
"0.56788987",
"0.5674587",
"0.56661344",
"0.5631285",
"0.5630559",
"0.5609727",
"0.56001705",
"0.5596847",
"0.5... | 0.0 | -1 |
Return the XPath from node a to node b, assumes b is a descendant of a. | def xpath(a, b):
if a.isSameNode(b):
return ""
return xpath(a, b.parentNode) + "/" + b.localName | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_path8(self):\n xpb = XPathBuilder()\n xp_1 = xpb.foo.baz\n xp_2 = xpb.bar.abc.join(xp_1)\n exp = '/bar/abc/foo/baz'\n self.assertEqual(xp_1, xp_2)\n self.assertEqual(xp_2.tostring(), exp)",
"def get_xpath(tag_name: str, parent, suffix = ''):\n xpath =... | [
"0.5497289",
"0.5488446",
"0.5398042",
"0.53868425",
"0.5333837",
"0.5326444",
"0.53179765",
"0.5249903",
"0.5121286",
"0.5086263",
"0.5082444",
"0.5056868",
"0.50500554",
"0.5035871",
"0.5035871",
"0.49958196",
"0.49624732",
"0.49436888",
"0.49340647",
"0.49328429",
"0.49323... | 0.8103554 | 0 |
Add a label to node's list of children, the XML contained in that label comes from xml_str. We want to make referencing variables easier, maybe using $varname. | def add_label(xml_str, node):
if xml_str:
s = u'<?xml version="1.0" ?><label>' + xml_str + u"</label>"
node.appendChild( parseString(s.encode("utf-8")).documentElement ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, label):\n self.label = label\n self.children = list()",
"def addLabels(t):\n if not t.label:\n t.label = \"\".join([choice(\"abcdefghijklmnopqrstuvwxyz\") for i in range(4)])\n for r,w in t.children:\n addLabels(r)",
"def __init__(self, label):\n self... | [
"0.64232975",
"0.6181848",
"0.60131395",
"0.5892141",
"0.5781065",
"0.57423294",
"0.5731213",
"0.5660578",
"0.56166065",
"0.5590489",
"0.5573439",
"0.5515644",
"0.5477117",
"0.54630226",
"0.5416833",
"0.5409699",
"0.5392758",
"0.53465724",
"0.5339193",
"0.5337083",
"0.5324728... | 0.71521944 | 0 |
Return a dictionary of multiple choice lists from the Excel Worksheet 'sheet'. The Worksheet named 'Select Choices' defines the choices for all multiple choice questions. This sheet must have three | def construct_choice_lists(sheet):
d = {}
for row in range(1,sheet.nrows):
c = {}
for col in range(0,sheet.ncols):
c[sheet.cell(0,col).value] = sheet.cell(row,col).value
list_name = c.pop("list name")
if list_name in d:
d[list_name].append(c)
else:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_menu_options():\n workbook_path = get_workbook_path()\n wb = openpyxl.load_workbook(workbook_path)\n sheet_names = wb.sheetnames\n return sheet_names",
"def get_sheet_data(self) -> List[SheetData]:\n result: List[SheetData] = []\n\n for c in range(self.columnCount() - 1):\n s = Sh... | [
"0.60501075",
"0.575098",
"0.5318569",
"0.53165835",
"0.5285447",
"0.52561027",
"0.52561027",
"0.52561027",
"0.52561027",
"0.52438134",
"0.51110536",
"0.50920993",
"0.50747657",
"0.5074488",
"0.5042221",
"0.5003982",
"0.49192867",
"0.49099895",
"0.4886586",
"0.48812103",
"0.4... | 0.7654838 | 0 |
Convert a properly formatted excel file into XForms for use with Open Data Kit. Return a list of all the XForms created. | def write_xforms(xls_file_path):
xforms = []
workbook = open_workbook(xls_file_path)
folder = os.path.dirname(xls_file_path)
choice_sheet = "Select Choices"
choices = construct_choice_lists( workbook.sheet_by_name(choice_sheet) )
for sheet in workbook.sheets():
if sheet.name != choice... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_xlsx_sheet(f, n=0):\n xl_file = pd.ExcelFile(f)\n dfs = xl_file.parse(xl_file.sheet_names[n], na_values=['n.a.', 'n.d.'])\n return dfs",
"def read_xlsx(self, filename):\n xlsx = pd.ExcelFile(filename)\n for sheet in xlsx.sheet_names:\n table_index_header = cfg.get_list... | [
"0.5343978",
"0.52173615",
"0.5207813",
"0.5159541",
"0.5144205",
"0.5137643",
"0.51044893",
"0.50839716",
"0.506976",
"0.5050417",
"0.5023947",
"0.4986781",
"0.49759924",
"0.49596763",
"0.4947392",
"0.49413222",
"0.49334276",
"0.49067864",
"0.48902297",
"0.4873562",
"0.48344... | 0.6615536 | 0 |
Replace all instances of '${tag}' with the XPath corresponding to the tag. | def sub_tag(str):
bracketed_tag = r"(\${" + tag_start_char + tag_char + r"*})"
m = re.search(bracketed_tag, str)
if m:
tag = m.group(1)
tag = tag[2:len(tag)-1]
if tag not in tag_xpath:
rai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_tag(tag, value, file):\r\n with open(file, \"r\") as origin:\r\n with open(file+\".replaced\", \"w\") as dest:\r\n dest.write(origin.read().replace(tag, str(value)))\r\n return file+\".replaced\"",
"def replace_tag_value( msg, tag, value ) :\n _TAG_RE = re.compile('\\x01' +... | [
"0.5578515",
"0.5398839",
"0.53104943",
"0.5310126",
"0.5291188",
"0.5275091",
"0.52065635",
"0.51992667",
"0.5098113",
"0.5070617",
"0.5046198",
"0.5034003",
"0.4993068",
"0.49627715",
"0.4956388",
"0.49514914",
"0.4910291",
"0.48976448",
"0.4868524",
"0.4832289",
"0.4815513... | 0.581539 | 0 |
execute multiplication and division immediately. | def _exec_md(self, stack, operand):
if stack and stack[-1] in {'*', '/'}:
operator, v = stack.pop(), stack.pop()
if operator == "*":
stack.append(v * operand)
else:
stack.append(v // operand)
else:
stack.append(operand)
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mul(a, b):\n c = Calculator()\n result = c.mul(a, b)\n click.echo('{} * {} = {}'.format(a, b, result))",
"def multiplication():\r\n error_handler()\r\n f1.delete(0, END)\r\n m1 = float(operand.get())\r\n m2 = float(operator.get())\r\n result = m1 * m2\r\n f1.insert(10, str(result))... | [
"0.64342624",
"0.61805516",
"0.60382664",
"0.60203797",
"0.59576017",
"0.5952465",
"0.5950916",
"0.59389263",
"0.5899231",
"0.58606964",
"0.5821872",
"0.581016",
"0.57954544",
"0.5795213",
"0.5795213",
"0.5795213",
"0.5795213",
"0.5795213",
"0.5763967",
"0.5756619",
"0.575159... | 0.55101085 | 55 |
execute plus and minus at the end of all parsed. | def _exec_pm(self, stack):
rslt = stack.popleft()
while stack:
operator, operand = stack.popleft(), stack.popleft()
if operator == "+":
rslt += operand
else:
# operator == "-"
rslt -= operand
return rslt | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_substract_and_sum(numbers, operators):\n while len(numbers) > 1:\n if operators[0] == \"+\": \n result = calc.sum(numbers[0], numbers[1])\n elif operators[0] == \"-\":\n result = calc.substract(numbers[0], numbers[1])\n operators, numbers = change_list_elemen... | [
"0.5932352",
"0.57771915",
"0.5509978",
"0.5507815",
"0.545019",
"0.53565687",
"0.53443295",
"0.52802455",
"0.527417",
"0.525476",
"0.5217023",
"0.5186919",
"0.5115234",
"0.5087408",
"0.5062166",
"0.5044847",
"0.50009185",
"0.49736407",
"0.49415055",
"0.49372658",
"0.49316794... | 0.5188196 | 11 |
Return a list of level seeds for a given gamekey | def ajax_levelseeds(request, gamekey):
seed_lst = tools.getLevelSeedsFromGameKey(gamekey)
data_response = {
"data": seed_lst,
"status": "OK"
}
return HttpResponse(json.dumps(data_response), content_type="application/json") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_game_levels(self):\n\n self._katakana_database.create_katakana_database_connection()\n\n raw_game_levels = self._katakana_database.katakana_db.execute(\n \"\"\"SELECT game_level FROM Games\"\"\").fetchall()\n\n all_game_levels = []\n for i in raw_game_levels:\n ... | [
"0.5885322",
"0.5726993",
"0.5407367",
"0.5301738",
"0.5284191",
"0.5212815",
"0.50632656",
"0.50508773",
"0.505008",
"0.5045081",
"0.4962722",
"0.49233738",
"0.488766",
"0.4876195",
"0.486169",
"0.48457703",
"0.4844681",
"0.482408",
"0.4821691",
"0.47913313",
"0.4763049",
... | 0.5952363 | 0 |
register a user on the fly because i hate users in django | def ajax_register(request, username, password):
user = User.objects.create_user(username, "", password)
if not user:
status = "ERROR"
message = "Invalid username or password"
else:
user.save()
status = "OK"
message = str.format("Created user '{0}', you may login now", username)
response = {
"status": ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_user():\n pass",
"def user_register():\n \n data = user_obj.user_register(request.forms) \n return data",
"def register_user(self):\n User.add_user(User(self.email.data, self.password.data))",
"def signup(self, request, user):\n pass",
"def register(user_... | [
"0.8530308",
"0.78690624",
"0.7817005",
"0.75655466",
"0.74967426",
"0.7426039",
"0.7367931",
"0.7360617",
"0.73598593",
"0.7309681",
"0.72699374",
"0.7269463",
"0.7240562",
"0.7205366",
"0.7192249",
"0.71875334",
"0.71837413",
"0.7179749",
"0.71564066",
"0.7136671",
"0.71356... | 0.0 | -1 |
log a death in the database | def ajax_died(request, game_id, user_id, depth, reason):
myGame = tools.getGameFromGameId(int(game_id))
myUser = tools.getUserFromUserId(int(user_id))
tools.logDeath(myGame, myUser, int(depth), str(reason))
response = {
"status": "OK",
"message": "logged death"
}
return HttpResponse(json.dumps(response), c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_death(self, state):",
"def die(self):\n events.trigger_event(\"on_entity_death\", self)",
"def record_death(self, name):\n self.log.info('{0} has died'.format(name))\n self.health_panels[name].set_dead()\n self.conversation.removeKnowledge('{0}-alive'.format(name))\n s... | [
"0.72399086",
"0.701081",
"0.67726815",
"0.6647561",
"0.662502",
"0.65819335",
"0.64344263",
"0.62199175",
"0.6132314",
"0.60777444",
"0.59452045",
"0.59283155",
"0.5908845",
"0.5903316",
"0.5892717",
"0.5827417",
"0.5791009",
"0.5779763",
"0.5734716",
"0.56824976",
"0.568101... | 0.0 | -1 |
log a win in the database | def ajax_victory(request, game_id):
myGame = tools.getGameFromGameId(int(game_id))
tools.logVictory(myGame)
response = {
"status": "OK",
"message": "logged victory"
}
return HttpResponse(json.dumps(response), content_type="application/json") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log(self, game: str, outcome: str):\n current_time = datetime.now()\n self.user.record.append([current_time.strftime(\"%c\"), game, outcome, self.user.balance])",
"def event_player_wins(self) -> None:\n win_amount = self.user.bet\n print(\"Congratulations, you win:\", win_amount)\... | [
"0.67273533",
"0.6163771",
"0.6120701",
"0.6114181",
"0.6078899",
"0.6041982",
"0.6039192",
"0.6013895",
"0.5989878",
"0.5979451",
"0.5954383",
"0.5947308",
"0.59428173",
"0.5881893",
"0.5870078",
"0.58621216",
"0.5859779",
"0.5834164",
"0.57967937",
"0.5786986",
"0.5754396",... | 0.0 | -1 |
log level progress for stat keeping | def ajax_progress(request, game_id, user_id, depth):
myGame = tools.getGameFromGameId(int(game_id))
myUser = tools.getUserFromUserId(int(user_id))
tools.logProgress(myGame, myUser, int(depth))
response = {
"status": "OK",
"message": "logged progress"
}
return HttpResponse(json.dumps(response), content_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _log_progress(self):\n self.num_of_requests_in_pipeline += 1\n if self.num_of_requests_in_pipeline % 20 == 0:\n print('-' * 200)\n print(f'DB PIPELINE: {self.num_of_requests_in_pipeline} items wenth though pipeline.')\n print('-' * 200)",
"def transfer_progress(... | [
"0.714131",
"0.71269464",
"0.70470834",
"0.69629145",
"0.6934919",
"0.6782616",
"0.67440385",
"0.6740498",
"0.6710249",
"0.6569314",
"0.65626985",
"0.6546168",
"0.6487",
"0.64472675",
"0.64472675",
"0.6433927",
"0.6432851",
"0.64311254",
"0.64308006",
"0.64246374",
"0.6358968... | 0.0 | -1 |
Main function This is the flow of actions of this main | def main(argv):
# 0: Initial steps
print_configuration_info()
# fix random seed for reproducibility
np.random.seed(7)
# Make an instance of the class Utils
utils = Utils()
# Obtain the file number
maxnumber = utils.find_file_maxnumber(RESULTS + DATASET + '/')
filenumber = ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(self):\r\n pass",
"def main(self):",
"def main(self) -> None:\n pass",
"def main():\n pass",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",... | [
"0.8427905",
"0.8220689",
"0.8114415",
"0.80345976",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
"0.80257344",
... | 0.0 | -1 |
Dummy function to print configuration parameters expressed as global variables in the script | def print_configuration_info():
print("Selected dataset:", DATASET)
print("Dataset base directory:", BASE_INPUT_DIR)
print("Daytime option:", DAYTIME)
print("Nones option:", NONES)
print("Selected action/activity representation:", OP)
print("Number of epochs: ", EPOCHS)
prin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printConf(self):\n print \"\"\n for pname, pvalue in self.neededParams.items():\n print pname, pvalue\n for pname, pvalue in self.optionalParams.items():\n print pname, pvalue",
"def printSettings():\n print \">>>\\n>>> SettingsTool: global variables:\"\n for ... | [
"0.7461699",
"0.7036818",
"0.70333016",
"0.6937575",
"0.6927378",
"0.6777318",
"0.6775346",
"0.6666382",
"0.6586468",
"0.6535474",
"0.64919525",
"0.6467023",
"0.6425723",
"0.64183",
"0.64038175",
"0.6391235",
"0.63494974",
"0.6276289",
"0.62646157",
"0.62633955",
"0.6179124",... | 0.6767941 | 7 |
Solve the discrete algebraic ricatti equation to compute the optimal feedback. | def sda_estimate(A, B, Q, R):
X = sda(A, B, Q, R)
K = np.linalg.inv(R + B.T @ X @ B) @ B.T @ X @ A
return -K | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = ... | [
"0.61143297",
"0.6101354",
"0.6066659",
"0.6060728",
"0.603991",
"0.6005973",
"0.59834266",
"0.5945585",
"0.5919671",
"0.5912027",
"0.5907284",
"0.586913",
"0.58657324",
"0.58402",
"0.5801388",
"0.57696843",
"0.5769187",
"0.5742733",
"0.5734056",
"0.5726234",
"0.56925076",
... | 0.0 | -1 |
Solve A^T P A P + Q = 0 | def solve_discrete_lyapunov(A, Q, method=None):
# newer versions of scipy solve A P A^T - P + Q = 0,
# while older ones solve A^T P A - P + Q = 0. I do not
# remember exactly which version of scipy made the change.
# I am going to assume you have the newer version installed.
# If the assertion bel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(P, Q):\n L = cho_factor(P)\n return cho_solve(L, Q)",
"def sol_p(t, p0, s0, u0, alpha, beta, gamma, eta, delta):\n u = sol_u(t, u0, alpha, beta)\n s = sol_s(t, s0, u0, alpha, beta, gamma)\n exp_gt = np.exp(-delta * t)\n p = p0 * exp_gt + eta / (delta - gamma) * (\n s - s0 * exp... | [
"0.7112369",
"0.6747462",
"0.67439276",
"0.6622388",
"0.6503022",
"0.63728845",
"0.6270085",
"0.6223849",
"0.6211934",
"0.6202324",
"0.61933964",
"0.61361104",
"0.61264217",
"0.60995156",
"0.6012261",
"0.6007698",
"0.5980388",
"0.5958294",
"0.5952482",
"0.5946611",
"0.5936482... | 0.621849 | 8 |
Compute infinite time horizon average LQR cost. Returns 1e6 if A+BK is not stable | def LQR_cost(A, B, K, Q, R, sigma_w):
L = A + B.dot(K)
if spectral_radius(L) >= 1:
return 1e6
M = Q + K.T.dot(R).dot(K)
P = solve_discrete_lyapunov(L, M)
return (sigma_w ** 2) * np.trace(P) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lksprob(alam):\r\n fac = 2.0\r\n sum = 0.0\r\n termbf = 0.0\r\n a2 = -2.0*alam*alam\r\n for j in range(1,201):\r\n term = fac*math.exp(a2*j*j)\r\n sum = sum + term\r\n if math.fabs(term) <= (0.001*termbf) or math.fabs(term) < (1.0e-8*sum):\r\n return sum\r\n ... | [
"0.60029477",
"0.5933232",
"0.58607453",
"0.5827601",
"0.57766134",
"0.57220405",
"0.5690132",
"0.5665845",
"0.56634825",
"0.56570524",
"0.5628769",
"0.5604078",
"0.55918825",
"0.5588187",
"0.5571809",
"0.55503905",
"0.55435735",
"0.55359924",
"0.5530741",
"0.55281013",
"0.55... | 0.6573204 | 0 |
Solve for K recursively. Not used. | def estimate_K(self, horizon, A, B):
Q, R = self.Q, self.R
# Calculate P matrices first for each step
P_matrices = np.zeros((horizon + 1, Q.shape[0], Q.shape[1]))
P_matrices[horizon] = Q
for i in range(horizon - 1, 0, -1):
P_t = P_matrices[i + 1]
P_matrices[i] = Q + (A.T @ P_t @ A) -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterate(rk):\n y = scipy.sparse.linalg.spsolve(P1, rk)\n RHS = scipy.sparse.csr_matrix.dot(P4, y) + rk\n zk = scipy.sparse.linalg.spsolve(P3, RHS)\n return zk",
"def fn(n, k):\n if n == k: return 1\n if k == 0: return 0\n return ((n-1)*fn(n-1, k) +... | [
"0.65435326",
"0.6303995",
"0.62335324",
"0.6223404",
"0.61771244",
"0.61697197",
"0.6146142",
"0.6124515",
"0.61158085",
"0.6081433",
"0.60603875",
"0.60549337",
"0.6022816",
"0.6015567",
"0.60017824",
"0.5987519",
"0.59837985",
"0.59735906",
"0.5944474",
"0.59432894",
"0.59... | 0.0 | -1 |
Solve the discrete time lqr controller. x[k+1] = A x[k] + B u[k] cost = sum x[k].TQx[k] + u[k].TRu[k] | def dlqr(A,B,Q=None,R=None):
#ref Bertsekas, p.151
if Q is None:
Q = np.eye(A.shape[0])
if R is None:
R = np.eye(B.shape[1])
P = scipy.linalg.solve_discrete_are(A, B, Q, R)
K = -scipy.linalg.solve(B.T.dot(P).dot(B) + R, B.T.dot(P).dot(A), sym_pos=True)
A_c = A + B.dot(K)
TO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LQRStep(n_state,\n n_ctrl,\n T,\n u_lower=None,\n u_upper=None,\n u_zero_I=None,\n delta_u=None,\n linesearch_decay=0.2,\n max_linesearch_iter=10,\n true_cost=None,\n true_dynamics=None,\n d... | [
"0.6856822",
"0.67716205",
"0.6512035",
"0.63664174",
"0.6199675",
"0.6168004",
"0.6133567",
"0.6129773",
"0.6099672",
"0.6093726",
"0.6058491",
"0.5990289",
"0.59402376",
"0.58544946",
"0.58435804",
"0.58374304",
"0.58292556",
"0.58270043",
"0.58121234",
"0.58121234",
"0.581... | 0.0 | -1 |
Check that the observability matrix is full rank. We check this by using the standard condition that [C CA CA^2 . . . CA^{n1}] is full rank | def check_observability(A, C):
assert len(A.shape) == 2
dim = A.shape[0]
stack = []
for i in range(dim):
term = C @ np.linalg.matrix_power(A, i)
stack.append(term)
obs_grammian = np.vstack(stack)
return np.linalg.matrix_rank(obs_grammian) == dim | {
"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 fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()",
"def is_full_row_rank(G):\n assert len(G.shape) == 2, \"should be a 2d numpy arrayp\"\n rows ... | [
"0.58528364",
"0.575484",
"0.570392",
"0.5627623",
"0.5623395",
"0.5601164",
"0.5532206",
"0.5532206",
"0.5532206",
"0.5532206",
"0.5505377",
"0.5505377",
"0.5463339",
"0.54319173",
"0.542496",
"0.5393358",
"0.53866196",
"0.5373487",
"0.5358698",
"0.535044",
"0.53352785",
"... | 0.62513566 | 0 |
Check that the controllability matrix [B, BA, ..., BA^{n1}] is full rank | def check_controllability(A, B):
assert len(A.shape) == 2
dim = A.shape[0]
stack = []
for i in range(dim):
term = B @ np.linalg.matrix_power(A, i)
stack.append(term)
grammian = np.hstack(stack)
return np.linalg.matrix_rank(grammian) == dim | {
"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 fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()",
"def check_grid_full(self):\n for row in self.game_state:\n for e in row:\n ... | [
"0.64367396",
"0.6185774",
"0.61180735",
"0.6107293",
"0.61059",
"0.6050762",
"0.6046627",
"0.6046486",
"0.59971195",
"0.5967931",
"0.59551543",
"0.5925763",
"0.59230703",
"0.59230703",
"0.59198326",
"0.5916389",
"0.58971936",
"0.5856238",
"0.5807457",
"0.58016616",
"0.579588... | 0.67005306 | 0 |
Returns a random dim x dim matrix with top eigenvalue bounded by bound dim | def sample_matrix(dim, bound):
return np.random.uniform(low=-bound, high=bound, size=(dim, dim)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_biggest_eigenvalue(cls, covariance_matrix):\n timer = TimerHandler()\n timer.start(\"eigen2\")\n eigvals = scipy.linalg.eigh(covariance_matrix, \n eigvals_only = True, \n eigvals = (covariance_matrix.shape[0] -1,... | [
"0.5875326",
"0.5783161",
"0.5597876",
"0.5518314",
"0.54774606",
"0.53589374",
"0.53341335",
"0.52804285",
"0.52785826",
"0.52338797",
"0.52313197",
"0.52312946",
"0.52151245",
"0.5212694",
"0.5212556",
"0.5212227",
"0.5209878",
"0.52093714",
"0.52040935",
"0.5180018",
"0.51... | 0.59177387 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.