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(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_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_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()
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 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 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
class SequenceTagger: def __init__(self, wl_kernel=None): """Initialize the SentenceTagger wl_kernel -- location of Wolfram kernel """ self.session = WolframLanguageSession() if wl_kernel == None else WolframLanguageSession(wl_kernel) def close(self): """Stop the Wolfram Kernel associated with this tagger""" self.session.stop() def predict(self, text: str, **kwargs) -> dict: """Get text entities in text text -- text to get entities from Keyword arguments: entity_types -- list of entity types to include """ forms = wl.System.Automatic if "entity_types" in kwargs: forms = wl.System.List(*kwargs["entity_types"]) expr = wl.System.TextContents(text, forms, wl.System.All) response = self.session.evaluate(expr) entities = [] for entity in response[0]: entities.append({ "text": entity["String"], "start_pos": entity["Position"][0] - 1, "end_pos": entity["Position"][1], "type": entity["Type"], "confidence": entity["Probability"], "interpretation": entity["Interpretation"] }) return { "text": text, "entities": entities }
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
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()
from wolframclient.evaluation import WolframLanguageSession from pickle_jar import savePickles, loadPickles, file_open from wolframclient.language import wl, wlexpr session = WolframLanguageSession() #Entity["Species", "Species:CorvusCorax"]["Dataset"] # animal_list = file_open('../constants/animals.txt') #for animal in animal_list: #print(session.evaluate(f'Interpreter["Species"][{animal}]["Image"]')) #print(session.evaluate(f'Interpreter["Species", "raven"]["MaximumLifeSpan"]')) print( session.evaluate( f'Interpreter["Species", "Species:CorvusCorax"]["MaximumLifeSpan"]'))
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 Engine: def __init__(self): config = get_config() wolfram_path = config.get("DEFAULT", "WOLFRAM_PATH") self.image_path = os.path.join(os.getcwd(), 'static', 'city') atexit.register(self.cleanup) if wolfram_path is None or len(wolfram_path) == 0: self.session = WolframLanguageSession() print("Wolfram Engine session opened on default path.") else: self.session = WolframLanguageSession(wolfram_path) print(f"Wolfram Engine session opened on '{wolfram_path}'.") self._define_wolfram_functions() def _define_wolfram_functions(self): self.get_weather = self.session.function(wlexpr('<|"Temperature" -> WeatherData[#, "Temperature"], "WindSpeed" ->WeatherData[#, "WindSpeed"],"Pressure"-> WeatherData[#,"Pressure"]|>&')) self.get_city = self.session.function(wlexpr('Module[{cities}, cities = TextCases[#, "City"];If[Length[cities] > 0, First[cities], ""]]&')) def test(self): self.check_session() return self.session.evaluate(wlexpr('NIntegrate[Sin[Sin[x]], {x, 0, 2}]')) def get_city_image(self, name): # search existing images if present lname = str.lower(name) for file in os.listdir(self.image_path): if file.endswith(".png"): if file == f"{lname}.png": print(f"Found image for '{name}' in cache.") return # get the image via websearch graphic = self.session.evaluate(wlexpr(f'WebImageSearch["{name}", "Images", MaxItems -> 1][[1]]')) path = os.path.join(self.image_path, f"{lname}.png") png_export = wl.Export(path, graphic, "PNG") return self.session.evaluate(png_export) def get_weather_info(self, text) -> dict: """ Returns a dictionary with some weather info for the first city found in the given (natural language) text. :param text: any text """ self.check_session() if text is None or len(text) == 0: return {} city = self.get_city(text) if city is None or len(city) == 0: return {} print(f"Found city: {city}") found = self.get_weather(city) if isinstance(found, dict) and found["Temperature"].args[0] != "NotAvailable": self.get_city_image(city) return { "Input": text, "City": city, "Temperature": found["Temperature"].args[0], "WindSpeed": found["WindSpeed"].args[0], "Pressure": found["Pressure"].args[0], "Info": self.session.evaluate(wlexpr(f'TextSentences[WikipediaData["{city}"]][[;; 5]]'))[0] } else: return {} def check_session(self): if self.session is None: raise Exception("The Engine is not present.") # noinspection PyBroadException def cleanup(self): """ Note that there is no way to catch the SIGKILL and stop the engine gracefully if this happens. :return: """ try: if self.session is not None: self.session.stop() print("Wolfram Engine stopped.") except Exception: pass
DATABASE_FILE = "travelogues.sqlite3" from wolframclient.evaluation import WolframLanguageSession from wolframclient.language import wl, wlexpr session = WolframLanguageSession(WOLFRAM_KERNEL_LOCATION) connection = sqlite3.connect(DATABASE_FILE) db = connection.cursor() db.execute("SELECT id, name, gender FROM travelers") travelers = db.fetchall() for traveler in travelers: if traveler[2] == None: #traveler[2] is gender name = traveler[1] traveler_id = traveler[0] # The following evaluates # Classify["NameGender", First[TextCases[name, "GivenName"]]] # in Wolfram Kernel gender = session.evaluate( wl.System.Classify( "NameGender", wl.System.First(wl.System.TextCases(name, "GivenName")))) if type(gender) is str and gender != "Indeterminate": db.execute( """UPDATE travelers SET gender = ? WHERE id = ?""", (gender, traveler_id)) connection.commit() session.stop()
from wolframclient.evaluation import WolframLanguageSession from wolframclient.language import wl from statistics import mean session = WolframLanguageSession() sample = session.evaluate(wl.RandomVariate(wl.NormalDistribution(0, 1), 1e6)) print(sample[:5]) session.evaluate(wl.Mean(sample)) mean(sample)
from wolframclient.evaluation import WolframLanguageSession from wolframclient.language import wl, wlexpr session = WolframLanguageSession() print(session.evaluate(wlexpr('Select[Range[5],PrimeQ]')))
from wolframclient.language import wl from wolframclient.evaluation import WolframLanguageSession session = WolframLanguageSession() session.evaluate(wl.StringReverse('abc')) # StringReverse["abc"] session.evaluate(wl.MinMax([1, 5, -3, 9]) # MinMax[{1, 5, -3, 9}]
from wolframclient.evaluation import WolframLanguageSession import logging # set the root level to INFO logging.basicConfig(level=logging.INFO) try: session = WolframLanguageSession() # this will trigger some log messages with the process ID, the sockets # address and the startup timer. session.start() # Warning: Infinite expression Power[0, -1] encountered. res = session.evaluate('1/0') finally: session.terminate()
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
""" 外环是逆时针,内环顺时针 """ from wolframclient.evaluation import WolframLanguageSession # MMA from wolframclient.language import wl, wlexpr, Global # MMA session = WolframLanguageSession() result = session.evaluate(wlexpr('Range[6]')) print(result)