https://community.wolfram.com RSS Feed for Wolfram Community showing questions tagged with Mathematics with no replies sorted by most viewed. https://community.wolfram.com/groups/-/m/t/2188842 There are a lot of smart people here, I'm sure someone has found a way to integrate the OEIS database so I don't have to leave Mathematica! If not I might be willing to implement that if there are others that would find it useful. FindSequenceFunction is very nice, but won't have all the radical stuff. Christopher Wolfe 2021-02-08T20:57:40Z https://community.wolfram.com/groups/-/m/t/240312 Dear All, I am using NonlinearModelFit to fit data with a function with 4 parameters. With Marquardt Levenberg Algorithm the errors are considered independent, but in reality errors are dependent each other. Is there a build in function which  I can use that when I type nonlimearmodelfit["ParameterErrors"] I can obtain an evaluation of the errors that takes into consideration that they are dependent each other? Many thanks, Best regards, Maria Maria Giovanna Dainotti 2014-04-21T13:05:46Z https://community.wolfram.com/groups/-/m/t/1448725 I've tried to implement Breadth First Search algorithm in MMA, to attempt to solve the 8-puzzle game. But in some cases, I ran out of memory, but on other cases it solves without problem. Here is the code I am using to make BFS, in the case of inicial = {{1, 6, 2}, {0, 4, 3}, {7, 5, 8}}; you get the desired answer, run the following code and see the result mutacion[tablero_List] := Module[{posc, directions, newposs, olddigits}, posc = Flatten[Position[tablero, 0]]; directions = Select[Tuples[Range[-1, 1], 2], Norm[#] == 1 &]; newposs = (posc + #) & /@ directions; newposs = Select[newposs, FreeQ[#, 4] \[And] FreeQ[#, 0] &]; olddigits = Extract[tablero, newposs]; MapThread[ ReplacePart[tablero, {#1 -> 0, posc -> #2}] &, {newposs, olddigits}]] q = {}; map = {}; inicial = {{1, 6, 2}, {0, 4, 3}, {7, 5, 8}}; final = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}}; AppendTo[q, {inicial, 0}] AppendTo[map, {inicial, 0}] While[q != {}, prim = First@MinimalBy[q, Last]; hijos = Flatten[Most[MapAt[mutacion, prim, 1]], 1]; If[Not@MemberQ[map, #, Infinity], AppendTo[q, {#, Last[prim] + 1}]] & /@ hijos; If[Not@MemberQ[map, #, Infinity], AppendTo[map, {#, Last[prim] + 1}]] & /@ hijos; q = DeleteCases[q, prim, Infinity]; If[MemberQ[hijos, final], Print["Found at the level : ", Last[prim] + 1]; Break[]]] but when inicial = {{2, 1, 5}, {6, 3, 4}, {8, 0, 7}};I have waited for more than 15 minutes without getting any response, maybe the problem is with the command MemberQ, since that command must make many comparisons in increasingly larger lists. I want to ask you please can you help me to correct my mistakes and thus be able to improve my code to obtain the solutions. Thanks in advance, your help is very necessary and important. Luis Ledesma 2018-09-10T19:12:54Z https://community.wolfram.com/groups/-/m/t/237108 Hi all, a quick question. I have a working Mathematica code that runs 8 kernels using ParallelDo. Now, to speed things up I have been trying, without success, to have each of these kernels compute the values of a function (it is the same function for all the kernels) for 1000 different values of the independent variables and return these values in an array called results. I have tried Needs["CUDALink`"] from inside and outside the ParallelDo instruction, and ParallelNeeds["CUDALink`"] from outside ParallelDo. In any case, it seems that Mathematica does not recognize any CUDA instruction. I was wondering if anyone has tried runing CUDA code from within ParallelDo. If you have or know of an example please let me know. Thanks. Gus Gustavo Carri 2014-04-14T20:52:57Z https://community.wolfram.com/groups/-/m/t/429851 I'm interested in finding graphs with certain properties, like [the smallest cubic bipartite asymmetric graph](http://math.stackexchange.com/q/1109733/19341). While working on a related graph-theoretic problem, concerning [edge-colrings](http://math.stackexchange.com/q/1121030/19341), I came along [Georges Graph](http://www.wolframalpha.com/input/?i=GeorgesGraph) at Wolfram|Alpha. It shows a nice collection of properties of the graph: asymmetric | bicolorable | biconnected | bicubic | bipartite | bridgeless | class 1 | connected | cubic | cyclic | local | noncayley | noneulerian | nonhamiltonian | nonplanar | perfect | perfect matching | regular | square-free | traceable | triangle-free | weakly regular So I'm interested if it's possible to search Wolfram|Alpha for graph with certain properties. How to build a query, that returns a list of graphs that are asymmetric, bicubic and $3$-edge colorable i.e. they have chromatic index $3$? Other ways to get that list are also welcome.. Cross-posted: http://mathematica.stackexchange.com/q/72628/1436 draks ... 2015-01-27T21:55:16Z https://community.wolfram.com/groups/-/m/t/471839 Hi, I would like to know if the upgrade for Mathematica 10.0.2 home edition to 10.1 home edition is seen as a whole new version and therefor should be a paid upgrade (aprox 90 dollar). regards, Lou l van Veen 2015-04-01T20:45:15Z https://community.wolfram.com/groups/-/m/t/412193 Dear Friends I have used Interpolation function in 3-D works. I only know that this interpolation gives the exact value of cologation points and attributes a approximate number to any points between them. How can I find the equation and mathematic assumptions that have been considered for thid multidimensional Interpolation Interpolation[{{x1,f1},{x2,f2},…}] construct an approximate function with values at points Soheil Bazazzadeh 2014-12-27T15:27:34Z https://community.wolfram.com/groups/-/m/t/1140640 <h1>Introduction</h1><br> My name is Taha Shaikh and I attended the 2017 Wolfram Alpha High School Summer Camp. At this camp, I researched and created a project about many-valued logic. In this exploration, I implemented multivalued logic with the Wolfram language. Multivalued logic is a branch of propositional calculus in which there are more than two truth values. Multivalued logic contrasts with traditional two-valued logic in which only two truth values exist: <i>True</i> and <i>False</i>. The most popular types of many-valued logic are three-valued Kleene and Priest logic, which incorporate an additional <i>Indeterminate</i> value. The truth function for conjunction, for example, is given by: ![Ternary Logic Conjunction Table][1] <hr> <h2>Procedure</h2> <br> The first step in this project was understanding the aim of the investigation and doing research on the topics at hand. Next, support for the new truth value <i>Undecided</i> was added to the basic boolean operations. I used Kleene and Priest logic tables to redefine the boolean operations. ![Different Logic Tables][2] Undecided = Undecided; Unprotect[And]; And[Undecided, True] := Undecided And[Undecided, Undecided] := Undecided Protect[And]; Unprotect[Boole]; Boole[Undecided] := 0 Boole[False] := -1 Protect[Boole]; Unprotect[Or]; Or[Undecided, False] := Undecided Or[Undecided, Undecided] := Undecided Protect[Or]; Unprotect[Not]; Not[Undecided] := Undecided Unprotect[Implies]; Implies[True, Undecided] := Undecided Implies[Undecided, Undecided] := True Implies[False, Undecided] := True Implies[Undecided, True] := True Implies[Undecided, False] := Undecided Protect[Implies]; Unprotect[Nand]; Nand[Undecided, Undecided] := Undecided Protect[Nand]; Unprotect[Nor]; Nor[Undecided, Undecided] := Undecided Protect[And]; <br> These functions ensured that the rest of the functions created worked smoothly. The next step was creating a function that would generate truth tables based on a given operation and the list of the variables used. The TernaryTable function used an input of a logic expression and the list of used variables and converts it into a truth table. Where Boolean logic has $2^2 = 4$ unary operators, the addition of a third value in ternary logic leads to a total of $3^3 = 27$ distinct operators on a single input value. It uses the Tuples function to run through all of the possible permutations of the three truth values and runs them through the given expression. <br> <br> TernaryTable[expr_, vars__] := ReplaceAll[expr, Thread[vars -> #]] & /@ Tuples[{True, False, Undecided}, {Length[vars]}] <br> An example of TernaryTable in action: ![enter image description here][3] This function uses the Tuples function to run through the various combinations and permutations of the three different truth values. The truth table generated has length $3^n$ in which $n$ is the number of variables used in the logic expression. In the case of this example, since four variables are present (x, y, z, w), the length of its truth table is $3^4$ or 81. This is because all possible permutations of the three truth values are considered when generating the truth table. Even though many of the outputs are the same, their individual logic expressions were unique. Creating a function that created truth tables was a good first step and helped me better visualize and understand the topic. <hr> <h2>Cooking Up Some Functions</h2><br> The main strategy for determining the identity of the truth table was brute-force-esque. All of the possible arrangements of the basic logic functions were ran through the tuples of the three logic values. Their logic expression was also calculated and correlated to their truth table. First, I made a function called LotsOfTernaryTables that produces a lot of ternary tables. Given the number of variables, it produces every possible truth table for every possible arrangement of the functions And, Or, Nand, Nor, and Not for the given variables. <br> LotsOfTernaryTables[x_] := MatrixForm[ Groupings[#, {And -> 2, Or -> 2, Nand -> 2, Nor -> 2, Not -> 1}, HoldForm] & /@ Tuples[{True, False, Undecided}, {x}]] <br> In this function, Groupings was used in coordination with Tuples to produce a huge number of different tables. <br><br> In order to visualize these massive tables, I created a function called TernaryPlot that generates a colorful plot of the different logic truth tables. It converts the outputs from LotsOfTernaryTables into numerical values and creates a colorful array plot. It uses similar mechanics to the previous function.<br> TernaryPlot[x_] := ArrayPlot[ Boole[Groupings[#, {And -> 2, Or -> 2, Nand -> 2, Nor -> 2, Not -> 1}]] & /@ Tuples[{True, False, Undecided}, {x}], ColorRules -> {1 -> Green, 0 -> LightBlue, -1 -> Red}] <br> The array plot created by this function has several visible patterns and sequences and makes very interesting art. A ternary plot with 3 variables, for example, looks like so:<br> ![enter image description here][4] <br><br> In this plot, every column represents an individual truth table. In this case, since there are three variables, each column contains $3^3=27$ values. When creating ternary plots with more variables, patterns become crazier and the resulting image has some pretty appealing qualities. The ternary plot for 6 variables looks like so:<br> ![enter image description here][5] <br> Finally, the last function I created was called TernaryFunction and was based off of the pre-existing BooleanFunction. When given a ternary truth table, this function would return the logic expression associated with it. After generating a list of truth tables and a list of logic expressions, the two lists were then correlated with each other. After retrieving the correct truth table, its corresponding logic expression was derived and returned. In order to assist with this process, the logarithm base 3 of the length of the truth table was calculated and used to narrow down the number of arguments that had to be processed. The function still works with an unlimited number of arguments as long as $log_3n$ is an integer with $n$ representing the length of the inputted truth table. <br><br> This is an example of TernaryFunction in action:<br> ![enter image description here][6] <br> The logic function is returned with the given variables as defined by the user. <hr> <h2>Differences From Binary Logic</h2><br> <p>Multi-valued logics are intended to preserve the property of designationhood, or being designated. Since there are more than two truth values, rules of inference may be intended to preserve more than just whichever corresponds to truth. For example, in a three-valued logic, sometimes the two greatest truth-values (when they are represented as e.g. positive integers) are designated and the rules of inference preserve these values. Precisely, a valid argument will be such that the value of the premises taken jointly will always be less than or equal to the conclusion.</p> <br> <hr> <h2>Applications of Ternary Logic</h2> <br> <p>An application of many valued logic is geared towards the design of electronic circuits which employ more than two discrete levels of signals, such as many-valued memories, arithmetic circuits, and field programmable gate arrays. Many-valued circuits have a number of theoretical advantages over standard binary circuits. For example, the interconnect on and off chip can be reduced if signals in the circuit assume four or more levels rather than only two. In memory design, storing two instead of one bit of information per memory cell doubles the density of the memory in the same die size. Applications using arithmetic circuits often benefit from using alternatives to binary number systems. For example, residue and redundant number systems can reduce or eliminate the ripple-through carries which are involved in normal binary addition or subtraction, resulting in high-speed arithmetic operations.</p> [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=tablemyb.png&userId=1138154 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=allthetables.png&userId=1138154 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=terntable.png&userId=1138154 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=plotarry.png&userId=1138154 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ternarylogic6-1.png&userId=1138154 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ternfunc.png&userId=1138154 Taha Shaikh 2017-07-07T11:10:37Z https://community.wolfram.com/groups/-/m/t/1140551 # Predicting fractal Dimension using Machine Learning ---------- ## Motivation Fractal Dimension is a way to measure the complexity of a fractal. This project's purpose it too estimate it with machine learning. Traditional methods such as box counting have shortcomings, such as a lack of versatility with many different types of fractals, and inefficient compute times. Machine learning was used to give good approximations of the fractal dimension of any fractal with reasonable speed. ## Data Collection I decided to use an image of a fractal as the input, and the dimension as the output. This allowed the algorithm to classify many types of fractals. ### Wikipedia Wikipedia has a set of fractal images, as well the corresponding fractal dimensions. I looked through them to pick the ones with high quality images for my training set, however it was not enough. ![enter image description here][1] ### Randomly Generated Julia Sets I chose to generate random Julia Sets, as there is a built in function for it in Wolfram Language. Julia Sets have a single parameter called c, and changing it generates unique fractals. I generated Julia Sets with random c values, both real and complex, to give the sets some variety. CreateJuliaFractals[size_] := Module[{jFunction = {JuliaSetPlot[#], #} &, jFractals}, jFractals = jFunction /@ Table[RandomComplex[], Floor[size/2]] \[Union] jFunction /@ Table[RandomReal[{-1, 1}], Ceiling[size/2]]; Association[#[[1]] -> JuliaFractalDimension[#[[2]]] & /@ jFractals] ] Calculating the fractal dimension from a given c value of a Julia Set is relatively simple. JuliaFractalDimension[c_] := 1 + Abs[c]^2/4 Log[2] ## Training I split the data into train and test and used the Predict function in Wolfram Language, as it has the capability of returning a result that differs from the training set. FractalDimensionPredictor[training_] := Predict[List @@ training] ## Evaluation I returned the real and predicted fractal dimension as well as the margin of error for every fractal in the test set. FractalMapEval[pred_, test_] := Keys[KeyMap[# -> {test[#], pred[#]} &, test]] ## Deployment I created a micro site in which people can put in pictures of any fractal and get an approximation of it's dimension. CloudDeploy[FormFunction[{"Fractal" -> "Image"}, Column[{#image, pred[#image]}] &, "PNG", AppearanceRules -> <|"Title" -> "Predict Fractal Dimension"|>], Permissions -> "Public"] ## Conclusion Before doing this project, I had no idea what fractal dimension was, and I learned many things including data generation and continuous classification. In the future I hope to use iterated function system to generate more fractals. Visit the micro site [here](https://www.wolframcloud.com/objects/7102eabb-7b80-4bb1-9652-eebcd75e90cd). Link to source code [here](https://github.com/LordDarkula/FractalNet). [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=fractalData.png&userId=515558 Aubhro Sengupta 2017-07-07T13:47:06Z https://community.wolfram.com/groups/-/m/t/406693 How can I get the prime factors of a number, with all the primes being less to a factor base $B$. For example given $B=8$, then the primes used can only be in $\{2,3,5,7\}$. And given $48$, it returns $2^43$. Anyone know how to do this in wolfram alpha? Thanks Ryan D'Souza 2014-12-12T20:08:31Z https://community.wolfram.com/groups/-/m/t/406556 Dear All, I'm working on an algorithm of a block cipher. One step of this algorithm is to build m*m bijective functions (here: m = 4). Earlier I assumed it means the input and output should be 4 bits respectively. But this understanding didn't fit in the algorithm well. According to the algorithm, there's a definition of bijective functions. ![enter image description here][1] [1]: /c/portal/getImageAttachment?filename=Bildschirmfoto2014-12-12um16.47.27.png&userId=406528 Anyone has an idea about the m*m bijective functions? Any pointer would be appreciated. Thanks in advance! Best Regards Qi Z 2014-12-12T15:51:40Z https://community.wolfram.com/groups/-/m/t/385883 How do I enter a step-wise function into WolframAlpha? How do I enter a step-wise differential equation? Jay Gourley 2014-11-08T04:16:08Z https://community.wolfram.com/groups/-/m/t/428854 Hi All, I have tried my best to speed up the simulation below. Could it be made more time efficient ? Please ignore the LV function for now. TFinal = 0.5; NN = 10; r = 0; dt = TFinal/NN; (*Initial Stock*) (*All the parameters should be easily extractable from the files \ available*) S0 = 1; Num = 100000; (**) Tmin = 0.01; T = Tmin; LV = Compile[{{x, _Real}}, 0.8]; (******************) ParallelEvaluate[Off[InterpolatingFunction::dmval]]; (*Initial Simulation Block*) SimPathsLV = Transpose[Reap[ Sow[ParallelTable[S0, {Num}]]; Sow[ SamplePaths2 = ParallelTable[ Nest[(a = RandomVariate[NormalDistribution[0, 1]]; #* Exp[((r - 0.5*(LV[#])^2)*dt + (LV[#])*Sqrt[dt]*a)]) &, S0, 1], {Num}]]; For[k = 0, T < TFinal, k++, T = T + dt; Sow[ SamplePaths2 = ParallelTable[ Nest[(a = RandomVariate[NormalDistribution[0, 1]]; #* Exp[((r - 0.5*(LV[#])^2)*dt + (LV[#])*Sqrt[dt]*a)]) &, SamplePaths2[[i]], 1], {i, 1, Num}]] (*Appending out iteration of the simulation*) ]][[2, 1]]] // Timing; SimPathsLV[[1]] Nabeel Butt 2015-01-26T19:53:49Z https://community.wolfram.com/groups/-/m/t/402946 Hello all, today I write because i have a doubt, by searching on the internet something for my project i found myself with this code in Matlab, which I am trying to translate to Mathematica but without success, I unfortunately know very little of Matlab, and would ask for your help, then I put the code in Matlab and my attempt in Mathematica, greetings to all. Thank you in advance. Code en matlab n=384; m=512; tx=[0:n-1]; ty[0:m-1]; rho=@(x,y) ((1-x^2/50^2-x*y/(15*50)-y^2/15^2)... *exp(-(x^2/50^2+y^2/15^2))) my attempt in Mathematica n=384; m=512; tx=Range[0,n-1]; ty=Range[0,m-1]; rho[x_,y_]:= 1 - x^2/50^2 - (x y)/(50*15) - y^2/15^2*Exp[-(x^2/50^2) - y^2/15^2] I hope I have done my job well, but if i have errors please let me know. Luis Ledesma 2014-12-06T03:53:02Z https://community.wolfram.com/groups/-/m/t/1008706 The late Richard Crandall worked to develop the following robust Mathematica code for calculating many digits of the MRB constant. Just before he died he did something with it to increase it's speed many fold! as seen in [Try to Beat these MRB Constant Records!][1] . After much consideration I decided he converted it to a low level language like C, C++ or Turbo C++. Unfortunately he died before he could share it with enough people. Can anyone here translate the code into one or more of those languages for the world? It has two flavors: first plain and then multi threaded. First: (*Newer loop with Newton interior.*)prec = 5000;(*Number of required \ decimals.*)expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.32 pr]; Print["Iterations required: ", n]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {-1, -d, 0}; T0 = SessionTime[]; Do[c = b - c; x = N[E^(Log[k + 1]/(k + 1)), iprec = Ceiling[prec/128]]; pc = iprec; Do[nprec = Min[2 pc, pr]; x = SetPrecision[x, nprec];(*Adjust precision*) x = N[x - x/(k + 1) + 1/x^k, nprec]; pc *= 2; If[nprec >= pr, Break[]], {ct, 1, 19}]; s += c*(x - 1); b *= 2 (k + n) (k - n)/((k + 1) (2 k + 1)); If[Mod[k, 1000] == 0, Print["Iterations: ", k, " Cumulative time (sec): ", SessionTime[] - T0];], {k, 0, n - 1}]; N[-s/d, pr]]; MRBtest2 = expM[prec] Then for the adventures, (*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 500000;(*Number of \ required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; MRBtest2 - MRBtest3 MRBtest3 is any known decimal expansion of the MRB constant. You can use the above Mathematica code to calculate as many trial digits for MRBtest3 as you wish. I have absolute confidence that the code gives accurate results for anywhere from 5000 to 2,000,000 digits. As far as interpeting the code is concerned I noted that `x = N[E^(Log[ll]/(ll)), iprec];` Gives k^(1/k) to only 1 decimal place; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0). On the other hand, While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));], takes the short precision x and gives it the necessary precision and accuracy for k^(1/k) (k Is ll there.) It actually computes k^(1/k). Then he remarks, "(N[Exp[Log[ll]/ll], pr])." After finding a fast way to compute k^(1/k) to necessary precision he uses Cohen's algorithm 1, found at [Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier,s Convergence Acceleration of Alternating Series][2], to accelerate convergence of Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}]. Looking at Cohen's paper: ![enter image description here][3] ![enter image description here][4] ![enter image description here][5] we see the $a_n$'s are multiplied over the c's. There Crandall craftily took advantage of Mathematica's dot product advantages. So `s += ctab.(xvals - 1);`is in place of ![enter image description here][6]. [1]: http://community.wolfram.com/groups/-/m/t/366628?p_p_auth=rwE8taHU [2]: http://people.mpim-bonn.mpg.de/zagier/files/exp-math-9/fulltext.pdf [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=68211.JPG&userId=366611 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=93142.JPG&userId=366611 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=93013.JPG&userId=366611 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=36464.JPG&userId=366611 Marvin Ray Burns A.G.S. (cum laude) 2017-02-05T19:55:23Z https://community.wolfram.com/groups/-/m/t/557572 Hi, I have the following situation and would like some feedback on my approach to solving the problem, since I am not sure if it's "mathematically legit": I have two transfer functions: function A is the transfer function of a system, function B is the transfer function of a reduced version of the same system. The transfer functions show the frequency response of the system, the input being a force and output being a displacement. I want to compare both functions and see what the deviation of the reduced order system is from the original system. Now, however, for the overall goal of the project, I am not so interested in the displacement, but rather the velocity. So it would be great if I could compare the velocities I am getting from both functions. This should just be the derivative of the transfer functions since the transfer functions are giving me the displacement? The transfer functions are complex and in the frequency domain (H_a(jw) and H_b(jw)), so the derivative of these should just be a multiplication with jw (since s=jw for steady state)? Is this correct? Thank you in advance! A N 2015-09-01T13:49:16Z https://community.wolfram.com/groups/-/m/t/469432 I have a large number of functions which I am combining into packages and will call those functions via a palette. I then use those functions in a notebook and may need to call them several times. The data entry for many of those functions is via a dynamic interface, which gives a nice check on the data as it is entered. My problem is that, if I call the same function twice in a Notebook then entering the data each time the function is called changes the data for the previous function already in my notebook. Is there a way around this? Malcolm Woodruff 2015-03-29T10:53:12Z https://community.wolfram.com/groups/-/m/t/550930 Hi, I have drawn these two tiling the plane pattens (A & B), are these just considered variations of some of the current, or are these new? Geometrically they are appear to be different (but with similarities) to all the ones I have seen. Type A is similar to type 4, but my type A has three equal sides, and the other two make the same length as one of the equal. Type 4 has four equal sides. Type B is similar to type 8, but my type B has two 90 deg angles and the primary unit can overlap its self at each quadrant and maintain the patten. I would be interested in any opinion about these two Plane Tile Pattens. Thanks! Reece Hill 2015-08-21T11:20:42Z https://community.wolfram.com/groups/-/m/t/1793523 I am looking for a solution for a minor but annoying flaw in a program that I made for building a CDF for analysing the properties of accumulations of random numbers. In the CDF I can choose for several types of such accumulations through a number of radiobuttons. With each radiobutton I can make a list that contains the sum of the accummulation in question along with several parameters and quantities that I for instance need for a text above the final chart of the accumulation and some additional special properties of it. Together with each radiobutton for any accumulation with a certain probability distribution the CDF has one or more inputfields for the necessary parameters, such as mean and standard deviation for a normal distribution. My problem is the following: After pushing a radiobutton and then inserting a number in an inputfield that goes with that button, and then hitting Enter or clicking with the mouse outside of the input field, the radiobutton turns white and in order to make the number in the input field do its work I have to push this radiobutton anew. What I want is that the new situation is activated right away after entering a number in the inputfield and then pushing Enter of clicking with the mouse outside of the inputfield. I hope there is a solution for this. This is the program all the way stripped down to the relevant section: Export["Testpanel.cdf", CreateDocument[{ DynamicModule[{y, beta, center, standarddeviation, mean}, Row[{ Row[{ Dynamic[ SeedRandom[1]; RadioButton[ Dynamic[y], {" Laplace", " distribution", " ", Accumulate[ RandomVariate[LaplaceDistribution[center, beta], 1000]], 0}]], TextCell[" Laplace "], center = 0; InputField[Dynamic[center], FieldSize -> 3], beta = 1.7; InputField[Dynamic[beta], FieldSize -> 3], TextCell[" "], Dynamic[ SeedRandom[1]; RadioButton[ Dynamic[y], {" normal", " distribution", " ", Accumulate[ RandomVariate[NormalDistribution[mean, standarddeviation], 1000]], 0}]], TextCell[" Normal "], mean = 0; standarddeviation = 1; InputField[Dynamic[mean], FieldSize -> 3], InputField[Dynamic[standarddeviation], FieldSize -> 3], TextCell[" "] }], Dynamic[Show[ ListPlot[ Partition[Riffle[Range[1, 500], y[[4]][[1 ;; 500]]], 2], PlotStyle -> {PointSize[0.003], White}, Background -> Black ], ImageSize -> 500]] }] ]}]] **Additional information**: In the meantime I discovered that after putting a new number in an inputfield instead of hitting Enter or clicking outside of the inputfield and then pushing the radiobutton again one may also get desired result by right away pushing the Radiobutton 3 times. So in fact my problem may be considered as solved. Laurens Wachters 2019-09-20T12:38:22Z https://community.wolfram.com/groups/-/m/t/1382823 The goal of this project has been to explore NAND expressions and look for expressions equivalent to XOR. The Wolfram Language can already simplify XOR expressions with NANDs by using the following function but it only simplifies to a two level tree. By using more than two levels there is a possibility of finding a simpler version of three or four input XOR expressions. The reason that I chose to use NAND gates is that they are universal gates (any expression can be represented with a combination of NAND gates). Other universal gates like NOR would work but it seemed simplest to just stick with NAND to keep things consistent. `BooleanMinimize[Xor[a, b, c], "NAND"] // TreeForm` ![NAND simplification for XOR[a,b,c] in Tree Form][1] ## Two Input Trees ## The first thing I implemented was a recursive function that creates all of the different NAND trees possible with a given amount of NAND gates. It works by assuming that each NAND gate only has two inputs. From this it runs through the possibilities for the NAND gate configurations on each input. ![Nand Tree Logic][2] The code starts by defining the first case of the recursive function and then on the next gates it runs through the different combinations with tuples to generate all of the outcomes. It also creates NAND trees with half of the amount of NAND implemented and it doesn't know what to do with an odd amount of gates so "nandTreeCreate" was implemented to fix that by multiplying the input by two. Additionally it uses a new NAND function that get's rid of trivial cases that aren't worth computing (Ex. Xor[a, !a]). nand[a_, a_] := Null; nand[a_, ! a_] := Null; nand[! a_, a_] := Null; nand[a_, b_] /; OrderedQ[{a, b}] := Sow@Nand[a, b]; nand[a_, b_] := Null; nandTreeGenerate[0] := {a, b, c, ! a, ! b, ! c} nandTuples[list1_, list2_] := Replace[Reap[ Do[nand[a, b], {a, list1}, {b, list2}]], {{_, {x_}} :> x, _ :> {}}] nandTreeGenerate[ 0] := {a,b,c,!a,!b,!c}; nandTreeGenerate[nGates_] := nandTreeGenerate[nGates] = Module[{subtrees = nandTreeGenerate /@ Range[0, nGates - 1]}, Join @@ Table[nandTuples[subtrees[[i]], subtrees[[nGates - i]]], {i, 1, nGates - 1}] ] nandTreeCreate[nGates_] := nandTreeGenerate[nGates*2] This turned out to be an effective set of functions but it wasn't very useful since it only generates two input NAND trees and no simpler forms of XOR were found by running tests with this function. The following function was used to compare it to XOR. Select[nandTreeCreate[5], TautologyQ[Equivalent[Xor[a, b, c], #]] &] ##Multi-Input Tree Generation ## By inputting the amount of leaves into the recursive function, I was able to expand it in order to account for more than two input NAND gates. This uses the same general structure as the two input NAND generate function except it is based on integer partitions to find all of the different combinations. nand[arg_] := Nand[arg]; nand[args___] /; Equivalent[args] := Null; nand[args___] /; OrderedQ[{args}] := Nand[args]; nand[args___] := Null; nandTuples[l_] := (nand @@ #) & /@ Tuples[l] nandTreeGenerate[1] := {a,b,c]}; nandTreeGenerate[nLeaves_] := nandTreeGenerate[nLeaves] DeleteCases[Module[{subtrees = nandTreeGenerate /@ Range[1, nLeaves - 1]}, Join @@ ((nandTuples[subtrees[[#]] & /@ #] & /@ (IntegerPartitions[nLeaves - 1])) ], Null] This works super well but it's still computationally intensive and I figured out later that some of the logic must be wrong since it misses a couple of cases every once and awhile. It's still good for getting a basic idea of the different cases that come from different leaf counts though. ## Random Generation ## It seems that the best way to generate expressions computationally comes from random generation. This is because it can be stopped and started within a time limit even though it doesn't get every possible expression. In order to implement this I used a function that inserts either a NAND gate or a variable at a random spot within the expression. varlist = {\[FormalA], \[FormalB], \[FormalC]}; addSomething[ex_] := Module[{positions}, positions = Position[ex, _myNand, {0, Infinity}]; Insert[ex, RandomChoice[{.2, .7, .7, .7} -> Join[{myNand[]}, varlist]], Append[RandomChoice[positions], 1]] ] makeTree[nLeaves_] := ( (Last@NestList[addSomething, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nor randTreeGenerate[nLeaves_, nTimes_] := makeTree /@ Table[nLeaves, nTimes] Although this is good for generating most functions, some cases become increasingly unlikely as it adds more terms. This makes it necessary to adjust the weights for NANDs and variables so that all of the cases have an equal chance of occurring. I didn't have enough time to find the right values so eventually I setup the weights as random integers so that it would have a good distribution for each of the different weight combinations. ##Visualizing the Data## At the end I made a couple of functions that could generate expressions for awhile and then put it in a form that's easy to analyze. There are two equivalents of the functions depending on if you want to input the iterations or the duration that it should run for. It also has the option to input what percentage of those expressions should use NOR gates if any variation is needed. Clear["Global`*"] counts = Table[0, {i, 0, 255}]; varlist = {a, b, c}; addSomething[ex_, nand_: 1, var_: 1] := Module[{positions}, positions = Position[ex, _myNand, {0, Infinity}]; Insert[ex, RandomChoice[{nand, var/3, var/3, var/3} -> Join[{myNand[]}, varlist]], Append[RandomChoice[positions], 1]] ] makeTreeNand[nLeaves_] := ( (Last@NestList[ addSomething[#, RandomInteger[{1, 20}], RandomInteger[{1, 20}]] &, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nand makeTreeNor[nLeaves_] := ( (Last@NestList[ addSomething[#, RandomInteger[{1, 20}], RandomInteger[{1, 20}]] &, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nor visualizeCount[leaves_, iterations_, Nand_] := Module[{tree, counts = Table[0, {i, 0, 255}], c}, Monitor[Do[ c = 100*N@i/iterations; tree = makeTreeNand[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++; , {i, 1, iterations * (Nand/100)} ], c]; Monitor[Do[ c = 100*N@i/iterations; tree = makeTreeNor[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++; , {i, 1, iterations * (1 - (Nand/100))} ], c]; Print[ListLogPlot[Sort[counts[[#]] & /@ Range[0, 254]] + 1]]; Print[ArrayPlot[ IntegerDigits[#, 2, 8] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1], Mesh -> True, ColorRules -> {0 -> Red, 1 -> Darker@Green}]]; Print[Column[ FullForm /@ (FullSimplify[BooleanFunction[#, varlist]] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1])]]; Print[BarChart[counts[[#]] & /@ Range[0, 254]]] ] visualizeWhile[leaves_, time_, Nand_: 100] := Module[{tree, c, start = UnixTime[]}, Monitor[ While[UnixTime[] < (start + (time*(Nand/100))), c = UnixTime[] - start; Do[tree = makeTreeNand[RandomInteger[{1, leaves}]]; len += 1; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++;, {100}] ], c]; start = UnixTime[]; Monitor[ While[UnixTime[] < (start + (time*(1 - (Nand/100)))), c = UnixTime[] - start; Do[tree = makeTreeNand[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++;, {100}] ], c]; Print[ListLogPlot[Sort[counts[[#]] & /@ Range[0, 254]] + 1]]; Print[ArrayPlot[ IntegerDigits[#, 2, 8] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1], Mesh -> True, MeshStyle -> {Black, Thick}, Background -> Black, ColorRules -> {0 -> Red, 1 -> Darker@Green}]]; Print[Column[ FullForm /@ (FullSimplify[BooleanFunction[#, varlist]] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1])]]; Print[BarChart[counts[[#]] & /@ Range[0, 254]]] ] Because there are only three variables being used, the amount of possible truth tables is 256. The function uses a list to keep track of the amount of times each of those truth tables occurred and at the end it creates a logarithmic line plot and a histogram. This particular test ran for 12 hours or so. The logarithmic plot is shifted up one to make it easier to analyze the data. ![Random Expression Logarithmic Plot][3] ![Random Expression Histogram][4] It also formats the truth tables that weren't generated into an array plot and lists the equivalent expressions for each of those truth tables. ![Expressions not generated][5] Xor[a,b,c,And[a,b,c]] Not[Xor[a,b,c,And[a,b],And[a,b,c]]] Not[Xor[a,b,c,And[a,c],And[a,b,c]]] Not[Xor[a,b,c,And[b,c],And[a,b,c]]] Not[Xor[a,b,c]] Not[Xor[a,b,And[a,c],And[b,c],And[a,b,c]]] Not[Xor[b,c,And[a,b],And[a,c],And[a,b,c]]] Xor[a,c,And[a,b],And[b,c],And[a,b,c]] Xor[a,b,c] Xor[a,b,c,And[b,c],And[a,b,c]] Xor[a,b,c,And[a,c],And[a,b,c]] Not[Xor[a,b,c,And[a,b,c]]] ##Conclusion## From random generation I was able to deduce to a reasonable degree of certainty that it is impossible to generate an equivalent NAND expression that's simpler than the one the Wolfram Language generates for three input XOR gates. There are most likely equivalent expressions out there for four or more input XOR expressions but that proves to be very computationally intensive and time consuming. It is pretty interesting how some expressions require significantly more NAND gates to be expressed because of their structure and the nature of NAND gates. It would be interesting to look into making expressions with NOR and XOR gates in the future and maybe putting more time into generating random expressions. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture2.PNG&userId=1371737 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Tree.png&userId=1371737 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture1.PNG&userId=1371737 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture3.PNG&userId=1371737 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture.PNG&userId=1371737 Ben Huenemann 2018-07-13T17:54:42Z