def test_stop_start_restart_status(self): session = WolframLanguageSession(self.KERNEL_PATH) self.assertFalse(session.started) self.assertTrue(session.stopped) session.start() self.assertTrue(session.started) self.assertFalse(session.stopped) session.stop() self.assertFalse(session.started) self.assertTrue(session.stopped) session.restart() self.assertTrue(session.started) self.assertFalse(session.stopped) session.terminate() self.assertFalse(session.started) self.assertTrue(session.stopped) session = WolframLanguageSession(self.KERNEL_PATH) session.stop() self.assertFalse(session.started) self.assertTrue(session.stopped) session.terminate() self.assertFalse(session.started) self.assertTrue(session.stopped)
def test_stop_start_restart_status(self): session = WolframLanguageSession(kernel_path) self.assertFalse(session.started) self.assertTrue(session.stopped) session.start() self.assertTrue(session.started) self.assertFalse(session.stopped) session.stop() self.assertFalse(session.started) self.assertTrue(session.stopped) session.restart() self.assertTrue(session.started) self.assertFalse(session.stopped) session.terminate() self.assertFalse(session.started) self.assertTrue(session.stopped) session = WolframLanguageSession(kernel_path) session.stop() self.assertFalse(session.started) self.assertTrue(session.stopped) session.terminate() self.assertFalse(session.started) self.assertTrue(session.stopped)
def _compute_eps(lam): session = WolframLanguageSession(wlpath) session.evaluate( wlexpr(''' randomgamma[alpha_, beta_, gamma_, samples_] := RandomVariate[GammaDistribution[alpha, beta, gamma, 0], samples]; ''')) random_gamma = session.function(wlexpr('randomgamma')) session.evaluate( wlexpr(''' integrant[exponents_, beta_, dimension_, clippingbound_, lam_, r_, q_] := Mean[NIntegrate[ (Sin[x]^(dimension-2)*Gamma[dimension/2]/(Sqrt[Pi]*Gamma[(dimension-1)/2]))*(((1-q)*(1-q+ q*Exp[(r^exponents-(r^2+clippingbound^2-2*r*clippingbound*Cos[x])^(exponents/2))/beta])^(lam)) +(q*(1-q+q*Exp[((r^2+clippingbound^2+2*r*clippingbound*Cos[x])^(exponents/2)-r^exponents)/beta])^(lam))),{x,0,Pi} ]]; ''')) integrant_moment = session.function(wlexpr('integrant')) samples = random_gamma(FLAGS.dimension / FLAGS.exponents, beta**(1 / FLAGS.exponents), FLAGS.exponents, FLAGS.num_samples) moment = integrant_moment(FLAGS.exponents, beta, FLAGS.dimension, FLAGS.clippingbound, lam, samples, FLAGS.q) eps = (FLAGS.T * mp.log(moment) + mp.log(1 / FLAGS.delta)) / lam session.terminate() return eps
def test_auto_start_session(self): try: session = WolframLanguageSession(kernel_path) res = session.evaluate("1+1") self.assertEqual(res, 2) except Exception as e: logger.exception(e) finally: session.terminate() self.assertTrue(session.stopped)
def test_auto_start_session(self): try: session = WolframLanguageSession(self.KERNEL_PATH) res = session.evaluate('1+1') self.assertEqual(res, 2) except Exception as e: logger.exception(e) finally: session.terminate() self.assertTrue(session.stopped)
def test_terminated_session_autorestart(self): session = None try: session = WolframLanguageSession(kernel_path) session.start() session.stop() res = session.evaluate("1+1") self.assertEqual(res, 2) finally: if session: session.terminate()
def test_terminated_session_autorestart(self): session = None try: session = WolframLanguageSession(self.KERNEL_PATH) session.start() session.stop() res = session.evaluate('1+1') self.assertEqual(res, 2) finally: if session: session.terminate()
class WOLFRAM: MADE = False def __init__(self): # err('dont use this for now') if self.MADE: raise Exception('just use one wl kernel') self.MADE = True # not working, need to debug atexit.register(self.terminate) self.session = None @log_invokation(timer=True) def _start_session(self, kwargs): self.session = WolframLanguageSession( kernel_loglevel=logging.DEBUG, # kernel_loglevel=logging.FATAL, **kwargs, ) def __enter__(self): pass def __exit__(self, exc_type, exc_val, exc_tb): self.terminate() def terminate(self): if self.session is not None: self.session.terminate() @log_invokation(first_only=True, with_args=True) def eval(self, s): if self.session is None: kwargs = {} if ismac() else dict( kernel='/home/matt/WOLFRAM/Executables/WolframKernel') self._start_session(kwargs) ev = self.session.evaluate_wrap_future(wl.UsingFrontEnd(s)) ev = ev.result() if ev.messages is not None: for m in ev.messages: err(m) return ev.result def __getattr__(self, name): return weval(name)
def solveFeasible(self,agentNum,u_N,UD): session=WolframLanguageSession() eps = 1/np.sqrt(agentNum)/agentNum/2.0 # N[FindInstance[x^2 - 3 y^2 == 1 && 10 < x < 100, {x, y}, Integers]] ans = [] result = [] while len(result) == 0: expr = "" # expr to evaluate for i in range(agentNum-1): expr = expr + "x" + str(i) + "> 0.05 &&" expr = expr + "x" + str(agentNum-1) + "> 0.05 &&" for i in range(agentNum): for j in range(i+1, agentNum): # abs(x_i - x_j) <= U_{i,j} expr = expr + "Abs[x" + str(i) + "-x" + str(j) + "-(" + str(UD[i,j]) + ")]<=" + str(eps) + "&&" for i in range(agentNum-1): expr = expr + "x" + str(i) + "+" expr = expr + "x" + str(agentNum-1) + "==" + str(u_N) + "&&" for i in range(agentNum-1): expr = expr + "x" + str(i) + "+" expr = expr + "x" + str(agentNum-1) + "<=" + str(u_N) expr = expr + ", {" for i in range(agentNum-1): expr = expr + "x" + str(i) + "," expr = expr + "x" + str(agentNum-1) + "}, Reals" expr = "N[FindInstance[" + expr + "]]" # print(expr) result = session.evaluate(wlexpr(expr)) session.terminate() # print(result) if len(result) > 0: ans = [result[0][i][1] for i in range(agentNum)] eps = eps * 1.1 print(eps) # for i in range(agentNum): # if ans[i] < 0.0000001: # ans[i] = ans[i] + 0.0000001 print(ans) return ans
def compute_dp(lam): session = WolframLanguageSession(wlpath) session.evaluate( wlexpr(''' randomgamma[alpha_, beta_, gamma_, samples_] := RandomVariate[GammaDistribution[alpha, beta, gamma, 0], samples]; ''')) random_gamma = session.function(wlexpr('randomgamma')) session.evaluate( wlexpr(''' integrant[p_, beta_, d_, Delta_, lam_, r_] := Mean[NIntegrate[ Sin[x]^(d-2)*Gamma[d/2]/(Sqrt[Pi]*Gamma[(d-1)/2])*(0.99+0.01*Exp[(r^p-(r^2+Delta^2+2*r*Delta*Cos[x])^(p/2))/beta])^(-lam),{x,0,Pi} ]]; ''')) integrant_moment = session.function(wlexpr('integrant')) samples = random_gamma(d / p, beta**(1 / p), p, num_samples) # print(samples) moment = integrant_moment(p, beta, d, Delta, lam, samples) # print(moment) eps = (T * mp.log(moment) + mp.log(1 / delta)) / lam session.terminate() return eps
def wolfram_stability(model, M): r"""Use the wolfram Noptimize to numerically compute if the given model is stable somewhere in the Kähler cone Parameters ---------- model : np.array[5, M.len] sum of line bundles M : pyCICY.CICY CICY object Returns ------- bool True if stable else False """ session = WolframLanguageSession()#kernel_loglevel=logging.ERROR line_slope = [] for line in model: tmp = M.line_slope() for i in range(M.len): tmp = tmp.subs({'m'+str(i): line[i]}) line_slope += [tmp] str_slope = str(line_slope).replace('**', '^').replace('[','{').replace(']', '}') str_cone = str(['t'+str(i)+'> 1' for i in range(M.len)]).replace('\'', '').replace('[','{').replace(']', '}') str_vars = str(['t'+str(i) for i in range(M.len)]).replace('\'', '').replace('[','{').replace(']', '}') success = False full_string = 'NMinimize[Join[{{Plus @@ (#^2 & /@ {})}}, '.format(str_slope) full_string += '{}],'.format(str_cone) full_string += '{}, AccuracyGoal -> 20, PrecisionGoal -> 20, WorkingPrecision -> 20]'.format(str_vars) optimize = wlexpr(full_string) results = session.evaluate(optimize) if np.allclose([0.], [results[0].__float__()], atol=0.01): success = True session.terminate() return success
self.ui.verticalLayout.removeWidget(self.label1) self.label1.deleteLater() self.label1 = None self.newQuestion() if __name__ == '__main__': session = WolframLanguageSession() commands = [ '''Get["definitions.mx"];''', '''questionRepo=Quiet@Import["repo.mx"];''' ] for i in commands: session.evaluate(wlexpr(i)) app = QtWidgets.QApplication([]) application = mywindow() application.show() try: sys.exit(app.exec()) except SystemExit: session.terminate() print("Wolfram Link has been terminated.")
class engineClass: ''' ''' def __init__(self): ''' ''' self.mathScriptPath = os.path.expanduser( '~') + '/Documents/Hosotani_SO11/Mathematica/SO11_Masses_v7.m' self.session = WolframLanguageSession() self.timeOut = 120 return None def _getRequiredAttributes(self, paramsDict, threadNumber="0", runDict={}, pointKey=''): ''' ''' phaseSpacePoint = {} phaseSpacePoint[pointKey] = runDict phaseSpacePoint[pointKey].update(paramsDict) return phaseSpacePoint def _clean(self, threadNumber): ''' ''' return None def _check0Mass(self, phaseSpaceDict): ''' ''' pointID = list(phaseSpaceDict.keys())[0] validPoint = True if (bool(phaseSpaceDict[pointID]) is True): if phaseSpaceDict[pointID]['Triviality'] is 0: validPoint = True else: validPoint = False else: validPoint = False return validPoint def runPoint(self, paramsDict, threadNumber='0', debug=False): ''' ''' # Set up logging utility logFileName = 'SO11_Analysis-' + threadNumber + '.log' logging.basicConfig(level=logging.INFO, filename=logFileName) # Export the data rules to the Mathematica association filetype paramsDict_wl = export(paramsDict, pandas_dataframe_head='association') dataRuleExpr = wlexpr(bytes('dataRule=', 'utf-8') + paramsDict_wl) resOut = {} try: # Run the Mathematica Weinber Angle Code with open(self.mathScriptPath, 'r') as mathIn: strMath = mathIn.read() analysExpr = wlexpr(strMath) self.session.evaluate(dataRuleExpr) # print(paramsDict) timeConstrEval = wl.TimeConstrained(analysExpr, self.timeOut) resOut = self.session.evaluate(timeConstrEval) # resOut = self.session.evaluate(analysExpr) # resOut = wl.TimeConstrained(self.session.evaluate(analysExpr), 60) # print(resOut) except Exception as e: print(e) raise # print('-------') return {'Triviality': 1} # finally: # self.session.terminate() # print('Results for run: ', resOut) try: resStatus = resOut.name except Exception as e: resStatus = None if resStatus == '$Aborted' or bool(resOut) is False: return {'Triviality': 1} else: return resOut def _terminateSession(self): ''' Terminates the current Wolfram session ''' self.session.terminate() return None
class WolframSampler: def __init__(self): """A wrapper to generateExperiments.wls Written as a class so the Wolfram session is only once at __init__ time. """ self.session = WolframLanguageSession(kernel=wolfram_kernel_path) self.session.evaluate('<<./capture/generate/randomSampling.wls') self.session.evaluate('<<./capture/generate/enumerativeSampling.wls') self._randomlySample = self.session.function('generateExperiments') self._enumerativelySample = self.session.function( 'generateEnumerations') def randomlySample(self, reagentVectors, oldReagents=None, nExpt=96, maxMolarity=9., finalVolume=500.): """Randomly sample possible experiments in the convex hull of concentration space defined by the reagentVectors Runs Josh's Mathematica function called `generateExperiments` defined in `randomSampling.wls` Shadows default arguments set at Wolfram level. Currently does not expose processVaules argument. :param reagentVectors: a dictionary of vector representations of reagents living in species-concentration space :param nExpt: the number of samples to draw :param maxMolarity: the maximum concentration of any species: defines a hypercube bounding the convex hull :param finalVolume: a scalar to act on the concentrations to convert to desired volume :return: a dictionary mapping: {reagents => list(volumes)} where list(volumes) has length nExpt :raises TypeError: since Mathematica will fail silently on incorrect types """ ## Easy mathematica debugging (get an error, uncomment here for vectors) #print("new", reagentVectors, '\n') #print('to be removed', oldReagents, '\n') if not isinstance(reagentVectors, dict): raise TypeError('reagentVectors must be dict, got {}'.format( type(reagentVectors))) if not isinstance(nExpt, int): raise TypeError('nExpt must be int, got {}'.format(type(nExpt))) if not isinstance(maxMolarity, float): raise TypeError('maxMolarity must be float, got {}'.format( type(maxMolarity))) if not isinstance(finalVolume, float): raise TypeError('finalVolume must be float, got {}'.format( type(finalVolume))) if oldReagents: if not isinstance(oldReagents, dict): raise TypeError('oldReagents must be dict, got {}'.format( type(oldReagents))) if oldReagents: result = self._randomlySample(reagentVectors, oldReagents, nExpt, maxMolarity, finalVolume) # result = self._randomlySample(oldReagents, reagentVectors, nExpt, maxMolarity, finalVolume) if "Volume of remaining space is zero" in result: raise ValueError( 'New reagents define a convex hull that is covered by that of old reagents.' ) else: result = self._randomlySample(reagentVectors, nExpt, maxMolarity, finalVolume) return result def enumerativelySample(self, reagentVectors, uniqueChemNames, deltaV=10., maxMolarity=9., finalVolume=500.): """Enumeratively sample possible experiments in the convex hull of concentration space defined by the reagentVectors Runs Josh's Mathematica function called `achievableGrid` defined in `enumerativeSampling.wls` Shadows default arguments set at Wolfram level. :param reagentVectors: a dictionary of vector representations of reagents living in species-concentration space :param uniqueChemNames: list of chemicals making up the reagents :param maxMolarity: the maximum concentration of any species: defines a hypercube bounding the convex hull :param deltaV: the spacing of reagent volumes that define the spacing of the grid in concentration space :param finalVolume: a scalar to act on the concentration points to convert to desired volume :return: a dictionary mapping: {reagents => list(volumes)} :raises TypeError: since Mathematica will fail silently on incorrect types """ if not isinstance(reagentVectors, dict): raise TypeError('reagentVectors must be dict, got {}'.format( type(reagentVectors))) if not isinstance(uniqueChemNames, list): raise TypeError('uniqueChemNames must be a list, got {}'.format( type(uniqueChemNames))) if not isinstance(maxMolarity, float): raise TypeError('maxMolarity must be float, got {}'.format( type(maxMolarity))) if not isinstance(deltaV, float): raise TypeError('deltaV must be float, got {}'.format( type(deltaV))) if not isinstance(finalVolume, float): raise TypeError('finalVolume must be float, got {}'.format( type(finalVolume))) return self._enumerativelySample(reagentVectors, uniqueChemNames, deltaV, maxMolarity, finalVolume) def terminate(self): """Kill the session thread""" self.session.terminate()