Wolfram Mathematica

12:05 AM

@OleksandrR. Hmm... You could pass FilterRules[Options[f], Options[g]] to g instead of individual options

@rm-rf but options given explicitly in the call to f will not be included in Options[f] (they are known only by OptionValue)...

rm -rf

@OleksandrR. Oh, you said "defaults for f", which is why I suggested that

Oleksandr R.

@rm-rf sorry, I suppose I was unclear. I meant the union of the defaults and any explicitly given options

rm -rf

Then why not do FilterRules[{opts}, Options[g]], where opts is from the definition of f[..., opts: OptionsPattern[]

Oleksandr R.

@rm-rf unfortunately that is a literal pattern match; it does not do the same magic as OptionValue does

rm -rf

12:11 AM

@OleksandrR. DeleteDuplicates[FilterRules[{opts}, Options[g]] ~Join~ Options[g], First@# === First@#2 &] then? Options that come first trump same options that come later (perhaps with a different value), so you could just join them and not bother deleting

Oleksandr R.

@rm-rf hm, interesting approach with DeleteDuplicates; I hadn't considered that. I was thinking of something like:

Options[gg] /.
 HoldPattern[opt_~(op : Rule | RuleDelayed)~_] :>
  opt~op~OptionValue[ff, opt]

rm -rf

@OleksandrR. The problem with that is that if opt is not a default option in ff, you'll get an error

Oleksandr R.

@rm-rf good point

rm -rf

If I understood you correctly, the following demonstrates what you want:

ClearAll@g
Options[g] = {"a" -> 2, "c" -> 2};
g[o : OptionsPattern[]] := {"a" -> OptionValue["a"],  "c" -> OptionValue["c"]}

ClearAll@f
Options[f] = {"a" -> 1, "b" -> 2};
f[o : OptionsPattern[]] := With[{gOpts = FilterRules[{o}, Options[g]]~Join~Options[g]},  g[gOpts]]

f["a" -> 3, "c" -> 4]
f["b" -> 2]
f["a" -> 2, "b" -> 2]

Oleksandr R.

@rm-rf almost... f["b" -> 2] should give {"a" -> 1, "c" -> 2} (defaults from f), not {"a" -> 2, "c" -> 2} (defaults from g)

rm -rf

12:27 AM

@OleksandrR. Oh, that can be done... I didn't know that was required too. Just join FilterRules[Options[f], Options[g]] before Options[g] in the With

i.e., gOpts = Join[FilterRules[{o}, Options[g]], FilterRules[Options[f], Options[g]], Options[g]]

You can actually omit the Options[g] at the end, as it'll pick up whatever is not specified from the defaults anyway

Oleksandr R.

@rm-rf hmm, seems like a viable approach

Thanks; I think I was overcomplicating matters

rm -rf

No problem :)

Oleksandr R.

@rm-rf oh, wait... f["a" -> 3, "c" -> 4] also should give {"a" -> 3, "c" -> 2} and a warning because "c" isn't a valid option for f

rm -rf

@OleksandrR. But I didn't add a check for that; by default it'll accept anything you give it

Only OptionValue will throw an error

Oleksandr R.

@rm-rf yes, I know. That's why I was trying to involve OptionValue and wished to avoid too many extra levels of checking

rm -rf

12:40 AM

Which brings us to what I was talking about earlier :)

@OleksandrR. The problem with using OptionValue for this is that you cannot map it on the options (or at least, that's what I seem to remember). The option needs to be explicit

Oleksandr R.

@rm-rf yes, that's indeed the case

Hence my ReplaceAll...

rm -rf

So you did not want to override other options in g by passing them through f?

Oleksandr R.

@rm-rf yeah, that's right. Only ones that are explicitly options of f should carry through.

rm -rf

You could perhaps add a simple check for that using FilterRules[{opts}, Options[f]] === {opts}

Oleksandr R.

1:00 AM

@rm-rf can you see a problem with changing my first attempt to include FilterRules[Options[gg], Options[ff]] in place of simply Options[gg] as the first arg to ReplaceAll?

Wait, same problems... should have tested before asking

@rm-rf oops, that's not right either... I screwed up by copying your test case, but copied it too literally (forgot to change f to ff!). That does actually work fine, AFAICT. So the question stands--do you see an issue? :)

ClearAll[gg];
Options[gg] = {a :> 1, c -> 3};
gg[opts : OptionsPattern[gg]] := {OptionValue[a], OptionValue[c]};

ClearAll[ff];
Options[ff] = {a -> 2, b :> 4};
ff[opts : OptionsPattern[ff]] := gg[
   FilterRules[Options[gg], Options[ff]] /.
    HoldPattern[opt_~(op : Rule | RuleDelayed)~_] :>
     opt~op~OptionValue[ff, opt]
   ];

ff[a -> 3, c -> 4]
ff[b -> 2]
ff[a -> 2, b -> 2]

halirutan

1:19 AM

Is there an obvious way a string from HoldComplete[a/b*c] in FullForm?

The output should be "HoldComplete[Times[Times[a,Power[b,-1]],c]]"

Oleksandr R.

@halirutan I think I misunderstand you. Why is ToString@FullForm@HoldComplete[a/b*c] not suitable?

halirutan

@OleksandrR. Because I'm dump ;-)

@OleksandrR. Thanks. It's not even too late for me, so I don't have an excuse for this cache miss..

Oleksandr R.

@halirutan I think you found a bug/omission though. Seemingly FullForm should be a member of $PrintForms. But it's Locked, so... tough...?

halirutan

@OleksandrR. I was too keen to know why smth like ToString[.., FullForm] was not working..

Oleksandr R.

@halirutan $PrintForms::usage claims that "it is automatically updated when Format definitions using new printforms are made." But Format[Unique[], FullForm] := Null; causes a big mess...

Maybe a question should be posted as this smells like a bug.

acl

1:27 AM

All, this seems to be one of the usual problems with needing f[b_?NumericQ] etc. which is the canonical question to link to, if any?

there's too many answers

halirutan

@OleksandrR. so I better not try it now..

Oleksandr R.

@halirutan actually this might be my unfamiliarity with Format rather than a bug per se. (I never use it because I find its attempts to do everything for you automatically highly confusing and unreliable.) This does work:

Format[myFullForm[x_], FullForm] := FullForm[x];
ToString[myFullForm@HoldComplete[a/b*c], FullForm]

halirutan

@OleksandrR. I only need it for a function and not always. So I'm fine with typing it manually.

Oleksandr R.

@acl I think the canonical answer is one of rcollyer's... he sent it to me before but I can't remember which it is now

acl

@OleksandrR. neither can I. I'll search for it later, no point in duplicating effort

Oleksandr R.

1:35 AM

@acl I found this to be an extraordinarily clear instance that could perhaps become a canonical answer but there have been so many of them in the mean time that I haven't written one. You could do so now if you feel like it.

acl

@OleksandrR. I don't that's the point :)

Oleksandr R.

@acl do you see any potential problems with this? Don't feel obliged if you're busy, but there's procrastination potential in there for you...

@acl I cast my vote as TL for now since someone else will find the right one later on and that will override mine

acl

@OleksandrR. sorry, I never use options. No clue.

@OleksandrR. as for procrastination, reading up on the recent collapse of the entire financial sector (at best) in cyprus is giving me procrastination material beyond my wildest dreams

Oleksandr R.

2:09 AM

@acl no problem, thanks anyway

@acl also in the news, Berezovsky has been found dead (as you probably saw already)

acl

@OleksandrR. yes; maybe he had invested there :)

Oleksandr R.

@acl I think that is indeed the suspicion

acl

@OleksandrR. I understood from the few articles I read that he had financial trouble after the abramovich court case

I don't think losing 20% or even 40% of your wealth would be such a huge blow if you have millions. if you're broke, though...

Oleksandr R.

@acl he probably already was in trouble and hoped for this to save him, but the court was completely unconvinced by anything he said and branded him a "fundamentally unreliable witness". So after that judgment there was no hope for appeal, really

acl

@OleksandrR. yep, read all about it in the guardian.

Gustavo Bandeira

2:25 AM

Quick question: How to use the Iff to check if a number is even? I've tried something like: If[Length[l] == EvenQ, ..., ...]

How to issue the command: "If n is odd, do..."

acl

@GustavoBandeira try If[EvenQ[Length@i],blah]

EvenQ is a predicate

Gustavo Bandeira

2:46 AM

@acl Oh, it worked. Thanks for your help.

Transcript for