xtodo WolframLang

th[ft_Function , xrest___] :=
tt[ With[{expr179= ft@argHq2Ky},
With[{x881= First@ expr179, y804= Last@ expr179},
{x881, y804} /. argHq2Ky -> #1 ] ] ,
 xrest] /;
SameQ[Length@ ft, 2];

2024-02-15

paclet package repo

2024-02-15 check the paclet repo. read in detail. especially check how to doc.
Paclets

2024-02-06

https://writings.stephenwolfram.com/2019/06/the-wolfram-function-repository-launching-an-open-platform-for-extending-the-wolfram-language/

2023-12-21

WolframLang: Format String

how to print in binary, hex.

2023-06-16

2023-05-20

2022-09-14

WolframLang: Define Function by Pattern

(* \|01f469 *)

StringLength[ FromCharacterCode[{128105, 8205, 128300}]] === 3
(* StringLength["\|01f469"] *)

2022-08-01 need test using diff encoding for WolframScript Wolfram Language File Encoding

2021-11-19 clear xah wolfram language notes

2022-07-03

pattern matching issues

number of rules.

assume just 1 rule:

whole expression or parts
if parts, issue of sequential items vs levelspec
when to stop: stop at first match e.g. 「{x,x}」, just one part.
when to stop: stop at first match, all?.

Replace[ f[x,x] , {x -> 3, y -> 4}, {1, Infinity  } ]

(* f[3, 3] *)

Replace[expr,rules,levelspec]
levelspec default to {0}
A list of rules can be given. The rules are tried in order. The result of the first one that applies is returned. If none of the rules apply, the original expr is returned.
If the rules are given in nested lists, Replace is effectively mapped onto the inner lists. Thus Replace[expr,{{r11,r12},{r21,…},…}] is equivalent to {Replace[expr,{r11,r12}],Replace[expr,{r21,…}],…}.
Replace
ReplaceAll looks at each part of expr, tries all the rules on it, and then goes on to the next part of expr. The first rule that applies to a particular part is used; no further rules are tried on that part or on any of its subparts.
ReplaceAll applies a particular rule only once to an expression.
ReplaceAll

2022-07-03

(*
WolframScript does not behave the same as notebook.
In notebook, these eval correctly.
in WolframScript, they do not.
*)

StringCases[ "αβ🌞ab", StringExpression[ LetterCharacter.. ] ]
(* {Î, Î, ð, ab} *)

StringCases[ "πσ", StringExpression[ "ΠΣ" ], IgnoreCase -> True ]
(* {} *)

2022-06-25

Attributes[ CompoundExpression ]
(* {HoldAll, Protected, ReadProtected} *)

(* CompoundExpression *)

FullForm[  a;b;c ]
(* FullForm[c] *)

FullForm[ Hold[ a;b;c ] ]
(* FullForm[Hold[a; b; c]] *)

FullForm[ HoldForm[ a;b;c ] ]
(* FullForm[HoldForm[a; b; c]] *)

What's the difference between Hold, HoldForm, Unevaluate

2022-05-14

# list file path of WolframLang
Get-Command wolframscript.exe | Format-List Source

# on windows, it's usually at
# C:\Program Files\Wolfram Research\WolframScript\wolframscript.exe

on linux or MacOS, type which wolframscript

2022-05-14 find out where WolframLang package located is. builtin, and user addon.

2022-05-14 read the char encoding WolframLang: Script to Find/Replace Strings in a Dir

2022-05-13

2022-05-13, commented on
https://reference.wolfram.com/language/ref/ParametricPlot.html

the two examples with Exclusions, has no effect.

ParametricPlot[{Tan[u], u}, {u, 0, 2 Pi},
 Exclusions -> Range[Pi/2, 2 Pi, Pi]]

ParametricPlot[{Tan[u], u + v}, {u, 0, 2 Pi}, {v, 0, 1},
 Exclusions -> {u == Pi/2, u == 3 Pi/2}, Axes -> None]

2022-02-09

WolframLang figure out, DiscretizeGraphics and DiscretizeRegion returns a MeshRegion.

2022-07-06

2022-07-06 WolframLang write Level, Apply, Sequence

sequence specification:

All → all elements
None → no elements
n → elements 1 through n
UpTo[n] → elements 1 up to at most n, as available
-n → last n elements
{n} → element n only
{m,n} → elements m through n inclusive
{m,n,s} → elements m through n in steps of s

All: all elements
None: no elements
n: elements 1 through n
UpTo[n]: elements 1 up to at most n, as available
-n: last n elements
{n}: element n only
{m,n}: elements m through n inclusive
{m,n,s}: elements m through n in steps of s

Drop

2022-05-29

Replace[expr,rules,levelspec]
levelspec default to {0}
A list of rules can be given. The rules are tried in order. The result of the first one that applies is returned. If none of the rules apply, the original expr is returned.
If the rules are given in nested lists, Replace is effectively mapped onto the inner lists. Thus Replace[expr,{{r11,r12},{r21,…},…}] is equivalent to {Replace[expr,{r11,r12}],Replace[expr,{r21,…}],…}.

Replace

ReplaceAll looks at each part of expr, tries all the rules on it, and then goes on to the next part of expr. The first rule that applies to a particular part is used; no further rules are tried on that part or on any of its subparts.
ReplaceAll applies a particular rule only once to an expression.

ReplaceAll

ReplaceList

ReplaceRepeated

TransformationRulesAndDefinitions

Patterns