Wolfram Mathematica

J. M. is slightly pensive

1:54 AM

It looks like you can just do robustScale[list_] := Standardize[list, Median, {-1, 1}.Quantile[#, {1/4, 3/4}]/2 &].

C. E.

2:16 AM

@J.M.isslightlypensive Do you know where the /2 comes from?

J. M. is slightly pensive

2:44 AM

@C.E. Yes, that part is peculiar. An answer would prolly involve looking at the implementation in scikit.

Pinti

7:33 AM

@b3m2a1 I would be also interested in some additional explanation of FEPrivate`* and related stuff. I saw that you already have a placeholder for this in "mresources" tutorial.

kirma

8:02 AM

Still holding breath while waiting for v12... wonder how many months past the optimistic projections it will be this time.

Lukas Lang

8:19 AM

@b3m2a1 It's doing both old and new style indices - so no "Updating search indexes" when opening it for the first time in 11.2/11.3

Carl Lange

9:37 AM

@kirma Next week?

Kuba

@LukasLang Thanks. I need to think more about what I need. Adding keys in 'datasets' nested in associations is one thing but I also encountered a problem with how to multiply 'dataset's' column by a column when the dataset is nested in association like in the former cases. Which all is easy with arrays but the problem is I'd need to work with indices not keys :(

kirma

10:15 AM

@CarlLange Let's hope so... :)

Chris K

11:27 AM

@LukasLang When making documentation with your ForScience`PacletUtils, is it all programmatic or can you just edit a page like with DocumentationTools and Workbench?

Lukas Lang

@Kuba Can you give a more concrete example of what you mean by "multiply dataset's column by..."? I'm not sure I can fully follow your description

Kuba

asso[["hts", All, "a"]] *= {0, 5} (*assuming All is 1;;2*)

@LukasLang ^

Lukas Lang

@ChrisK The documentation pages are generated from scratch each time something changes, so editing them manually is not really an option. (You could of course generate them to some directory, modify them, and put them into the real paclet directory, but that'd probably be quite messy with how things are at the moment). The goal was to support the generation everything that's necessary directly from code so that everything is in one place

@Kuba Is this the result you meant?

<|"hts" -> <|"nb" -> <|"a" -> <|"nb" -> {0, 5}, "nb2" -> {0, 5}|>,
     "b" -> 2|>,
   "nb2" -> <|"a" -> <|"nb" -> {0, 5}, "nb2" -> {0, 5}|>,
     "b" -> 2|>|>|>

Or was the code you posted just intended as pseudo-code?

Lukas Lang

11:54 AM

I assume this is the output you're after, right?

<|"hts" -> <|"nb" -> <|"a" -> 0, "b" -> 2|>,
   "nb2" -> <|"a" -> 5, "b" -> 2|>|>|>

Kuba

@LukasLang yes, my code was a wish

The latter block is what I am after

If *= {0, 5} case is to problematic even an answer to *= 2 would be nice

Szabolcs

12:14 PM

@LukasLang How realistic would it be to do a reverse conversion from an existing notebook to your markup language, which in turn would be convert to doc pages?

I am interested in this, but I am very cautious about starting to use any one technology. I can't afford to invest into something then discover that it can't handle everything I need and can't be fixed or much worse: that it stops being maintained a year from now on. This is always a high risk with stuff that's maintained by a single person.

The cost of migrating to a different technology is usually very high. One thing that can create some security is to reduct the migration costs in some way. E.g. "I don't have to worry because even if this fails in the future, it has an exporter to Markdown/Workbench doc notebooks/Whatever.

I have been looking at @b3m2a1's tools and now I am also looking at your tools. My worry in both cases is that it might be very expensive (= take a lot of time) to migrate to your method of creating docs, but then I might be forced to migrate away again in the future (or to take over the development of the doc generator or similar).

If you look at IGraph/M's documentation, you will see that from the tech perspective it's really bad. It's just a single long notebook with many sections.

Why?

Because I don't trust the Workbench doc tools either. What if they come out with a new Workbench version that break something and breaks compatibility with an older M version that I need? There's already partial breakage from M11.1 onwards ...

With small packages like BoolEval or MaTeX it's less risky. But IGraph/M is just too big to take this risk ...

... unless ...

there is a safe way out and an easy way in: i.e. both starting to use the tools is cheap and there are several ways to export to other formats which I can think of as future assurance

The big problem is that currently there is not a single tool that I trust this way. Looking at you, WRI!!

4

I'd go with WRI's tools but they're too complex and already too buggy. Just look at the sources, it's a hot mess. I already need to post-process the result and fix multiple issues.

If at least they were simple I'd have some confidence that I can fix issues myself in the future.

That's why I'm attracted to simple markup languages like Markdown or what you created here

Kuba

1:25 PM

Does it make a performance difference when the function working on big data has a Hold* attribute?

e.g.

foo[ data_ ]:= data[[99]] + data[[100]]

Chris K

@Szabolcs I'm in the same boat, except I'm less able to tweak things myself

Kuba

I thought it will be faster with HoldAll, it is not though.

Chris K

Workbench/DocumentationTools is a bit clumsy but it gets me 95% of where I want to go

1010011010

Hi everybody,

FindRoot somehow decides to divide by zero when I pass my systems of equations

Chris K

the remaining 5% -- cross-version compatibility, removing broken URL dropdown, adding details thumbnail or something -- I'm stuck

sounds like Wolfram is working on something in the near-ish future, but what and when?

1010011010

1:31 PM

What can I do about it? How does the searching algorithm work?

Chris K

if it is as easy to edit as the function repository templates, that'd be OK with me

kirma

2:04 PM

@1010011010 Have you tried different values of Method option?

Szabolcs

2:36 PM

@Kuba Do you know if it's possible to install paclets system-wide, similar to $BaseDirectory vs $UserBaseDirectory?

I guess the only way is to extract into $BaseDirectory.

@ChrisK If they don't break compatibility with older versions, that would give me some confidence to move to using the Workbench.

Kuba

@Szabolcs You could try to block PacletManager`Package`$userRepositoryDir to be $BaseDir / Paclets / Repository but I have not tried it.

see more in: https://github.com/kubaPod/MPM/blob/master/MPM/MPM.m#L298

Szabolcs

3:18 PM

OK, so no non-hackish way then.

Lukas Lang

3:29 PM

@Kuba What about something like this?

Merger[op_, pos : _Integer | _String | _Key][{data_, operand_}] :=
 MapAt[op@{#, operand} &, data, pos]
Merger[op_, pos_][{data_, operand_Association}] :=
 Merge[{data, operand}, op]
Merger[op_, pos_][{data_, operand_}] :=
 MapAt[op@{#, operand} &, data, pos]

ModifyParts[dataset_, pos_, operator_, operand_] :=
 Fold[Merger, Apply[operator], Reverse@pos][{dataset, operand}]
ModifyParts[pos_, operator_, operand_][dataset_] :=
 ModifyParts[dataset, pos, operator, operand]

ModifyParts[default, {"hts", All, "a"}, Times, <|"nb" -> 0,

The only condition is that the operator must not do anything for one argument

First I thought about using `Merge` on its own, e.g. as `Nest[Merge, Apply[Times],
3]@{asso, <|"hts" -> <|"nb" -> <|"a" -> 0|>, "nb2" -> <|"a" -> 5|>|>|>}` (which is what I frequently use), but for your structure it is a bit tedious...

The nice this about the merge approach is that keys don't have to be present in both associations:

Merge[Total]@{<|"a" -> 1, "b" -> 2|>, <|"b" -> 2, "c" -> 3|>}
(* <|"a" -> 1, "b" -> 4, "c" -> 3|> *)

Or, for subtracting things:

Merge[Total]@{<|"a" -> 1, "b" -> 2|>, -<|"b" -> 2, "c" -> 3|>}
(* <|"a" -> 1, "b" -> 0, "c" -> -3|> *)

Lukas Lang

3:53 PM

@Szabolcs In general, it will probably be quite tricky to convert notebooks to the markup language used by my documentation builder. But looking at your IGraph/M notebook, it should be possible to write a rather simple converter to get one/several tutorial pages. The doc page templates you have e.g. for the MaTeX paclet should also be convertible. I'll take a closer look and let you know if I manage to get acceptable results.

Szabolcs

4:32 PM

Did anyone else know that a double-Condition was also allowed in Block/Module? I have only ever used single ones.

Clear[myfun]
myfun[x_] := Module[{a, b},
  a = x;
  Condition[
   b = a^2;
   b /; (b > 1/4),
   (a < 1)
   ]
  ]

Szabolcs

4:45 PM

(Note: myfun[x] will evaluate only if x is a number between 0.5 < x < 1.0.)

L.K.

5:15 PM

I'm facing a problem with the density plot, for e.g
`ListDensityPlot[
Table[Sin[j^2 + i], {i, 0, Pi, 0.02}, {j, 0, Pi, 0.02}],
PlotLegends -> Automatic]`
Is there away to get large axes labels, with large ticks label?

Jason B.

5:39 PM

@Szabolcs - my experience is you can nest those conditions arbitrarily deep. The graph functions that are in top level take advantage of this

myfun[x_] :=
Module[{a, b, c},
a = x; (Print[1];
b = a; (Print[2]; c = b; (Print[3]; c) /; c > 0.2) /; b > 0.1) /;
a > 0]

b3m2a1

5:56 PM

@ChrisK That should be pretty easy to do. I actually had something like that for my old docs system (which I'm admittedly trying to kill because the WRI docs pages are too complicated to work with quickly and cleanly). I'm trying to get back to working on my new WRI-independent docs system soon and I can do some work to make everything as easy as that, esp. with respect to inserting links, See Also things, auto-populating the metadata, and all that jazz.

More and more I think that things that are independent of WRI have potentially better staying power, although admittedly the adoption rate will likely be poor.

At this point I personally have a full toolchain for making docs, paclets, packages, webpages, etc. and it has all served me quite well but of course if I want to make it useful for anyone else I need to a) document and b) make it easy to use

And both of those are hard

@Pinti Oh right I do... I'll give that an update soon hopefully

Lukas Lang

9:59 PM

@b3m2a1 I have two questions regarding the ``FEPrivate`*`` stuff:
* Is it possible to switch between boxes using ``FEPrivate`If[…]``? Something like ``Cell[BoxData[FEPrivate`If[…,RowBox[{…}],GridBox[{{…}}]]]]`` - unfortunately, all my attempts have ended in "An unknown box name (…) was sent..."
* Can I toggle TaggingRules using only the front-end? I currently have ``ButtonBox[...,ButtonFunction:>FEPrivate`Set[FrontEnd`CurrentValue[
FrontEnd`EvaluationNotebook[], {TaggingRules, ...}], True],
Evaluator->None]``, which somehow works, but I get an error "Could not process unknown packet 'True' ".

b3m2a1

10:19 PM

@LukasLang you need a DynamicBox, e.g. this:

Cell[
 BoxData[
  DynamicBox@
   FEPrivate`If[
    FEPrivate`Or[
     FEPrivate`SameQ[
      FrontEnd`CurrentValue[FrontEnd`EvaluationNotebook[],
       StyleDefinitions],
      "Default.nb"
      ],
     FEPrivate`MemberQ[
      FrontEnd`CurrentValue[FrontEnd`EvaluationNotebook[],
       StyleDefinitions],
      "Default.nb",
      Infinity
      ]
     ],
    "\"doop\"",
    "\"bloop\""
    ]
  ]
 ]

That'll change your boxes depending on if your stylesheet is "Default.nb" or not

But it won't call into the kernel so it's fast.

DyanmicBox just basically lets the FE process the expression

You get the same results from wrapping things in DynamicBox as FE`Evaluate

e.g. after I changed my stylesheet:

FEPrivate`If[
   FEPrivate`Or[
     FEPrivate`SameQ[
       FrontEnd`CurrentValue[FrontEnd`EvaluationNotebook[],
     StyleDefinitions],
       "Default.nb"
       ],
     FEPrivate`MemberQ[
       FrontEnd`CurrentValue[FrontEnd`EvaluationNotebook[],
     StyleDefinitions],
       "Default.nb",
       Infinity
       ]
     ],
   "\"doop\"",
   "\"bloop\""
   ] // FE`Evaluate

"\"bloop\""

I think I used this to turn the little 11.1-style togglers on and off in my docs stylesheets