https://community.wolfram.com RSS Feed for Wolfram Community showing questions tagged with Mathematics with no replies sorted by most likes. https://community.wolfram.com/groups/-/m/t/908332 **Abstract** The goal of this project is to implement the Huffman lossless data compression algorithm which is a compression algorithm based on the frequency of data. The trick is that the words which are more commonly used must be shorter than the words which are less common. The English language already uses this approach, for example, the word "the" is frequently used and short but the word "approximation", which is much less frequent is longer. - Introduction to Huffman coding - Word frequency data - Huffman algorithm code in Mathematica and a few examples - Correlation between words and Huffman codes **Introduction to Huffman coding** Huffman coding is a statistical technique, which attempts to reduce the amount of bits required to represent a string or a symbol. The concept of Huffman algorithm is that the shorter binary codes are assigned to the most frequently used symbols and longer codes to the symbols which appear less frequently. The Huffman code for an alphabet (set of symbols or words) may be generated by constructing a binary tree with nodes containing the symbols to be encoded and their probabilities of occurrence (that's where the statistical part comes in). This means that you must know all of the symbols that will be encoded and their probabilities prior to constructing a tree. In computer science and information theory, a Huffman code is a particular type of optimal prefix code that is commonly used for lossless data compression. The algorithm was originally developed by David A. Huffman. **Word frequency data:** As an input for the Huffman coding algorithm, we use the 5000 most frequently used words in English. See the database [Here][1]. The following is the visualization of most commonly used words, $\qquad \qquad \qquad \qquad \qquad \qquad $![enter image description here][2] **Examples of Huffman codes** merge[k_] := Replace[k, {{a_, aC_}, {b_, bC_}, rest___} :> {{{a, b}, aC + bC}, rest}]; mergeSort[d_List] := FixedPoint[merge @ SortBy[#, Last] &, d][[1, 1]]; findPosition[l_List, k_List] := Map[ (# -> Flatten[Position[k, #] - 1]) &, DeleteDuplicates[l] ]; huffman[l_List] := Module[{sortList, code, words}, words = l[[All, 1]]; sortList = mergeSort[l]; code = findPosition[words, sortList]; {Flatten[l /. code], code}; code ] These are a few examples of encoded words using Huffman algorithm $\qquad \qquad \qquad \qquad \qquad \qquad $![enter image description here][3] **Correlation between words and Huffman codes** The following is the correlation plot of the numbers of letters in a word and number of bits produced by Huffman algorithm. As you can see from the plot the most commonly used words in English tend to be shorter and the overall the trend in English and in Huffman code is the same. $\qquad \qquad \qquad \qquad \qquad \qquad $![enter image description here][4] The following plot represents the number of bits of English words and the number of bits of Huffman codes. The number of bits per English word was computed using a conversion factor of $\log_2(26) ~ 4.7$ bits per word, where 26 is the number of letters in the English alphabet. $\qquad \qquad \qquad \qquad \qquad \qquad $![enter image description here][5] The blue line is a scatter plot of the number of bits in English versus the number of bits in the Huffman code. The red line is $y=x$. .As you can see the Huffman coding is much more efficient and the slope of the curve tells us that the Huffman coding uses three times less space than the English language. [1]: https://en.wiktionary.org/wiki/Wiktionary:Frequency_lists/PG/2006/04/1-10000 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=wordcloud.png&userId=900670 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Matrix.PNG&userId=900670 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=corr.png&userId=900670 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=5310corr.png&userId=900670 Vahagn Hayrapetyan 2016-08-19T12:34:09Z https://community.wolfram.com/groups/-/m/t/1184139 Why this question affects my choice of finite element solver ------------------------------------------------------------ In my project, I am importing a complex geometry from an STL file into Mathematica as a `MeshRegion`. I would like to edit this mesh significantly: For instance, drastically reduce or increase the number of elements (for finite element analysis) or make boolean operations. But I am not sure if Mathematica can re-mesh a `MeshRegion` that is obtained from discrete data. This question is of personal importance for me because it will help decide if I can go ahead with using `NDSolve` for the finite element analysis of my project: If re-meshing is very problematic in Mathematica, it may be wiser to import volume meshes from external software, or do all of the finite element analysis in a dedicated solver like Comsol. Re-meshing an already discretized `MeshRegion` -------------------------------------------- Let me illustrate. When I work with an `ImplicitRegion`, I seem to have full control, I can make a mesh with very many or few elements, and apply boolean operations too: IR = ImplicitRegion[ x^6 - 5 x^4 y + 3 x^4 y^2 + 10 x^2 y^3 + 3 x^2 y^4 - y^5 + y^6 + z^2 <= 1, {x, y, z}]; << NDSolve`FEM` ToElementMesh[IR, MaxCellMeasure -> Infinity, AccuracyGoal -> 0]["Wireframe"] ToElementMesh[RegionDifference[IR, Cuboid[]], MaxCellMeasure -> 0.001]["Wireframe"] ![enter image description here][1] Next, I create a `MeshRegion` by applying `DiscretizeRegion`. This leaves me in basically the same situation as importing some STL mesh into Mathematica as `MeshRegion`: MR = DiscretizeRegion[IR]; (* same as MR = Import["filename.stl", "MeshRegion"] *) Now I can no longer downsample: ToElementMesh[MR, MaxCellMeasure -> Infinity, AccuracyGoal -> 0] ToElementMesh[MR] ![enter image description here][2] Same thing! No downsampling appears to have happened. Possibly no re-meshing whatsoever. Mathematica returns basically the same number of elements (`TetrahedronElement["<" 16793 ">"]` vs `TetrahedronElement["<" 16841 ">"]`, respectively). Also I can no longer apply boolean operations: RegionDifference[MR, Cuboid[]] // DiscretizeRegion returns an error ![enter image description here][3] Is there some way I could gain control of the `DiscretizeRegion` in the same way as `ImplicitRegion`? In practice, I am presented with discrete data (STL file) and I would like to be able to re-mesh it, do boolean operations, and run FEM in full control of my mesh. Is that possible? Bad brute force solution ----- You can brute force Mathematica to re-mesh using this hack: MR2 = DiscretizeGraphics[ RegionPlot3D[ RegionMember[MR, {x, y, z}] == True && RegionMember[Cuboid[], {x, y, z}] == False, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotPoints -> 20]] ToElementMesh[MR2, MaxCellMeasure -> Infinity, AccuracyGoal -> 0] ![enter image description here][4] However, converting the `MeshRegion` (picture above, left) with `ToElementMesh` hopelessly overmeshes things (picture above, right). I get about 500k tetrahedral elements. Once again I don't know how to control my mesh for finite element analysis. Disclaimer ----- I have posted this question to Mathematica Stackexchange [here][5], where it has gone unanswered for several days. Because of the importance of this question for my modeling work (I need to decide if I can go ahead with Mathematica for the finite element analysis part of my project), I decided to post it to the Wolfram Community to hopefully get some developer feedback. I am happy to summarise the insights of this this discussion for the Stackexchange community once we have (hopefully) reached some conclusions. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=1184102 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=1184102 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=3.png&userId=1184102 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=4.png&userId=1184102 [5]: https://mathematica.stackexchange.com/questions/155484/is-it-possible-to-re-mesh-downsample-upsample-a-discretizeregion-object Alexander Erlich 2017-09-13T17:30:32Z https://community.wolfram.com/groups/-/m/t/55094 In the process of developing [url=http://demonstrations.wolfram.com/author.html?author=Jaime%20Rangel-Mondragon]some demonstrations I published recently[/url] about bisecting the perimeter of triangles I came across the following result. Consider the arc AB of a circle, the segment AB not necesarily being a diameter of the circle. If M is the apex in the middle of the arc and we join it to the center N of AB, then clearly AN = BN. In other words, if we join the middle M of arc AB with the middle N of segment AB, segments MN and AB are perpendicular and AN = BN. Perhaps the following manipulate would clarify the idea.[mcode] Manipulate[  Block[{r}, r = Sqrt[1 + h^2];   {c1, c2} = If[h < 0, {6, 5}, {5, 6}];   Graphics[{{EdgeForm[Thick], ColorData[2, c1], Disk[{0, -h}, r],      ColorData[2, c2],      Disk[{0, -h}, r, {ArcTan @@ {1, h}, ArcTan @@ {-1, h}}]},     ColorData[2, c1], Rectangle[{-1, -h}, {1, 0}], Black,     Line[{{-1, 0}, {1, 0}}], Line[{{0, -h + r}, {0, 0}}],     Style[{Text["A", {-1, -.1}], Text["B", {1, -.1}],       Text["M", {0, -h + r + .1}], Text["N", {0, -.1}]}, 20, Bold]},    PlotRange -> 1.2]],    {{h, 0, "circle"}, -1, 2, Slider}] [/mcode] [img=width: 411px; height: 455px;]/c/portal/getImageAttachment?filename=pic1.png&userId=48389[/img] Now for the interesting part. Suppose that there is a point C on the arc AB and instead of defining N as the perpendicular from M to AB, we take N as the perpendicular from M to AC and now relabel as D the middle point of segment AB (if point C is at the left of M we take N to be the perpendicular from M to BC). The following manipulate illustrates this. [mcode] Manipulate[  r = Sqrt[1 + h^2];  al = If[h == 0, Pi/2, ArcTan[1/h]];  a = If[h > 0, {al - Pi/2,     3 Pi/2 - al}, {Pi/2 - al, Pi/2 + al}];  ac = cc Last[a] + (1 - cc) First[a];  c = {0, h} + r {Cos[ac], Sin[ac]};  n = If[First[c] > 0, {-1, 0} +     Projection[{1, h + r}, c + {1, 0}], {1, 0} +     Projection[{-1, h + r}, c - {1, 0}]];  Graphics[{EdgeForm[Thick],    Circle[{0, h}, r, a], Black, Line[{{-1, 0}, c, {1, 0}, {-1, 0}}],    Line[{{0, h + r}, n}],    Style[{Text["A", {-1, -.1}], Text["B", {1, -.1}],      Text["M", {0, h + r + .1}], Text["D", {0, -.1}], Text["C", c],      Text["N", n]}, 20, Bold]},   PlotRange -> {{-1.5, 1.5}, {-.2, 2.5}}],    {{h, 0, "circle"}, -3, .9, Slider},  {{cc, .3, "point C"}, 0, 1, Slider}] [/mcode] [img=width: 411px; height: 447px;]/c/portal/getImageAttachment?filename=pic2.png&userId=48389[/img] Surprisingly, considering lengths, AN = NC + CB (or BN=NC+AC if C is to the left of M). Perhaps some reader can come up with a proof of this result?. What has this to do with bisecting perimeters of triangles and what is the importance of point D to even having received a label? Well, it turns out that the segment DN bisects the perimeter of triangle ABC. In seeking for an algebraic proof of this result, we set a = (1, 0), b = (-1, 0), d=(0,0) and the center of the circle at (0, h) with variable h. The radius of the circle is then r = Sqrt[1 + h^2]. Thus m = (0, h + r) and c = (0, h) + r (cos (t), sin (t)) for some value of t not exceeding pi/2 (the other bound will be mentioned later). The point n is then obtained as[mcode]{a, b} = {{-1, 0}, {1, 0}}; r = Sqrt[1 + h^2]; m = {0, h + r}; c = {0, h} + r {Cos[t], Sin[t]}; n = FullSimplify[a + (m - a).(c - a) (c - a)/((c - a).(c - a))] [/mcode][mcode] {1/2 (-1 + (h + Sqrt[1 + h^2]) Cos[t] + Sin[t]), 1/2 (-Cos[t] + (h + Sqrt[1 + h^2]) (1 + Sin[t]))} [/mcode] With these values, the expression we want to verify being equal to zero is tested as:[mcode] FullSimplify[Norm[n - a] - Norm[n - c] - Norm[c - b] /. Abs[xx_]^2 -> xx^2, t < Pi/2] [/mcode][mcode] -Sqrt[(-1 + h (-h + Sqrt[1 + h^2])) (-1 + Sin[t])] + Sqrt[(1 +     h (h + Sqrt[1 + h^2])) (1 + Sin[t])] -  Sqrt[2] Sqrt[1 + h^2 + Sqrt[1 + h^2] (-Cos[t] + h Sin[t])] [/mcode]So, we are left with the following (probably) true theorem [img=width: 692px; height: 96px;]/c/portal/getImageAttachment?filename=pic3.png&userId=48389[/img] but this takes us further away from the proof we want. Jaime Rangel-Mondragon 2013-07-02T22:05:08Z https://community.wolfram.com/groups/-/m/t/1729183 # Introduction Suppose one wants to know the average temperature throughout a time series. With the existing resources, the only option is to calculate the average of every single data point for the entire time interval. This option, however, is extremely inefficient as every point is needed in order to generate the average. To solve this problem, we examine how we may divide the time series into years, months, weeks, dates, and hours so that when the average is calculated, we can simply extract the temperature values for the years, months, etc. and reduce the number of objects that is needed for the average to be calculated. I will start by extracting the complete years that occur during this time series. By doing so, we created objects that will represent all the data points for that year. We may then continue this process and extract the complete months from the time that does not assemble a complete year. Then, we continue this process by grouping the dates that are left into combinations of six - day weeks and days. # Time Series Summarization I have decided that I will write out the time series as a combination of years, months, weeks, days, and hours. The logic that I will use to break down a time series will be the following: ![Logic Flow Of Time Series Summarization][1] Notice that one unique feature of my optimization model considers six-day weeks instead of the traditional seven-day format. I have decided to do so for several reasons: - It is actually more efficient to write out time series combinations when the weeks are six days long. I wrote the program that will determine for week length of n days how many week/day objects will be needed to assemble a time series of m days for all m that is less than the max number of days in a month (Thus, 1 <= m <= 30). When I sum of all the number of objects needed across all m values for each of the n values, I realized that n=6 actually has the lowest total, which means that n = 6 will be the most efficient. Also, it takes less objects to assemble periods of 30, 31 days when n=6 because 6 divides these values almost evenly. - This will eliminate any potential for the need to reconsider the optimization strategy for the beginning and the ending of the time series: If the traditional seven-day week format is used, then the optimizing strategy will take one extra step because if we consider the time series [June 1st, July 5th], then grouping this time series into 5 weeks instead of the month of June plus 5 days will mean that less objects is needed when we calculate the average. Using the six-day week format will eliminate such concerns. Once we extracted the weeks and dates, we will create the most efficient combination for this time series. Based on the tree diagram, I can go ahead and assemble the most efficient combination. I will construct the TimeSeriesCombination to obtain the most optimal time series combination.The following is a combination of years (expressed as yyyy, where yyyy stands for the year), months (yyyymm), weeks (yyyymmddW), dates (yyyymmdd), hours (yyyymmddhh), expressed in chronological order. TimeSeriesCombination[DateObject[{2019, 6, 2, 1}], DateObject[{2019, 7, 5, 0}]] {"2019060201", "2019060202", "2019060203", "2019060204", "2019060205", "2019060206", "2019060207", "2019060208", "2019060209", "2019060210", "2019060211", "2019060212", "2019060213", "2019060214", "2019060215", "2019060216", "2019060217", "2019060218", "2019060219", "2019060220", "2019060221", "2019060222", "2019060223", "20190603W", "20190609W", "20190615W", "20190621W", "20190627W", "20190703", "20190704", "2019070500"} To make this time series more readable, we can go ahead and group it by the type of object. In this case, all consecutive hours will be grouped together, than days, weeks, etc. ![enter image description here][2] #Evaluation: In Application To Weather Data Using this optimized time series summarization, I can find the maximum, minimum, and the mean air temperature for a time series. For now, the functions only apply to Waltham, MA. An extra parameter will be needed to allow users to select their locations. The temperature interval can be determined by looking at the objects generate by the TimeSeriesCombination function and using these as keys to search up generated weather temperature data (I have created a data file producing process that is intended to improve the Wolfram Knowledge Base) and using the weather temperature data to calculate the overall maximum, minimum, and mean value during this time interval. MaxTemperatureInterval[DateObject[{2016, 8, 13, 0}], DateObject[{2018, 2, 23, 23}]] Quantity[81.788, "DegreesFahrenheit"] MinTemperatureInterval[DateObject[{2016, 8, 13, 0}], DateObject[{2018, 2, 23, 23}]] Quantity[0.710001, "DegreesFahrenheit"] MeanTemperatureInterval[DateObject[{2016, 8, 13, 0}], DateObject[{2018, 2, 23, 23}]] Quantity[48.5953, "DegreesFahrenheit"] #Evaluation: How Efficient Is This Function? We decided to conduct a test to see how much the generated function improves the overall efficiency of finding data of that time series. We determine how time, in seconds, it takes for the algorithm we determined, and also the existing algorithm, to determine the mean temperature throughout 300 time series, each ending at 2018/12/31 but have lengths of 1 day, 2 days, ... We find that initially the existing method is more efficient. However, as the number of days increase my method starts to prevail. ![Comparison Of The Run Of The Two Functions][3] Based on the plot, we can see that past 90 days my function will be significantly more efficient than the existing method. I anticipate that as the number of days increase, my method will become more and more efficient compared to the existing method. # Why This Function Is Actually More Important Than Just The Efficiency To double check that my code makes sense, I go back to check the calculated value against the value that is calculated using the existing method. When I look at the values, there seems to be some differences. ![enter image description here][4] The difference is even bigger when we are looking at smaller time intervals. ![enter image description here][5] While I wonder what is causing this difference, I remembered my initial experiment on time series and remembered that the number of data points for each day is not equal: ![enter image description here][6] Using the data files that I have, I calculated and confirmed that the existing system simply takes all the data points during that time interval and averages it out. What this means is that the mechanism will favor some mechanisms over the others. In the case between 2018/11/13 to 2018/11/15, the temperature is larger because the date, whose temperature is 46.5 F (higher than the other two dates) is favored during the calculation. Thus, my method of calculation will provide a more calculation of the mean because every day will have the same weight during the calculation. Note that my mechanism is not perfect. This comes from the fact that the daily temperatures are calculated with the same method that caused the inaccuracies in the existing mechanism, and the unequal representation of hours is a glaring issue in calculating daily temperatures: ![enter image description here][7] In this case, the temperature during 2:00 and 10:00 is not even calculated! When calculating averages, 18:00-24:00 will be heavily favored and the mean temperature for the date will be a lot close to the 70 F mark as a result. Thus, daily temperatures should eventually be calculated by averaging the values for all the hours. # Future Work I can examine whether inserting other time intervals (quarters, decades, centuries, minutes, seconds) will allow for an even more efficient processing, and implement these intervals if it is indeed more efficient to do so. I can also use the time series summation to look at other data (Dow Jones index, etc.) to generate relevant statistical analysis such as forecasting. #Further Exploration GitHub link: [https://github.com/altan4377/WSS-2019][8] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=TreeDiagram.jpg&userId=1726252 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ResultsColumnForm.jpg&userId=1726252 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ComparisonOfMethods-MineVSExisting.jpg&userId=1726252 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Inaccuracy-1.jpg&userId=1726252 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Inaccuracy-2.jpg&userId=1726252 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Inaccuracy-3.jpg&userId=1726252 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Inaccuracy-3-WithTitle.jpg&userId=1726252 [8]: https://github.com/altan4377/WSS-2019 Yun-chi Tang 2019-07-10T18:47:16Z https://community.wolfram.com/groups/-/m/t/1382879 ## Introduction It is often said that a picture is worth a thousand words, and it’s true that a graphic can equal a thousand data points. Graphics can reveal to us trends that we wouldn’t have seen otherwise and show us information in a new light. Yet, making the right representation can be a struggle, especially when given data without context. ## Purpose The goal of this project was to create a function that finds the best possible graphical representation for numerical data. The function analyzes whether the data should be either a bar chart, a line plot, a scatter plot, a pie chart, points on a map, a histogram, a bubble plot, or a waterfall chart. ![The eight types of graphics used in this project][1] ## Process The first step was gathering sample data for each type of graphic. To accomplish this step, the most commonly used and easy to identify types of charts were determined. As mentioned before, these types of graphics were determined to be bar charts, waterfall charts, pie charts, scatter plots, line plots, bubble charts, histograms, and geo charts. Bar charts are used for comparative purposes, and can encompass multiple variables. The input for this type of graphic can vary greatly, but must be contained either in a single list or in a series of nested lists. ![enter image description here][2] ![enter image description here][3] Line plots are also used for comparative purposes, but are either used as a comparison across time or to show a relationship between two variables. The data for line plots often comes in pairs. Since line plots sometimes deal with dates and times, the data was split into two variables, LinePlotExamples and TimeLinePlotExamples. ![enter image description here][4] ![enter image description here][5] Pie charts are often used when dealing with percents or parts of a whole. Therefore, the sum of the data used in pie charts usually either sums to 1 or 100. ![enter image description here][6] ![enter image description here][7] Waterfall charts are often used by businesses to show change in respect to a previous event. The first bar represents the initial value. Each bar from that point shows either a rise or a drop in value. The last bar represents the final value after the series of rises and drops. Due to the nature of the chart, the data for waterfall charts often includes alternation between positive and negative numbers. ![enter image description here][8] ![enter image description here][9] Scatter plots are often used to show correlation between two variables. Unlike line plots, scatter plots can still be created when the data is out of order. ![enter image description here][10] ![enter image description here][11] Bubble charts are similar to scatter plots except that they show correlation across three variables. One variable is represented by position on the x-axis, another by position on the y-axis, and the last by the radius of the bubble. The data for bubble charts always comes in triplets. ![enter image description here][12] ![enter image description here][13] Histograms are used to show distribution and often have a bell shape to them. ![enter image description here][14] ![enter image description here][15] Finally, geo charts are used for the purpose of pointing out different parts of the world. As a result, the data for geo charts resembles longitude and latitude coordinates. ![enter image description here][16] ![enter image description here][17] After all the training data had been determined, the function DataClassify[] was created by using the built-in function Classify[]. DataClassify = Classify[Flatten[{barChartexamples, waterfallExamples, pieChartExamples, LinePlotExamples, TimeLinePlotExamples, BubbleChartExamples, HistogramExamples, ScatterPlotExamples, GeoExamples }]] The function DataClassify[] identifies which type of chart would be most appropriate. Next, the function Visualize[] was created. This function graphs the data in the format specified by DataClassify[]. Visualize[x_List] := ToExpression[DataClassify[ToString[x]]][x] Finally, a microsite was created to display the function. URLShorten[CloudDeploy[FormPage["data" -> <| "Interpreter" -> "Expression", "Label" :> "Enter the data as a list" |>, CloudEvaluate[Visualize[#data]] &]]] The microsite can be found at [https://wolfr.am/w5hrqZM8][18]. ## Code All the code is included below. DataClassify = Classify[Flatten[{barChartexamples, waterfallExamples, pieChartExamples, LinePlotExamples, TimeLinePlotExamples, BubbleChartExamples, HistogramExamples, ScatterPlotExamples, GeoExamples }]] Visualize[x_List] := ToExpression[DataClassify[ToString[x]]][x] URLShorten[CloudDeploy[FormPage["data" -> <| "Interpreter" -> "Expression", "Label" :> "Enter the data as a list" |>, CloudEvaluate[Visualize[#data]] &]]] ##Examples Some examples of the function Visualize[] at work are below. Visualize /@ { {{8.5, 6.7, 8.8, 7}, {9, 7.2, 6.4, 7.3}, {9.5, 8, 7.4, 7.8}, {9.5, 7.5, 6, 8.4}}, {{1, 4}, {5, 6}, {9, 16}, {16, 19}, {17, 30}}, {1100, 250, 50, -250, 275, 250, -250, -25, 50}, {{"1970", 20}, {"1975", 50}, {"1980", 90}, {"1985", 110}, {"1990", 280}}, {.61, .12, .15, .11, .2, .3, .2, .5}, {{40, 6, 541}, {35, 11, 390}, {15, 4, 825}, {7, 6, 503}, {12, 16, 403}, {45, 5, 375}, {5, 8, 657}, {35, 17, 787}, {30, 4, 44}, {25, 15, 354}}, RandomVariate[WeibullDistribution[3, 1], 1000], {{-40.30294, 167.57691}, {-27.99694, 152.31741}, {-12.00480, 60.45049}, {-24.75070, 169.87108}, {19.59415, 75.12872}}, {{1, 5}, {5, 8}, {2, 9}, {9, 2}, {11, 19}, {5, 16}, {4, 3}, {6, 17}, {1, 1.5}, {3, 2.9}, {2, 1.7}, {5, 5.3}, {11, 10.69}, {4, 3.94}, {9, 8.80}, {6, 5.7}, {8, 7.6}, {9.9, 8.8}} } {![enter image description here][19], ![enter image description here][20], ![enter image description here][21], ![enter image description here][22], ![enter image description here][23], ![enter image description here][24], ![enter image description here][25], ![enter image description here][26], ![enter image description here][27]} ##Improvements While the project did accomplish all of its goals, improvements can still be made. One way to improve this project is to continue to feed it more training data. The data for this project was gathered by finding as many of that type of chart as possible and decoding the chart into the data. As can be imagined, this approach is limited, and the training data is limited. A better approach would be to funnel multitudes of sorted data into the training sets. This project could further be improved by distinguishing variations in each type of graphic. For example, when dealing with a bar chart of multiple categories, either a stacked bar chart or a grouped one can be used. The two charts below both show the same data in different formats. Table[BarChart[RandomReal[1, {3, 3}], ChartLayout -> l], {l, {"Stacked", "Grouped"}}] ![enter image description here][28], ![enter image description here][29] Similarly, with scatter plots, the decision of whether or not to include a line of best fit could be considered. In the two examples below, a line of best fit would be more appropriate for the chart on the right as opposed to the one on the left. ![enter image description here][30] ![enter image description here][31] The initial planning for this project did include more detailed options, which can be seen in the flowchart below. Expanding on the initial flowchart could improve this project. ![enter image description here][32] Further improvements for this project would be including more types of graphics. Additional graphics that could be included are Gantt charts, gauge charts, Pareto Charts, area graphs, line histograms, polar area charts, Spie charts, and circular area charts. For more information on these types of charts, the links in section labelled "Background Info Links/References" can be studied. The following pages of early planning notes may also be helpful. ![enter image description here][33] ![enter image description here][34] ![enter image description here][35] ![enter image description here][36] ##Background Info Links/References [https://www.mymarketresearchmethods.com/types-of-charts-choose/][37] [https://eazybi.com/blog/data_visualization_and_chart_types/][38] [http://blog.visme.co/types-of-graphs/][39] Special thanks to Dariia Porechna and Katie Orenstein for their help. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=collage.jpg&userId=1371956 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bargraph1.jpg&userId=1371956 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bargraph2.jpg&userId=1371956 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=linegraph1.jpg&userId=1371956 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=linegraph2.jpg&userId=1371956 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=piechart1.jpg&userId=1371956 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=piechart2.jpg&userId=1371956 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=waterfallgraph1.jpg&userId=1371956 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=waterfallgraph2.jpg&userId=1371956 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=scatterplot1.jpg&userId=1371956 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=scatterplot2.jpg&userId=1371956 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bubblechart1.jpg&userId=1371956 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bubblechart2.jpg&userId=1371956 [14]: http://community.wolfram.com//c/portal/getImageAttachment?filename=histogram1.jpg&userId=1371956 [15]: http://community.wolfram.com//c/portal/getImageAttachment?filename=histogram2.jpg&userId=1371956 [16]: http://community.wolfram.com//c/portal/getImageAttachment?filename=geochart1.jpg&userId=1371956 [17]: http://community.wolfram.com//c/portal/getImageAttachment?filename=geochart2.jpg&userId=1371956 [18]: https://wolfr.am/w5hrqZM8 [19]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bargraph1.jpg&userId=1371956 [20]: http://community.wolfram.com//c/portal/getImageAttachment?filename=linegraph1.jpg&userId=1371956 [21]: http://community.wolfram.com//c/portal/getImageAttachment?filename=waterfallgraph1.jpg&userId=1371956 [22]: http://community.wolfram.com//c/portal/getImageAttachment?filename=linegraph2.jpg&userId=1371956 [23]: http://community.wolfram.com//c/portal/getImageAttachment?filename=piechart1.jpg&userId=1371956 [24]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bubblechart1.jpg&userId=1371956 [25]: http://community.wolfram.com//c/portal/getImageAttachment?filename=histogram1.jpg&userId=1371956 [26]: http://community.wolfram.com//c/portal/getImageAttachment?filename=geochart1.jpg&userId=1371956 [27]: http://community.wolfram.com//c/portal/getImageAttachment?filename=scatterplot1.jpg&userId=1371956 [28]: http://community.wolfram.com//c/portal/getImageAttachment?filename=stackedbar.jpg&userId=1371956 [29]: http://community.wolfram.com//c/portal/getImageAttachment?filename=groupedbar.jpg&userId=1371956 [30]: http://community.wolfram.com//c/portal/getImageAttachment?filename=scatterplot1.jpg&userId=1371956 [31]: http://community.wolfram.com//c/portal/getImageAttachment?filename=scatterplot2.jpg&userId=1371956 [32]: http://community.wolfram.com//c/portal/getImageAttachment?filename=functionplanning-1.png&userId=1371956 [33]: http://community.wolfram.com//c/portal/getImageAttachment?filename=page1.jpg&userId=1371956 [34]: http://community.wolfram.com//c/portal/getImageAttachment?filename=page2.jpg&userId=1371956 [35]: http://community.wolfram.com//c/portal/getImageAttachment?filename=page3.jpg&userId=1371956 [36]: http://community.wolfram.com//c/portal/getImageAttachment?filename=page4.jpg&userId=1371956 [37]: https://www.mymarketresearchmethods.com/types-of-charts-choose/ [38]: https://eazybi.com/blog/data_visualization_and_chart_types/ [39]: http://blog.visme.co/types-of-graphs/ Aparna Kumar 2018-07-13T19:34:29Z https://community.wolfram.com/groups/-/m/t/2251422 In a 2D space, we can use simple affine equations to create fractal shapes that resemble [Barnsley's Fern][1]. Now, there is something interesting about these shapes that is discussed in [a MathOverflow post][2]. It says: > If you allow for a larger class of functions (stochastic, 3-dimentional real maps, and introduce a log-density plot and color each point according to orbit history, the possibilities are endless (image created by Silvia Cordedda):<br/>![Fractal Flower][3] Now the problem is, recreating such images needs much more details that I am not aware of. Obviously, one cannot simply extend the generating equations of Barnsley's Fern to 3D and hope that something magical like this pops out. So I need some guidance from the experts on this site about this. Have you ever done something like this in Mathematica? (I have also asked this question on [Mathematica SE][4] which didn't attract any answers. So I decided to give it another try in here. Thanks in advance). [1]: https://en.wikipedia.org/wiki/Barnsley_fern [2]: https://mathoverflow.net/a/178471/93602 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=c.jpg&userId=2022885 [4]: https://mathematica.stackexchange.com/q/244957/37848 polfosol baltazar 2021-04-23T11:42:33Z https://community.wolfram.com/groups/-/m/t/2096163 I wanted to see if covariant and contravariant coordinates could be represented in Mathematica and settled on using underscripts and overscripts, since superscripts are exponents. I'm posting the notebook as images and also attaching it. You may have to magnify the page in your browser to be able to read the code in the images. ![enter image description here][1] ![enter image description here][2] ![enter image description here][3] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=3375schwarzschild1.jpg&userId=29126 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=schwarzschild2.jpg&userId=29126 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=schwarzschild3.jpg&userId=29126 Frank Kampas 2020-10-16T20:18:34Z https://community.wolfram.com/groups/-/m/t/1819304 # Introduction: (**My questions are at the end of the post**). To work with lists of 1 billion significant digits of a number, one option is to use [NumericArray\[\]][1], specifically with the option “*UnsignedInteger8*”, so that each digit will occupy only **1 Byte** instead of 8 Bytes, ie the consumption memory will be reduced by a factor of 8. Below is exemplified the use of NumericArray[] (new and experimental - v.12), both digits are generated with RealDigits[] and the number of Bytes are counted: ByteCount@RealDigits[Pi, 10, 1000][[1]] ![im1][2] ByteCount@ NumericArray[RealDigits[Pi, 10, 1000][[1]], "UnsignedInteger8"] ![im2][3] # Examples with one billion digits: Below are some examples with mathematical constants with one billion digits, in the case of Pi the time required to evaluate on my machine was about 35 minutes, but for other constants the time was varied, for: E, GoldenRatio, Sqrt2 the time was shorter, in descending order, while for EulerGamma I aborted the operation after about 5 hours. Note that the size of the operation is 10^9 Bytes, or 1 Gigabyte, but if not done this way, with NumericArray, would probably crash the system (+8Gb), at least on my machine. - Pi: EvaluationData[n = 1000000000; {num = NumericArray[RealDigits[Pi, 10, n][[1]], "UnsignedInteger8"], ByteCount@num}] ![im3][4] Counting the digits for each type, not in appearance order but in numerical order, I used Table[] and Lookup[] in Counts[]: counts = Table[{i, Lookup[Counts@(num // Normal), i]}, {i, 0, 9}] ![im4][5] Testing the result with Part[]: num[[;; 10]] // Normal ![im5][6] num[[857897882 ;; 857897899]] // Normal ![im6][7] num[[1000000000]] ![im7][8] Note that above the significant billionth digit (taking into account the "3" on the left) of Pi is "1" and is different from the billionth digit of Pi, which is "9". All values can be checked by downloading some constants with billion digits from this [site][9], and can be by torrent (about 10 Gigabytes). Below are the result of some more numbers with one billion digits: - E: ![im8][10] - GoldenRatio: ![im9][11] - Sqrt2: ![im10][12] # List and graph of results: - List: cPi = {{0, 99993942}, {1, 99997334}, {2, 100002410}, {3, 99986912}, {4, 100011958}, {5, 99998885}, {6, 100010387}, {7, 99996061}, {8, 100001839}, {9, 100000272}}; cE = {{0, 100004425}, {1, 99982925}, {2, 99999169}, {3, 100002498}, {4, 100018922}, {5, 100003884}, {6, 99987241}, {7, 99997536}, {8, 100005348}, {9, 99998052}}; cGolden = {{0, 100007840}, {1, 99999865}, {2, 100002106}, {3, 99979351}, {4, 99995481}, {5, 99999934}, {6, 100004208}, {7, 100018237}, {8, 99995223}, {9, 99997755}}; cSqrt2 = {{0, 100010228}, {1, 99998382}, {2, 99995644}, {3, 99995415}, {4, 100012725}, {5, 100002636}, {6, 100012683}, {7, 99980315}, {8, 99995120}, {9, 99996852}}; - Graph (%/100): c1 = Table[N[cPi[[i, 2]]/10^9], {i, 1, 10}]; c2 = Table[N[cE[[i, 2]]/10^9], {i, 1, 10}]; c3 = Table[N[cGolden[[i, 2]]/10^9], {i, 1, 10}]; c4 = Table[N[cSqrt2[[i, 2]]/10^9], {i, 1, 10}]; ListLinePlot[{c1, c2, c3, c4}, PlotLegends -> {"Pi", "E", "Golden", "Sqrt2"}, ImageSize -> Large] Do[Print[Map[ PieChart[#, SectorOrigin -> {Automatic, 1}, LabelingFunction -> "RadialOutside", ChartLegends -> {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, ChartStyle -> "Pastel", PlotLabel -> s /. {1 -> Text[Style["Pi", Large, Bold]], 2 -> Text[Style["E", Large, Bold]], 3 -> Text[Style["GoldenRatio", Large, Bold]], 4 -> Text[Style["Sqrt2", Large, Bold]]}] &, {c1, c2, c3, c4}][[s]]], {s, 1, 4}] ![im11][13] ![im12][14] # Questions for the community: - **Question 1**): Does Mathematica already use the fastest method to calculate EulerGamma digits (I aborted after more than 5 hours)? - **Question 2**): Compiling NumericArray[] ([compiled type][15]) is set to new in V.12. **Below is my attempt**, did I do it right? How do I get the most out of this feature (my attempt got the same time and byte performance as NumericArray in the normal way)? How does it work? cf = FunctionCompile[ Function[Typed[arg, TypeSpecifier["NumericArray"]["UnsignedInteger8", 1]], arg]] ![im13][16] EvaluationData[n = 1000000000; {z = cf[NumericArray[RealDigits[Pi, 10, n][[1]], "UnsignedInteger8"]], ByteCount@z}] ![im14][17] Does anyone in the community know to answer any of the above questions to help me? Thanks. [1]: https://reference.wolfram.com/language/ref/NumericArray.html [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=i0a.png&userId=1316061 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=i0b.png&userId=1316061 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=10998i1.png&userId=1316061 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=5541i2.png&userId=1316061 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2040i3.png&userId=1316061 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=7463i4.png&userId=1316061 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=4903i5.png&userId=1316061 [9]: https://archive.org/details/Math_Constants [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2464i6.png&userId=1316061 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=6612i7.png&userId=1316061 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=7960i8.png&userId=1316061 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=i8aa.png&userId=1316061 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=i8a.png&userId=1316061 [15]: https://reference.wolfram.com/language/ref/compiledtype/NumericArray.html [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=4787i9.png&userId=1316061 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=4196i10.png&userId=1316061 Claudio Chaib 2019-11-04T18:41:44Z https://community.wolfram.com/groups/-/m/t/1382967 I was assigned by Stephen Wolfram to create a sorting a network that could sort a specific list. To do this, I started by analyzing the optimal sorting network for a list of 16 items, which is in fact, the largest solution that humanity has found so far. ![This is 16][1] in the image above, there are two boxes, I noticed the pattern in the smallest of the two first, which in every optimal sort I checked, was used off the bat to group up sets of 4. ![this is 7][2] Next, by analyzing 14,15 and 16, 14, and 15 shown below. ![enter image description here][3] I derived a pattern for what was happening in the larger boxes, namely, there are beams of length 2^n or of the form {1+c,2^n+c} where c mod(2^(n+1)) <2^n. After this, I was prompted to create an algorithm that could automatically create a list of list of pairs that specified these connections. Essentially, I was looking for something of the form {{1,2},{3,4},{5,6},{7,8},{1,3},{2,4},{5,7},{6,8},{1,5},{2,6},{3,7},{4,8}}. The code to do this was complicated, though through perseverance I successfully did it. The code is shown below: function1[distanceBetweenEle_, list_, finalList_] := (Module[{arc, apair, apairamid, pairs}, Partition[list, distanceBetweenEle, distanceBetweenEle]; apair = Part[Partition[list, distanceBetweenEle, distanceBetweenEle], Span[1, -1, 2]]; Map[{#, # + distanceBetweenEle} &, Flatten[apair]]; apairamid = Map[ Function[ {itemInList}, {itemInList, itemInList + distanceBetweenEle} ], Flatten[apair] ]; pairs = Select[ apairamid, Function[ {item}, Not[Part[item, 2] > Length@list] ] ]; arc = Join[finalList, pairs]; If [(Length[list] + 1 > distanceBetweenEle*2), function1[distanceBetweenEle*2, list, arc], Return[arc]; ]]) This was a great start. Though we now had to figure out what to do for the second half of the list. So let us take a look at the ends of the optimal algorithm for 14th 15 and 16 elements. ![This is the ends of 14-16][4] The first thing that most people should notice is that the connections follow no clear pattern. Despite this, there is one portion we will be able to exploit. If you look at the images above, you will notice that all new connections originated from the new segments. We can exploit this and proceed to only check connections from the old segment. The code for how I did this is below. ClearAll[thingsToCheck] thingsToCheck[L_, list_List, nope_] := Insert[list, {L, nope}, {#}] & /@ Prepend[(First /@ Position[list, L | 1] + 1), 1] ClearAll[mainFunction] mainFunction[L_, list_List] := Select[Flatten[thingsToCheck[#, list, L] & /@ Range[1, L - 1], 1] // DeleteDuplicates, Length[#] === Length[Split[#]] &] Finally, I needed to implement a checker to check if the list could be sorted. No exploits were used for this segment, though in the future, presorting the first half could simplify the checker and would allow for greater number of checked permutations. The code is shown below. ClearAll[swap] swap[list_, {n_, m_}] := If[list[[n]] > list[[m]], ReplacePart[ list, {n -> Part[list, m], m -> Part[list, n]} ], list ] ClearAll[allSwapInstructions] allSwapInstructions[swapInstruc_, id_] := Fold[swap, id, swapInstruc] ClearAll[checker] checker[swapInstruc_, L_, id_] := Range[L] === allSwapInstructions[swapInstruc, id] Finally, we devised a final code snippet that connected all previous codes segments together: ClearAll[theOnesThatWork] theOnesThatWork[list_List, len_, id_, firstHalf_] := SelectFirst[Join[firstHalf, #] & /@ list, checker[#, len, id] &] And we were done. Some testing is shown below: id = {5, 2, 4, 1, 3}; step1 = mainFunction[5, {{2, 3}}] theOnesThatWork[step1, 5, id, function1[1, Range@5, {}]] step2 = Flatten[mainFunction[5, #] & /@ step1, 1]; theOnesThatWork[step2, 5, Reverse[Range[5]], function1[1, Range@5, {}]] Special thanks to http://demonstrations.wolfram.com/SortingNetworks/ [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ihasuhthzzzz.png&userId=1372143 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=7.png&userId=1372143 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=14and15.png&userId=1372143 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Endsof456.png&userId=1372143 Sasha Kucher 2018-07-13T19:59:16Z 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 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/935721 I'm interested in learning how to get started in electronic publishing in Mathematica. I'm creating supplements for my differential equations course to teach the relevant mathematics and Mathematica coding simultaneously. I'd like to be able to distribute these notebooks to a wider audience, but am unsure the best way to proceed. The Mathematica supplement for the first section is attached for your interest (note: it's longer than most of the notebooks will be because I have a lot of content related to list operations that won't typically be there). Bill Kinney 2016-10-06T21:17:04Z https://community.wolfram.com/groups/-/m/t/832567 Hi all, I'm pretty new to the Machine Learning package in Mathematica, and so far I like how easy it is to use. However, one thing that I wish it had was more information about how mathematica is treating high-dimensional datasets. In particular, I would like to be able to understand which features are relatively more or less important in the classification model. For example, I have a 34-dimensional dataset of clinical variables for patients who either did or did not respond to cancer treatment. The classifiication label being used is 'CR' for complete response and 'RESISTANT' for resistant to treatment. trainSet = Import["TrainSetCR.mx"]; validationSet = Import["ValidationSetCR.mx"]; I am using `Classify` to train both Logistic Regression and Random Forest classifiers for these data. I can get some high-level information about the classifiers produced using these methods with the `ClassifierInformation` function, but I would like to understand how the classifier is treating each feature. For Logistic Regression, I can use the `Function` property to get the function the classifier is using, but it is hard to understand. CRClassifier = Classify[trainSetCR, Method -> "LogisticRegression"]; ClassifierInformation[CRClassifier] CRClassifierProperties = ClassifierInformation[CRClassifier, "Properties"] ClassifierInformation[CRClassifier, "Function"] ClassifierMeasurements[CRClassifier, validationSet] /@ {"Accuracy", "ConfusionMatrixPlot"} For Random Forest, I cannot find any property that would allow me to understand how each feature is being used to classify the data. CRClassifier = Classify[trainSetCR, Method -> "RandomForest"]; ClassifierInformation[CRClassifier] CRClassifierProperties = ClassifierInformation[CRClassifier, "Properties"] ClassifierMeasurements[CRClassifier, validationSet] /@ {"Accuracy", "ConfusionMatrixPlot"} I really do enjoy using the Machine Learning package in Mathematica because it is easy to configure and try various machine learning techniques. However, I think the package could do a little bit better at allowing users to understand how these models are treating various features. I've attached my dataset and mathematica notebook for any who would like to look at the data. Any suggestions on how I could approach understanding these models in greater depth would be greatly appreciated. Brady Hunt 2016-03-31T15:02:37Z https://community.wolfram.com/groups/-/m/t/602402 Awhile ago I wrote the Demonstration [Packing Squares with Side 1/n](http://demonstrations.wolfram.com/PackingSquaresWithSide1N/). It is based on the Paulhus* method, which starts with a rectangle slightly larger than all the fractional squares, then packs all the squares into it via a clever method. $$\sum\limits_{a=2}^\infty \frac{1}{a^2} = \frac{\pi^2}{6}-1 \approx 0.644934067 \approx 0.644934069 \approx \frac{545}{467} \times \frac{21}{38}$$ ![Method of Paulhus][1] Oblongs of size $ \frac{1}{1} \times \frac{1}{2}$, $ \frac{1}{2} \times \frac{1}{3}$, $ \frac{1}{3} \times \frac{1}{4}$, $ \frac{1}{4} \times \frac{1}{5}$, ... have a total area of 1. $\sum\limits_{a=1}^\infty \frac{1}{a (a+1)} =1$ I believe it's still an unsolved question whether the infinite rectangles can fit in the unit square. If it's been solved, I'd love to see the paper. Anyways, I haven't figured out how to modify my code to intelligently handle oblongs instead of squares. Can anyone figure that out and use the code to pack the first 2000 oblongs in the unit square? (*) M. M. Paulhus, "An Algorithm for Packing Squares," Journal of Combinatorial Theory, Series A, 82(2), 1998 pp. 147–157. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=PaulhusPacking.gif&userId=21530 Ed Pegg 2015-10-30T15:32:06Z 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/323630 I'm new to using Wolfram Alpha for teaching, having switched from Maple. When teaching calculus with Maple in our computer lab, I had students use the "changevar" command as a tool for gaining an intuition of what makes an appropriate substitution when discussing the integration by substitute method. For example, >Original:=Int((cos(x)+1)^3*sin(x),x) > New:=changevar(cos(x)+1=U,Original,U) takes the original integral and constructs a new integral in terms of the variable, U. The idea is to get students to experiment with various choices for U, see what works best, and perform the algebra/substitution details outside of class. There is an analogous tool for integration by parts. Are there similar commands in Wolfram Alpha? Paul Fishback 2014-08-18T21:29:10Z https://community.wolfram.com/groups/-/m/t/3106777 With versions 13, and 14 SurfaceIntegrate simplifies a lot of writing. Is it possible to use spherical or other non-Cartesian coordinate charts. Here's just a simple example: SurfaceIntegrate[ Grad[1/r, {r, \[Theta], \[Phi]}, "Spherical"], {r, \[Theta], \[Phi]} \[Element] Sphere[]] Frank Kuehnel 2024-01-21T23:44:50Z https://community.wolfram.com/groups/-/m/t/2949003 I was puzzled by Daniel Lichtbau’s comments on PCA (Principal **Componen**t Analysis). He demonstrated that the PrincipalComponents function is **not** what it is called and it does the Principal **Coordinate** Analysis. https://community.wolfram.com/groups/-/m/t/2943840 This is confusing and disturbing because I consider PCA or SVD as the most important method that connects Engineering, statistics and other diciplines. I tried to use the PrincipalComponents function in the past and found that it did not provide the loading vector (V) so I use the SingularValueDecomposition function instead. In summary, the SingularValueDecomposition function should be used for PCA and WL does not have a function for PCA now. 1. The PrincipalComponents should be renamed as Principal Coordinate Analysis (Daniel Lichtbau found) 2. **Most importantl**y, it would be great if WL shows the "V" for PCA and other dimension reduction methods such as multidimensional scaling. Without the "V”, we don't know how the reduced vectors are derived (it is a black box and it is like "WL says just use it"). I found that applying the Normal function to the DimensionReducerfunction (e.g., dimredLSA//Normal) show detail information but I don’t believe I understand them. &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/d3cb46b5-c99d-4cfc-8f7e-0046ade951f9 Sangdon Lee 2023-06-30T17:36:53Z https://community.wolfram.com/groups/-/m/t/2862059 I used these examples today when I taught the monotonicity of functions so that my students could better understand the concepts of increasing and decreasing functions. Both will appear in almost every section in a Calculus class and probably in other classes too, so you should be able to deal with them. In mathematics, a monotonic function (or monotone function) is a function between ordered sets that preserves or reverses the given order. This concept first arose in calculus and was later generalized to the more abstract setting of order theory. ---------- ## Definition of increasing functions# A function is called monotonically increasing (also increasing or non-decreasing) if for all $x$ and $y$ such that $x\leq y$ one has $f\left(x\right) \leq f\left(y\right)$, so $f$ preserves the order - **Example 1** Examine the monotonicity of the function $$f(x)=4x-7$$ The domain of the function is $D_f=\mathbb{R}$. Let $x_1,x_2 \in D_f $ and $x_1<x_2$, then we have: $$\begin{align} x_1&<x_2 \\ 4x_1&<4x_2 \\ 4x_1-7&<4x_2-7 \\ f(x_1)&<f(x_2) \end{align}$$ Hence the function $f(x)$ is increasing on $D_f$ ResourceFunction["FunctionMonotonicity"][4 x - 7, x, All] ![enter image description here][1] - **Example 2** Examine the monotonicity of the function $$f(x)=(x-1)^2-1, \quad x> 1$$ The domain of the function is $D_f=(1,\infty]$ Let $x_1,x_2 \in D_f $ and $x_1<x_2$, then we have: $$\begin{align} x_1&<x_2 \Rightarrow \\ x_1-1&<x_2-1 \Rightarrow \\ (x_1-1)^2&<(x_2-1)^2 \Rightarrow \\ (x_1-1)^2-1&<(x_2-1)^2-1 \Rightarrow \\ f(x_1)&<f(x_2) \end{align}$$ Hence the function $f(x)$ is increasing on $D_f$ ResourceFunction["FunctionMonotonicity"][(x - 1)^2 - 1, x, All] ![enter image description here][2] ---------- ## Definition of decreasing functions ## A function is called monotonically decreasing (also decreasing or non-increasing) if, whenever $x\leq y$, then $f\left(x\right) \geq f\left(y\right)$, so it reverses the order - **Example 3** Examine the monotonicity of the function $$f(x)=2-x^3$$ The domain of the function is $D_f=\mathbb{R}$. Let $x_1,x_2 \in D_f $ and $x_1<x_2$, then we have: $$\begin{align} x_1&<x_2 \Rightarrow \\ x_1^3&<x_2^3 \Rightarrow \\ -x_1^3&>-x_2^3 \Rightarrow \\ 2-x_1^3&>2-x_2^3 \Rightarrow \\ f(x_1)&>f(x_2) \end{align}$$ Hence the function $f(x)$ is decreasing on $D_f$ ResourceFunction["FunctionMonotonicity"][2 - x^3, x, All] ![enter image description here][3] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2023-03-30at2.53.30AM.png&userId=2600850 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2023-03-30at2.55.12AM.png&userId=2600850 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2023-03-30at2.56.20AM.png&userId=2600850 Athanasios Paraskevopoulos 2023-03-30T00:05:51Z https://community.wolfram.com/groups/-/m/t/2717455 hello, i am new in Mathematica and would like to plot the orbits as shown in the 2 photos attached i have also attached a notebook with what I have. &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/6dfd55aa-675f-4f73-8c37-444eea3e5206 Adika stadevant Okelo 2022-12-05T22:05:48Z