10 and 15 are presets. Non-presets (including 13) follow the following formula:

 iSpherePoints[n_Integer] := Block[{offset, r, z, NKSSpecialFunctions`SpherePoints`Dump`\[Phi]},
    offset = 2. / (n + 2);
    z = ((Range[n] * offset) + offset / 2.) - 1;
    r = Sqrt[1 + -(z ^ 2)];
    NKSSpecialFunctions`SpherePoints`Dump`\[Phi] = Range[n] * N[GoldenAngle];
    Transpose[{r * Cos[NKSSpecialFunctions`SpherePoints`Dump`\[Phi]], r * Sin[NKSSpecialFunctions`SpherePoints`Dump`\[Phi]], z}]
 ];

which works very nice for large n.

I mean, we could make an WFR function that does it better and with different metrics… Like most uniform area, or smallest standard deviation between angles of nearest neighbours, or …

–SH

Where do you paste it?

Issue with RelationalDatabase and searching for a substring in a property.

With a Wolfram provided entityclass the search of a substring in a property works. Example:

Quiet@EntityList[
  FilteredEntityClass["Aircraft", 
   EntityFunction[c, 
    StringMatchQ[c["Manufacturer"], ___ ~~ "Boei" ~~ ___]]]]

Now lets try with an entityclass created from an external database. Created a very simple table "Employees" with two fields: "employeeID" and "fullname", added five records.

This was done with both mySQL and Microsoft SQL

dc = <|
   "Backend" -> "mysql",
   "Name" -> name,
   "Port" -> port,
   "Host" ->, host,
   "Username" -> username,
   "Password" -> pwd
   |>;
dr = DatabaseReference[dc];
rd = RelationalDatabase["Employees", dr];
store = EntityStore[rd];
EntityRegister[store]
(*Employees*)

Testing connectivity

EntityValue[Entity["Employees"], "Properties"]
(*{EntityProperty["Employees", "employee_ID"], EntityProperty["Employees", "full_name"]}*)
EntityValue[EntityList["Employees"], {"employee_ID", "full_name"}]
(*{{1, "Diego Maradona"}, {2, "John Doe"}, {3, "Jane Doe"}, {4, 
  "Diego Rivera"}}*)
EntityList[
 FilteredEntityClass["Employees", 
  EntityFunction[c, 
   StringMatchQ[c["full_name"], ___ ~~ "Doe" ~~ ___]]]]
(*EntityValue: Generic Database error/*)
(*Failure["DatabaseFailure", 
 <|"MessageTemplate" :> "1305 FUNCTION database.REGEXP_LIKE does not exist", 
  "MessageParameters" :> Association[], "FailureCode" :> "InternalError", 
  "SQLString" :> "SELECT `Employees_T28`.`employee_ID` AS `employee_ID` \nFROM `Employees` AS \
`Employees_T28` \nWHERE REGEXP_LIKE(`Employees_T28`.full_name, %(param_1)s, %(REGEXP_LIKE_1)s) \
= 1", "SQLParameters" :> Association["param_1" -> "^.*Doe.*$", "REGEXP_LIKE_1" -> "cm"]|>]*)

If you filter mathematica stackexchge for posts having the tag “bugs” you get 1529 posts with 96 from this year. Have these been reviewed by Wolfram?

See https://mathematica.stackexchange.com/a/118866/5478

Net Train cannot handle large datasets in V12 while it was fine in V11 CASE:4268171

identical neural nets with identical data causes a memory overflow somewhere in the internal fucntions.

V11

V12

DegreeGraphDistribution misbehaves

DegreeGraphDistribution is effectively undocumented. There is no clear statement in the docs about what it is supposed to mean. I can't even decide if certain behaviours are bugs or not.

(Of course, using our common sense we can see that these behaviours are clearly bugs. However, when reporting issues with Graph it is often a requirement to stick to the letter of the documentation.)

However, after a lot of guesswork, I suspect that:

• It should sample uniformly from the set of graphs with a given degree sequence. Confirming of correcting this was outright refused by the developer when contacted through support. A simple test shows that it does not in fact sample uniformly. I can't even decide if this is a bug because of no documentation and no support (perhaps the sampler is meant to be approximately uniform only?)

• For non-graphical sequences, it samples non-uniformly (not even approximately) from non-simple graphs. Again, answers to any questions about this were plainly denied. A typical answer is "no information is available".

• Without a proper definition, I am completely lost when trying to figure out how this should work with functions like GraphPropertyDistribution

• The syntax for directed graphs is again undocumented

The situation has been like this for many years, and nothing has changed after many reports. This is symptomatic of how problems with Graph are handled in general.

Related: https://community.wolfram.com/groups/-/m/t/1756560?p_p_auth=QIf48N5F (Note: still no response.)

• In my opinion NumericArray would be very useful - if one could fully use it, see e.g. this discussion;
• The frequent occurrence of functions qualified as "EXPERIMENTAL" (in particular in v12) unsettles me a bit;

• I would like to see a consistent behavior when plotting functions with quantities (there was a former post about this I cannot find), e.g.:

  f[Quantity[x_, "Meters"]] := Quantity[x^2, "Joules"]
  
  Table[f[x], {x, Quantity[0, "Meters"], Quantity[10, "Meters"]}] (* does work *)  
  Plot[f[x], {x, Quantity[0, "Meters"], Quantity[10, "Meters"]}]  (* does not work *)
  (* possible workaround: *)
  ListLinePlot[Table[{x, f[x]}, {x, Quantity[0, "Meters"], Quantity[10, "Meters"]}], AxesLabel -> Automatic] 
  

Wolfram Workbench throws errors for single stepping unless the code contains at minimum an undocumented number of lines.

[CASE:4286463] Error with Histogram

Attachments:

Error with Histogram.nb

Some explicit examples would be useful here because there are 10s of formats…

Related to Kirk's post above, MMA has a huge shortcoming with 2D plotting. In addition to zooming and panning, The plot functions fail on large datasets. For example, I plotted a 30 million point data set in MATLAB and it was fine. I could zoom in and out, etc. I plotted a 30 million point dataset in Wolfram SystemModeler and similarly had no issues. I tried a 30 million data point set in MMA and brought the system to its knees. I had to write a decimation program (based on a stackexchange post) that automatically "Enveloped" the data, reducing the number of points in the plot. MMA should do something like this automatically (or take an option like "AutoDecimate") while allowing zooming in (with each zoom you can then increase the resolution to combine detailed viewing with fast interface response).

Regards,

Neil

This one is the posted [solution][1] to SW's EIWL exercise 22.13.

NearestNeighborGraph[
 Table[Rasterize[Style[FromLetterNumber[n], 20]], {n, 26}], 2, 
 VertexLabels -> All]

Reported to WRI July 31, 2018: CASE:4093797. Not fixed in 12.0. I don't think it is a serious issue but SW may think otherwise since it is in his book.

For this one I got an email from support on Aug 8, 2019

[CASE:4287750] The current Mathematica addresses an issue you reported

In February 2018 you reported an issue with Mathematica wherein GeoHistogram was failing with weighted data in certain instances. We believe that the issue has been resolved in the current 12.0 release of Mathematica.

It is actually not fixed in 12.0. I consider this to be a much more serious issue. User reported an issue with an attached notebook to reproduce it and receives an email that it has been fixed, but it has not been fixed. Clearly something is broken in WRI's issue management / QA process.

I also posted the example that fails on [MSE][2].

Hi Peter,

Thank you for explaining the reason for the erroneous email that I received. I think WRI would benefit from making the issue/bug management process more transparent and exposed.

The MSE community has discussed this here. Patrick Scheibe has a well thought out post on how WRI and its users could benefit from this.

I look forward to WRI seriously considering these options and implementing a better and more transparent issue/bug management and QA process.

Rohit

Hi Arnoud,

That is really good to hear. Yes, I would be interested in joining the prerelease program.

Thanks, Rohit

The false-positives of the Dataset type system can be quite annoying, especially since it fails with a single Failure object instead of the usual messages. One frequent issue for me is the fact that variables can't be used as Part specifications:

Dataset[{1, 2, 3}][Table[#[[i]], {i, 3}] &]
(* Failure["i is not a valid Part specification"] *)

And another one with the Geo functions, GeoHistogram fails with WeightedData and GeoRange:

GeoHistogram[
 WeightedData[
  CountryData["UnitedStates", 
   "LargestCities"], #["Population"] &], 
  GeoRange -> 
  Entity["AdministrativeDivision", {"California", "UnitedStates"}]]

I think the WeightedData case is used more often than the "list of GeoPositions" case (at least for me) and it would be great to see this fixed. Related: https://mathematica.stackexchange.com/questions/190697/geohistogram-with-georange-fails-with-weighteddata/190704#190704

@Arnoud Buzing And another one related to region. See attachment.

Attachments:

RegionDifference.nb

I can work around most little bugs I run into in the core Kernel itself--and Kernel bugs just make me reimplement functionality, which means I have a more robust implementation that I understand in the end--but there are many things in the FE I can't work around, almost entirely related to Dynamic and its brethren as there is no way to really robustly control the FE from the WL at the low level (even using undocumented functions).

I'd really like a discussion, then, of the generally poor performance of Dynamic and the crazy work-arounds one has to do to make it clean.

Here's one such issue. First I make a Dynamic which uses a TaggingRule to listen for a specific key:

Dynamic[
 {
  RandomReal[],
  CurrentValue[
   EvaluationNotebook[], 
   {TaggingRules, "test"}
   ]
  }
 ]

Then if I update a completely unrelated key, that Dynamic gets updated, e.g. by:

CurrentValue[
  EvaluationNotebook[], 
  {TaggingRules, "not-test"}
  ] = 1

I emailed John Fultz about this and he said the best option was something like:

DynamicModule[{cachedValue},
 DynamicWrapper[
  Dynamic[
   {
    RandomReal[],
    cachedValue
    }
   ], cachedValue = CurrentValue[EvaluationNotebook[], {TaggingRules, "test"}]]
 ]

which kinda works in this case but which is definitely not scalable and I'm not even convinced is robust in the more complicated workflows I want to build.

Long term I want to be able to use the FE as an IDE with efficient tab management, toolbars, file browsing, extension-specific stylesheets, etc.

I have all the infrastructure for this and I use it day-to-day, but the FE is too slow to really encourage other people to use it--and much of the reason for this is in the poor performance of Dynamic (there are other issues like the fact that NotebookWrite is ridiculously slow, but that's probably harder to fix).

@Arnoud Buzing Here is a nice one:

Graphics3D /@ NestList[BeveledPolyhedron[#, 0.1] &, Dodecahedron[], 3]