你的 Mathematica 工具包里有什么？

我最喜欢的技巧是小型代码生成宏，它允许您用一个简短的命令替换一堆标准样板命令。或者，您可以创建用于打开/创建笔记本的命令。

以下是我在日常 Mathematica 工作流程中使用了一段时间的内容。我发现自己经常做以下几件事:

1. 使笔记本有一个私人上下文，加载包(s)我需要，使它自动保存。
2. 在使用这个笔记本一段时间后，我想在一个单独的笔记本中做一些草稿计算，它有自己的私有上下文，同时可以访问我在“ main”笔记本中使用的定义。因为我设置了私有上下文，所以需要手动调整 $ContextPath

通过手工一遍又一遍地做所有这些是一件痛苦的事情，所以让我们自动化吧! 首先，一些实用代码:

(* Credit goes to Sasha for SelfDestruct[] *)
SetAttributes[SelfDestruct, HoldAllComplete];
SelfDestruct[e_] := (If[$FrontEnd =!= $Failed,
SelectionMove[EvaluationNotebook[], All, EvaluationCell];
NotebookDelete[]]; e)


writeAndEval[nb_,boxExpr_]:=(
NotebookWrite[nb,  CellGroupData[{Cell[BoxData[boxExpr],"Input"]}]];
SelectionMove[nb, Previous, Cell];
SelectionMove[nb, Next, Cell];
SelectionEvaluate[nb];
)


ExposeContexts::badargs =
"Exposed contexts should be given as a list of strings.";
ExposeContexts[list___] :=
Module[{ctList}, ctList = Flatten@List@list;
If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList,
Message[ExposeContexts::badargs]];
$ContextPath = DeleteDuplicates[$ContextPath];
$ContextPath]


Autosave[x:(True|False)] := SetOptions[EvaluationNotebook[],NotebookAutoSave->x];

现在，让我们创建一个宏，它将把下列单元格放在笔记本中:

SetOptions[EvaluationNotebook[], CellContext -> Notebook]
Needs["LVAutils`"]
Autosave[True]

宏观来看:

MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:=
SelfDestruct@Module[{contBox,lvaBox,expCtxtBox,assembledStatements,strList},
contBox = MakeBoxes[SetOptions[EvaluationNotebook[], CellContext -> Notebook]];
lvaBox = MakeBoxes[Needs["LVAutils`"]];


assembledStatements = {lvaBox,MakeBoxes[Autosave[True]],"(*********)"};
assembledStatements = Riffle[assembledStatements,"\[IndentingNewLine]"]//RowBox;
writeAndEval[InputNotebook[],contBox];
writeAndEval[InputNotebook[],assembledStatements];
If[exposedCtxts =!= Null,
strList = Riffle[("\"" <> # <> "\"") & /@ exposedCtxts, ","];
expCtxtBox = RowBox[{"ExposeContexts", "[", RowBox[{"{", RowBox[strList], "}"}], "]"}];
writeAndEval[InputNotebook[],expCtxtBox];
]
]

现在，当我输入 MyPrivatize[]是创建私有上下文和加载我的标准包。现在，让我们创建一个命令，它将打开一个带有自己私有上下文的新的草稿笔记本(这样您就可以随心所欲地修改它，而不会有搞砸定义的风险) ，但是可以访问您当前的上下文。

SpawnScratch[] := SelfDestruct@Module[{nb,boxExpr,strList},
strList = Riffle[("\"" <> # <> "\"") & /@ $ContextPath, ","];
boxExpr = RowBox[{"MyPrivatize", "[",
RowBox[{"{", RowBox[strList], "}"}], "]"}];
nb = CreateDocument[];
writeAndEval[nb,boxExpr];
]

由于 SelfDestruct的缘故，这个命令在运行时不会在当前的笔记本中留下任何痕迹——这很好，因为否则它只会创建混乱。

对于额外的样式点，您可以使用 InputAutoReplacements为这些宏创建关键字触发器，但是我将留给读者作为练习。

一般 PDF/EMF 出口问题及解决方案

1)这是完全出乎意料和没有文件的，但 Mathematica导出和保存 PDF 和 EPS 格式的图形使用一套风格定义，不同于用来显示屏幕上的笔记本电脑。默认情况下，笔记本显示在屏幕上的“工作”样式环境(这是 ScreenStyleEvironment全局 $FrontEnd选项的默认值) ，但是打印在 "Printout"样式环境(这是 PrintingStyleEnvironment全局 $FrontEnd选项的默认值)。当一个以栅格格式(如 GIF 和 PNG)或 EMF 格式导出图形时，Mathematica生成的图形看起来与笔记本电脑内部的图形一模一样。在这种情况下，似乎使用了 "Working"样式环境来呈现。但是，当您导出/保存 PDF 或 EPS 格式的任何内容时，情况并非如此！在这种情况下，$FrontEnd1与“工作”风格的环境有很大的不同。首先，$FrontEnd2。其次，它对不同样式的字体大小使用自己的值，这导致生成的 PDF 文件中的字体大小变化与原始屏幕上的表示相比不一致。后者可以被称为 $FrontEnd3，这是非常恼人的。 但令人高兴的是，这是可以避免的 通过设置 ABC0全球 $FrontEnd选项为“工作”:

SetOptions[$FrontEnd, PrintingStyleEnvironment -> "Working"]

2)导出为 EMF 格式的常见问题是，大多数程序(不仅仅是 Mathematica)生成的文件在默认大小下看起来很漂亮，但是放大后会变得很难看。这是因为 在屏幕分辨率保真度采样元文件。通过对原始图形对象进行 Magnify处理，可以提高生成的 EMF 文件的质量，从而提高原始图形采样的准确性。比较两个文件:

graphics1 =
First@ImportString[
ExportString[Style["a", FontFamily -> "Times"], "PDF"], "PDF"];
graphics2 = Magnify[graphics1, 10];
Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics2]

如果您将这些文件插入到 Microsoft Word 中并放大它们，您将看到第一个“ a”上有锯齿，而第二个没有(使用 Mathematica6进行测试)。

Chris Degnen提出了另一种通过 ImageResolution的方法(这种方法至少从 Mathematica8开始有效) :

Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics1, ImageResolution -> 300]

3)在 Mathematica中，我们有三种方法将图形转换成图元文件: 通过 Export到 "EMF"(强烈推荐的方法: 生成尽可能高质量的图元文件) ，通过 Save selection As...菜单项(产生的精确数字要小得多，不推荐)和通过 Edit ► Copy As ► Metafile菜单项(我强烈建议不要走这条路)。

缓存表达式

我发现这些函数对缓存任何表达式都非常有用。这两个函数的有趣之处在于，持有的表达式本身被用作哈希表/符号缓存或缓存索引的键，相比之下，著名的数学制表法只能在函数定义为 f [ x _ ] : = f [ x ] = ... 的情况下才能缓存结果。因此，你可以缓存代码的任何部分，如果一个函数要被调用多次，但只是代码的某些部分不能被重新计算，这是很有用的。

独立于表达式的参数缓存表达式。

SetAttributes[Cache, HoldFirst];
c:Cache[expr_] := c = expr;


Ex: Cache[Pause[5]; 6]
Cache[Pause[5]; 6]

第二次表达式不等待就返回6。

使用可依赖于缓存表达式的参数的别名表达式缓存表达式。

SetAttributes[CacheIndex, HoldRest];
c:CacheIndex[index_,expr_] := c = expr;


Ex: CacheIndex[{"f",2},x=2;y=4;x+y]

如果 expr 需要一些时间来计算，那么计算{“ f”，2}会快得多，例如检索缓存的结果。

对于这些函数的变体，以便具有本地化缓存(即。缓存内存会自动释放到 Block 结构之外)请参阅本文后面的 避免重复调用插值

删除缓存值

在不知道函数的定义数时删除缓存值。我认为定义在它们的论点中某处是空白的。

DeleteCachedValues[f_] :=
DownValues[f] = Select[DownValues[f], !FreeQ[Hold@#,Pattern]&];

在知道函数的定义数量时删除缓存的值(速度稍微快一些)。

DeleteCachedValues[f_,nrules_] :=
DownValues[f] = Extract[DownValues[f], List /@ Range[-nrules, -1]];

这使用了这样一个事实，即函数的定义位于 DownValue 列表的末尾，而缓存的值位于。

使用符号存储数据和类似对象的函数

这里还有一些有趣的函数来使用象对象这样的符号。

众所周知，您可以将数据存储在符号中，并使用 DownValue 快速访问它们

mysymbol["property"]=2;

你可以使用这些函数来访问符号的键(或属性)列表，这些函数基于 treeves 在本网站上发表的文章:

SetAttributes[RemoveHead, {HoldAll}];
RemoveHead[h_[args___]] := {args};
NKeys[symbol_] := RemoveHead @@@ DownValues[symbol(*,Sort->False*)][[All,1]];
Keys[symbol_] := NKeys[symbol] /. {x_} :> x;

我经常使用这个函数来显示符号 DownValue 中包含的所有信息:

PrintSymbol[symbol_] :=
Module[{symbolKeys},
symbolKeys = Keys[symbol];
TableForm@Transpose[{symbolKeys, symbol /@ symbolKeys}]
];

Finally here is a simple way to create a symbol that behaves like an object in object oriented programming (it just reproduces the most basic behaviour of OOP but I find the syntax elegant) :

Options[NewObject]={y->2};
NewObject[OptionsPattern[]]:=
Module[{newObject},
newObject["y"]=OptionValue[y];


function[newObject,x_] ^:= newObject["y"]+x;
newObject /: newObject.function2[x_] := 2 newObject["y"]+x;


newObject
];

属性在返回的 Module 创建的符号中作为 DownValue 存储，而方法作为延迟 Upvalue 存储。我找到了 function 2的语法，它是 Mathematica 的树木资料结构中函数的通常 OO 语法。

有关每个符号具有的现有值类型的列表，请参见 http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html和 http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html。

例如，试试这个

x = NewObject[y -> 3];
function[x, 4]
x.function2[5]

如果您想使用这里提供的一个名为 Heritage itRules 的包来模拟对象继承，则可以进一步深入 Http://library.wolfram.com/infocenter/mathsource/671/

您还可以将函数定义不存储在 newObject 中，而是存储在类型符号中，因此如果 NewObject 返回的是 type [ newObject ]而不是 newObject，那么您可以像下面这样定义 function 和 function 2 在 NewObject 之外(而不是在其中) ，并且具有与之前相同的用法。

function[type[object_], x_] ^:= object["y"] + x;
type /: type[object_].function2[x_] := 2 object["y"]+x;

使用 UpValue [ type ]查看在类型符号中定义的函数和 function 2。

这里将进一步介绍关于最后一种语法的想法 https://mathematica.stackexchange.com/a/999/66。

选择等价物的改进版本

@ rcolyer: 非常感谢将 SelectEquvalents 带到表面，这是一个令人惊奇的功能。 下面是上面列出的 SelectEquvalents 的改进版本，它具有更多的可能性和使用选项，这使它更容易使用。

Options[SelectEquivalents] =
{
TagElement->Identity,
TransformElement->Identity,
TransformResults->(#2&) (*#1=tag,#2 list of elements corresponding to tag*),
MapLevel->1,
TagPattern->_,
FinalFunction->Identity
};


SelectEquivalents[x_List,OptionsPattern[]] :=
With[
{
tagElement=OptionValue@TagElement,
transformElement=OptionValue@TransformElement,
transformResults=OptionValue@TransformResults,
mapLevel=OptionValue@MapLevel,
tagPattern=OptionValue@TagPattern,
finalFunction=OptionValue@FinalFunction
}
,
finalFunction[
Reap[
Map[
Sow[
transformElement@#
,
{tagElement@#}
]&
,
x
,
{mapLevel}
]
,
tagPattern
,
transformResults
][[2]]
]
];

下面是如何使用这个版本的例子:

正确使用 Mathematica 收集/收集

如何在 Mathematica 实现数据透视表功能？

Mathematica 快速二维分组算法

内袋

Daniel Lichtblau 在这里描述了一个用于增长列表的有趣的内部数据结构。

在 Mathematica 实现四叉树

调试功能

这两篇文章指出了用于调试的有用函数:

如何在使用 Mathematica、 workbench、 mma 调试器或其他工具编写小代码或大代码时进行调试? (ShowIt)

Https://stackoverflow.com/questions/5459735/the-clearest-way-to-represent-mathematicas-evaluation-sequence/5527117#5527117 (TraceView)

下面是另一个基于 Reap 和 Sow 的函数，它可以从程序的不同部分提取表达式，并将它们存储在一个符号中。

SetAttributes[ReapTags,HoldFirst];
ReapTags[expr_]:=
Module[{elements},
Reap[expr,_,(elements[#1]=#2/.{x_}:>x)&];
elements
];

举个例子

ftest[]:=((*some code*)Sow[1,"x"];(*some code*)Sow[2,"x"];(*some code*)Sow[3,"y"]);
s=ReapTags[ftest[]];
Keys[s]
s["x"]
PrintSymbol[s] (*Keys and PrintSymbol are defined above*)

其他资源

下面是一些有趣的学习链接:

Mathematica 学习资源集

更新于此: https://mathematica.stackexchange.com/a/259/66

PutAppend with PageWidth-> Infinity

在 Mathematica中，使用 PutAppend命令是维护正在运行的日志文件以及中间计算结果的最直接的方法。但是它在将表达式导出到文件时默认使用 PageWith->78设置，因此不能保证每个中间输出在日志中只占用一行。

PutAppend本身没有任何选项，但跟踪其评估结果显示，它是基于 OpenAppend函数的，该函数具有 PageWith选项，并允许通过 SetOptions命令更改其默认值:

In[2]:= Trace[x>>>"log.txt",TraceInternal->True]
Out[2]= {x>>>log.txt,{OpenAppend[log.txt,CharacterEncoding->PrintableASCII],OutputStream[log.txt,15]},Null}

所以我们可以通过设置 PutAppend一次只附加一行:

SetOptions[OpenAppend, PageWidth -> Infinity]

更新

在版本10中引入了 臭虫(在版本11.3中修复) : SetOptions不再影响 OpenWrite和 OpenAppend的行为。

一个解决方案是使用显式的 PageWidth -> Infinity选项实现您自己的 PutAppend版本:

Clear[myPutAppend]
myPutAppend[expr_, pathtofile_String] :=
(Write[#, expr]; Close[#];) &[OpenAppend[pathtofile, PageWidth -> Infinity]]

请注意，我们也可以通过 WriteString来实现它，如 这个答案所示，但是在这种情况下，有必要通过 ToString[expr, InputForm]将表达式初步转换成相应的 InputForm。

我相信很多人都遇到过这样的情况: 他们运行某些程序，意识到它不仅困住了程序，而且还困住了 已经十分钟没存钱了！

剪辑

经过一段时间的这种痛苦，我有一天发现，可以创建自动保存从内部的 Mathematica代码。我认为使用这样的自动保存在过去帮助了我很多，我总是觉得 可能性本身是没有很多人意识到他们可以做的事情。

我使用的原始代码在底部。多亏了这些评论，我发现它是有问题的，而且最好用另一种方式来做，使用 ScheduledTask(这只在 Mathematica8中有效)。

这方面的代码可以在 Sjoerd C. de Vries的 这个答案中找到 (因为我不确定是否可以把它复制到这里，所以我只把它作为一个链接留在这里。)

下面的解决方案是使用 Dynamic。这将节省笔记本每60秒，但显然 除非它的细胞是可见的。我把它留在这里只是为了完成任务。(适用于 Mathematica6及7的使用者)

编辑

为了解决这个问题，我在笔记本的开头使用了这段代码:

Dynamic[Refresh[NotebookSave[]; DateString[], UpdateInterval -> 60]]

这将每60秒节省您的工作。
与 NotebookAutoSave[]相比，我更喜欢它，因为它在处理输入之前保存，而且因为有些文件比输入更多的是文本。

我最初是在这里找到它的: http://en.wikipedia.org/wiki/Talk:Mathematica#Criticisms

请注意，一旦运行此行，即使关闭并重新打开文件(只要启用了动态更新) ，也会进行保存。

此外，由于在 Mathematica中没有撤消，所以请注意不要删除所有内容，因为保存将使其不可逆转(作为预防措施，我从每个完成的笔记本中删除这段代码)

这篇文章是由 Alberto Di Lullo 写的(他似乎没有出现在 Stack Overflow 上)。

CopyToClipboard，用于 Mathematica 7(在 Mathematica 8中它是内置的)

CopyToClipboard[expr_] :=
Module[{nb},
nb = CreateDocument[Null, Visible -> False, WindowSelected -> True];
NotebookWrite[nb, Cell[OutputFormData@expr], All];
FrontEndExecute[FrontEndToken[nb, "Copy"]];
NotebookClose@nb];

原文: http://forums.wolfram.com/mathgroup/archive/2010/Jun/msg00148.html

我发现这个例程对于将大实数以普通十进制形式复制到剪贴板非常有用。例如 CopyToClipboard["123456789.12345"]

Cell[OutputFormData@expr]巧妙地删除了报价。

函数 format[expr_]可用于缩进/格式化跨页的未格式化的 mathematica表达式

indent[str_String, ob_String, cb_String, delim_String] :=
Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
f[c_] := c;
f /@ Characters@str // StringJoin];
format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"];


(*
format[Hold@Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
f[c_] := c;
f /@ Characters@str // StringJoin]]
*)

档号: https://codegolf.stackexchange.com/questions/3088/indent-a-string-using-given-parentheses

我发现在开发将这个快捷键添加到我的 SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.tr文件中的软件包时，它非常有用。

(* Evaluate Initialization Cells: Real useful for reloading library changes. *)


Item[KeyEvent["i", Modifiers -> {Control, Command}],
FrontEndExecute[
FrontEndToken[
SelectedNotebook[],
"EvaluateInitialization"]]],

接下来，对于每个 Packagename.m，我制作一个用于测试的 PackagenameTest.nb笔记本，测试笔记本的前2个单元格被设置为初始化单元格。在我放进去的第一个牢房里

Needs["PackageManipulations`"]

加载由 Leonid 编写的非常有用的 包装操作库

PackageRemove["Packagename`Private`"]
PackageRemove["Packagename`"]
PackageReload["Packagename`"]

所有这些都做实际的包重新加载。注意前两行只有 Remove的所有符号，因为我希望保持上下文尽可能干净。

然后用于编写和测试包的工作流就变成了这样的东西。

1. 保存对 Packagename.m的更改。
2. 转到 PackagenameTest.nb然后做 CTRL + ALT + i。

这会导致初始化单元格重新加载包，这使得测试非常简单。

不预先设置上下文的打印系统符号定义

下面的 contextFreeDefinition[]函数将尝试打印符号的定义，而不预先设置最常见的上下文。然后可以将定义复制到 Workbench 并格式化为可读性(选择它，右键单击，Source-> Format)

Clear[commonestContexts, contextFreeDefinition]


commonestContexts[sym_Symbol, n_: 1] := Quiet[
Commonest[
Cases[Level[DownValues[sym], {-1}, HoldComplete],
s_Symbol /; FreeQ[$ContextPath, Context[s]] :> Context[s]], n],
Commonest::dstlms]


contextFreeDefinition::contexts = "Not showing the following contexts: `1`";


contextFreeDefinition[sym_Symbol, contexts_List] :=
(If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
Internal`InheritedBlock[{sym}, ClearAttributes[sym, ReadProtected];
Block[{$ContextPath = Join[$ContextPath, contexts]},
Print@InputForm[FullDefinition[sym]]]])


contextFreeDefinition[sym_Symbol, context_String] :=
contextFreeDefinition[sym, {context}]


contextFreeDefinition[sym_Symbol] :=
contextFreeDefinition[sym, commonestContexts[sym]]

与规则[]

注意: 这个函数不像 With和 Module那样对变量进行本地化，这意味着嵌套的本地化构造不会像预期的那样工作。withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] 威尔在嵌套的 With和 Rule中取代 a和 b，而 With不这样做。

这是 With的一个变体，它使用规则而不是 =和 :=:

ClearAll[withRules]
SetAttributes[withRules, HoldAll]
withRules[rules_, expr_] :=
Internal`InheritedBlock[
{Rule, RuleDelayed},
SetAttributes[{Rule, RuleDelayed}, HoldFirst];
Unevaluated[expr] /. rules
]

我发现这在清理实验和本地化变量期间编写的代码时很有用。有时我会以 {par1 -> 1.1, par2 -> 2.2}的形式结束参数列表。使用 withRules参数值很容易插入到以前使用全局变量编写的代码中。

用法就像 With:

withRules[
{a -> 1, b -> 2},
a+b
]

反锯齿3D 图形

这是一个非常简单的反别名3D 图形技术，即使您的图形硬件本身不支持它。

antialias[g_, n_: 3] :=
ImageResize[Rasterize[g, "Image", ImageResolution -> n 72], Scaled[1/n]]

这里有一个例子:

注意，对于 n或大图像大小的大值倾向于暴露图形驱动程序错误或引入人工制品。

笔记本的不同功能

笔记本 diff 功能在 <<AuthorTools`包中可用，并且(至少在版本8中)在未记录的 NotebookTools`上下文中可用。这是一个小图形用户界面，区别于目前打开的两款笔记本电脑:

PaletteNotebook@DynamicModule[
{nb1, nb2},
Dynamic@Column[
{PopupMenu[Dynamic[nb1],
Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]],
PopupMenu[Dynamic[nb2],
Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]],
Button["Show differences",
CreateDocument@NotebookTools`NotebookDiff[nb1, nb2]]}]
]

此代码生成一个调色板，该调色板将所选内容作为图像上传到 StackExchange。在 Windows 上，提供了一个额外的按钮，可以更忠实地呈现所选内容。

将代码复制到笔记本单元格中并进行计算。然后从输出中弹出调色板，并使用 Palettes -> Install Palette...安装它

如果你有任何问题，在这里发表评论。下载笔记本版本 给你。

Begin["SOUploader`"];


Global`palette = PaletteNotebook@DynamicModule[{},


Column[{
Button["Upload to SE",
With[{img = rasterizeSelection1[]},
If[img === $Failed, Beep[], uploadWithPreview[img]]],
Appearance -> "Palette"],


If[$OperatingSystem === "Windows",


Button["Upload to SE (pp)",
With[{img = rasterizeSelection2[]},
If[img === $Failed, Beep[], uploadWithPreview[img]]],
Appearance -> "Palette"],


Unevaluated@Sequence[]
]
}],


(* Init start *)
Initialization :>
(


stackImage::httperr = "Server returned respose code: `1`";
stackImage::err = "Server returner error: `1`";


stackImage[g_] :=
Module[
{getVal, url, client, method, data, partSource, part, entity,
code, response, error, result},


getVal[res_, key_String] :=
With[{k = "var " <> key <> " = "},
StringTrim[


First@StringCases[
First@Select[res, StringMatchQ[#, k ~~ ___] &],
k ~~ v___ ~~ ";" :> v],
"'"]
];


data = ExportString[g, "PNG"];


JLink`JavaBlock[
url = "http://stackoverflow.com/upload/image";
client =
JLink`JavaNew["org.apache.commons.httpclient.HttpClient"];
method =
JLink`JavaNew[
"org.apache.commons.httpclient.methods.PostMethod", url];
partSource =
JLink`JavaNew[
"org.apache.commons.httpclient.methods.multipart.\
ByteArrayPartSource", "mmagraphics.png",
JLink`MakeJavaObject[data]@toCharArray[]];
part =
JLink`JavaNew[
"org.apache.commons.httpclient.methods.multipart.FilePart",
"name", partSource];
part@setContentType["image/png"];
entity =
JLink`JavaNew[
"org.apache.commons.httpclient.methods.multipart.\
MultipartRequestEntity", {part}, method@getParams[]];
method@setRequestEntity[entity];
code = client@executeMethod[method];
response = method@getResponseBodyAsString[];
];


If[code =!= 200, Message[stackImage::httperr, code];
Return[$Failed]];
response = StringTrim /@ StringSplit[response, "\n"];


error = getVal[response, "error"];
result = getVal[response, "result"];
If[StringMatchQ[result, "http*"],
result,
Message[stackImage::err, error]; $Failed]
];


stackMarkdown[g_] :=
"![Mathematica graphics](" <> stackImage[g] <> ")";


stackCopyMarkdown[g_] := Module[{nb, markdown},
markdown = Check[stackMarkdown[g], $Failed];
If[markdown =!= $Failed,
nb = NotebookCreate[Visible -> False];
NotebookWrite[nb, Cell[markdown, "Text"]];
SelectionMove[nb, All, Notebook];
FrontEndTokenExecute[nb, "Copy"];
NotebookClose[nb];
]
];


(* Returns available vertical screen space,
taking into account screen elements like the taskbar and menu *)




screenHeight[] := -Subtract @@
Part[ScreenRectangle /. Options[$FrontEnd, ScreenRectangle],
2];


uploadWithPreview[img_Image] :=
CreateDialog[
Column[{
Style["Upload image to the Stack Exchange network?", Bold],
Pane[


Image[img, Magnification -> 1], {Automatic,
Min[screenHeight[] - 140, 1 + ImageDimensions[img][[2]]]},
Scrollbars -> Automatic, AppearanceElements -> {},
ImageMargins -> 0
],
Item[
ChoiceButtons[{"Upload and copy MarkDown"}, \
{stackCopyMarkdown[img]; DialogReturn[]}], Alignment -> Right]
}],
WindowTitle -> "Upload image to Stack Exchange?"
];


(* Multiplatform, fixed-width version.
The default max width is 650 to fit Stack Exchange *)
rasterizeSelection1[maxWidth_: 650] :=
Module[{target, selection, image},
selection = NotebookRead[SelectedNotebook[]];
If[MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]], selection],


$Failed, (* There was nothing selected *)


target =
CreateDocument[{}, WindowSelected -> False, Visible -> False,
WindowSize -> maxWidth];
NotebookWrite[target, selection];
image = Rasterize[target, "Image"];
NotebookClose[target];
image
]
];


(* Windows-only pixel perfect version *)
rasterizeSelection2[] :=
If[
MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]],
NotebookRead[SelectedNotebook[]]],


$Failed, (* There was nothing selected *)


Module[{tag},
FrontEndExecute[
FrontEndToken[FrontEnd`SelectedNotebook[], "CopySpecial",
"MGF"]];
Catch[
NotebookGet@ClipboardNotebook[] /.
r_RasterBox :>
Block[{},
Throw[Image[First[r], "Byte", ColorSpace -> "RGB"], tag] /;
True];
$Failed,
tag
]
]
];
)
(* Init end *)
]


End[];