\n([\s\S]*?)<\/div><\/i>/g, function (w, g) {
+ return g
+ })
+ return cell_text
+}
+
+function fullCellHighlight(cell_text, scheme) {
+ cell_text = removeFullCellHighlight(cell_text);
+ return '
\n' + cell_text + '
<\/i>'
+}
+
+function highlight(text, scheme) {
+ var scheme = scheme;
+ // replace by a span, wile preserving leading and trailing spaces
+ var rep = text.replace(/(\S[\S\s]*\S)/, function (w, internal_text) {
+ return '' + internal_text + ''
+ })
+ return rep
+ //return ''+text+''
+}
+
+
+function add_div(text) {
+ if (text.match(/^([\S\s]*)<\/div>$/) == null) {
+ return '
' + text + '
'
+ } else {
+ return text
+ }
+}
+
+function rem_div(text) {
+ return text.replace(/^([\S\s]*)<\/div>$/, function (w, g) {
+ return g
+ })
+}
+
+function highlightInCmdMode(event, scheme) {
+ var cell = IPython.notebook.get_selected_cell()
+ var cm = IPython.notebook.get_selected_cell().code_mirror
+ var selectedText = window.getSelection().toString();
+ var cell_text = cell.get_text();
+ if (selectedText.length == 0) {
+ cell_text = fullCellHighlight(cell_text, scheme);
+ } else {
+ var identifiedText = align(selectedText, cell_text);
+ cell_text = cell_text.replace(identifiedText, highlight(identifiedText, scheme));
+ }
+ cell.set_text(cell_text);
+ cell.render();
+ return false;
+}
+
+function highlightInEditMode(event, scheme) {
+ var cell = IPython.notebook.get_selected_cell()
+ var cm = cell.code_mirror
+ var selectedText = cm.getSelection()
+ if (selectedText.length == 0) {
+ var cell_text = cell.get_text();
+ cell_text = fullCellHighlight(cell_text, scheme);
+ cell.set_text(cell_text);
+ } else {
+ cm.replaceSelection(highlight(selectedText, scheme))
+ }
+ return false;
+}
+
+function removeHighlights() {
+ var cell = IPython.notebook.get_selected_cell();
+ var cell_text = removeFullCellHighlight(cell.get_text());
+ cell_text = cell_text.replace(/([\s\S]*?)<\/span>/g,
+ function (w, g) {
+ return g
+ }
+ )
+ cell.set_text(cell_text)
+ cell.render();
+}
+
+//*****************************************************************************************
+// Utilitary functions for finding a candidate corresponding text from an unformatted selection
+
+/* In case of text selection in rendered cells, the returned text retains no formatting
+therefore, when looking for this text in the actual formatted text, we need to do a
+kind of "fuzzy" alignment. Though there exists specialized libraries for such task,
+we have developed here a simple heuristics that should work 90% of the time,
+but the problem cannot get a perfect solution.
+A first point is to replace special characters that could be interpreded with
+a special meaning in regular expressions. Then the idea is to find the exact matches
+on the longest substring from the beginning of text, then the longest substring
+from the end of the text. Finally, given the locations of the two substring,
+we extract the corresponding global match in the original text.
+*/
+function escapeRegExp(str) {
+ return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "#");
+ // return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+ return str
+}
+
+// Extract the longest matching substring from the beginning of the text
+function exsub_up(sub, text) {
+ for (k = 0; k <= sub.length; k++) {
+ if (text.match(sub.substr(0, k)) == null) {
+ k = k - 2
+ break
+ }
+ }
+ return text.match(sub.substr(0, k + 1))
+}
+
+// Extract the longest matching substring from the end of the text
+function exsub_down(sub, text) {
+ var L = sub.length
+ try {
+ for (k = 0; k <= sub.length; k++) {
+ tst = sub.substr(L - k - 1, L);
+ if (text.match(tst) == null) {
+ // console.log(tst)
+ k = k - 1
+ break
+ }
+ }
+ return text.match(sub.substr(L - k - 1, L))
+ } catch (e) {
+ console.log('Error', e)
+ return ""
+ }
+
+}
+
+// Function that tries to find the best match of the unformatted
+// text in the formatted one.
+
+function align(tofind, text) {
+
+ sub = escapeRegExp(tofind)
+ textModified = escapeRegExp(text)
+ //console.log(textModified.match(sub))
+ if (textModified.match(sub) == null) {
+ a = exsub_up(sub, textModified)
+ b = exsub_down(sub, textModified)
+ return text.substr(a.index, b.index + b[0].length - a.index)
+ } else {
+ var tmpMatch = textModified.match(sub)
+ return text.substr(tmpMatch.index, tmpMatch[0].length)
+ }
+}
+
+
+
+// ***************** Keyboard shortcuts ******************************
+
+var add_cmd_shortcuts = {
+ 'Alt-g': {
+ help: 'highlight selected text',
+ help_index: 'ht',
+ handler: function (event) {
+ highlightInCmdMode("", mark);
+ return false;
+ }
+ },
+ 'Alt-h': {
+ help: 'highlight selected text',
+ help_index: 'ht',
+ handler: function (event) {
+ highlightInCmdMode("", burk);
+ return false;
+ }
+ },
+};
+
+
+var add_edit_shortcuts = {
+ 'Alt-g': {
+ help: 'highlight selected text',
+ help_index: 'ht',
+ handler: function (event) {
+ var highlight = mark;
+ highlightInEditMode("", mark);
+ return false;
+ }
+ },
+ 'Alt-h': {
+ help: 'highlight selected text',
+ help_index: 'ht',
+ handler: function (event) {
+ var highlight = burk;
+ highlightInEditMode("", burk);
+ return false;
+ }
+ },
+};
+
+
+//******Toolbar buttons *************************************************
+
+function highlightText(scheme) {
+ var cell = IPython.notebook.get_selected_cell();
+ var rendered = cell.rendered;
+ if (rendered) highlightInCmdMode("", scheme);
+ else highlightInEditMode("", scheme);
+}
+
+
+function build_toolbar() {
+ var test = ' '
+
+
+ $("#maintoolbar-container").append(test);
+ $("#test").css({
+ 'padding': '5px'
+ });
+
+ $("#submenu").hide(); // initially hide the submenu
+
+ //buttons initial css -- shall check if this is really necessary
+ // $("#higlighter_menu").css({
+ // 'padding': '2px 8px',
+ // 'display': 'inline-block',
+ // 'border': '1px solid',
+ // 'border-color': '#cccccc',
+ // 'font-weight': 'bold',
+ // 'text-align': 'center',
+ // 'vertical-align': 'middle',
+ // 'margin-left': '0px',
+ // 'margin-right': '0px'
+ // })
+
+
+ //Actions
+
+
+ $("#higlighter_menu")
+ .on('click', function () {
+ $("#submenu").toggle();
+ $("#menu-hgl").toggleClass("fa-caret-right")
+ $("#menu-hgl").toggleClass("fa-caret-left")
+ })
+ .attr('title', 'Highlight Selected Text');
+
+
+ $("#b1")
+ .on('click', function () {
+ highlightText("burk")
+ })
+ .on('mouseover', function () {
+ $("#b1").removeClass("btn btn-default").addClass("btn burk")
+ //.addClass("burk");
+ }) //!!
+ .on('mouseout', function () {
+ $("#b1").addClass("btn btn-default")
+ })
+
+
+ $("#b2")
+ .on('click', function () {
+ highlightText("mark")
+ })
+ .on('mouseover', function () {
+ $("#b2").removeClass("btn btn-default").addClass("btn mark")
+ }) //!!
+ .on('mouseout', function () {
+ $("#b2").addClass("btn btn-default")
+ })
+
+ $("#b3")
+ .on('click', function () {
+ highlightText("girk")
+ })
+ .on('mouseover', function () {
+ $(this).removeClass("btn btn-default").addClass("btn girk")
+ }) //!!
+ .on('mouseout', function () {
+ $(this).addClass("btn btn-default")
+ })
+
+ $("#b4")
+ .on('click', function () {
+ highlightText("birk")
+ })
+ .on('mouseover', function () {
+ $(this).removeClass("btn btn-default").addClass("btn birk")
+ }) //!!
+ .on('mouseout', function () {
+ $(this).addClass("btn btn-default")
+ })
+
+ $("#b5")
+ .on('click', function () {
+ highlightText("pirk")
+ })
+ .on('mouseover', function () {
+ $(this).removeClass("btn btn-default").addClass("btn pirk")
+ }) //!!
+ .on('mouseout', function () {
+ $(this).addClass("btn btn-default")
+ })
+
+
+ $("#remove_highlights")
+ .on('click', function () {
+ removeHighlights()
+ })
+ .attr('title', 'Remove highlightings in selected cell');
+} // end build_toolbar
+
+//******************************* MAIN FUNCTION **************************
+
+define(["require",
+ 'base/js/namespace'
+], function (requirejs, Jupyter) {
+
+ var security = requirejs("base/js/security")
+
+ var load_css = function (name) {
+ var link = document.createElement("link");
+ link.type = "text/css";
+ link.rel = "stylesheet";
+ link.href = requirejs.toUrl(name);
+ document.getElementsByTagName("head")[0].appendChild(link);
+
+ };
+
+ //Load_ipython_extension
+ var load_ipython_extension = requirejs(['base/js/namespace'], function (Jupyter) {
+ "use strict";
+ if (Jupyter.version[0] < 3) {
+ console.log("This extension requires Jupyter or IPython >= 3.x")
+ return
+ }
+
+ console.log("[highlighter] Loading highlighter.css");
+ load_css('./highlighter.css')
+
+ IPython.keyboard_manager.edit_shortcuts.add_shortcuts(add_edit_shortcuts);
+ IPython.keyboard_manager.command_shortcuts.add_shortcuts(add_cmd_shortcuts);
+
+ build_toolbar();
+
+ var _on_reload = true; /* make sure cells render on reload */
+
+ //highlighter_init_cells(); /* initialize cells */
+
+
+ /* on reload */
+ $([Jupyter.events]).on('status_started.Kernel', function () {
+
+ //highlighter_init_cells();
+ console.log("[highlighter] reload...");
+ _on_reload = false;
+ })
+
+ }); //end of load_ipython_extension function
+
+ return {
+ load_ipython_extension: load_ipython_extension,
+ };
+}); //End of main function
+
+console.log("Loading ./highlighter.js");
\ No newline at end of file
diff --git a/.local/share/jupyter/nbextensions/highlighter/icon.png b/.local/share/jupyter/nbextensions/highlighter/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c47f176f09eb19ce6abd15748778d5544ab7bcc
Binary files /dev/null and b/.local/share/jupyter/nbextensions/highlighter/icon.png differ
diff --git a/.local/share/jupyter/nbextensions/highlighter/image.gif b/.local/share/jupyter/nbextensions/highlighter/image.gif
new file mode 100644
index 0000000000000000000000000000000000000000..8a551ae16e8edd500a0aeb5082ce285747f82104
Binary files /dev/null and b/.local/share/jupyter/nbextensions/highlighter/image.gif differ
diff --git a/.local/share/jupyter/nbextensions/highlighter/readme.md b/.local/share/jupyter/nbextensions/highlighter/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..cad658c52f415622620b37f4e5feb010e1937ccb
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/highlighter/readme.md
@@ -0,0 +1,47 @@
+Highlighter
+===========
+
+- Firstable, the extension provides several toolbar buttons for highlighting a selected text _within a markdown cell_. Three different \`color schemes' are provided, which can be easily customized in the stylesheet `highlighter.css`. The last button enables to remove all highlightings in the current cell.
+- This works both when the cell is _rendered_ and when the cell is in edit mode;
+- In both modes, it is possible to highlight formatted portions of text (In rendered mode, since the selected text loose its formatting, an heuristic is applied to find the best alignment with the actual text)
+- When no text is selected, the whole cell is highlighted;
+- The extension also provides two keyboard shortcuts (Alt-G and Alt-H) which fire the highlighting of the selected text.
+- Highlights can be preserved when exporting to html or to LaTeX -- details are provided in [export_highlights](https://rawgit.com/jfbercher/small_nbextensions/master/usability/highlighter/export_highlights.html)
+
+
+
+
+
+Installation
+------------
+
+The extension can be installed with the nice UI available on jupyter_nbextensions_configurator website, which also allows to enable/disable the extension.
+
+You may also install the extension from the original repo: issue
+
+```bash
+jupyter nbextension install https://rawgit.com/jfbercher/small_nbextensions/master/highlighter.zip --user
+```
+at the command line.
+
+
+Testing
+-------
+
+Use a code cell with
+
+```python
+%%javascript
+require("base/js/utils").load_extensions("highlighter/highlighter")
+```
+
+
+Automatic load
+--------------
+
+You may also automatically load the extension for any notebook via
+
+```bash
+jupyter nbextension enable highlighter/highlighter
+```
+
diff --git a/.local/share/jupyter/nbextensions/highlighter/tst_highlights.pdf b/.local/share/jupyter/nbextensions/highlighter/tst_highlights.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..8df38f38a27ca8eda9ff32f0ca87c363405c25ad
Binary files /dev/null and b/.local/share/jupyter/nbextensions/highlighter/tst_highlights.pdf differ
diff --git a/.local/share/jupyter/nbextensions/hinterland/hinterland.js b/.local/share/jupyter/nbextensions/hinterland/hinterland.js
new file mode 100644
index 0000000000000000000000000000000000000000..7fde256416cd71b290be1e696ffe6d6f840495fd
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/hinterland/hinterland.js
@@ -0,0 +1,194 @@
+define([
+ 'module',
+ 'jquery',
+ 'base/js/namespace',
+ 'base/js/keyboard',
+ 'notebook/js/cell',
+ 'notebook/js/codecell',
+ 'notebook/js/completer',
+], function (
+ module,
+ $,
+ Jupyter,
+ keyboard,
+ cell,
+ codecell,
+ completer
+) {
+ 'use strict';
+
+ var Cell = cell.Cell;
+ var CodeCell = codecell.CodeCell;
+ var Completer = completer.Completer;
+
+ var log_prefix = '[' + module.id + ']';
+
+ // default config (updated on nbextension load)
+ var config = {
+ enable_at_start: true,
+ exclude_regexp: ':',
+ include_regexp: '',
+ tooltip_regexp: '\\(',
+ hint_delay: 20,
+ hint_inside_comments: false,
+ };
+ // flag denoting whether hinting is enabled
+ var do_hinting;
+
+ // ignore most specially-named keys
+ var specials = [
+ keyboard.keycodes.enter,
+ keyboard.keycodes.esc,
+ keyboard.keycodes.backspace,
+ keyboard.keycodes.tab,
+ keyboard.keycodes.up,
+ keyboard.keycodes.down,
+ keyboard.keycodes.left,
+ keyboard.keycodes.right,
+ keyboard.keycodes.shift,
+ keyboard.keycodes.ctrl,
+ keyboard.keycodes.alt,
+ keyboard.keycodes.meta,
+ keyboard.keycodes.capslock,
+ keyboard.keycodes.space,
+ keyboard.keycodes.pageup,
+ keyboard.keycodes.pagedown,
+ keyboard.keycodes.end,
+ keyboard.keycodes.home,
+ keyboard.keycodes.insert,
+ keyboard.keycodes.delete,
+ keyboard.keycodes.numlock,
+ keyboard.keycodes.f1,
+ keyboard.keycodes.f2,
+ keyboard.keycodes.f3,
+ keyboard.keycodes.f4,
+ keyboard.keycodes.f5,
+ keyboard.keycodes.f6,
+ keyboard.keycodes.f7,
+ keyboard.keycodes.f8,
+ keyboard.keycodes.f9,
+ keyboard.keycodes.f10,
+ keyboard.keycodes.f11,
+ keyboard.keycodes.f12,
+ keyboard.keycodes.f13,
+ keyboard.keycodes.f14,
+ keyboard.keycodes.f15
+ ];
+
+ /**
+ * copied from base/js/keyboard, since it isn't exported
+ * Return `true` if the event only contains modifiers keys.
+ * false otherwise
+ **/
+ function only_modifier_event (event) {
+ var key = keyboard.inv_keycodes[event.which];
+ return (
+ (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) &&
+ (key === 'alt'|| key === 'ctrl'|| key === 'meta'|| key === 'shift')
+ );
+ }
+
+ function patch_cell_keyevent () {
+ console.log(log_prefix, 'patching Cell.prototype.handle_codemirror_keyevent');
+ var orig_handle_codemirror_keyevent = Cell.prototype.handle_codemirror_keyevent;
+ Cell.prototype.handle_codemirror_keyevent = function (editor, event) {
+ if (do_hinting && (this instanceof CodeCell) && !only_modifier_event(event)) {
+ // Tab completion.
+ this.tooltip.remove_and_cancel_tooltip();
+ // don't attempt completion when selecting, or when using multicursor
+ if ( !editor.somethingSelected() &&
+ editor.getSelections().length <= 1 &&
+ !this.completer.visible &&
+ specials.indexOf(event.keyCode) == -1) {
+ var cell = this;
+ // set a timeout to try to ensure that CodeMirror inserts
+ // the new key *before* the completion request happens
+ setTimeout(function () {
+ var cur = editor.getCursor();
+ var pre_cursor = editor.getRange({
+ line: cur.line,
+ ch: cur.ch - 1
+ }, cur);
+ if ( pre_cursor !== '' &&
+ (config.hint_inside_comments || editor.getTokenAt(cur).type !== "comment") &&
+ (config.include_regexp.test(pre_cursor) || config.tooltip_regexp.test(pre_cursor)) &&
+ !config.exclude_regexp.test(pre_cursor) ) {
+ if (config.tooltip_regexp.test(pre_cursor)) {
+ cell.tooltip.request(cell);
+ }
+ else {
+ cell.completer.startCompletion();
+ cell.completer.autopick = false;
+ }
+ }
+ }, config.hint_delay);
+ }
+ }
+ return orig_handle_codemirror_keyevent.apply(this, arguments);
+ };
+ }
+
+ function set_hinterland_state (new_state) {
+ do_hinting = new_state;
+ $('.hinterland-toggle > .fa')
+ .toggleClass('fa-check', do_hinting);
+ console.log(log_prefix, 'continuous hinting', do_hinting ? 'on' : 'off');
+ }
+
+ function toggle_hinterland () {
+ set_hinterland_state(!do_hinting);
+ }
+
+ function add_menu_item () {
+ if ($('#help_menu').find('.hinterland_toggle').length > 0) {
+ return;
+ }
+ var menu_item = $('')
+ .insertAfter('#keyboard_shortcuts');
+ var menu_link = $('')
+ .text('Continuous hints')
+ .addClass('hinterland-toggle')
+ .attr('title', 'Provide continuous code hints')
+ .on('click', toggle_hinterland)
+ .appendTo(menu_item);
+ $('')
+ .addClass('fa menu-icon pull-right')
+ .prependTo(menu_link);
+ }
+
+ function load_notebook_extension () {
+
+ Jupyter.notebook.config.loaded.then(function on_success () {
+ $.extend(true, config, Jupyter.notebook.config.data.hinterland);
+ // special defaults:
+ // default include is taken from Completer, rather than the blank
+ if (config.include_regexp === '') {
+ config.include_regexp = Completer.reinvoke_re;
+ }
+ // now turn regexps loaded from config (which will be strings) into
+ // actual RegExp objects.
+ var regexp_names = ['exclude_regexp', 'include_regexp', 'tooltip_regexp'];
+ for (var ii=0; ii < regexp_names.length; ii++) {
+ if (config[regexp_names[ii]] === '') {
+ continue;
+ }
+ try {
+ config[regexp_names[ii]] = new RegExp(config[regexp_names[ii]]);
+ }
+ catch (err) {
+ console.warn(log_prefix, 'error parsing', regexp_names[ii] + ':', err);
+ }
+ }
+ }, function on_error (err) {
+ console.warn(log_prefix, 'error loading config:', err);
+ }).then(function on_success () {
+ patch_cell_keyevent();
+ add_menu_item();
+ set_hinterland_state(config.enable_at_start);
+ });
+ }
+
+ return {
+ load_ipython_extension : load_notebook_extension
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/move_selected_cells/README.md b/.local/share/jupyter/nbextensions/move_selected_cells/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b5cafc60c1d92905f1be60f470c07b74942a6e3
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/move_selected_cells/README.md
@@ -0,0 +1,12 @@
+# Move selected cells
+
+This is a quick (and dirty) extension - move up or down several selected cell*s*. Moving cells or series of cells via simple keystrokes can be super useful.
+Note: Alternatively, it is now possible to use the `keyboard_shortcut_editor` to bind the move cell up & move cell down actions to Alt-up and Alt-down (or anything else).
+
+Initial version for Jupyter 4.0: a bit dirty because it would be better to act on DOM elements and write a correct move_cells() function.
+New version, updated to Jupyter 4.2+, now takes advantage of `Jupyter.notebook.move_selection_{down, up}` new functions
+
+
+Keyboard shortcuts: *Alt-up* and *Alt-down* (works also with single cells!)
+
+**Cell selection**: Cells can be selected using the rubberband (if this extension is enabled) or via Shift-up/Shift-down or Shift-K/Shift-J
diff --git a/.local/share/jupyter/nbextensions/move_selected_cells/move_selected_cells.yaml b/.local/share/jupyter/nbextensions/move_selected_cells/move_selected_cells.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..fef69c1504160b06c32a36371c09611603f19327
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/move_selected_cells/move_selected_cells.yaml
@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Name: Move selected cells
+Description: Move selected cell*s* using keybaord shortcuts Alt-up and Alt-down
+Link: README.md
+Main: main.js
+Compatibility: 4.x, 5.x
diff --git a/.local/share/jupyter/nbextensions/python-markdown/main.js b/.local/share/jupyter/nbextensions/python-markdown/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..84f39fe25749d238bc9e92548ea3b8e9a38a23b9
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/python-markdown/main.js
@@ -0,0 +1,212 @@
+// Allow Python-code in markdown cells
+// Encapsulate using {{...}}
+// - You can also return html or markdown from your Python code
+// - You can embed images, however they will be sanitized on reload.
+
+// TODO: Markdown cells will only be reevaluated when a notebook is dirty
+// (i.e. you have made changes). If you save it before reevaluating MD cells,
+// they will show the old value.
+
+define([
+ 'base/js/namespace',
+ 'jquery',
+ 'require',
+ 'notebook/js/cell',
+ 'base/js/security',
+ 'components/marked/lib/marked',
+ 'base/js/events',
+ 'notebook/js/textcell'
+], function(IPython, $, requirejs, cell, security, marked, events, textcell) {
+ "use strict";
+
+ /*
+ * Find Python expression enclosed in {{ }}, execute and add to text as
+ * tags. The actual content gets filled in later by a callback.
+ * Already executed expressions are cached in cell metadata.
+ *
+ * @method execute_python
+ * @param cell {Cell} notebook cell
+ * @param text {String} text in cell
+ */
+ var execute_python = function(cell,text) {
+ /* never execute code in untrusted notebooks */
+ if (IPython.notebook.trusted === false ) {
+ return undefined
+ }
+ /* always clear stored variables if notebook is dirty */
+ if (IPython.notebook.dirty === true ) delete cell.metadata.variables;
+ // search for code in double curly braces: {{}}
+ var found = false;
+ var newtext = text.replace(/{{(.*?)}}/g, function(match,tag,cha) {
+ found = true;
+ if (tag === "") return undefined;
+ var code = tag;
+ var id = 'python_'+cell.cell_id+'_'+cha; /* create an individual ID */
+ var thiscell = cell;
+ var thismatch = tag;
+
+ /* there a two possible options:
+ a) notebook dirty or variable not stored in metadata: evaluate variable
+ b) notebook clean and variable stored in metadata: display stored value
+ */
+ if (typeof cell.metadata.variables === "undefined") {
+ cell.metadata.variables = {}
+ }
+ var val = cell.metadata.variables[thismatch];
+ if (IPython.notebook.dirty === true || val === undefined || jQuery.isEmptyObject(val)) {
+ cell.metadata.variables[thismatch] = {};
+ var execute_callback = function (out_data)
+ {
+ var html;
+ if (out_data.msg_type === "error") {
+ var text = "**" + out_data.content.ename + "**: " + out_data.content.evalue;
+ html = marked(text);
+ } else if (out_data.msg_type === "stream") {
+ html = marked(out_data.content.text);
+ var t = html.match(/^\s*![]()
tag, still get eaten by sanitizer... */
+ svg = btoa(svg);
+ html = '
';
+ } else if (ul['image/jpeg'] != undefined) {
+ var jpeg = ul['image/jpeg'];
+ html = '
';
+ } else if (ul['image/png'] != undefined) {
+ var png = ul['image/png'];
+ html = '
';
+ } else if (ul['text/markdown'] != undefined) {
+ html = marked(ul['text/markdown']);
+ } else if (ul['text/html'] != undefined) {
+ html = ul['text/html'];
+ } else {
+ html = marked(ul['text/plain']);
+ // [\s\S] is used to also catch newlines
+ var t = html.match(/^\s*
([\s\S]*?)<\/p>\s*$/); //strip
and
that marked (maybe) adds and we don't want + html = t !== null ? t[1] : html; + var q = html.match(/^'([\s\S]*?)'$/); // strip quotes from strings + if (q !== null) html = q[1] + } else if (out_data.msg_type === "execute_result" | out_data.msg_type === "display_data" ) { + var ul = out_data.content.data; + if (ul != undefined) { + if (ul['text/latex'] != undefined) { + html = ul['text/latex']; + } else if (ul['image/svg+xml'] != undefined) { + var svg = ul['image/svg+xml']; + /* embed SVG in an';
+ } else if (ul['image/jpeg'] != undefined) {
+ var jpeg = ul['image/jpeg'];
+ html = '';
+ } else if (ul['image/png'] != undefined) {
+ var png = ul['image/png'];
+ html = '';
+ } else if (ul['text/markdown'] != undefined) {
+ html = marked(ul['text/markdown']);
+ } else if (ul['text/html'] != undefined) {
+ html = ul['text/html'];
+ } else {
+ html = marked(ul['text/plain']);
+ // [\s\S] is used to also catch newlines
+ var t = html.match(/^\s*([\s\S]*?)<\/p>\s*$/); //strip
and
that marked adds and we don't want + html = t !== null ? t[1] : html; + var q = html.match(/^'([\s\S]*?)'$/); // strip quotes from strings + if (q !== null) html = q[1] + } + } + } else { + return; + } + thiscell.metadata.variables[thismatch] = html; + var el = document.getElementById(id); + el.innerHTML = el.innerHTML + html; // output result + }; + var callbacks = { iopub : { output: execute_callback } }; + if (cell.notebook.kernel != null) { + cell.notebook.kernel.execute(code, callbacks, {silent: false, store_history : false, stop_on_error: false }); + return ""; // add HTML tag with ID where output will be placed + } + return undefined; + } else { + /* Notebook not dirty: replace tags with metadata */ + val = cell.metadata.variables[tag]; + return ""+val+"" + } + }); + if (found == true) return newtext; + return undefined + }; + + /* + * Render markdown cell and replace {{...}} with python code + * + */ + var render_cell = function(cell) { + var element = cell.element.find('div.text_cell_render'); + var text = execute_python(cell, element[0].innerHTML); + if (text !== undefined) { + element[0].innerHTML = text; + MathJax.Hub.Queue(["Typeset",MathJax.Hub,element[0]]); + } + }; + + /* force rendering of markdown cell if notebook is dirty */ + var original_render = textcell.MarkdownCell.prototype.render; + textcell.MarkdownCell.prototype.render = function() { + if (IPython.notebook.dirty === true) { + this.rendered = false + } + return original_render.apply(this) + }; + + var set_trusted_indicator = function() { + var ind = $('.notebook-trusted'); + if (IPython.notebook.trusted === true) { + ind.attr('title','Notebook is trusted'); + ind.removeClass('fa-question'); + ind.addClass('fa-check'); + } else { + ind.attr('title','Notebook is not trusted'); + ind.removeClass('fa-check'); + ind.addClass('fa-question'); + } + }; + + + /** + * Add CSS file + * + * @param name filename + */ + var load_css = function (name) { + var link = document.createElement("link"); + link.type = "text/css"; + link.rel = "stylesheet"; + link.href = requirejs.toUrl(name); + document.getElementsByTagName("head")[0].appendChild(link); + }; + + + /** + * Update all references variables in markdown cells + * + */ + var update_md_cells = function () { + var ncells = IPython.notebook.ncells(); + var cells = IPython.notebook.get_cells(); + for (var i = 0; i < ncells; i++) { + var cell = cells[i]; + if (cell.metadata.hasOwnProperty('variables')) { + render_cell(cell) + } + } + }; + + var load_ipython_extension = function() { + load_css('./main.css'); + events.on("rendered.MarkdownCell", function (event, data) { + render_cell(data.cell); + }); + events.on("trust_changed.Notebook", set_trusted_indicator); + + $('#save_widget').append(''); + set_trusted_indicator(); + + /* Show values stored in metadata on reload */ + events.on("kernel_ready.Kernel", function () { + if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) { + update_md_cells() + } else { + events.on("notebook_loaded.Notebook", function () { + update_md_cells() + }) + } + }); + }; + + return { + load_ipython_extension : load_ipython_extension + }; +}); diff --git a/.local/share/jupyter/nbextensions/python-markdown/python-markdown-pre.png b/.local/share/jupyter/nbextensions/python-markdown/python-markdown-pre.png new file mode 100644 index 0000000000000000000000000000000000000000..5226d959bc375b4cc1ceda7cc9168fafe434adf8 Binary files /dev/null and b/.local/share/jupyter/nbextensions/python-markdown/python-markdown-pre.png differ diff --git a/.local/share/jupyter/nbextensions/python-markdown/untrusted.png b/.local/share/jupyter/nbextensions/python-markdown/untrusted.png new file mode 100644 index 0000000000000000000000000000000000000000..36c2b1ff08b166b4f386dcdb44f49ed4df4a098e Binary files /dev/null and b/.local/share/jupyter/nbextensions/python-markdown/untrusted.png differ diff --git a/.local/share/jupyter/nbextensions/rubberband/rubberband.yaml b/.local/share/jupyter/nbextensions/rubberband/rubberband.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fa643c51afdfb54820a9602c62402f08b3ebf585 --- /dev/null +++ b/.local/share/jupyter/nbextensions/rubberband/rubberband.yaml @@ -0,0 +1,7 @@ +Type: IPython Notebook Extension +Name: Rubberband +Description: The rubberband extension allows selecting multiple cells +Link: readme.md +Icon: icon.png +Main: main.js +Compatibility: 4.x, 5.x diff --git a/.local/share/jupyter/nbextensions/ruler/edit.js b/.local/share/jupyter/nbextensions/ruler/edit.js new file mode 100644 index 0000000000000000000000000000000000000000..5e4283e27a91f25b2f2294f9d9bce83d83d5c7a4 --- /dev/null +++ b/.local/share/jupyter/nbextensions/ruler/edit.js @@ -0,0 +1,4 @@ +define(['./main'], function (ruler) { + "use strict"; + return ruler; +}); diff --git a/.local/share/jupyter/nbextensions/ruler/main.js b/.local/share/jupyter/nbextensions/ruler/main.js new file mode 100644 index 0000000000000000000000000000000000000000..c2d6e68649a709adb5b4e21562e356618363df49 --- /dev/null +++ b/.local/share/jupyter/nbextensions/ruler/main.js @@ -0,0 +1,124 @@ +// Add rulers to codecells +define([ + 'base/js/namespace', + 'base/js/events', + 'services/config', + 'notebook/js/codecell', + 'codemirror/lib/codemirror', + 'codemirror/addon/display/rulers' +], function (Jupyter, events, configmod, codecell, codemirror) { + "use strict"; + + var log_prefix = '[ruler]'; + + // define default config parameter values + var params = { + ruler_column: [78], + ruler_color: ["#ff0000"], + ruler_linestyle: ["dashed"], + ruler_do_css_patch: false + }; + + + var rulers = []; + + var isNumber = function (n) { + return !isNaN(parseFloat(n)) && isFinite(n); + }; + + // updates default params with any specified in the provided config data + var update_params = function (config_data) { + for (var key in params) { + if (config_data.hasOwnProperty(key)) { + params[key] = config_data[key]; + } + } + }; + + var on_config_loaded = function () { + + if (Jupyter.notebook !== undefined) { + var i, config = Jupyter.notebook.config; + } else { + var i, config = Jupyter.editor.config; + } + + if (config.data.hasOwnProperty('ruler_color') && config.data.ruler_color.length > 0) { + params.ruler_color = config.data.ruler_color; + } + + if (config.data.hasOwnProperty('ruler_column')) { + var new_columns = []; + for (i in config.data.ruler_column) { + if (isNumber(config.data.ruler_column[i])) { + new_columns.push(config.data.ruler_column[i]); + } + } + if (new_columns.length > 0) { + params.ruler_column = new_columns; + } + } + + if (config.data.hasOwnProperty('ruler_linestyle') && config.data.ruler_linestyle.length > 0) { + params.ruler_linestyle = config.data.ruler_linestyle; + } + + for (i in params.ruler_column) { + rulers.push({ + color: params.ruler_color[i % params.ruler_color.length], + column: params.ruler_column[i], + lineStyle: params.ruler_linestyle[i % params.ruler_linestyle.length] + }); + } + console.debug(log_prefix, 'ruler specs:', rulers); + + if (Jupyter.notebook !== undefined) { + var i, config = Jupyter.notebook.config; + + // Change default for new cells + codecell.CodeCell.options_default.cm_config.rulers = rulers; + // Apply to any already-existing cells + var cells = Jupyter.notebook.get_cells().forEach(function (cell) { + if (cell instanceof codecell.CodeCell) { + cell.code_mirror.setOption('rulers', rulers); + } + }); + + } + else { + Jupyter.editor.codemirror.setOption('rulers', rulers); + } + }; + + var load_extension = function () { + + // first, check which view we're in, in order to decide whether to load + var conf_sect; + if (Jupyter.notebook) { + // we're in notebook view + conf_sect = Jupyter.notebook.config; + } + else if (Jupyter.editor) { + // we're in file-editor view + conf_sect = Jupyter.editor.config; + } + else { + // we're some other view like dashboard, terminal, etc, so bail now + return; + } + + conf_sect.loaded + .then(function () { + update_params(conf_sect.data); + }) + .then(on_config_loaded) + .catch(function on_error(reason) { + console.warn(log_prefix, 'error:', reason); + }); + }; + + var extension = { + load_ipython_extension: load_extension + }; + return extension; +}); diff --git a/.local/share/jupyter/nbextensions/runtools/demo.gif b/.local/share/jupyter/nbextensions/runtools/demo.gif new file mode 100644 index 0000000000000000000000000000000000000000..d906670d94ad392efddd35dc3f5d3e1e2b051f44 Binary files /dev/null and b/.local/share/jupyter/nbextensions/runtools/demo.gif differ diff --git a/.local/share/jupyter/nbextensions/runtools/gutter.css b/.local/share/jupyter/nbextensions/runtools/gutter.css new file mode 100644 index 0000000000000000000000000000000000000000..cebc4a99835ca52becb18ada654f0360b6ca4a1c --- /dev/null +++ b/.local/share/jupyter/nbextensions/runtools/gutter.css @@ -0,0 +1,3 @@ +.CodeMirror-cellstate { + width: 0.5em; +} diff --git a/.local/share/jupyter/nbextensions/runtools/main.js b/.local/share/jupyter/nbextensions/runtools/main.js new file mode 100644 index 0000000000000000000000000000000000000000..c07de86a71165f61b8f307549a9b333f502ac3da --- /dev/null +++ b/.local/share/jupyter/nbextensions/runtools/main.js @@ -0,0 +1,745 @@ +// Extended code execution commands and more + +define([ + 'base/js/namespace', + 'jquery', + 'require', + 'base/js/events', + 'services/config', + 'base/js/utils', + 'notebook/js/codecell' +], function(Jupyter, $, requirejs, events, configmod, utils, codecell) { + "use strict"; + + var run_list = []; /* list of cells to be run */ + + // define default config parameter values + var params = { + run_cells_above: 'Alt-a', + run_cells_below: 'Alt-b', + toggle_marker: 'Alt-t', + mark_all_codecells: 'Alt-m', + unmark_all_codecells: 'Alt-u', + run_marked_cells: 'Alt-r', + run_all_cells: 'Alt-x', + run_all_cells_ignore_errors: 'Alt-f', + stop_execution: 'Ctrl-c', + marked_color: '#20f224', + scheduled_color: '#00def0', + run_color: '#f30a2d' + }; + + /** + * Add event if user clicks on codemirror gutter + * + */ + function add_gutter_events() { + var ncells = Jupyter.notebook.ncells(); + var cells = Jupyter.notebook.get_cells(); + for (var i = 0; i < ncells; i++) { + var cell = cells[i]; + if ((cell.cell_type === "code")) { + cell.code_mirror.on("gutterClick", changeEvent); + if (is_marked(cell)) { + var g = cell.code_mirror.getGutterElement(); + $(g).css({ + "background-color": params.marked_color + }); + } + } + } + } + + /* + * Initialize toolbar and gutter after config was loaded + */ + function initialize() { + $.extend(true, params, Jupyter.notebook.config.data.runtools); + + add_gutter_events(); + + /* Add run control buttons to toolbar */ + $(Jupyter.toolbar.add_buttons_group([ + Jupyter.keyboard_manager.actions.register ({ + help: 'Toggle Runtools Toolbar', + icon: 'fa-cogs', + handler: toggle_toolbar + }, 'toggle-runtools-toolbar', 'runtools') + ])).find('.btn').attr('id', 'toggle_runtools').css({ + 'outline': 'none' + }); + + /* Add keyboard shortcuts */ + var add_command_shortcuts = {}; + add_command_shortcuts[params["run_cells_above"]] = { + help: 'Run cells above', + help_index: 'xa', + handler: function() { + execute_cells_above(); + return false; + } + }; + add_command_shortcuts[params["run_cells_below"]] = { + help: 'Run cells below', + help_index: 'aa', + handler: function() { + execute_cells_below(); + return false; + } + }; + add_command_shortcuts[params["toggle_marker"]] = { + help: 'Toggle marker', + help_index: 'mt', + handler: function() { + toggle_marker(); + return false; + } + }; + add_command_shortcuts[params["mark_all_codecells"]] = { + help: 'Mark all codecells', + help_index: 'ma', + handler: function() { + mark_all(); + return false; + } + }; + add_command_shortcuts[params["unmark_all_codecells"]] = { + help: 'Unmark all codecells', + help_index: 'mu', + handler: function() { + mark_none(); + return false; + } + }; + add_command_shortcuts[params["run_marked_cells"]] = { + help: 'Run marked cells', + help_index: 'rm', + handler: function() { + run_marked_cells(); + return false; + } + }; + add_command_shortcuts[params["run_all_cells"]] = { + help: 'Run all cells', + help_index: 'ra', + handler: function() { + var pos = Jupyter.notebook.element.scrollTop(); + execute_all_cells(); + Jupyter.notebook.element.animate({ + scrollTop: pos + }, 100); + return false; + } + }; + add_command_shortcuts[params["run_all_cells_ignore_errors"]] = { + help: 'Run all cells - ignore errors', + help_index: 'rf', + handler: function() { + run_all_cells_ignore_errors(); + return false; + } + }; + Jupyter.keyboard_manager.command_shortcuts.add_shortcuts(add_command_shortcuts); + Jupyter.keyboard_manager.edit_shortcuts.add_shortcuts(add_command_shortcuts); + + events.on('finished_execute.CodeCell', finished_execute_event); + } + + /** + * Hide or show a cell + * + * @param cell + * @param io 'i' for cell input, 'o' for cell output + * @param showme {Boolean} show (true) or hide (false) cell + */ + function showCell(cell, io, showme) { + if (io === 'i') { + if (showme === true) { + cell.element.find("div.input").show(); + cell.metadata.hide_input = false; + } else { + cell.element.find("div.input").hide(); + cell.metadata.hide_input = true; + } + } else { + if (showme === true) { + cell.element.find('div.output').show(); + cell.metadata.hide_output = false; + } else { + cell.element.find('div.output').hide(); + cell.metadata.hide_output = true; + } + } + } + + function _show_input_output_of_marked(show, char) { + var cells = Jupyter.notebook.get_cells(); + var ncells = cells.length; + for (var i = 0; i < ncells; i++) { + var _cell = cells[i]; + if (is_marked(_cell)) + showCell(_cell, char, show); + } + } + + /** + * Hide or show input of all marked code cells + * + * @param show {Boolean} show (true) or hide (false) code cells + */ + function show_input(show) { + _show_input_output_of_marked(show, 'i'); + } + + /** + * Hide or show output area of all marked code cells + * + * @param {Boolean} show show (true) or hide (false) + */ + function show_output(show) { + _show_input_output_of_marked(show, 'o'); + } + + + /** + * Execute next cell in run list, if it is still marked + * + */ + function execute_next_marked_cell() { + var cells = Jupyter.notebook.get_cells(); + var end = cells.length; + while (run_list.length > 0) { + var runcell = run_list.shift(); + for (var i = 0; i < end; i++) { + if (runcell === cells[i]) { + if (runcell.metadata.run_control !== undefined && runcell.metadata.run_control.marked === true) { + var g = runcell.code_mirror.getGutterElement(); + $(g).css({ + "background-color": params.run_color + }); + runcell.execute(); + return; + } + } + } + } + } + + function _execute_without_selecting(idx_start, idx_end, stop_on_error) { + // notebook.execute_cells alters selection, this doesn't + var cells = Jupyter.notebook.get_cells(); + idx_start = idx_start !== undefined ? idx_start : 0; + idx_end = idx_end !== undefined ? idx_end : cells.length; + for (var ii = idx_start; ii < idx_end; ii++) { + cells[ii].execute(stop_on_error); + } + } + + function execute_cells_above() { + _execute_without_selecting(0, Jupyter.notebook.get_selected_index()); + } + + function execute_cells_below() { + _execute_without_selecting(Jupyter.notebook.get_selected_index(), undefined); + } + + function execute_all_cells(stop_on_error) { + _execute_without_selecting(0, undefined, stop_on_error); + } + + /** + * Run code cells marked in metadata + * + */ + function run_marked_cells() { + var cells = Jupyter.notebook.get_cells(); + var end = cells.length; + run_list = []; + /* Show all marked cells as scheduled to be run with new gutter background color */ + for (var i = 0; i < end; i++) { + var cell = cells[i]; + if (cell instanceof codecell.CodeCell) { + var last_line = cell.code_mirror.lastLine(); + var cell_empty = ( last_line === 0 && cell.code_mirror.getLine(last_line) === ""); + if (cell.metadata.run_control !== undefined && cell_empty === false) { + if (cell.metadata.run_control.marked === true) { + var g = cell.code_mirror.getGutterElement(); + $(g).css({ + "background-color": params.scheduled_color + }); + run_list.push(cell); + } + } + } + } + execute_next_marked_cell(); + } + + /* + * Execute next cell in run_list when notified execution of last cell has been finished + * @param evt Event + * @param data Cell that has finished executing + */ + var finished_execute_event = function(evt, data) { + var cell = data.cell; + /* Reset gutter color no non-queued state */ + if (is_marked(cell)) { + var g = cell.code_mirror.getGutterElement(); + $(g).css({ + "background-color": params.marked_color + }); + } + execute_next_marked_cell(); + }; + + /** + * + * @param cell + * @param value + */ + function setCell(cell, value) { + if (!(cell instanceof codecell.CodeCell)) return; + if (cell.metadata.run_control === undefined) cell.metadata.run_control = {}; + if (cell.metadata.run_control.marked === undefined) cell.metadata.run_control.marked = false; + if (value === undefined) value = !cell.metadata.run_control.marked; + var g = cell.code_mirror.getGutterElement(); + if (value === false) { + cell.metadata.run_control.marked = false; + $(g).css({ + "background-color": "" + }); + } else { + cell.metadata.run_control.marked = true; + $(g).css({ + "background-color": params.marked_color + }); + } + } + + function setCellsMarked(cells, value) { + var ncells = cells.length; + for (var i = 0; i < ncells; i++) { + setCell(cells[i], value); + } + } + + /** + * Toggle code cell marker + */ + function toggle_marker() { + setCellsMarked(Jupyter.notebook.get_selected_cells(), undefined); + } + + /** + * + */ + function mark_all() { + setCellsMarked(Jupyter.notebook.get_cells(), true); + } + + /** + * + */ + function mark_none() { + setCellsMarked(Jupyter.notebook.get_cells(), false); + } + + /** + * + * @param cell notebook cell instance + * @param state {string} state to be display [ '', 'locked', 'executed', 'modified' ] + */ + function set_cell_state(cell, state) { + var icon = ""; + if (state === 'locked') { + icon = ''
+ }
+ cell.code_mirror.setGutterMarker(0, "CodeMirror-cellstate", celltypeMarker(icon))
+ }
+
+ /**
+ * Change event to mark/unmark cell
+ *
+ * @param cm codemirror instance
+ * @param line current line
+ * @param gutter not used
+ */
+ function changeEvent(cm, line, gutter) {
+ if (gutter === "CodeMirror-foldgutter") return; /* Don't collide with codefolding extension */
+
+ var cmline = cm.doc.children[0].lines[line];
+ if (cmline === undefined) {
+ return;
+ }
+ var cell = $(cm.display.gutters).closest('.cell').data('cell');
+ if (cell.metadata.run_control === undefined)
+ cell.metadata.run_control = {};
+ setCell(cell, !cell.metadata.run_control.marked);
+ }
+
+ /**
+ *
+ * @param cell cell to be tested
+ * @returns {boolean} true if marked
+ */
+ var is_marked = function(cell) {
+ return (cell instanceof codecell.CodeCell) &&
+ cell.metadata.run_control !== undefined &&
+ cell.metadata.run_control.marked;
+ };
+
+ /**
+ * Return div element to set in cellstate gutter
+ *
+ * @param val HTML string
+ * @returns {Element} div Element
+ */
+ function celltypeMarker(val) {
+ var marker = document.createElement("div");
+ marker.style.color = "#822";
+ marker.innerHTML = val;
+ return marker;
+ }
+
+ /**
+ * Lock/Unlock current code cell
+ * if (cell.metadata.run_control != undefined && cell.metadata.run_control.read_only) {
+ * cell.code_mirror.setOption('readOnly', cell.metadata.run_control.read_only);
+ */
+ var lock_cell = function(locked) {
+ var ncells = Jupyter.notebook.ncells();
+ for (var i = ncells - 2; i >= 0; i--) {
+ var cells = Jupyter.notebook.get_cells();
+ if ((cells[i].cell_type === "code") && is_marked(cells[i])) {
+ if (locked === true) {
+ cells[i].metadata.editable = false;
+ set_cell_state(cells[i], 'locked')
+ } else {
+ cells[i].metadata.editable = true;
+ set_cell_state(cells[i], '')
+ }
+ }
+ }
+ };
+
+ /**
+ * Execute all cells and don't stop on errors
+ *
+ */
+ var run_all_cells_ignore_errors = function() {
+ execute_all_cells(false);
+ };
+
+ /**
+ * Create floating toolbar
+ *
+ */
+ var create_runtools_div = function() {
+ var btn = '';
+
+ var runtools_wrapper = $('
')
+ .text("Runtools")
+ .append(btn)
+ .draggable()
+ .append("
");
+
+ $("#header").append(runtools_wrapper);
+ $("#runtools-wrapper").css({
+ 'position': 'absolute'
+ });
+ $('#run_c').on('click', function(e) {
+ var idx = Jupyter.notebook.get_selected_index();
+ _execute_without_selecting(idx, idx + 1);
+ e.target.blur();
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#run_ca').on('click', function(e) {
+ execute_cells_above();
+ e.target.blur();
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#run_cb').on('click', function(e) {
+ execute_cells_below();
+ e.target.blur();
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#run_a').on('click', function(e) {
+ execute_all_cells();
+ e.target.blur();
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#run_af').on('click', function(e) {
+ run_all_cells_ignore_errors();
+ e.target.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#run_m').on('click', function(e) {
+ run_marked_cells();
+ e.target.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#interrupt_b').on('click', function(e) {
+ interrupt_execution();
+ e.target.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#mark_toggle').on('click', function() {
+ toggle_marker()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#mark_all').on('click', function() {
+ mark_all()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#mark_none').on('click', function() {
+ mark_none()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#show_input').on('click', function() {
+ show_input(true);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#hide_input').on('click', function() {
+ show_input(false);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#show_output').on('click', function() {
+ show_output(true);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#hide_output').on('click', function() {
+ show_output(false);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#lock_marked').on('click', function() {
+ lock_cell(true);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ $('#unlock_marked').on('click', function() {
+ lock_cell(false);
+ this.blur()
+ })
+ .tooltip({
+ delay: {
+ show: 500,
+ hide: 100
+ }
+ });
+ };
+
+ /**
+ * Show/hide toolbar
+ *
+ */
+ var toggle_toolbar = function() {
+ var dom = $("#runtools-wrapper");
+
+ if (dom.is(':visible')) {
+ $('#toggle_runtools').removeClass('active').blur();
+ dom.hide();
+ } else {
+ $('#toggle_runtools').addClass('active');
+ dom.show();
+ }
+
+ if (dom.length === 0) {
+ create_runtools_div()
+ }
+ };
+
+
+ /**
+ * Add CSS file
+ *
+ * @param name filename
+ */
+ var load_css = function(name) {
+ var link = document.createElement("link");
+ link.type = "text/css";
+ link.rel = "stylesheet";
+ link.href = requirejs.toUrl(name);
+ document.getElementsByTagName("head")[0].appendChild(link);
+ };
+
+ /**
+ * Add gutter to a new cell
+ *
+ * @param event
+ * @param nbcell
+ *
+ */
+ var createCell = function(event, nbcell) {
+ var cell = nbcell.cell;
+ if (cell instanceof codecell.CodeCell) {
+ var gutters = cell.code_mirror.getOption('gutters').slice();
+ if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+ gutters.push('CodeMirror-cellstate');
+ cell.code_mirror.setOption('gutters', gutters);
+ cell.code_mirror.on("gutterClick", changeEvent);
+
+ }
+ }
+ };
+
+
+ /**
+ * Initialize all cells with new gutter
+ */
+ var initGutter = function() {
+ var cells = Jupyter.notebook.get_cells();
+ var ncells = cells.length;
+ for (var i = 0; i < ncells; i++) {
+ var cell = cells[i];
+ if (cell instanceof codecell.CodeCell) {
+ var gutters = cell.code_mirror.getOption('gutters').slice();
+ if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+ gutters.push('CodeMirror-cellstate');
+ cell.code_mirror.setOption('gutters', gutters);
+ }
+ }
+ /**
+ * Restore hide/show status after reload
+ */
+ if (cell.metadata.hasOwnProperty('hide_input') && cell.metadata.hide_input === true)
+ showCell(cell, 'i', false);
+ if (cell.metadata.hasOwnProperty('hide_output') && cell.metadata.hide_output === true)
+ showCell(cell, 'o', false);
+ if (cell.is_editable() === false) {
+ set_cell_state(cell, 'locked');
+ }
+ cell.code_mirror.refresh();
+ }
+ events.on('create.Cell', createCell);
+ };
+
+ /**
+ * Called from notebook after extension was loaded
+ *
+ */
+ var load_extension = function() {
+ load_css('./main.css');
+ load_css('./gutter.css'); /* set gutter width */
+ requirejs(['./cellstate'], function() {
+ if (Jupyter.notebook._fully_loaded) {
+ initGutter();
+ } else {
+ events.one('notebook_loaded.Notebook', initGutter);
+ }
+ });
+ Jupyter.notebook.config.loaded.then(initialize);
+ };
+
+ return {
+ load_jupyter_extension: load_extension,
+ load_ipython_extension: load_extension
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/runtools/runtools.yaml b/.local/share/jupyter/nbextensions/runtools/runtools.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..995b80334ad2b8bd8b2f3f9d8c6922036a939d74
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/runtools/runtools.yaml
@@ -0,0 +1,59 @@
+Type: IPython Notebook Extension
+Name: Runtools
+Description: Runtools provide a number of additional functions for working with code cells in the IPython notebook
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 5.x
+Parameters:
+- name: runtools.run_cells_above
+ description: run cells above
+ input_type: hotkey
+ default: Alt-a
+- name: runtools.run_cells_below
+ description: run cells below
+ input_type: hotkey
+ default: Alt-b
+- name: runtools.toggle_marker
+ description: Toggle marker
+ input_type: hotkey
+ default: Alt-t
+- name: runtools.mark_all_codecells
+ description: Mark all codecells
+ input_type: hotkey
+ default: Alt-m
+- name: runtools.unmark_all_codecells
+ description: Unmark all codecells
+ input_type: hotkey
+ default: Alt-u
+- name: runtools.run_marked_cells
+ description: run marked cells
+ input_type: hotkey
+ default: Alt-r
+- name: runtools.stop_execution
+ description: stop execution
+ input_type: hotkey
+ default: Ctrl-c
+- name: runtools.run_all_cells
+ description: run all cells
+ input_type: hotkey
+ default: Alt-x
+- name: runtools.run_alls_cells_ignore_errors
+ description: run all cells - ignore errors
+ input_type: hotkey
+ default: Alt-f
+- name: runtools.marked_color
+ description: |
+ Color for marking a codecell
+ default: '#20f224'
+ input_type: color
+- name: runtools.scheduled_color
+ description: |
+ Color when a codecell is scheduled to be rund
+ default: '#00def0'
+ input_type: color
+- name: runtools.run_color
+ description: |
+ Color while a codecell is being run
+ default: '#f30a2d'
+ input_type: color
diff --git a/.local/share/jupyter/nbextensions/runtools/runtools_execute.png b/.local/share/jupyter/nbextensions/runtools/runtools_execute.png
new file mode 100644
index 0000000000000000000000000000000000000000..ed8e96c1d3cf35acf07b2d6e58c5b9aceb0cef01
Binary files /dev/null and b/.local/share/jupyter/nbextensions/runtools/runtools_execute.png differ
diff --git a/.local/share/jupyter/nbextensions/runtools/runtools_lock.png b/.local/share/jupyter/nbextensions/runtools/runtools_lock.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b0a56161b2ca60b219517df85c2aeafa53a97f8
Binary files /dev/null and b/.local/share/jupyter/nbextensions/runtools/runtools_lock.png differ
diff --git a/.local/share/jupyter/nbextensions/runtools/runtools_nb.png b/.local/share/jupyter/nbextensions/runtools/runtools_nb.png
new file mode 100644
index 0000000000000000000000000000000000000000..162c3660003be2186dbc4fbfd0a2101f93a2b5bc
Binary files /dev/null and b/.local/share/jupyter/nbextensions/runtools/runtools_nb.png differ
diff --git a/.local/share/jupyter/nbextensions/runtools/runtools_show_hide.png b/.local/share/jupyter/nbextensions/runtools/runtools_show_hide.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ff9477aa0c17d40a79b896164ac7be718953c50
Binary files /dev/null and b/.local/share/jupyter/nbextensions/runtools/runtools_show_hide.png differ
diff --git a/.local/share/jupyter/nbextensions/scratchpad/LICENSE b/.local/share/jupyter/nbextensions/scratchpad/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e11323e4e259a9c535528bf18957f954af354a05
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/scratchpad/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2016, Min RK
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of nbextension-scratchpad nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.local/share/jupyter/nbextensions/scratchpad/README.md b/.local/share/jupyter/nbextensions/scratchpad/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..069bd4858d50840d83b89567331a19f4737dad19
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/scratchpad/README.md
@@ -0,0 +1,14 @@
+# Scratchpad notebook extension
+
+Adds a scratchpad cell to Jupyter notebook.
+This is a cell in which you can execute code against the current kernel without modifying the notebook document.
+
+Scratchpad cells can be executed using `Shift-Enter` (other shortcuts are appled to the notebook document). The scratchpad can be toggled by clicking the icon in the bottom-right, or via the keyboard shortcut `Ctrl-B`.
+
+
+
+
+## Credits
+
+This extension is a copy of the extension from MinRK here:
+`git clone git://github.com/minrk/nbextension-scratchpad`.
diff --git a/.local/share/jupyter/nbextensions/scratchpad/main.js b/.local/share/jupyter/nbextensions/scratchpad/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..d92b821a13c7fe15f8c82407cc9726de0102d37b
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/scratchpad/main.js
@@ -0,0 +1,149 @@
+define([
+ 'require',
+ 'jquery',
+ 'base/js/namespace',
+ 'base/js/events',
+ 'base/js/utils',
+ 'notebook/js/codecell',
+], function (
+ requirejs,
+ $,
+ Jupyter,
+ events,
+ utils,
+ codecell
+) {
+ "use strict";
+ var CodeCell = codecell.CodeCell;
+
+ var Scratchpad = function (nb) {
+ var scratchpad = this;
+ this.notebook = nb;
+ this.kernel = nb.kernel;
+ this.km = nb.keyboard_manager;
+ this.collapsed = true;
+
+ // create elements
+ this.element = $("");
+ this.close_button = $("").addClass("fa fa-caret-square-o-down scratchpad-btn scratchpad-close");
+ this.open_button = $("").addClass("fa fa-caret-square-o-up scratchpad-btn scratchpad-open");
+ this.element.append(this.close_button);
+ this.element.append(this.open_button);
+ this.open_button.click(function () {
+ scratchpad.expand();
+ });
+ this.close_button.click(function () {
+ scratchpad.collapse();
+ });
+
+ // create my cell
+ var cell = this.cell = new CodeCell(nb.kernel, {
+ events: nb.events,
+ config: nb.config,
+ keyboard_manager: nb.keyboard_manager,
+ notebook: nb,
+ tooltip: nb.tooltip,
+ });
+ cell.set_input_prompt();
+ this.element.append($("").addClass('cell-wrapper').append(this.cell.element));
+ cell.render();
+ cell.refresh();
+ this.collapse();
+
+ // override ctrl/shift-enter to execute me if I'm focused instead of the notebook's cell
+ var execute_and_select_action = this.km.actions.register({
+ handler: $.proxy(this.execute_and_select_event, this),
+ }, 'scratchpad-execute-and-select');
+ var execute_action = this.km.actions.register({
+ handler: $.proxy(this.execute_event, this),
+ }, 'scratchpad-execute');
+ var toggle_action = this.km.actions.register({
+ handler: $.proxy(this.toggle, this),
+ }, 'scratchpad-toggle');
+
+ var shortcuts = {
+ 'shift-enter': execute_and_select_action,
+ 'ctrl-enter': execute_action,
+ 'ctrl-b': toggle_action,
+ }
+ this.km.edit_shortcuts.add_shortcuts(shortcuts);
+ this.km.command_shortcuts.add_shortcuts(shortcuts);
+
+ // finally, add me to the page
+ $("body").append(this.element);
+ };
+
+ Scratchpad.prototype.toggle = function () {
+ if (this.collapsed) {
+ this.expand();
+ } else {
+ this.collapse();
+ }
+ return false;
+ };
+
+ Scratchpad.prototype.expand = function () {
+ this.collapsed = false;
+ var site_height = $("#site").height();
+ this.element.animate({
+ height: site_height,
+ }, 200);
+ this.open_button.hide();
+ this.close_button.show();
+ this.cell.element.show();
+ this.cell.focus_editor();
+ //$("#notebook-container").css('margin-left', 0);
+ };
+
+ Scratchpad.prototype.collapse = function () {
+ this.collapsed = true;
+ //$("#notebook-container").css('margin-left', 'auto');
+ this.element.animate({
+ height: 0,
+ }, 100);
+ this.close_button.hide();
+ this.open_button.show();
+ this.cell.element.hide();
+ };
+
+ Scratchpad.prototype.execute_and_select_event = function (evt) {
+ if (utils.is_focused(this.element)) {
+ this.cell.execute();
+ } else {
+ this.notebook.execute_cell_and_select_below();
+ }
+ };
+
+ Scratchpad.prototype.execute_event = function (evt) {
+ if (utils.is_focused(this.element)) {
+ this.cell.execute();
+ } else {
+ this.notebook.execute_selected_cells();
+ }
+ };
+
+ function setup_scratchpad () {
+ // lazy, hook it up to Jupyter.notebook as the handle on all the singletons
+ console.log("Setting up scratchpad");
+ return new Scratchpad(Jupyter.notebook);
+ }
+
+ function load_extension () {
+ // add css
+ var link = document.createElement("link");
+ link.type = "text/css";
+ link.rel = "stylesheet";
+ link.href = requirejs.toUrl("./scratchpad.css");
+ document.getElementsByTagName("head")[0].appendChild(link);
+ // load when the kernel's ready
+ if (Jupyter.notebook.kernel) {
+ setup_scratchpad();
+ } else {
+ events.on('kernel_ready.Kernel', setup_scratchpad);
+ }
+ }
+
+ return {
+ load_ipython_extension: load_extension,
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/scroll_down/config.yaml b/.local/share/jupyter/nbextensions/scroll_down/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..96aa07c5cd50c71a41d349ecab042fae2af1000d
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/scroll_down/config.yaml
@@ -0,0 +1,12 @@
+Type: IPython Notebook Extension
+Name: ScrollDown
+Description: Scroll outputs down automatically
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: scrollDownIsEnabled
+ description: enable scroll_down toolbar button
+ input_type: checkbox
+ default: false
diff --git a/.local/share/jupyter/nbextensions/select_keymap/select_keymap.yaml b/.local/share/jupyter/nbextensions/select_keymap/select_keymap.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9cf0d305997740d06e924178c656134f3b302771
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/select_keymap/select_keymap.yaml
@@ -0,0 +1,15 @@
+Type: Jupyter Notebook Extension
+Name: Select CodeMirror Keymap
+Link: README.md
+Description: "A little extension to choose between CodeMirror keymaps: default, emacs, vim, and sublime"
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: select_keymap_line_wrap
+ description: Enable line wrap in CodeMirror
+ input_type: checkbox
+ default: true
+- name: select_keymap_local_storage
+ description: Store keymap selection on the client instead of server config
+ input_type: checkbox
+ default: true
diff --git a/.local/share/jupyter/nbextensions/skill/main.js b/.local/share/jupyter/nbextensions/skill/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..93ff45950cdf69aa0add4ea582db2ca0adc7c281
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/skill/main.js
@@ -0,0 +1,14 @@
+define(function() {
+ "use strict";
+ // jupyter nbextensions must export a load_ipython_extension function to
+ // avoid throwing an error. Also, loading the module should do nothing
+ // unless the function is called, so we wrap requiring the codemirror mode
+ // in the load call.
+ return {
+ load_ipython_extension: function () {
+ requirejs(['./skill'], function () {
+ console.log('[SKILL Syntax] loaded');
+ });
+ }
+ };
+});
\ No newline at end of file
diff --git a/.local/share/jupyter/nbextensions/skill/skill.js b/.local/share/jupyter/nbextensions/skill/skill.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ee3ace423c7e1a2cf8645eeb8b366bb2302c390
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/skill/skill.js
@@ -0,0 +1,159 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/**
+ * Author: Ben Varkey Benjamin, based on implementation by Koh Zi Chun
+ */
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("codemirror/lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["codemirror/lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("skill", function () {
+ var BUILTIN = "builtin", COMMENT = "comment", STRING = "string",
+ ATOM = "atom", NUMBER = "number", BRACKET = "bracket";
+ var isOperatorChar = /[+\-*&%=<>!|\/@]/;
+
+ function makeKeywords(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+
+ var keywords = makeKeywords(
+"ALIAS DATA ERC IDC IF IS IT LVS MP NG OP OPT PN SIMULATOR VAR VDC VF VN VN2 VNP VNPP VPD VS a2d abs absAbstract absAttachTechLib absCopyBinOptions absDeleteBin absDeleteBinMoveCellsTo absDeselectAllBins absDeselectBin absDeselectBinFrom absDeselectCell absDeselectCellFrom absDeselectCells absDeselectCellsInList absDisableUpdate absDistributeCells absEnableUpdate absExit absExportLEF absExportOptions absExportReport absExtract absGetBinOption absGetBinType absGetBins absGetCellProp absGetLibrary absGetOption absGetSelectedBins absGetSelectedCells absGetTerminalProp absImportCTLF absImportDEF absImportGDS absImportLEF absImportLogical absImportOptions absImportVerilog absMoveSelectedCellsToBin absNewBin absPins absRenameBin absRevalidateSelectedCells absSelect absSelectAllBins absSelectBin absSelectBinFrom absSelectCell absSelectCellFrom absSelectCells absSelectCellsInList absSetBinOption absSetCellProp absSetLibrary absSetOption absSetTerminalProp absSort absVerify absVersion abs_jitter ac acos acosh add1 addCheck addDefstructClass addDependent addPoint addSubwindow addSubwindowTitle addTitle addToExportList addToNamespace addWaveLabel addWindowLabel adpInitFloorplan adpnlSetEnv aedCopyCDF aedDeleteCDF aedEditCDF aelCheckRange aelDisplayOPParam aelEngNotation aelEnvCompile aelEnvCreate aelEnvExecute aelEnvFreeCompExpr aelEnvGetErrStr aelEnvGetGlobal aelEnvInterpret aelEnvListDeferredFuncs aelEnvListDeferredGlobals aelEnvListExprFuncs aelEnvListExprGlobals aelEnvListFuncs aelEnvListGlobals aelEnvListGlobalsValues aelEnvName aelEnvSetGlobalList aelEnvSetGlobals aelGetSignifDigits aelNumber aelPopSignifDigits aelPushSignifDigits aelSetLineage aelSignum aelStrDblNotation aelSuffixNotation aelSuffixWithUnits aelSumOPParam ahdlUpdateViewInfo alias allocateInstance almDefineParam_accuracyMode almDefineParam_additionalParam almDefineParam_fq almDefineParam_noiseParaLabel almDefineParam_nportFileB almDefineParam_otherParaLabel almDefineParam_tranAdvanParaLabel almDefineParam_tranParaLabel almGetModuleName almGetNamePrefix almGetNetlistProcedure almGetNetlistType almGetOpPointParamMap almGetOtherParameterList almGetParameterList almGetPropMappingList almGetStringParameterList almGetTerminalList almGetTerminalMap almGetViewInfoNameList almHasViewInformation almSetModuleName almSetNamePrefix almSetNetlistProcedure almSetOpPointParamMap almSetOtherParameterList almSetParameterList almSetPropMappingList almSetStringParameterList almSetTerminalList almSetTerminalMap alphaNumCmp alphalessp amsCheckCV amsError amsGetInstanceName amsGetNetlister amsGetPortExpr amsGetUniqueName amsInfo amsIsPresent amsMapName amsMtlinePrintParams amsMtlineTermOrder amsNetlist amsNportTermOrder amsPrint amsPrintAlias amsPrintAliases amsPrintAttribute amsPrintAttributes amsPrintIO amsPrintIOs amsPrintInstance amsPrintInstanceMasterName amsPrintInstanceParameter amsPrintInstanceParameters amsPrintInstancePorts amsPrintParameter amsPrintParameters amsPrintPort amsPrintPorts amsPrintWire amsPrintWires amsProcessCellViews amsSpectreToVams amsUIOptionsForm amsUIRunNetlisterForm amsUpdateTextviews amsWarning amseGeneralSetupForm amseQuickSetupForm analysis ancAdjustNameCase ancGetSimInstName and angle annPinCurrentInfoBalloon annToggleInfoBalloonVisibilityStatus ansAnalogRegCDFsimInfo ansCdlCompPrim ansCdlGetMultiplicity ansCdlGetSegmentConnections ansCdlGetSegmentInfo ansCdlGetSegmentInstParams ansCdlGetSimPropValue ansCdlHnlPrintInst ansCdlPrintConnections ansCdlPrintInheritedParams ansCdlPrintInstName ansCdlPrintInstParams ansCdlPrintInstProps ansCdlPrintModelName ansCdlPrintModuleName ansCdlPrintString apaExport apaExportCB apaStop apaStopCB appTrigger append append1 appendPath appendWaves apply applyEnterFun argc arglist argmax argmin argv armSetCalc arrayp arrayref artBlankString artClose artCloseAllFiles artCurrentInstSimName artEnableAnnotationBalloon artFlush artFprintf artGenerateHierSymbolCDF artGetCdfTargetCV artGetCellViewDesignVarList artInvalidateAmap artListOpenFiles artListToWaveform artMakeString artMakeStringPrec15 artOutfile asiAddAnalysis asiAddAnalysisField asiAddAnalysisOption asiAddDesignVarList asiAddEnvOption asiAddFlowchartLink asiAddFlowchartStep asiAddKeepOption asiAddModelLibSelection asiAddOceanAlias asiAddSimOption asiAddVerilogArgs asiAnalogAutoloadProc asiChangeAnalysis asiChangeAnalysisField asiChangeAnalysisOption asiChangeAnalysisOptionFormProperties asiChangeEnvOption asiChangeEnvOptionFormProperties asiChangeFlowchartStep asiChangeKeepOption asiChangeKeepOptionFormProperties asiChangeSimOption asiChangeSimOptionFormProperties asiCheck asiCheckAcEnabledWhenNoiseEnabled asiCheckAnalysis asiCheckBlank asiCheckBlankInstExists asiCheckBlankNetExists asiCheckBlankNumeric asiCheckBlankNumericGeq asiCheckBlankNumericGreater asiCheckBlankNumericLeq asiCheckBlankNumericNequal asiCheckDesignVariable asiCheckDigitalSimulationSuccess asiCheckExpression asiCheckExpressionGreater asiCheckMultipleGreater asiCheckSimulationSuccess asiCloseOceanScript asiConstructDigitalNetlist asiCornerSimCB asiCreateAnalysisField asiCreateAnalysisOption asiCreateCdsenvFile asiCreateFlowchart asiCreateFormatter asiCreateLogFileVerilog asiDcStore asiDefineDataAccessFunction asiDefineDataMappingFunction asiDeleteAnalysis asiDeleteAnalysisField asiDeleteAnalysisOption asiDeleteEnvOption asiDeleteFlowchartLink asiDeleteFlowchartStep asiDeleteKeepOption asiDeleteSimOption asiDisableAnalysis asiDisplayAnalysis asiDisplayAnalysisField asiDisplayAnalysisOption asiDisplayAnalysisOptionFormProperties asiDisplayEnvOption asiDisplayEnvOptionFormProperties asiDisplayFlowchart asiDisplayHighPerformanceOption asiDisplayKeepOption asiDisplayKeepOptionFormProperties asiDisplayNetlistOption asiDisplaySimOption asiDisplaySimOptionFormProperties asiEditDigitalStimulus asiEnableAnalysis asiExecuteFlowchart asiFinalNetlist asiFormatAnalysis asiFormatAnalysisList asiFormatControlStmts asiFormatDefinitionFileList asiFormatDesignVarList asiFormatGraphicalStimuli asiFormatGraphicalStimulusFileList asiFormatInitCond asiFormatKeepList asiFormatMTSModelAndSimOptions asiFormatModelLibSelectionList asiFormatNodeSet asiFormatSimulatorOptions asiFormatTextStimulusFileList asiGetAnalogKeepList asiGetAnalogRunDir asiGetAnalogSimulator asiGetAnalysis asiGetAnalysisField asiGetAnalysisFieldChoices asiGetAnalysisFieldList asiGetAnalysisFieldVal asiGetAnalysisFormFieldChoices asiGetAnalysisFormFieldVal asiGetAnalysisName asiGetAnalysisNameList asiGetAnalysisOptionChoices asiGetAnalysisOptionList asiGetAnalysisOptionSendMethod asiGetAnalysisOptionVal asiGetAnalysisParamNameList asiGetAnalysisSigList asiGetAnalysisSimFieldList asiGetAnalysisType asiGetCalcResultsDir asiGetCommandFooter asiGetCommandLineOption asiGetCornerDesignVarList asiGetCornerList asiGetCornerModelSelectionList asiGetCornerModelingStyles asiGetCornerName asiGetCornerResultsDir asiGetCornerTemperature asiGetCurrentSession asiGetDefinitionFileList asiGetDesignCellName asiGetDesignLibName asiGetDesignVarList asiGetDesignViewName asiGetDigitalCommandLineOption asiGetDigitalKeepList asiGetDigitalNetlistFileName asiGetDigitalRunDir asiGetDigitalSimExecName asiGetDigitalSimulator asiGetDigitalSimulatorLogFileName asiGetDigitalStimulusFileName asiGetDrlData asiGetEnabledAnalysisList asiGetEnvOptionChoices asiGetEnvOptionVal asiGetFlowchart asiGetFormFieldChoices asiGetFormFieldVal asiGetFormattedVal asiGetFormatter asiGetHighPerfformanceOptionVal asiGetId asiGetKeepList asiGetKeepOptionChoices asiGetKeepOptionVal asiGetLogFileList asiGetMarchList asiGetModelLibFile asiGetModelLibSection asiGetModelLibSelectionList asiGetNetlistDir asiGetNetlistOption asiGetNetworkId asiGetOutputList asiGetPlotList asiGetPredefinedCommandLineOption asiGetPsfDir asiGetReservedWordList asiGetSelObjName asiGetSelObjType asiGetSelObjValue asiGetSession asiGetSimCommandLineOrder asiGetSimExecName asiGetSimInputFileList asiGetSimInputFileName asiGetSimInputFileSuffix asiGetSimName asiGetSimOptionChoices asiGetSimOptionNameList asiGetSimOptionSendMethod asiGetSimOptionVal asiGetSimulationRunCommand asiGetSimulatorList asiGetSimulatorSrcList asiGetStimulusGlobals asiGetStimulusInputs asiGetTextStimulusFileList asiGetTool asiGetTopCellView asiGetVerilogCommandLineOption asiGetVerilogHost asiGetVerilogHostMode asiInitAdvAnalysis asiInitAnalysis asiInitDataAccessFunction asiInitEnvOption asiInitMixedKeepOption asiInitSimOption asiInitVerilog asiInitVerilogEnvOption asiInitVerilogFNLEnvOption asiInitVerilogHNLEnvOption asiInitVerilogSimOption asiInitialize asiInitializeNetlisterMixed asiInterruptSim asiInvalidateControlStmts asiInvalidateFlowchartStep asiIsAnalysisEnabled asiIsCaseSensitive asiIsConfigDesign asiLoadState asiMTSIncludeFileExtension asiMTSIncludeFormat asiMapInstanceName asiMapNetName asiMapOutputName asiMapTerminalName asiNeedSuffixEvaluation asiNetlist asiNetlistMixed asiOpenOceanScript asiPartitionDesign asiPrepareDigitalSimulation asiQuitSimulator asiRawNetlist asiRegCallBackOnSimComp asiRegisterTool asiRemoveAllModelLibSelection asiRunSimulation asiSaveState asiSelectAnalysisCompParam asiSelectAnalysisInst asiSelectAnalysisNet asiSelectAnalysisSource asiSelectInst asiSelectNet asiSelectSourceInst asiSelectTerm asiSelectTermNet asiSendAnalysis asiSendControlStmts asiSendDesignVars asiSendInitCond asiSendInitFile asiSendKeepList asiSendModelPath asiSendNetlist asiSendNodeSets asiSendOptions asiSendRestore asiSendSim asiSendUpdateFile asiSetAnalogSimulator asiSetAnalysisFieldChoices asiSetAnalysisFieldVal asiSetAnalysisFormFieldChoices asiSetAnalysisFormFieldVal asiSetAnalysisFormWidth asiSetAnalysisOptionChoices asiSetAnalysisOptionFormProperties asiSetAnalysisOptionVal asiSetDesignVarList asiSetDigitalSimulator asiSetEnvOptionChoices asiSetEnvOptionVal asiSetFormFieldChoices asiSetFormFieldVal asiSetHighPerformanceOptionVal asiSetHostOptions asiSetKeepList asiSetKeepOptionChoices asiSetKeepOptionVal asiSetMarchList asiSetNetlistFormatterClass asiSetNetlistOption asiSetPlotList asiSetProjectDirChangeSetup asiSetSimOptionChoices asiSetSimOptionVal asiSetSyncFlag asiSetValid asiSetVerilogHost asiSetVerilogHostMode asiTransientStore asiUnRegCallBackOnSimComp asiVerilogNetlistMoreCB asiWriteOceanScript asin asinh assert assoc assq assv atan atan2 atanh atof atoi atom auCdl auHiUltraPCell auLvs auLvsGetLabelSuffix auProbeAddDevsForNet avSwitch average awvAddSubwindow awvAnalog2Digital awvAppendExpression awvAppendList awvAppendWaveform awvClearPlotWindow awvClearSubwindowHistory awvClearWindowHistory awvCloseCalculator awvCloseWindow awvCloseWindowMenuCB awvCreateBus awvCreateBusFromWaveList awvCreatePlotWindow awvDeleteAllWaveforms awvDeleteSubwindow awvDeleteWaveform awvDigital2Analog awvDisableRedraw awvDisplayDate awvDisplayGrid awvDisplaySubwindowTitle awvDisplayTitle awvEraseWindowMenuCB awvEval awvExitWindowFunctionAdd awvExitWindowFunctionDel awvExitWindowFunctionGet awvGetCurrentSubwindow awvGetCurrentWindow awvGetDisplayMode awvGetDrawStatus awvGetInitializationTimeout awvGetOnSubwindowList awvGetPlotStyle awvGetSavePromptNeeded awvGetSmithModeType awvGetSubwindowList awvGetUnusedEntityList awvGetWaveNameList awvGetWindowList awvGetXAxisLabel awvGetXMarkerNames awvGetYAxisLabel awvGetYMarkerNames awvInitWindowFunctionAdd awvInitWindowFunctionDel awvInitWindowFunctionGet awvIsPlotWindow awvLoadMenuCB awvLoadWindow awvLogXAxis awvLogYAxis awvPlaceWaveformLabel awvPlaceWindowLabel awvPlaceXMarker awvPlaceYMarker awvPlotExpression awvPlotList awvPlotSignals awvPlotSimpleExpression awvPlotWaveform awvPlotWaveformOption awvPrintWaveform awvRedisplaySubwindow awvRedisplayWindow awvRedrawWindowMenuCB awvRefreshOutputPlotWindows awvRemoveDate awvRemoveLabel awvRemoveSubwindowTitle awvRemoveTitle awvResetAllWindows awvResetWindow awvResumeViVA awvRfLoadPull awvSaveMenuCB awvSaveWindow awvSaveWindowImage awvSetCurrentSubwindow awvSetCurrentWindow awvSetCursorPrompts awvSetDisplayMode awvSetDisplayStatus awvSetInitializationTimeout awvSetOptionDefault awvSetOptionValue awvSetOrigin awvSetPlotStyle awvSetSavePromptNeeded awvSetSmithModeType awvSetSmithXLimit awvSetSmithYLimit awvSetUpdateStatus awvSetWaveNameList awvSetWaveformDisplayStatus awvSetXAxisLabel awvSetXLimit awvSetXScale awvSetYAxisLabel awvSetYLimit awvSetYRange awvSimplePlotExpression awvSmithAxisMenuCB awvTableSignals awvUpdateAllWindows awvUpdateWindow awvZoomFit awvZoomGraphX awvZoomGraphXY awvZoomGraphY awviEditMenuCB awviMakeActiveMenuCB awviPLoadMenuCB awviPSaveMenuCB awviPUpdateMenuCB awviShowOutputMenuCB axlAddJobPolicy axlAddModelPermissibleSectionLists axlAddOutputExpr axlAddOutputSignal axlAddOutputs axlAddOutputsColumn axlAddSpecToOutput axlAttachJobPolicy axlCloseSession axlCloseSessionInWindow axlCloseSetupDB axlCommitSetupDB axlCommitSetupDBAndHistoryAs axlCommitSetupDBas axlCorners axlCreateSession axlCustomADETestName axlDeleteJobPolicy axlDeleteOutput axlDeleteOutputsColumn axlDetachJobPolicy axlDiffSetup axlExportOutputView axlExportSetup axlGetAllCornersEnabled axlGetAllParametersDisabled axlGetAllSweepsEnabled axlGetAllVarsDisabled axlGetAttachedJobPolicy axlGetCopyRefResultsOption axlGetCorner axlGetCornerCountForName axlGetCornerNameForCurrentPointInRun axlGetCorners axlGetCornersForATest axlGetCurrentHistory axlGetCurrentResultSimulationHost axlGetCurrentRunMode axlGetDataViewHistoryUserMenu axlGetElementParent axlGetEnabled axlGetEnabledGlobalVarPerTest axlGetHistory axlGetHistoryCheckpoint axlGetHistoryEntry axlGetHistoryGroup axlGetHistoryGroupChildren axlGetHistoryGroupChildrenEntry axlGetHistoryLock axlGetHistoryName axlGetHistoryPrefix axlGetHistoryResults axlGetJobPolicy axlGetJobPolicyTypes axlGetLocalResultsDir axlGetMainSetupDB axlGetModel axlGetModelBlock axlGetModelFile axlGetModelGroup axlGetModelGroupName axlGetModelGroups axlGetModelPermissibleSectionLists axlGetModelSection axlGetModelTest axlGetModels axlGetNominalCornerEnabled axlGetOrigTestToolArgs axlGetOutputUserDefinedData axlGetOverwriteHistory axlGetOverwriteHistoryName axlGetParameter axlGetParameterValue axlGetParameters axlGetParasiticParaLCV axlGetParasiticRunMode axlGetParasiticSchLCV axlGetPointNetlistDir axlGetPointPsfDir axlGetPointRunDir axlGetPointTroubleshootDir axlGetPreRunScript axlGetReferenceHistoryItemName axlGetResultsLocation axlGetReuseNetlist axlGetRunData axlGetRunDistributeOptions axlGetRunMode axlGetRunModes axlGetRunOption axlGetRunOptionName axlGetRunOptionValue axlGetRunOptions axlGetScript axlGetScriptPath axlGetScripts axlGetSessionCellName axlGetSessionFromSetupDB axlGetSessionLibName axlGetSessionViewName axlGetSessionWindowNumber axlGetSetupDBDir axlGetSpec axlGetSpecData axlGetSpecWeight axlGetSpecs axlGetTemperatureForCurrentPointInRun axlGetTest axlGetTestToolArgs axlGetTests axlGetToolSession axlGetTopLevel axlGetUseIncremental axlGetUserDefinedOutputsColumns axlGetVar axlGetVarValue axlGetVars axlGetWCCCorner axlGetWCCHistory axlGetWCCRangeBound axlGetWCCResult axlGetWCCSpec axlGetWCCSpecs axlGetWCCTest axlGetWCCTime axlGetWCCVar axlGetWCCVarMonotonicity axlGetWCCVars axlGetWYCSigmaTargetLimit axlGetWindowSession axlImportPreRunScript axlImportSetup axlIsICRPProcess axlIsLocalResultsDir axlIsSimUsingStatParams axlJPGUICusReadFromForm axlJPGUICustDiffer axlJPGUICustHIFields axlJPGUICustOffset axlJPGUICustSelected axlJPGUICustWriteToForm axlJobIntfcDebugPrintf axlJobIntfcDebugToFile axlJobIntfcDebugp axlJobIntfcExitMethod axlJobIntfcHealthMethod axlJobIntfcSetDebug axlJobIntfcStartMethod axlLoadCorners axlLoadCornersFromPcfToSetupDB axlLoadHistory axlLoadSetupState axlMainAppSaveSetup axlMapInstTermToNet axlNewSetupDB axlNewSetupDBLCV axlNoSession axlOpenResDB axlOutputResult axlOutputsExportToFile axlOutputsImportFromFile axlPutCorner axlPutDisabledCorner axlPutHistoryEntry axlPutModel axlPutModelGroup axlPutRunOption axlPutScript axlPutTest axlPutVar axlReadHistoryResDB axlReadResDB axlRegisterCustomDeviceFilter axlRegisterJobIntfc axlRegisteredJPGUICust axlRegisteredJobIntfcNames axlRemoveElement axlRemoveSetupState axlRemoveSimulationResults axlRenameOutputsColumn axlResetActive axlRunAllTests axlRunAllTestsWithCallback axlRunSimulation axlSaveJobPolicy axlSaveSetup axlSaveSetupState axlSaveSetupToLib axlSessionConnect axlSessionDisconnect axlSessionRegisterCreationCallback axlSessionSignalList axlSessionSignalSignature axlSetAllCornersEnabled axlSetAllParametersDisabled axlSetAllSweepsEnabled axlSetAllVarsDisabled axlSetCopyRefResultsOption axlSetCurrentRunMode axlSetDefaultCornerEnabled axlSetDefaultVariables axlSetEnabled axlSetHistoryLock axlSetJobPolicyProperty axlSetMainSetupDB axlSetMainSetupDBLCV axlSetModelBlock axlSetModelFile axlSetModelGroupName axlSetModelPermissibleSectionLists axlSetModelSection axlSetModelTest axlSetNominalCornerEnabled axlSetOutputUserDefinedData axlSetOverwriteHistory axlSetOverwriteHistoryName axlSetParameter axlSetPreRunScript axlSetPreRunScriptEnabled axlSetReferenceHistoryItemName axlSetReuseNetlistOption axlSetRunDistributeOptions axlSetRunOptionName axlSetScriptPath axlSetTestToolArgs axlSetUseIncremental axlSetWCCTime axlSetWYCSigmaTargetLimit axlSetupStates axlStop axlStopAll axlStopAllJobs axlStopJob axlToolSetOriginalSetupOptions axlToolSetSetupOptions axlViewHistoryResults axlViewResDB axlWriteDatasheet axlWriteDatasheetForm axlWriteOceanScriptLCV b1f band bandwidth bcdp begin bitfield bitfield1 blankstrp bnand bndAddInstsBindingByName bndAddObjectsBinding bndGetBoundObjects bndGetSiblingBoundObjects bndRemoveInstBindingByName bndRemoveObjectBinding bndRemoveTermBindingByName bndReplaceInstsBindingByName bndReplaceObjectsBinding bndReplaceTermsBindingByName bndSetInstsBindingByName bndSetObjectsBinding bndSetTermsBindingByName bnor bnot booleanp bor bottomEdge boundp break breakpt breakptMethod buildString bxnor bxor cPwrContour cReflContour caaar caadr caar caddr cadr calCalcInput calCalculatorFormCB calCreateSpecialFunction calCreateSpecialFunctionsForm calGetBuffer calRegisterSpecialFunction calSetBuffer calSetCurrentTest calSpecialFunctionInput calcVal caliModeToggle caliRestoreDefaultWindowSize callAs callInitProc callNextMethod callUserAutoInitProc cancelEnterFun captabSummary car case caseq cat catch ccpCopy ccpCopyConfig ccpCopyDesign ccpCopyExactDesign ccpExpand ccpExpandConfig ccpExpandDesign ccpExpandExactDesign ccpRegMonitor ccpRegTrigger ccpRemoveTrigger ccpRename ccpRenameReferenceLib cdar cddr cdfCopyCDF cdfCopyParam cdfCreateBaseCellCDF cdfCreateBaseLibCDF cdfCreateParam cdfCreateUserCellCDF cdfCreateUserLibCDF cdfDeleteCDF cdfDeleteParam cdfDump cdfDumpAll cdfEditScaleFactors cdfFindParamByName cdfFormatFloatString cdfGetBaseCellCDF cdfGetBaseLibCDF cdfGetCellCDF cdfGetCustomViaCDF cdfGetInstCDF cdfGetLibCDF cdfGetUnitScaleFactor cdfGetUserCellCDF cdfGetUserLibCDF cdfParseFloatString cdfRefreshCDF cdfSaveCDF cdfSetUnitScaleFactor cdfSyncInstParamValue cdfUpdateCustomViaParam cdfUpdateInstParam cdfUpdateInstSingleParam cdr cdsGenViaDefs cdsGetInstPath cdsGetNetlistMode cdsGetToolsPath cdsName cdsNetExpr cdsParam cdsPlat cdsSetNetlistMode cdsTerm ceiling centerBox changeClass changeEnterFun changeNextEnterFun changeWorkingDir charToInt checkContextBit ciAddLeadingSlash ciAddProcessRules ciAddRuleGroup ciAddStructArg ciAddTrailingSlash ciAlignPinsOnCellSide ciAllCellViewsInHierarchy ciAxisCreate ciAxisDelete ciAxisExists ciAxisListCon ciAxisListParams ciAxisReplaceParams ciBasicGetParamValue ciBuildModgenParams ciBundleSignalsIterator ciCPRegistrationFromLAM ciCacheCellName ciCacheConstraintCellName ciCacheConstraintLibName ciCacheConstraintViewName ciCacheDiscardEdits ciCacheFind ciCacheGet ciCacheGetAllNetNames ciCacheIsLayout ciCacheIsModified ciCacheIsWritable ciCacheLCV ciCacheLibName ciCacheListAxesNames ciCacheListCon ciCacheListConstrainedObjectNames ciCacheListConstrainedObjects ciCacheListTemplates ciCacheListTypeNames ciCacheListTypes ciCacheMakeEditable ciCacheMakeReadOnly ciCacheNeedRefresh ciCachePurge ciCacheSave ciCacheTopCellName ciCacheTopLibName ciCacheTopViewName ciCacheViewName ciCachep ciCanCGBeUsed ciCheckConstraints ciClearNetSuperTypes ciClusterBoundaryForCluster ciCollectDeviceInfo ciCombineInstNetsPins ciConAppendOneMember ciConCreate ciConCreateExpanded ciConDelete ciConFind ciConGetAxisName ciConGetCache ciConGetComment ciConGetCreatedTime ciConGetMembersOfType ciConGetName ciConGetNote ciConGetOwner ciConGetPriority ciConGetStatus ciConGetType ciConIsInContext ciConIsOutOfContext ciConIsOverridden ciConIsWritable ciConListMemberNames ciConListMembers ciConListParamNames ciConListParams ciConListTemplates ciConRemoveMembers ciConResetAllParams ciConResetParams ciConSetAxis ciConSetNote ciConSetPriority ciConSetStatus ciConTypeHasNamedParameter ciConUpdateMembers ciConUpdateParams ciConUprevCellBoundary ciConVerify ciConp ciConstraintLCV ciConstraintViewLessp ciConvertParamsDPLToParams ciConvertParamsToDPL ciConvertToConArg ciCreateFilter ciCreateGuardRing ciCreateHierarchicalConstraintNotes ciCreateModgen ciCreateModgenDummy ciCreateModgenForStructure ciCreateRoutePriorityCon ciCreateRoutingLayerEnumString ciCurrentPathIterator ciDefaultParamToMatchFilter ciDeleteClusterMembersWithinModgens ciDeleteGuardRing ciDeleteRuleGroup ciDeleteStructArgs ciDeleteSymmetriesWithinModgens ciDesignLCV ciEnableAssistant ciEnableAutoConstraintNotes ciExpandAndRepeatName ciExpandIteratedDeviceInfo ciExpandMembers ciExpandName ciExtractRowNumber ciFindDeviceArraysForDev ciFindObjectInHier ciFindOpenCellView ciFindOpenCellViews ciGUIArgsToConArgs ciGenerateArrayChannelDesc ciGenerateBestFitPattern ciGenerateCascodedCurrentMirrorChannelDesc ciGenerateCascodedCurrentMirrorPattern ciGenerateConstraintGroups ciGenerateCurrentMirrorChannelDesc ciGenerateCurrentMirrorPattern ciGenerateDiffPairChannelDesc ciGenerateDiffPairPattern ciGenerateLargeMfactorPattern ciGeneratorCheckInstsNetsPinsInstTerms ciGeneratorForInstSymmetry ciGeneratorForNetSymmetry ciGetCellTermDefaultNetName ciGetCellView ciGetCellViewForObjectPath ciGetConstraintGroupsEnum ciGetCustomFilterNames ciGetDefaultNetName ciGetDeviceBulkTermName ciGetDeviceInfo ciGetDeviceNames ciGetDeviceTermName ciGetFirstDeviceTermName ciGetFluidGuardRingDeviceEnum ciGetFoundryRules ciGetGuardRing ciGetGuardRingMPPName ciGetLAMComponentTypes ciGetMatchParam2DList ciGetMembersOfType ciGetNetNames ciGetNetSubTypes ciGetNetSuperTypes ciGetObjectCellView ciGetOpenCellViews ciGetParamMapping ciGetParamName ciGetParamValFromParameters ciGetParamValue ciGetParamValueOrDefault ciGetParamValues ciGetRoutingLayer ciGetRoutingLayers ciGetRule ciGetRuleGroupByName ciGetRuleGroupName ciGetRuleGroups ciGetStructArg ciGetStructArgs ciGetStructGeneratorExpressions ciGetStructPDKMult ciGetTechFile ciGetTechMPPNames ciGetTermNames ciGuardRingForCluster ciGuardRingForModgen ciHasCellAnyRegTerm ciHaveSameBulkNets ciHaveSameParamValues ciHierCompareConstraint ciHierCompareConstraints ciHierUpdateConstraints ciHighestLevelNet ciIgnoreDevice ciInstIterator ciInstTermIterator ciIsDevice ciIsNet ciIsNetSuperType ciListEditors ciListGeneratableConstraintGroups ciListProcessRules ciListStructGeneratorExpressions ciListStructPDKMults ciListStructTypes ciListTemplateTypes ciListTypes ciLoadConfigXML ciLoadDotCadenceFiles ciLoadIcon ciLoadIcons ciLxComparisonReport ciMOSActiveLoadStructIterator ciMOSCascodeIterator ciMOSCascodedCurrentMirrorStructIterator ciMOSCascodedCurrentMirrorStructIterator2 ciMOSCommonGateStructIterator ciMOSCrossCoupledDifferentialPairStructIterator ciMOSCrossCoupledQuadStructIterator ciMOSCurrentMirrorStructIterator ciMOSDifferentialPairStructIterator ciMOSInverterStructIterator ciMOSParallelStructIterator ciMOSTransmissionGateStructIterator ciMakeHierContext ciMakeObjectInfo ciMapParam ciMapTerm ciMapTermName ciMatchedFingerWidth ciMatchedParametersForCurrent_Mirror ciMatchedParamsForInstanceSymmetry ciMatchedParamsForSameSizeInstances ciMemberIndexToModgenPatternSymbol ciMergeParams ciModgenDummyNetName ciModgenForSameCellSizeAndBulk ciModgenMergeLayersFromArgs ciNetIterator ciNetNames ciNetOnTerm ciNetPredicates ciNetRegexs ciNextConName ciNextObjName ciNextTemplateName ciNumDevices ciNumTermsEQ2 ciObjectIsInContext ciObjectListCon ciObjectPathAndName ciOpenCellView ciOpenPanicCellView ciOrientationForModgen ciPadModgenPattern ciPinIterator ciPlacerControlledWellGeneration ciPrintMappedDefaultNetNames ciPrintMappedDeviceNames ciPrintMappedNetNames ciPrintMappedParams ciPrintMappedTerminals ciPrintReport ciPullConstraint ciPullConstraints ciPushConstraint ciPushConstraints ciRefreshCellView ciRegTypeBindingParameter ciRegexReplaceStructArgs ciRegisterAssistant ciRegisterConstraintEditor ciRegisterConstraintGenerator ciRegisterCustomDeviceFilter ciRegisterDefaultNetName ciRegisterDevice ciRegisterDynamicParamDef ciRegisterFinder ciRegisterIterator ciRegisterNet ciRegisterNetNames ciRegisterNetPredicate ciRegisterNetRegexs ciRegisterNetSuperType ciRegisterStructure ciReinitStructTemplateDefs ciRemoveConstrainedPinNetsFromRails ciRemoveHierarchicalConstraintNotes ciRemoveLeadingSlash ciRemoveProcessRules ciRemoveSymmetricPinAlignments ciRemoveTrailingSlash ciReopenCellView ciReorderAssistants ciReplaceStructArgs ciResolveBulkNet ciResolveNet ciRunFinder ciRunMatchingConstraintsGenerator ciSameCellIterator ciSaveConstraintGenerator ciSeparateInstsNetsPins ciSetCMCGSKILLCallbacks ciSetDefaultConstraintEditor ciSetHaloOptions ciSetHaloPolicy ciSetMaxHaloGroupSize ciSetStructArgVal ciSetStructArgs ciSetStructGeneratorExpressions ciSetStructPDKMult ciSetSymmetricAxes ciSigTypeMatchesNetType ciSignalIterator ciSimpleName ciSortDeviceInfoByFingerWidth ciSortDeviceInfoByMfactor ciSortDeviceInfoByX ciSortDeviceInfoByXY ciSortDeviceInfoByY ciSortDeviceInfoByYX ciSortedOpenCellViews ciTemplateAddCons ciTemplateCreate ciTemplateCreateDefinition ciTemplateCreateExpanded ciTemplateDefinitionExists ciTemplateDelete ciTemplateDeleteCons ciTemplateFind ciTemplateGetCreatedTime ciTemplateGetDefName ciTemplateGetName ciTemplateGetNote ciTemplateGetType ciTemplateListCon ciTemplateListParamNames ciTemplateListParams ciTemplateResetAllParams ciTemplateResetParams ciTemplateSetNote ciTemplateSortParamDefs ciTemplateUpdateParams ciTemplatep ciToFloat ciTypeBindingParameter ciTypeHasBindingParameter ciTypeIsType ciTypeIsUserDefined ciTypeListCon ciUnRegisterTerm ciUnexpandDeviceInfo ciUnexpandIteratedDeviceInfo ciUnexpandPhysicalDeviceInfo ciUniqueMembers ciUnregisterAssistant ciUnregisterConstraintGenerator ciUnregisterIterator ciUnregisterNetSuperType ciUpdateModgenParamsAndMembers ciUprevEAConstrs ciUtilsAddNTimes ciUtilsAddQuotes ciUtilsBuildString ciUtilsGetArgVal ciUtilsMakeNumberRange ciUtilsMakeUnique ciUtilsRemoveNils ciUtilsRepeatNTimes ciUtilsReplaceNils ciVariantInfoForFingersAndFingerWidth ciWithinConstraint ciXYInstSymmetricIterator ciXYNetSymmetricIterator ciXYPinSymmetricIterator ciXYSortInsts ciXYSymmetricIterator ciwAddTranslatorItem ciwCreateMenu ciwCreatePulldown ciwHiExit ciwMenuInit ciwMenuInstall ciwMenuLoadFile ciwRemoveTranslatorItem className classOf classp clear clearAll clearAllEnterFunctions clearExitProcs clearSubwindow clip clipX close closeResults cmdCtrlOption cmdOption cmdShiftOption colorIndex compare compareTime complex complexp compress compression compressionVRI compressionVRICurves concat cond conjugate conn2Sch conn2SchImpHdlDisplay conn2SchStartUp connectRules cons constar cont continue converge convolve copy copyDefstructDeep cos cosh count cpfAddCLPLibs cpfAddCLPSearchPath cpfDefineEquivalentExpression cpfDefinePowerSwitchInstance cpfExportPowerIntent cpfExtractPowerIntent cpfFindReferenceLibs cpfGetCLPLibs cpfGetCLPSearchPath cpfGetCellNetVoltage cpfGetDefaultPowerDomainPGNets cpfGetDevicePowerGroundNetPair cpfGetEquivalentExpression cpfGetInstancePowerGroundNetPair cpfGetMatchingGroundNet cpfGetMatchingGroundNets cpfGetModelPowerGroundNetPair cpfGetNetVoltage cpfGetNetVoltages cpfGetPowerDomainNamePrefix cpfGetPowerGroundNetPairs cpfGetPowerGroundNetVoltagePairs cpfGetPowerSwitchInstanceInfo cpfGetReferenceLibs cpfGetSpecialCellExcludeDataPins cpfGetUserNetlistConfigViewName cpfGetUserNetlistViewNameList cpfHiExportPowerIntent cpfHiPowerIntentExtractOptions cpfHiPropagateSignalType cpfIsNetExternalControlledShutoff cpfIsPowerSwitchInstance cpfRegDefaultPowerDomainPGNets cpfRegDevicePowerGroundNetPair cpfRegInstancePowerGroundNetPair cpfRegModelPowerGroundNetPair cpfRegPowerGroundNetPairs cpfRegisterPowerDomainNamePrefix cpfRegisterSpecialCell cpfRemoveCLPLib cpfRemoveCLPSearchPath cpfRemovePowerIntent cpfRemovePowerSwitchInstance cpfResetCLPLibs cpfSetCLPLibs cpfSetCLPSearchPath cpfSetCellNetVoltage cpfSetNetExternalControlledShutoff cpfSetNetVoltage cpfSetNetVoltages cpfSetPowerGroundNetVoltagePairs cpfSetPowerIntentExtractOptions cpfSetReferenceLibs cpfSetSpecialCellExcludeDataPins cpfSetUserNetlistConfigViewName cpfSetUserNetlistViewNameList cpfValidatePowerIntent cphClearCellPhysicalBinding cphClearInstPhysicalBinding cphClearOccurPhysicalBinding cphCloseConfig cphCloseWindow cphCreatePhysConfig cphDeleteCellFingerSplit cphDeleteCellIgnoreForCheck cphDeleteCellIgnoreForGen cphDeleteCellMFactorSplit cphDeleteCellParamIgnoreForCheck cphDeleteCellParamIgnoreForGen cphDeleteCellParamNameMapping cphDeleteCellRemoveDevice cphDeleteCellRounding cphDeleteCellSFactorSplit cphDeleteCellTermIgnoreForCheck cphDeleteCellTermIgnoreForGen cphDeleteCellTermNameMapping cphDeleteCellVPLGen cphDeleteInstFingerSplit cphDeleteInstIgnoreForCheck cphDeleteInstIgnoreForGen cphDeleteInstMFactorSplit cphDeleteInstParamIgnoreForCheck cphDeleteInstParamIgnoreForGen cphDeleteInstRemoveDevice cphDeleteInstRounding cphDeleteInstSFactorSplit cphDeleteInstTermIgnoreForCheck cphDeleteInstTermIgnoreForGen cphDeleteOccurFingerSplit cphDeleteOccurIgnoreForCheck cphDeleteOccurIgnoreForGen cphDeleteOccurMFactorSplit cphDeleteOccurParamIgnoreForCheck cphDeleteOccurParamIgnoreForGen cphDeleteOccurRemoveDevice cphDeleteOccurRounding cphDeleteOccurSFactorSplit cphDeleteOccurTermIgnoreForCheck cphDeleteOccurTermIgnoreForGen cphFindOpenConfig cphGetCell cphGetCellFingerSplit cphGetCellForceDescend cphGetCellIgnoreForCheck cphGetCellIgnoreForGen cphGetCellMFactorSplit cphGetCellParamIgnoreForCheck cphGetCellParamIgnoreForGen cphGetCellParamNameMapping cphGetCellPhysicalBinding cphGetCellPhysicalCell cphGetCellPhysicalLib cphGetCellPhysicalView cphGetCellRemoveDevice cphGetCellRounding cphGetCellSFactorSplit cphGetCellStopList cphGetCellTermIgnoreForCheck cphGetCellTermIgnoreForGen cphGetCellTermNameMapping cphGetCellVPLGen cphGetCellVPLGenParams cphGetCellViewBinding cphGetCellViewList cphGetCstList cphGetFingerSplit cphGetForceDescend cphGetIgnoreForCheck cphGetIgnoreForGen cphGetInstFingerSplit cphGetInstForceDescend cphGetInstIgnoreForCheck cphGetInstIgnoreForGen cphGetInstMFactorSplit cphGetInstParamIgnoreForCheck cphGetInstParamIgnoreForGen cphGetInstPhysicalCell cphGetInstPhysicalLib cphGetInstPhysicalView cphGetInstRemoveDevice cphGetInstRounding cphGetInstSFactorSplit cphGetInstStopList cphGetInstTermIgnoreForCheck cphGetInstTermIgnoreForGen cphGetInstViewBinding cphGetInstViewList cphGetLayoutXLConfig cphGetLib cphGetLibList cphGetMFactorSplit cphGetOccurFingerSplit cphGetOccurForceDescend cphGetOccurIgnoreForCheck cphGetOccurIgnoreForGen cphGetOccurMFactorSplit cphGetOccurParamIgnoreForCheck cphGetOccurParamIgnoreForGen cphGetOccurPhysicalCell cphGetOccurPhysicalLib cphGetOccurPhysicalView cphGetOccurRemoveDevice cphGetOccurRounding cphGetOccurSFactorSplit cphGetOccurStopList cphGetOccurTermIgnoreForCheck cphGetOccurTermIgnoreForGen cphGetOccurViewBinding cphGetOccurViewList cphGetParamIgnoreForCheck cphGetParamIgnoreForGen cphGetParamNameMapping cphGetPhysicalCell cphGetPhysicalLib cphGetPhysicalTermName cphGetPhysicalView cphGetRemoveDevice cphGetRounding cphGetSFactorSplit cphGetSelectedSet cphGetStopList cphGetStopPoint cphGetTermIgnoreForCheck cphGetTermIgnoreForGen cphGetTermNameMapping cphGetTopCellView cphGetView cphGetViewBinding cphGetViewList cphGetWinConfig cphGetWindowId cphIsConfigModified cphIsLeaf cphIsParamIgnoredForCheck cphIsParamIgnoredForGen cphIsRemoveDevice cphIsTermIgnoredForCheck cphIsTermIgnoredForGen cphIsUnderPhysConfig cphLaunchFromLayout cphOpenConfig cphOpenWindow cphSaveAsConfig cphSaveConfig cphSbAddIOPin cphSbDefineIOPinLabelFlag cphSbDefineObstruction cphSbDefineSoftBlock cphSbDelIOPin cphSbDelIOPinById cphSbDelObstruction cphSbDisplayAllIOPinsInfo cphSbDisplayBoundaryInfo cphSbDisplayIOPinInfo cphSbDisplayObstruction cphSbDisplaySoftBlockAttributes cphSbEditIOPin cphSbEditIOPinById cphSbEditSoftBlockAttributes cphSbGetAllIOPins cphSbGetFilteredIOPins cphSbGetIOPinId cphSbGetIOPinName cphSbGetSoftBlockId cphSbGetSoftBlocks cphSbIsValidIOPin cphSbLoadSoftBlocks cphSbRemoveSoftBlock cphSbSaveSoftBlocks cphSbSetPolygonalBoundary cphSbSetRectangularBoundary cphSbSetRectangularBoundaryUsingUtil cphSetCellFingerSplit cphSetCellForceDescend cphSetCellIgnoreForCheck cphSetCellIgnoreForGen cphSetCellMFactorSplit cphSetCellParamIgnoreForCheck cphSetCellParamIgnoreForGen cphSetCellParamNameMapping cphSetCellPhysicalBinding cphSetCellRemoveDevice cphSetCellRounding cphSetCellSFactorSplit cphSetCellStopList cphSetCellTermIgnoreForCheck cphSetCellTermIgnoreForGen cphSetCellTermNameMapping cphSetCellVPLGen cphSetCellVPLGenParams cphSetCellViewBinding cphSetCellViewList cphSetCstList cphSetInstFingerSplit cphSetInstForceDescend cphSetInstIgnoreForCheck cphSetInstIgnoreForGen cphSetInstMFactorSplit cphSetInstParamIgnoreForCheck cphSetInstParamIgnoreForGen cphSetInstPhysicalBinding cphSetInstRemoveDevice cphSetInstRounding cphSetInstSFactorSplit cphSetInstStopList cphSetInstStopPoint cphSetInstTermIgnoreForCheck cphSetInstTermIgnoreForGen cphSetInstViewBinding cphSetInstViewList cphSetLibList cphSetOccurFingerSplit cphSetOccurForceDescend cphSetOccurIgnoreForCheck cphSetOccurIgnoreForGen cphSetOccurMFactorSplit cphSetOccurParamIgnoreForCheck cphSetOccurParamIgnoreForGen cphSetOccurPhysicalBinding cphSetOccurRemoveDevice cphSetOccurRounding cphSetOccurSFactorSplit cphSetOccurStopList cphSetOccurStopPoint cphSetOccurTermIgnoreForCheck cphSetOccurTermIgnoreForGen cphSetOccurViewBinding cphSetOccurViewList cphSetStopList cphSetViewList cphUprevDesign cphUprevIncremental cphUprevLibrary cphVisitNextNode cphVisitStart cphVisitStop cphVisitedInstance cphVisitedPath cphVisitedSwitchMaster cphVisitedTarget cputime createDir createDirHier createFinalNetlist createNetlist cross csh cstAddToConstraintGroup cstCreateConstraint cstCreateConstraintGroupIn cstCreateConstraintGroupOn cstDeleteConstraint cstDeleteConstraintGroup cstFindConstraintGroupIn cstFindConstraintGroupOn cstFindFirstConstraint cstGet1DTableValue cstGet2DTableValue cstGetConstraintGroups cstGetDefaultConstraintGroupName cstGetTwoWidthTableValue cstGetUnreferencedConstraints cstIsId cstSetDefaultConstraintGroupName ctAddCellToCompTypeGroup ctCreateCompTypeGroup ctDeleteCellFromCompTypeGroup ctDeleteCompTypeGroup ctGetCellCompTypeGroup ctGetCompTypeCells ctGetCompTypeGroupAttr ctGetCompTypeNames ctSetCompTypeGroupAttr currentSubwindow currentWindow d2a dB10 dB20 dBm dagAddActionToObject dagCreateClass dagCreateNode dagDeleteActionFromObject dagDestroyNode dagDisplayTool dagGetCurrentObject dagGetCurrentTool dagLinkParentToChild dagNumToTool dagOpenTool dagPopTool dagPushTool dagRefreshObject dagSetActionStatus dagSetCurrentTool dagSetExpandedActionStatus dagSetFont dagUnlinkParentFromChild dataTrigger dataTypes db10 db20 dbAbutIsInteractive dbAddAreaToPinGroupGuide dbAddFigToFigGroup dbAddFigToNet dbAddFigToPin dbAddFigToPinGroupGuide dbAddFigsToPin dbAddObjectToGroup dbAddObjectsToMarker dbAddPinToPinGroupGuide dbAddPlaceAreaCompTypeSetDef dbAddPlaceAreaRailDef dbAddRowCompTypeSetDef dbAddRowRailDef dbAddStrapObject dbAllCellViews dbAreaBoundaryHasLayerPriorityOrder dbAreaBoundaryHasValidRoutingLayers dbBoundaryQuery dbCVHasInheritedSig dbCVHasInheritedTerm dbCVHasNetSetProp dbCellViewAreLayerShiftsValid dbCellViewClearLayerShifts dbCellViewHasLayerShifts dbCellViewInitForLayerShifting dbCellViewUpdateLayerShifts dbChangeGroupType dbCheckParamCell dbCheckRecursion dbClearPcellCache dbClose dbCloseBag dbColorShapeQuery dbCompressPointArray dbCompressionPlot dbComputeBBox dbComputeBBoxNoNLP dbConcatTransform dbConnectObject dbConvertArcToLine dbConvertDonutToPolygon dbConvertEllipseToPolygon dbConvertLineToPath dbConvertPathSegToPolygon dbConvertPathToPolygon dbConvertRectToPolygon dbCopyCellView dbCopyFig dbCopyProp dbCopyPropList dbCopyShape dbCopySingleProp dbCreateArc dbCreateAreaBlockage dbCreateAreaBoundary dbCreateAreaHalo dbCreateAreaPinGroupGuide dbCreateBusNetDef dbCreateBusTermDef dbCreateCluster dbCreateClusterBoundary dbCreateCompTypeSetDef dbCreateConn dbCreateConnByName dbCreateConnByNewName dbCreateCoverObstruction dbCreateCustomViaVariant dbCreateDiffMaskGroup dbCreateDonut dbCreateDot dbCreateEdgePinGroupGuide dbCreateEllipse dbCreateEnumProp dbCreateExtParamInst dbCreateExtParamInstByMasterName dbCreateFigGroup dbCreateGCellPattern dbCreateGroup dbCreateGuide dbCreateHierProp dbCreateInst dbCreateInstByMasterName dbCreateInstTerm dbCreateInstTermByPosition dbCreateLabel dbCreateLayerBlockage dbCreateLayerHalo dbCreateLib dbCreateLine dbCreateMarker dbCreateNet dbCreatePRBoundary dbCreateParamInst dbCreateParamInstByMasterName dbCreateParamSimpleMosaic dbCreateParamSimpleMosaicByMasterName dbCreatePath dbCreatePathSeg dbCreatePin dbCreatePlaceArea dbCreatePolygon dbCreateProp dbCreateRailDef dbCreateRangeProp dbCreateRect dbCreateRoute dbCreateRow dbCreateSameMaskGroup dbCreateSigNetExpr dbCreateSimpleMosaic dbCreateSnapBoundary dbCreateStdViaVariant dbCreateSteiner dbCreateStrap dbCreateStrongGroup dbCreateTerm dbCreateTermNetExpr dbCreateTextDisplay dbCreateTopology dbCreateTrackPattern dbCreateTrunk dbCreateTrunkConnect dbCreateTwig dbCreateUniqueNamedNet dbCreateVectorInstDef dbCreateVia dbCreateViaShapeArray dbCreateXformPCell dbDebugStats2 dbDefineProc dbDeleteAllNet dbDeleteAllTerminalAntennaRules dbDeleteEmptyNet dbDeleteGroupByName dbDeleteGroupMemberFromGroup dbDeleteObject dbDeleteObjectFromGroup dbDeletePropByName dbDeleteSigNetExpr dbDeleteStrap dbDeleteTermNetExpr dbDeleteTerminalAntennaRuleOnLayer dbDeleteTerminalAntennaRules dbDeleteTopology dbDeleteTrunk dbDeleteTrunkConnect dbDeleteTwig dbDisableCellViewCounter dbDisconnectObject dbDumpPcDefinePcell dbDumpPcell dbDumpPcellWithLib dbEnableCellViewCounter dbEnableUndo dbEvalParamCell dbExpandToMemNameExpr dbExternallyConnectPins dbFigGroupQuery dbFindAbutFig dbFindAnyInstByName dbFindAreaBoundaryByName dbFindBusNetDefByName dbFindBusTermDefByName dbFindClusterBoundaryByName dbFindClusterByName dbFindMemInstByName dbFindMosaicByName dbFindNetByName dbFindOpenBag dbFindOpenCellView dbFindPinGroupGuideByName dbFindProp dbFindRowByName dbFindRowHeader dbFindSigByAlias dbFindSigByName dbFindTermByName dbFindTermByPosition dbFindVectorInstDefByName dbFindViaHeaderByName dbFindViaVariantByName dbFix dbFixParamCell dbFlattenInst dbFlattenInst2 dbFreeze dbFullLibPath dbFullPath dbGet dbGetAnyInstSwitchMaster dbGetAreaBoundaryLayerPriorityOrder dbGetAreaBoundaryPinGroupGuide dbGetAreaBoundaryValidRoutingLayers dbGetAreaPinGroupGuideAreas dbGetBag dbGetBagDdId dbGetBagOwner dbGetBagTimeStamp dbGetBlockageColor dbGetBuildInfo dbGetCellViewCompTypeSetDef dbGetCellViewCounter dbGetCellViewDdId dbGetCellViewEEQMaster dbGetCellViewInheritedSig dbGetCellViewInheritedTerm dbGetCellViewNetVoltageRange dbGetCellViewPlaceArea dbGetCellViewRailDef dbGetCellViewSymmetry dbGetCellViewTopologies dbGetColorModel dbGetDatabaseType dbGetFigAbutName dbGetFigAbutRefName dbGetFigGroupByName dbGetFigPinGroupGuide dbGetFileDatabaseType dbGetFileTimeStamp dbGetFluidShapeByName dbGetGroupByName dbGetGroupsWithDef dbGetHierPathTransform dbGetInstByName dbGetInstNameNumInst dbGetInstTermStraps dbGetInstTermTwigs dbGetInstTransform dbGetInstanceByName dbGetIntegrationColorModel dbGetLibDataCompressionLevel dbGetMaxHierDepth dbGetMaxNumBit dbGetMemName dbGetMemNetSig dbGetMemNetSigName dbGetNameNumBit dbGetNeighbor dbGetNeighborList dbGetNetPowerDomain dbGetNetTerms dbGetNetTopologies dbGetNetVoltageRange dbGetNetVoltageRangeSource dbGetOpenBags dbGetOpenCellViews dbGetOverlaps dbGetPRBoundaryPinGroupGuides dbGetPathSegStyle dbGetPinConnection dbGetPinFigAccessDirection dbGetPinFigName dbGetPinFigPlacementStatus dbGetPinGroupGuideEdgeBoundary dbGetPinGroupGuideEdgeName dbGetPinGroupGuideEdgeStartOffset dbGetPinGroupGuideEdgeStopOffset dbGetPinGroupGuideKeepoutSpacing dbGetPinGroupGuideLayerPriorityOrder dbGetPinGroupGuideMinPinSpacing dbGetPinGroupGuideMinPinWidth dbGetPinGroupGuideValidRoutingLayers dbGetPinGroupGuides dbGetPinMinPinSpacing dbGetPinMinPinWidth dbGetPinPinGroupGuides dbGetPlaceAreaCompTypeSetDef dbGetPlaceAreaOrient dbGetPlaceAreaRailDef dbGetPlaceAreaUtilization dbGetPlacementGrid dbGetPropByName dbGetRedoHandles dbGetRowCompTypeSetDef dbGetRowRailDef dbGetSameMaskDiffMaskGroups dbGetShapeColor dbGetShapeSameMaskGroups dbGetShapeStraps dbGetShapeTwigs dbGetSigNameMemNets dbGetSigNetExpr dbGetSoftConnectTermConnectToLayer dbGetSoftConnectTermPinlessLayer dbGetStrapName dbGetStrapObjects dbGetStrapTopology dbGetStrapTwig dbGetStrongGroups dbGetTermGroundSensitivity dbGetTermNetExpr dbGetTermSupplySensitivity dbGetTerminalAntennaRuleOnLayer dbGetTerminalAntennaRules dbGetTopologyName dbGetTopologyNet dbGetTopologyObjects dbGetTopologyPatternType dbGetTrackPatternFirstTrackColor dbGetTrueOverlaps dbGetTrunkAnchor dbGetTrunkConnectName dbGetTrunkConnectTopology dbGetTrunkConnectTrunks dbGetTrunkDirection dbGetTrunkLongOffset1 dbGetTrunkLongOffset2 dbGetTrunkLongOffsetSource dbGetTrunkLongOffsetSource1 dbGetTrunkLongOffsetSource2 dbGetTrunkName dbGetTrunkOrthoOffset dbGetTrunkSide dbGetTrunkTopology dbGetTrunkTwigs dbGetTwigName dbGetTwigObject dbGetTwigPinName dbGetTwigTrunk dbGetUndoHandles dbGetVersion dbGetViaCutLayerControl dbGetViaLayer1Control dbGetViaLayer2Control dbGetViaStraps dbGetViaTwigs dbGetq dbGuideQuery dbHasExternalConnections dbHasFigAbutName dbHasFigAbutRefName dbHasInstance dbHasMustConnections dbHasShape dbHasShortedTerminals dbInstClearLayerShifts dbInstGetLayerShifts dbInstHasLayerShifts dbInstQuery dbInstSetLayerShifts dbIsAnyInstBaseNameUsed dbIsBagId dbIsBagReadable dbIsBagWritable dbIsBlockageColored dbIsBlockageColoringAllowed dbIsCellViewModified dbIsCellViewStdViaMaster dbIsConnCurrent dbIsFluidPcell dbIsId dbIsNetNameDescend dbIsObjectBound dbIsObjectConnected dbIsSameMaster dbIsShapeColorLocked dbIsShapeColored dbIsShapeColoringAllowed dbIsSigInherited dbIsSigNameGlobal dbIsTermInherited dbIsTermSoftConnect dbIsTopologyPatternId dbIsTrackPatternColorAlternating dbIsTrackPatternColored dbIsTrackPatternColoringAllowed dbIsVPLGen dbIsValidSigNetExpr dbIsValidTermNetExpr dbIsViaColorStateLocked dbLayerAnd dbLayerAndNot dbLayerBlockageQuery dbLayerEnclose dbLayerHoles dbLayerInside dbLayerNoHoles dbLayerOr dbLayerOutside dbLayerSize dbLayerStraddle dbLayerTile dbLayerXor dbMakeBagCurrent dbMakeNet dbMarkerQuery dbMergeNet dbMergeSignal dbMergeSingleProp dbMergeStrongGroups dbMoveChildNet dbMoveFig dbMoveGroupMember dbMovePinToNet dbMoveShape dbMustConnectPins dbNetHasTopology dbNetIsSig dbObjectHasConnection dbOpenAutoSavedCellView dbOpenBag dbOpenCellViewByType dbOpenHier dbOpenPanicCellView dbParseSigNetExpr dbParseTermNetExpr dbPinGroupGuideHasKeepoutSpacing dbPinGroupGuideHasLayerPriorityOrder dbPinGroupGuideHasMinPinSpacing dbPinGroupGuideHasMinPinWidth dbPinGroupGuideHasValidRoutingLayers dbPinHasMinPinSpacing dbPinHasMinPinWidth dbPlacementBlockageQuery dbPointArrayAnd dbPointArrayAndNot dbPointArrayOr dbPointArraySize dbPointArrayXor dbProduceMemName dbProduceOverlap dbProduceOverlapInst dbPurge dbPurgeBag dbReOpenBag dbRedoToHandle dbRefreshBag dbRefreshCellView dbRefreshLibDataCompressionLevel dbRegPostSaveAsTrigger dbRegPostSaveTrigger dbRegPurgeTrigger dbRegSaveTrigger dbRegVPLGenCreateCellName dbRemoveFigFromFigGroup dbRemoveObjectsFromMarker dbRemovePinGroupGuideEdge dbRemovePlaceAreaCompTypeSetDef dbRemovePlaceAreaRailDef dbRemoveRowCompTypeSetDef dbRemoveRowRailDef dbRemoveStrapObject dbRenameNet dbReopen dbReplaceEnumProp dbReplaceHierProp dbReplaceInstParamList dbReplaceParam dbReplaceProp dbReplacePropList dbReplaceRangeProp dbReplaceSigNetExpr dbReplaceTermNetExpr dbRowQuery dbSave dbSaveBag dbSavePcellCache dbSavePcellCacheForCV dbSavePcellCacheForCVOnly dbSearchCDF dbSearchPropByName dbSet dbSetAreaBoundaryLayerPriorityOrder dbSetAreaBoundaryValidRoutingLayers dbSetAutoSave dbSetBlockageColor dbSetBoundaryEdge dbSetCellViewEEQMaster dbSetCellViewNetVoltageRange dbSetCellViewSymmetry dbSetColorModel dbSetConnCurrent dbSetFigAbutName dbSetFigAbutRefName dbSetInstHeaderMasterName dbSetInstHeadersCounter dbSetIntegrationColorModel dbSetLibDataCompressionLevel dbSetNIMsgMode dbSetNetNameDescend dbSetNetPowerDomain dbSetNetVoltageRange dbSetNetVoltageRangeSource dbSetPathSegPoints dbSetPathSegStyle dbSetPinFigAccessDirection dbSetPinFigName dbSetPinFigPlacementStatus dbSetPinGroupGuideEdge dbSetPinGroupGuideEdgeStartOffset dbSetPinGroupGuideEdgeStopOffset dbSetPinGroupGuideKeepoutSpacing dbSetPinGroupGuideLayerPriorityOrder dbSetPinGroupGuideMinPinSpacing dbSetPinGroupGuideMinPinWidth dbSetPinGroupGuideValidRoutingLayers dbSetPinMinPinSpacing dbSetPinMinPinWidth dbSetPlaceAreaOrient dbSetPlaceAreaUtilization dbSetPlacementGrid dbSetShapeColor dbSetShapeColorLocked dbSetSoftConnectTermConnectToLayer dbSetSoftConnectTermPinlessLayer dbSetStrapName dbSetStrapTwig dbSetTermGroundSensitivity dbSetTermMustJoin dbSetTermSoftConnect dbSetTermSupplySensitivity dbSetTerminalAntennaRuleOnLayer dbSetTerminalAntennaRules dbSetTextDisplayNameValueVisible dbSetTopologyName dbSetTopologyNet dbSetTrackPatternColorAlternating dbSetTrackPatternFirstTrackColor dbSetTrunkAnchor dbSetTrunkConnectName dbSetTrunkConnectTrunks dbSetTrunkDirection dbSetTrunkLongOffset1 dbSetTrunkLongOffset2 dbSetTrunkLongOffsetSource dbSetTrunkLongOffsetSource1 dbSetTrunkLongOffsetSource2 dbSetTrunkName dbSetTrunkOrthoOffset dbSetTrunkSide dbSetTwigName dbSetTwigObject dbSetTwigPinName dbSetUndoHandle dbSetViaColorStateLocked dbSetViaCutLayerControl dbSetViaLayer1Control dbSetViaLayer2Control dbSetViaParamDefault dbSetViaShapePurpose dbSetq dbShapeQuery dbSoftConnectTermHasConnectToLayer dbSoftConnectTermHasPinlessLayer dbSteinerQuery dbStronglyConnectPins dbSubAreaFromPinGroupGuide dbSubFigFromNet dbSubFigFromPin dbSubFigFromPinGroupGuide dbSubFigsFromPin dbSubPinFromPinGroupGuide dbTransformAccessDirection dbTransformBBox dbTransformCellView dbTransformPoint dbTransformPointList dbUndefineProc dbUndoToHandle dbUnregPostSaveAsTrigger dbUnregPostSaveTrigger dbUnregPurgeTrigger dbUnregSaveTrigger dbUnregVPLGenCreateCellName dbUnsetAreaBoundaryLayerPriorityOrder dbUnsetAreaBoundaryValidRoutingLayers dbUnsetLibDataCompressionLevel dbUnsetNetVoltageRange dbUnsetNetVoltageRangeSource dbUnsetPinGroupGuideKeepoutSpacing dbUnsetPinGroupGuideLayerPriorityOrder dbUnsetPinGroupGuideMinPinSpacing dbUnsetPinGroupGuideMinPinWidth dbUnsetPinGroupGuideValidRoutingLayers dbUnsetPinMinPinSpacing dbUnsetPinMinPinWidth dbUnsetTermMustJoin dbUpdatePcellCache dbValidP dbViaQuery dbWeaklyConnectPins dbWriteSkill dbWriteSkillWithLib dbm dbobjectp dc dcmatchSummary ddAmUsingDM ddAutoCheckin ddAutoCheckout ddAutoCtlGetVars ddAutoCtlSetVars ddCatAddItem ddCatClose ddCatFindCat ddCatGetCatMembers ddCatGetCatName ddCatGetCellsNotInCat ddCatGetLibCats ddCatIsObjInCat ddCatOpen ddCatOpenEx ddCatRefresh ddCatRemove ddCatSave ddCatSubItem ddCheckin ddCheckout ddClearLibUnmanaged ddCreateLib ddDeleteLocal ddDeleteObj ddDumpLibList ddGetCoManagedSet ddGetForcedLib ddGetForcedLibEx ddGetLibList ddGetObj ddGetObjAccess ddGetObjAccessEx ddGetObjChildren ddGetObjChildrenEx ddGetObjDMSys ddGetObjFiles ddGetObjFilesEx ddGetObjGroup ddGetObjGroupEx ddGetObjLastModify ddGetObjLastModifyEx ddGetObjLib ddGetObjName ddGetObjOwner ddGetObjOwnerEx ddGetObjParent ddGetObjReadPath ddGetObjReadPathEx ddGetObjSize ddGetObjSizeEx ddGetObjType ddGetObjWritePath ddGetObjWritePathEx ddGetPathDMSys ddGetStartup ddGetTmpdirWarn ddGetTriggerList ddGetUpdatedLib ddIsId ddIsObjLibMarked ddIsObjReadable ddIsObjReadableEx ddIsObjWritable ddIsObjWritableEx ddIsPathManageable ddIsPathManaged ddLibHasTmpDir ddLibIs5X ddLockDescribe ddLockFree ddLockGetStatus ddLockPath ddLockSet ddLockSetEx ddMapGetDataTypeFileName ddMapGetDataTypeList ddMapGetFileDataType ddMapGetFileTool ddMapGetFileViewType ddMapGetToolNameDataType ddMapGetToolNameList ddMapGetToolNameViewType ddMapGetViewTypeFileName ddMapGetViewTypeList ddMapIsFileNameKnown ddMapIsToolLegal ddMapIsToolNameKnown ddMarkObjMaster ddNeedCheckout ddObjHasNamedObj ddObjHasNamedObjEx ddObjIsInMaster ddObjIsInTmp ddProduceObjRelNames ddProduceObjRelNamesEx ddRegTrigger ddReleaseObj ddSetForcedLib ddSetForcedLibEx ddSetLibDmType ddSetLibUnmanaged ddSetTmpdirWarn ddUnregTrigger ddUpdateLibList ddsAboutDFII ddsBrowserAction ddsCheckSessionName ddsCheckinPreferences ddsCheckoutPreferences ddsCloseLibManager ddsCvtAMSTranslateCell ddsCvtAMSTranslateLib ddsCvtToolBoxAMS ddsEditProp ddsEndSyncWithForm ddsFileBrowseCB ddsGetCurrentLib ddsGetCustomLibSelect ddsGetLibManLCV ddsGetServiceName ddsHiCloseData ddsHiCreateLibrary ddsHiDefragCellView ddsHiDefragLib ddsHiMakeReadOnly ddsHiOpenCdsLibEditor ddsHiPreferences ddsHiRefresh ddsLEWhatsNewAtStartup ddsOnLineHelp ddsOpenConvertToolBox ddsOpenLibManager ddsProgramName ddsRefresh ddsRegCustomLibSelect ddsServSelect ddsSetLibManLCV ddsSyncWithForm ddsUnregCustomLibSelect ddsUpdateSyncWithForm ddsViewDDProp ddsWhatsNew deBack deCopy deCustomizeToolbars deDisableApp deEditInPlace deEnableApp deFileNew deFileOpen deFindAssistant deFindPlugin deFindToolbar deForward deGetAllApplicationNames deGetAllRootTypes deGetAllViewTypes deGetAppClassInfo deGetAppInfo deGetCellView deGetConfigId deGetContext deGetEIP deGetEditCellView deGetEditContext deGetEditLevel deGetEditRootType deGetEditViewType deGetLowerTierApp deGetMaxEditLevel deGetMaxInContextLevel deGetPlugins deGetProbeContext deGetProbeTrigger deGetPushed deGetRootType deGetRootViewTypeList deGetVector deGetViewType deHiSetDefaultApplication deInheritEnabling deInheritMenus deInstallApp deInstallPlugin deIsEditInContext deManageToolbar deMapUserTypeToViewType deMapViewTypeToUserType deNew deNewCellView deOpen deOpenCellView dePush deRegApp deRegPlugin deRegProbeTrigger deRegUserTriggers deRemovePlugin deReturn deSetCellView deSetConfigId deSetContext deSetHistoryOpenMode deSetProbeContext deSetWorkspace deSwap deToggleAssistantVisibility deToggleAssistants deToggleToolbars deUnInheritEnabling deUnInheritMenus deUnRegApp deUnRegProbeTrigger deUnRegUserTriggers deUnmanageToolbar deViewTypeIsRegistered debugQuit debugStatus declare declareLambda declareNLambda declareSQNLambda defCapDepends defCapPrefixes defInitProc defMathConstants defUserInitProc defcell defclass defgeneric defglobalfun define definitionFile defmacro defmethod defprop defstruct defstructp defun defvar delay delete deleteChecks deleteDir deleteFile deleteJob deletePoint deleteSubckt deleteSubwindow deleteWaveform deoEnableTrigger deoExitTrigger deoGetAssistantList deoGetBindkeys deoMenuTrigger deoOnApplicationChange deoOnEvent deoOnTabSwitch deoPostInstallTrigger deoRequireToolbars deoUpdateToolbar deriv desVar design destructuringBind dft dftbb difference digitalHostMode digitalHostName disableAllChecks disableChecks disableDeviceChecking discipline display displayChecks displayMode displayNetlist displaySubckt dlAddArc dlAddBox dlAddCircle dlAddDonut dlAddEventObject dlAddPath dlAddPoint dlAddPolygon dlAddRasterText dlAddSegment dlAddSkillObject dlAddStrokeText dlAttachDlistToWidget dlAttachDlistToWindow dlClearDisplayList dlCloseWidget dlConfigureButton dlDetachDlistFromWidget dlDetachDlistFromWindow dlDisplay dlDlistToIcon dlDrawArc dlDrawBox dlDrawCircle dlDrawDonut dlDrawPath dlDrawPoint dlDrawPolygon dlDrawRasterText dlDrawSegment dlDrawStrokeText dlEnableItem dlFitDlistOnDraw dlMakeDisplayList dlMakeDlistButton dlMakePenTable dlMakeStipple dlMakeWidget dlMapWidget dlMoveButton dlResizeButton dlSaveDlist dlSetClearOnDraw dlSetCurrentPen dlSetDlistPosition dlSetDlistScale dlSetPenColor dlSetPenFillStyle dlSetPenFilled dlSetPenStipple dlSetPenTable dlSetWidgetName dlUnMapWidget dmAddCellToCategory dmCreateCellCategory dmRemoveCellCategory dmRemoveCellFromCategory dmbGetCurrentLib dmbLibBrowserFormDone dmbOpenLibBrowser dmbSetBrowserInteractions dmbSyncWithCellForm dmbSyncWithForm dmbUpdateBrowser dmvStart dnl do dplp dptActivate dptChangeColor dptColorLibrary dptCreateTrackPattern dptDeleteAllTrackPatterns dptGetAllColorGroups dptGetColorGroup dptGetColorModel dptGetLayerDefaultColor dptGetLayerTrackPatternConstraint dptGetTrackPatternPattern dptGetUnfoldedColor dptHasColorInfo dptHiStitch dptHiUnStitch dptHierUpdateColor dptIsShapeHierColorLocked dptIsTrackPatternFiltered dptLPPMergeToColor dptMakeDiffColor dptMakeSameColor dptMarkersToMaskColors dptPropagateLocks dptReColor dptReconstructStitch dptRemoveDiffColor dptRemoveSameColor dptRemoveTrackPatternFilters dptSaveAll dptSetColorModel dptSetLayerDefaultColor dptSetLayerTrackPatternConstraint dptSetTrackPatternFiltered dptSetTrackPatternPattern dptShowMaskColor dptUpdateColor drAddElem drCreateEmptyWaveform drCreateVec drCreateWaveform drDeleteColor drDeleteDisplay drDeleteLineStyle drDeletePacket drDeleteStipple drDumpDrf drFindPacket drGetColor drGetDisplay drGetDisplayIdList drGetDisplayName drGetDisplayNameList drGetElem drGetLineStyle drGetLineStyleIndexByName drGetPacket drGetPacketAlias drGetPacketFillStyle drGetPacketList drGetStipple drGetStippleIndexByName drGetWaveformXType drGetWaveformXVec drGetWaveformYType drGetWaveformYVec drIsDataVector drIsParamWave drIsWaveform drLoadDrf drPutWaveformXVec drPutWaveformYVec drSetElem drSetPacket drType drVectorLength drain drawEnterFun drbBrowseFormCB drdAddTarget drdBatchCheck drdBatchCheckLicenseAvailable drdCompactObjects drdCompactSelSet drdCompactorOptions drdEnablePixelThreshold drdIsPixelThresholdEnabled drdListConstraintCategoryRules drdRemoveTarget drdToggleSmartSnapMode drdVerifyObjects drdVerifySelSet dreInvokeDre drplACPRWithMask drplEvmBpsk drplJitter drplPacVolGnExpDen drplParamSweepRFJc drplParamSweepRFJcc drplRFJc drplRFJcc drplSwpHp drplSwpSp drplSwpYp drplSwpZm drplSwpZp dtpr dump dutyCycle dutycycle dwindow dwindowp eadRemoveParasitics ed edgeTriggeredEyeDiagram edi ediFinishStatus edifDisplay edifLayerNumMap edifinDisplay edifinMakeRenameString edifoutAddCellInfo edifoutAddInstInfo edifoutAddInterfaceInfo edifoutAddLibraryInfo edifoutAddNetInfo edifoutAddPortInfo edifoutAddViewInfo edifoutEditCellProperty edifoutEditInstProperty edifoutEditLibProperty edifoutEditNetProperty edifoutEditPortProperty edifoutEditProperty edifoutEditViewProperty edifoutMakeRenameString edit edl enableAllChecks enableChecks enableDeviceChecking enableTrigger encrypt enterArc enterBox enterCircle enterDonut enterEllipse enterLine enterMultiRep enterNumber enterPath enterPoint enterPoints enterPolygon enterScreenBox enterSegment enterString envCyclicIndexToString envCyclicStringToIndex envGetAvailableTools envGetDefVal envGetLoadedTools envGetModifiedTools envGetVal envGetVarType envIsToolModified envIsVal envLoadFile envLoadVals envOption envRegLoadDumpTrigger envRegSetTrigger envSetToolCurrValToDefault envSetToolDefaultToCurrVal envSetVal envSetVarCurrValToDefault envSetVarDefaultToCurrVal envStoreEnv eq equal eqv err error errset errsetstring eval evalstring evcdFile evcdInfoFile evenp evmOFDM evmQAM evmQpsk exists existss exit exp expandMacro expandMacroDeep expr expt eyeDiagram eyeMeasurement fallTime famAddValue famCreateFamily famEval famGetSweepName famGetSweepValues famIsFamily famMap famValue fboundp fileLength fileSeek fileTell fileTimeModified findClass findNamespace findSymbol finishEnterFun fix fix2 fixp flet flip float floatp floor fnlAbortNetlist fnlCurrentCell fnlCurrentCellCdsName fnlCurrentInst fnlCurrentInstCdsName fnlCurrentIteration fnlCurrentModelExtName fnlCurrentSig fnlCurrentSigPathName fnlGetGlobalSigNames fnlInstCdsNameExtName fnlPathList fnlPrint fnlSearchPropString fnlSigCdsNameExtName fnlTermCdsNameExtName fnlTermExtName fnlTopCell for forall foralls forcenode foreach foreachs fors fourEval fprintf freq freq_jitter frequency fscanf funcall ga gac gac_freq gac_gain gainBwProd gainMargin gc gcsummary gdmAddSpecToSpecList gdmCreateSpec gdmCreateSpecFromDDID gdmCreateSpecList gdmExecute gdmInspectSpec gdmIsSpecId gdmNextFromSpecList gdmObjIsCreated gdmRemovename gdmResetSpecList gdmSpecListp gdmSpecType gdmSpecp gdmcancel gdmci gdmco gdmdelete gdmexport gdmhistory gdmsetdefver gdmsetname gdmstatus gdmsubmit gdmupdate geAddHilightArc geAddHilightBlockage geAddHilightCircle geAddHilightDistance geAddHilightDonut geAddHilightDot geAddHilightEllipse geAddHilightFig geAddHilightLabel geAddHilightLine geAddHilightPath geAddHilightPathSeg geAddHilightPolygon geAddHilightRectangle geAddHilightRow geAddHilightRuler geAddHilightTrackPattern geAddInstProbe geAddNetProbe geAddNetProbeFromTo geAddPathProbe geAddSelectBox geAddSelectPoint geAddTermProbe geAdjustPoint geAdvWireSelection geAskOverwriteMode geBackgroundCellView geCellViewToDlist geCenter geChangeCellView geChangeEditMode geChangeHilightPacketName geClosePolygon geCompressPointArray geComputeQueryBbox geCoordp geCopySelSet geCreateBend geCreateHilightGroup geCreateHilightSet geCreateMarker geCreateMarkerByBBox geCreateMarkerByPoints geCreatePacket geCreateTaper geCreateTrl geCreateWindowHilightSet geCycleSelectNext geDSAFreeze geDeleteAllAreaViewLevel geDeleteAllHilightSet geDeleteAllInstViewLevel geDeleteAllMarker geDeleteAllProbe geDeleteAllWindowHilightSet geDeleteAreaViewLevel geDeleteHilightGroup geDeleteHilightObject geDeleteHilightSet geDeleteHilightSetInWindows geDeleteInstProbe geDeleteInstViewLevel geDeleteNetProbe geDeletePathProbe geDeleteProbe geDeleteSelSet geDeleteStoredSelectionSet geDeleteTermProbe geDeselectAll geDeselectAllFig geDeselectAllObject geDeselectArea geDeselectFig geDeselectFigNoFilter geDeselectFigPoint geDeselectObject geDeselectObjectNoFilter geDeselectObjectPoint geDeselectPoint geDeselectProtected geDeselectStoredSelectionSet geDisableBackgroundCellView geDiscardEdits geDispWinEnvProps geDrawHilightSet geEditInPlace geEditSelSet geEditSingleObject geEditToWindowPoint geEnableBackgroundCellView geEnterAddInstProbe geEnterAddNetProbe geEnterAddTermProbe geEnterDeleteInstProbe geEnterDeleteNetProbe geEnterDeleteTermProbe geEquivWindow geEquivWindowSet geExplainProbe geFindPathToCellViewInst geGetAdjustedPath geGetAllAreaViewLevel geGetAllInstViewLevel geGetAllProbe geGetAreaViewLevel geGetCellViewWindow geGetCrossProbeValue geGetCurrentHilightSet geGetCurrentWindowHilightSet geGetDisabledMenus geGetEditCellView geGetEditCellViewWindow geGetEditRep geGetEnablePredicate geGetFigHilightObjectId geGetHierMemInst geGetHilightObjectFigId geGetInstHier geGetInstHierPath geGetInstTransform geGetInstViewLevel geGetLockInfo geGetMarkerDisplayText geGetMarkerOwner geGetMarkerReason geGetMarkerType geGetObjectSelectedSet geGetPotentialSelection geGetProbeNetStopLevel geGetProbeUserLPP geGetScrollPercent geGetSelProtectedObjects geGetSelSet geGetSelSetCount geGetSelSetFigPoint geGetSelectedInstancesCount geGetSelectedSet geGetSortedSelectByLine geGetStoredSelectionSets geGetTopCellViewWindow geGetTopLevelCellView geGetWindowBox geGetWindowCellView geGetWindowRep geGetWindowSelProtectionHighlight geGetWindowSelProtectionSelectability geGetWindowStatus geHasMarker geHiCommonFindMarker geHiDeleteAllMarker geHiDeleteMarker geHiDisplaySelectionForm geHiDragFig geHiExplainMarker geHiFindMarker geHiSetSelProtectionEF geHiStoreSelectionForm geHiUnsetSelProtectionEF geHighlightProtected geInsertHilightObjectsInGroup geInstIdToFileSpec geIsAutoStoreSelectionOn geIsFigAllSelected geIsFigPartiallySelected geIsFigSelected geIsGraphicalWindow geIsMarkerShape geIsObjectAllSelected geIsObjectPartiallySelected geIsObjectSelected geIsPathReentrant geIsPolygonReentrant geIsSelProtection geIsValidHilightGroup geIsValidHilightId geIsValidHilightObject geIsValidHilightSet geLoadIcon geLoadNextProbe geLoadProbe geMakeProbeWithColor geMakeProbeWithLabel geMakeProbeWithOnColor geMakeProbeWithoutColor geNewWindow geOpen gePointQuery gePointToFig gePopHilightStack gePopWindowHilightStack gePrintAllProbe geProbeP gePush gePushHilightStack geQuerySelSet geRefresh geRefreshCellView geRefreshCellViews geRefreshWindow geRefreshWorldView geRegCrossProbeTrigger geRegSaveAllTrigger geResetBackgroundCellView geResetCellView geResetHilightSetHaloParameters geRestoreWinView geReturn geReturnToLevel geSave geSaveAs geSaveHier geSaveIcon geSaveProbe geSaveWinView geScroll geSelObjectsPartiallySelected geSelectAll geSelectAllFig geSelectArea geSelectByline geSelectFig geSelectFigNoFilter geSelectFigPoint geSelectFigs geSelectNextAutoStoreSet geSelectNextInSelSet geSelectObject geSelectObjectNoFilter geSelectPoint geSelectPreviousAutoStoreSet geSelectPreviousInSelSet geSelectProtected geSelectStoredSelectionSet geSelectToggleObject geSelectViaPile geSetAreaViewLevel geSetAutoStoreSelection geSetBackgroundCellView geSetCrossProbeValue geSetEnablePredicate geSetEnterFunctionSelectionMode geSetHilightSetHaloParameters geSetInstViewLevel geSetLimitedProbe geSetMaxCreatedProbe geSetProbeDirection geSetProbeNetStopLevel geSetProbeUserLPP geSetScrollPercent geSetSelProtection geSetSelProtectionAllObjects geSetSelProtectionHighlightOptionForm geSetSelProtectionHighlightOptions geSetWindowStatus geShareWindowHilightSet geShift geSingleSelectBox geSingleSelectPoint geStoreSelectionSet geSubSelectBox geSubSelectPoint geSwitch geToggleAreaSelectOption geToggleFilterSize geTogglePartialSelect geToggleWindowSelProtectionHighlight geToggleWindowSelProtectionSelectability geTransformUserBBox geTransformUserPoint geUnRegCrossProbeTrigger geUnhighlightProtected geUnsetAllSelProtection geUnsetSelProtection geUpdateWindowMenus geValidateWindow geWindowToEditPoint geWriteCellView geZoomToBackgroundAndEditCV geZoomToBackgroundCV geZoomToGrid geiLoadProbe geiSaveProbe gensym geqp get getAllLoadedFiles getApplicableMethods getAsciiWave getCallingFunction getCompatContextVersion getCurSaveContextVersion getCurrentTime getCurrentWindow getData getDependents getDirFiles getFnWriteProtect getFunType getFunctions getGFbyClass getGFproxy getInstallPath getLogin getMaxScreenCoords getMethodName getMethodRole getMethodSpec getMethodSpecializers getNativeContextVersion getOutstring getPrompts getResult getSG getShellEnvVar getSkillPath getSkillVersion getSymbolNamespace getTempDir getVarWriteProtect getVersion getWarn getWorkingDir get_filename get_pname get_string getc getchar getd getq getqq gets globalProc globalSigAlias globalSignal gmax gmin gmsg gmux go gp gpc gpc_freq gpc_gain graphicsOff graphicsOn greaterp groupDelay gt hardCopy hardCopyOptions harmonic harmonicFreq harmonicFreqList harmonicList hdbAddConfigToBag hdbBind hdbClose hdbCloseConfigsInBag hdbCreateConfigBag hdbCreatePathVector hdbCreatePathVectorStack hdbDestroyPathVector hdbExplainBinding hdbExplainSignature hdbExplainStop hdbGetCellName hdbGetLibName hdbGetPathStackStr hdbGetPathStr hdbGetPathVectorStackTop hdbGetTopCellName hdbGetTopLibName hdbGetTopViewName hdbGetViewName hdbIsAtStopPoint hdbIsConfig hdbIsOpenConfig hdbOpen hdbPopCell hdbPopPathVect hdbPushCell hdbPushPathVect hdbReOpenNewConfig hdbSave hdbSaveAs hdbSetDefaultLibListString hdbSetDefaultStopListString hdbSetDefaultViewListString hdbSetObjBindRule hdbSetTopCellViewName heHiEditConfig heHiSetInstBinding heHiShowViewsFound heHiUpdate help hiAbout hiAbsolutePan hiAddCyclicChoice hiAddField hiAddFields hiAddFixedMenu hiAddMenuItem hiAddNonRepeatPrefix hiAddTextWordDelimiter hiAddToolbarItem hiAddToolbarItems hiAdvanceProgressBarOneStep hiAppendInputCmd hiApplyWinConfig hiBindKeyModifiers hiBoxCenter hiCancelProgressBox hiChangeBannerLabel hiChangeFormCallback hiChangeFormTitle hiCheckAbort hiClearCurrentTextSelection hiCloseWindow hiCollapseTreeItem hiConfigureBindKeys hiCreate2DMenu hiCreateAction hiCreateAppForm hiCreateBBoxField hiCreateBooleanButton hiCreateButton hiCreateButtonBoxField hiCreateColorArray hiCreateComboField hiCreateCyclicField hiCreateDockWindow hiCreateFileSelectorField hiCreateFloatField hiCreateFloatSpinBox hiCreateForm hiCreateFormButton hiCreateFormLabel hiCreateFrameField hiCreateHorizontalFixedMenu hiCreateHypertextField hiCreateIntField hiCreateLabel hiCreateLayerCyclicField hiCreateListBoxField hiCreateListField hiCreateMLTextField hiCreateMenu hiCreateMenuItem hiCreateOptionsForm hiCreateOutputStringField hiCreatePointField hiCreatePointListField hiCreatePulldownMenu hiCreateRadioField hiCreateReportField hiCreateScaleField hiCreateScrollRegion hiCreateSeparatorField hiCreateSeparatorMenuItem hiCreateSimpleHypertextField hiCreateSimpleMenu hiCreateSliderMenuItem hiCreateSpinBox hiCreateStringField hiCreateTabField hiCreateToggleField hiCreateToolbar hiCreateToolbarComboBox hiCreateToolbarSeparator hiCreateToolbarTypein hiCreateTree hiCreateTreeItem hiCreateTreeTable hiCreateVerticalFixedMenu hiCreateWindow hiCreateWorldView hiDBoxCancel hiDBoxOK hiDeiconifyWindow hiDeleteBannerLabel hiDeleteBannerMenu hiDeleteBannerMenus hiDeleteField hiDeleteFields hiDeleteForm hiDeleteMenu hiDeleteMenuItem hiDeleteToolbar hiDeleteToolbarItem hiDeleteToolbarItems hiDeltaPan hiDisableAsstBindKeyPrefix hiDisableMenuItem hiDisableTailViewfile hiDisplayAppDBox hiDisplayBlockingDBox hiDisplayColorDialog hiDisplayFileDialog hiDisplayFixedMenu hiDisplayForm hiDisplayHistory hiDisplayListBox hiDisplayMenu hiDisplayModalDBox hiDisplayModelessDBox hiDisplayNonBlockingDBox hiDisplayProgressBox hiDisplaySaveForRestoreDialog hiDisplayUserDBox hiDisplayWindow hiDisplayWindowMenu hiDockWindow hiDynamicPanAbsolute hiDynamicPanGrabbing hiDynamicPanInteractive hiDynamicPanRelative hiEditPropList hiEditfile hiEnableAsstBindKeyPrefix hiEnableBlink hiEnableMenuItem hiEnableTailViewfile hiEncap hiEndLog hiEnqueueCmd hiEscapeHTMLTags hiEscapeStringChars hiExpandTreeItem hiExportImage hiExportImageDialog hiFileDialogDone hiFileDialogSelection hiFileDialogSetSelection hiFixedMenuDown hiFlush hiFlushCIW hiFlushLogFile hiFocusToCIW hiFocusToCursor hiFocusToEncap hiFormApply hiFormCancel hiFormClose hiFormDefaults hiFormDone hiFormFinish hiFormList hiFormUnmap hiGenTextIndex hiGenerateThumbnails hiGetAbsWindowScreenBBox hiGetActiveTabWindow hiGetAnyFile hiGetAppType hiGetAttention hiGetBBoxResource hiGetBannerLabels hiGetBannerMenus hiGetBannerPoint hiGetBeepVolume hiGetBindKey hiGetBindKeyInheritAlias hiGetBindKeyInheritRoot hiGetBindKeyPrefixList hiGetBindKeys hiGetButtonAreaHeight hiGetCIWindow hiGetClipboard hiGetCommandPoint hiGetCurrentCmd hiGetCurrentField hiGetCurrentForm hiGetCurrentIndex hiGetCurrentTextSelection hiGetCurrentTextSelectionLoc hiGetCurrentWindow hiGetCursor hiGetDBoxDefaultLocation hiGetDbuPoint hiGetDefaultThumbnail hiGetDefaultThumbnailResolution hiGetDisabledAsstBindKeyPrefixes hiGetDisplayName hiGetDrawThruDelta hiGetEFDrawThruDelta hiGetEFunCursor hiGetEncapSkillCmd hiGetExistingDirectory hiGetExistingFile hiGetExistingFiles hiGetFieldInfo hiGetFieldOverlaps hiGetFieldScope hiGetFont hiGetFormLocation hiGetFormSize hiGetGeometryResource hiGetHelp hiGetIconName hiGetInsertionPosition hiGetLayerCyclicValue hiGetListBoxFieldFit hiGetListBoxValue hiGetLogFileName hiGetMagnifierSize hiGetMaxScreenCoords hiGetMenuItems hiGetMouseMoveSampleRate hiGetMouseStopDetectTime hiGetMultiClickTime hiGetNonRepeatPrefixes hiGetNumMenus hiGetNumVisibleItems hiGetPoint hiGetProgress hiGetProgressBarCurrentStep hiGetProgressBarTotalSteps hiGetProgressTotalSteps hiGetRepeatCommand hiGetScreenPoint hiGetScreenSize hiGetScrollBarInfo hiGetSessionWindow hiGetSharedIcon hiGetStringResource hiGetStrokeBBox hiGetStrokeFirstPt hiGetStrokeLastPt hiGetTextCharAtLoc hiGetTextClass hiGetTextDispLoc hiGetTextFieldFit hiGetTextIndexLoc hiGetTextLineColumn hiGetTextSelByLoc hiGetTextSelection hiGetTextSourceLength hiGetTextWidth hiGetTextWordDelimiter hiGetThumbnailFilename hiGetToolbarObjName hiGetTopListItem hiGetTree hiGetTreeItemDescription hiGetTreeItemIcons hiGetTreeItemParent hiGetTreeItems hiGetTreeParent hiGetUndoLimit hiGetUserAbort hiGetViewBBox hiGetWMOffsets hiGetWidgetType hiGetWinConfig hiGetWinConfigInfo hiGetWinObjName hiGetWindowDisplayState hiGetWindowFixedMenu hiGetWindowIconifyState hiGetWindowList hiGetWindowMenu hiGetWindowName hiGetWindowState hiGetWindowToolbars hiGoToIndex hiGoToLine hiGraphicMode hiHelp hiHideProgressBar hiHideToolbar hiHighlightField hiHypertextReadin hiHypertextReplace hiHypertextScroll hiIconifyWindow hiIgnoreProp hiInEnterFun hiInFormApply hiInheritBindKey hiInsertBannerMenu hiInsertMenuItem hiInsertToolbar hiInsertToolbarItem hiInsertToolbarItems hiInstantiateForm hiIs2DMenu hiIsBlinkEnabled hiIsForm hiIsFormDisplayed hiIsIcon hiIsInFieldCancel hiIsInReplay hiIsInstantiated hiIsMagnifierAnchored hiIsMagnifierOpened hiIsMenu hiIsMenuItemEnabled hiIsMenuSlotFilled hiIsProgressBoxCancelled hiIsScrollRegion hiIsWidgetType hiIsWindowSpecifier hiItemInsertTree hiItemRemoveTree hiLaunchBrowser hiLayerDispMainForm hiLayerMatchCyclicStr hiLayerStringToLPP hiListBoxCancel hiListBoxDone hiListView hiLoadIconData hiLoadIconFile hiLoadImageFile hiLogDragEvents hiLookupHRFtag hiLowerTab hiLowerWindow hiMakeLPChoiceList hiMapWindow hiMarkNestable hiMarkNonNestable hiMatchColor hiMatchColorByName hiModalDBoxHelp hiModelessDBoxHelp hiMoveField hiMoveFixedMenu hiMoveInsBarToEnd hiMoveToFormField hiMoveWindow hiNextWinView hiOffsetField hiOffsetFields hiOpenWindow hiPan hiPickWindow hiPlaceToolbar hiPrevWinView hiPrintToLogFile hiQueryFont hiQuit hiRaiseTab hiRaiseWindow hiReadWinConfig hiReattachField hiReattachToolbar hiRedo hiRedraw hiRefreshTextWindow hiRegCloseProc hiRegCurWindowTrigger hiRegSetBindKeyProc hiRegTimer hiRegZoomPanProc hiRegisterBindKeyPrefix hiRemoveFixedMenu hiRemoveNonRepeatPrefix hiRemovePromptLine hiRemoveTextWordDelimiter hiRepeat hiReplaceAllBannerMenus hiReplaceTextWordDelimiter hiReplayFile hiReportDeselectAllItems hiReportDeselectItem hiReportDeselectItems hiReportGetSelectedItems hiReportSelectAllItems hiReportSelectItem hiReportSelectItems hiResetAbort hiResetProgressBox hiResizeField hiResizeMagnifier hiResizeWindow hiRestoreView hiSaveAsViewfile hiSaveForRestore hiSaveIconData hiSaveView hiSaveViewfile hiSaveWinConfig hiScaleBox hiScaleMagnifier hiScrollWindowBottom hiScrollWindowDown hiScrollWindowLeft hiScrollWindowRight hiScrollWindowToCurrentIndex hiScrollWindowToIndex hiScrollWindowToName hiScrollWindowTop hiScrollWindowUp hiSelectTextByLoc hiSetAbort hiSetActionChecked hiSetBeepVolume hiSetBindKey hiSetBindKeys hiSetButtonIcon hiSetButtonLabel hiSetCallbackStatus hiSetCurrentField hiSetCurrentForm hiSetCurrentIndex hiSetCurrentTextSelectionLoc hiSetCurrentWindow hiSetCursor hiSetDBoxDefaultLocation hiSetDisabledIcon hiSetDrawThruDelta hiSetEFDrawThruDelta hiSetEFunCursor hiSetEncapHistory hiSetEncapPrompt hiSetEncapSkillCmd hiSetFieldEditable hiSetFieldEnabled hiSetFilter hiSetFilterOptions hiSetFont hiSetFormBlock hiSetFormButtonEnabled hiSetFormHighlights hiSetFormMinMaxSize hiSetFormName hiSetFormPosition hiSetFormSize hiSetFormToDefaults hiSetIconName hiSetInsertionPosition hiSetLayerCyclicValue hiSetListItemCenter hiSetListItemVisible hiSetMenuItemCallback hiSetMenuItemStatusTip hiSetMenuItemText hiSetMouseMoveSampleRate hiSetMouseStopDetectTime hiSetMultiClickTime hiSetProgress hiSetProgressAndText hiSetProgressBannerText hiSetProgressBar hiSetProgressButtonText hiSetProgressLabel hiSetProgressText hiSetProgressTotalSteps hiSetScrollBarValue hiSetSessionFocus hiSetShadowMode hiSetSplashBackground hiSetSplashDefaultBackground hiSetSplashFamily hiSetSplashIcon hiSetSplashLicense hiSetSplashProduct hiSetTabWindowIcon hiSetTabWindowTip hiSetTabWindowTitle hiSetTextClass hiSetTextHighlightColor hiSetTextSelectAll hiSetTextSelection hiSetToolbarObjName hiSetTopListItem hiSetTreeItemDescription hiSetTreeItemIcons hiSetUndoLimit hiSetUserPreferences hiSetViewfile hiSetWinObjName hiSetWinStyle hiSetWindowAtts hiSetWindowDefaultPrompt hiSetWindowFocus hiSetWindowIcon hiSetWindowMenu hiSetWindowName hiShowBindKeys hiShowBindKeysByAppType hiShowBindKeysByWindow hiShowFieldBorders hiShowListBox hiShowProgressBar hiShowToolbar hiSleep hiStartGenTextIndex hiStartLog hiStoreFormLocation hiStringToIcon hiStroke hiSwapTreeItemSelectionIcons hiSwitchWindowType hiSynchronize hiTextDisplayString hiTextWidth hiToggleAnchorMagnifier hiToggleEnterForm hiToggleMagnifier hiToggleMagnifierResolution hiTreeAppendItem hiTreeAppendItems hiTreePrependItem hiTreePrependItems hiTreeRemoveAllItems hiTreeRemoveItem hiTreeRemoveItems hiTreeTableDeselectAllItems hiTreeTableDeselectItem hiTreeTableDeselectItems hiTreeTableGetExpandedItemCount hiTreeTableGetExpandedItems hiTreeTableGetItemCount hiTreeTableGetItems hiTreeTableGetSelectedItemCount hiTreeTableGetSelectedItems hiTreeTableSelectAllItems hiTreeTableSelectItem hiTreeTableSelectItems hiUndo hiUndockWindow hiUnmapWindow hiUnregCloseProc hiUnregCurWindowTrigger hiUnregZoomPanProc hiUnselectText hiUnselectTextAll hiUnselectTextByLoc hiUnselectTextClass hiUpdate hiUpdateFormBlock hiUpdateMagOptions hiUpdateTextSelectionColors hiUseMagnifierResolution hiUsingMagnifierResolution hiVectorPan hiViewfile hiWinConfigModified hiWindowSaveImage hiZoomAbsoluteScale hiZoomExpandAtMouse hiZoomExpandAtPoint hiZoomIn hiZoomInAtMouse hiZoomInMagnifier hiZoomOut hiZoomOutAtMouse hiZoomOutMagnifier hiZoomRelativeScale hiZoomWindowAtMouse hiZoomWindowAtPoint histo histogram2D history hlcheck hnlAbortNetlist hnlAddExtraParameters hnlCDLPrintBJTElement hnlCDLPrintBSIM3SOIElement hnlCDLPrintCapElement hnlCDLPrintCapacitorElement hnlCDLPrintCds_Thru hnlCDLPrintDiodeElement hnlCDLPrintGeneralElement hnlCDLPrintICIsrcElement hnlCDLPrintICVsrcElement hnlCDLPrintInductorElement hnlCDLPrintIsrcElement hnlCDLPrintJfetElement hnlCDLPrintMultiCNPNElement hnlCDLPrintMultiCPNPElement hnlCDLPrintMultiENPNElement hnlCDLPrintMultiEPNPElement hnlCDLPrintNMOSfetElement hnlCDLPrintNPNElement hnlCDLPrintPMOSfetElement hnlCDLPrintPNPElement hnlCDLPrintResElement hnlCDLPrintResistorElement hnlCDLPrintSchottkyTranElement hnlCDLPrintTlineElement hnlCDLPrintVCIsrcElement hnlCDLPrintVCVsrcElement hnlCDLPrintVsrcElement hnlCatIncrementalNetlistFiles hnlCellExtracted hnlCellInAllCells hnlCloseCellFiles hnlCloseMasterList hnlCompletePrint hnlDoInstBased hnlDoNetBased hnlEMHGetDigitaGlobalNets hnlEMHGetDigitalNetlistFileName hnlEMHSetVerbosityLevel hnlFindAllCells hnlFindAllInstInCell hnlGenIncludeFile hnlGetCellHdbProps hnlGetGlobalModelMappedName hnlGetGlobalNetMappedName hnlGetInstanceCount hnlGetMappedInstNames hnlGetMappedModelNames hnlGetMappedNames hnlGetMappedNetNames hnlGetMasterCells hnlGetPropVal hnlGetRoundProp hnlGetScaleCapacitance hnlGetScaleMarginalDelay hnlGetScaleTimeUnit hnlGetSimulator hnlGetSourceFile hnlGetSourceFileModels hnlGetSymbolPropVal hnlGetTermByName hnlGetTermNameOfSig hnlHspiceInstPropVal hnlHspicePrintInstPropEqVal hnlHspicePrintInstPropVal hnlHspicePrintMOSfetModel hnlHspicePrintNMOSfetElement hnlIfNoProcedure hnlIgnoreTerm hnlInitMap hnlInitPrint hnlIsAPatchCord hnlIsAStoppingCell hnlIsCellNetlistable hnlIsCurrentInstStopping hnlMakeNetlistFileName hnlMapCellModuleName hnlMapCellName hnlMapInstName hnlMapModelName hnlMapName hnlMapNetName hnlMapTermName hnlMultipleCells hnlNameOfSignal hnlNetNameOnTerm hnlNetNameOnTermName hnlNmpSetNameSpaces hnlOpenTopCell hnlPcellIsParamOverridden hnlPrintDevices hnlPrintMessage hnlPrintNetlist hnlPrintSignal hnlPrintString hnlRunNetlister hnlScaleCapacitance hnlScaleMarginalDelay hnlScaleTimeUnit hnlSetCellFiles hnlSetDef hnlSetMappingType hnlSetPseudoTermDir hnlSetVars hnlSortTerms hnlSortTermsToNets hnlStartNetlist hnlStopNetlist hnlStringToList hnlVerilogPrintBehaveModel hnlVerilogPrintBehavePortOrder hnlVerilogPrintBidiXfr hnlVerilogPrintBufif0Notif0 hnlVerilogPrintBufif1Notif1 hnlVerilogPrintCmos hnlVerilogPrintLibraryModel hnlVerilogPrintLogGate hnlVerilogPrintNmosPmos hnlVerilogPrintPrimGate hnlVerilogPrintVhdlImport hnlWriteBlockControlFile hnlWriteMap hnllsCVInUserStopCVList hostMode hostName hsmDeselect hsmGetSelectedSet hsmSelect i ic iccIsConnected iccSendCommand iccSendSkillCommand idfHiAbout if ifreq ih iim iinteg ilAddTopLevelErrorHandler ilDebugCountLevels ilGetGFbyClass ilGetIdeSessionWindow ilRemoveMethod ilRemoveTopLevelErrorHandler ilSlotBoundp ilToolBox ilgAddRecentFiles ilgInvokeIDE ilgLastDir ilgRunSKILLIDE ilgSetLastDir im imag impHdlDisplay importSkillVar importSymbol inNext inScheme inSkill inStepOut include includeFile index infile info initializeInstance inl inportp installDebugger instring int intToChar integ integerp intersect ip ip3Plot ipcActivateBatch ipcActivateMessages ipcBatchProcess ipcBeginProcess ipcCloseProcess ipcContProcess ipcGetExitStatus ipcGetPid ipcGetPriority ipcIsActiveProcess ipcIsAliveProcess ipcKillAllProcesses ipcKillProcess ipcReadProcess ipcSetPriority ipcSkillProcess ipcSleep ipcSoftInterrupt ipcStopProcess ipcWait ipcWaitForProcess ipcWriteProcess ipn ipnVRI ipnVRICurves iqCreateDummyCell ir isBBox isCallable isClass isContextLoaded isDir isExecutable isFile isFileEncrypted isFileName isInfinity isLargeFile isLink isLocation isMacro isNaN isPortAtEOF isReadable isVarImported isWritable iseCloseSchWindow iseCloseSimWindow iseCompleteInteractive iseEnterNodeNamesList iseExitSimulator iseGetExtName iseGetInputFromEncapWindow iseGetMappedProbeList iseGetProbeList iseInitSchematicWindow iseInitSimWindow iseNetExtNameCdsName iseOpenWindows isePrintName isePrintNameCB isePrintSimulatorCommand iseReleaseNodeFrom iseSearchForASchWindow iseSendOutputToEncapHistory iseSetEncapBindKeys iseSetNodeTo iseSimulate iseStartInteractive iseStartSimulator iseUpdateNetlist iseUpdateStimulus itime ivCallProc ivCompilingFor ivConcICe ivCreatePCells ivDRC ivERC ivExtract ivGetCellView ivLVS ivVerify kf killJob labels lambda last lbuiGetCheckedOutLicenses lbuiPrintLicenseUseReport lceClearLogicalConn lceExtract lceExtractArea lceGetExtractLayers lceGetFracturedShapes lceGetFracturedShapesFromNet lceGetIncompleteNets lceGetOption lceHiExtract lceHierExtract lceIsExtractLayer lcePrintExtractLayers lcePrintExtractVias lcePrintTechLibExtractLayers lcePrintTechLibExtractVias lceSetOption lconc ldtrDefReadOA ldtrDefWriteOA ldtrLefReadOA ldtrLefWriteOA leAlign leApplyAreaFunction leApplyLastCopyTransform leArrowFunc leAttachFig leBalloonCycleThru leBalloonToggleOnOff leChopShape leClearAllRuler leCloseWindow leConvertInstToMosaic leConvertShapeToPathSeg leConvertShapeToPolygon leCreateAutoPin leCreatePath leCreatePin leCreateRuler leCycleSnapModes leCycleSnapPatternDisplay leDefineExternalPins leDefineInternalPins leDefineMPPTemplate leDefinePPPins leDefineWeaklyConnectedPins leDeiconifyLSW leDescend leDesignSummary leDoubleClick leEIPZoomAbsoluteScale leEditDesignProperties leEditInPlace leEnvLoad leExportLabel leFinishTrunk leFinishWire leFlattenInst leFreezeInst leFullSelectFigOfSelSet leGetAreaEstimationDisplayNames leGetAreaEstimatorFunction leGetAreaEstimatorParamList leGetAreaEstimatorRunMode leGetCoordinateForm leGetEditFigGroup leGetEntryLayer leGetEnv leGetGlobalGridsVisible leGetLSWBBox leGetLocalGridsVisible leGetObjectSelectable leGetObjectVisible leGetRefPoint leGetSnapPatternVisible leGetSnapToSPTransform leGetTechFormList leGetValidLayerList leGetValidPurposeList leHiAbout leHiAddShapeToNet leHiAddToGroup leHiAddWireVia leHiAlign leHiAttach leHiBatchChecker leHiCancelStitch leHiCellviewTrackPatterns leHiChop leHiClearRuler leHiClearRulerInHier leHiConvertInstToMosaic leHiConvertPolygonToPath leHiConvertShapeToPathSeg leHiConvertShapeToPolygon leHiCopy leHiCreateAreaBoundary leHiCreateBend leHiCreateBlockage leHiCreateBus leHiCreateChoiceOfPin leHiCreateCircle leHiCreateClusterBoundary leHiCreateClusters leHiCreateDonut leHiCreateEllipse leHiCreateGeometricWire leHiCreateGroup leHiCreateGuardRing leHiCreateInst leHiCreateLabel leHiCreatePRBoundary leHiCreatePath leHiCreatePin leHiCreatePinsFromLabels leHiCreatePlacementArea leHiCreatePolygon leHiCreateRect leHiCreateRow leHiCreateRuler leHiCreateSlot leHiCreateSnapBoundary leHiCreateTaper leHiCreateTrl leHiCreateVia leHiCreateWire leHiDelete leHiDeleteAllAreaViewLevel leHiDeleteAreaViewLevel leHiDeleteShapeFromNet leHiDescend leHiDisplayPadOpeningInfoForm leHiDisplayStartRouterForm leHiDisplayTechGraphForm leHiEditBalloonOptions leHiEditDRDOptions leHiEditDRDRuleOptions leHiEditDisplayOptions leHiEditDynamicMeasurementOptions leHiEditEditorOptions leHiEditInPlace leHiEditObjectInfo leHiEditProp leHiEditSlot leHiEditTbOptions leHiFlatten leHiFlip leHiGuidedRouting leHiGuidedRoutingReverseEnvelope leHiLayerGen leHiLayerTap leHiMakeCell leHiMarkNet leHiMerge leHiModifyCorner leHiMousePopUp leHiMove leHiMoveOrigin leHiOptionLayer leHiP2P leHiPaste leHiPlotQueueStatus leHiPropagateNets leHiQuery leHiQuickAlign leHiReShape leHiRemasterInstances leHiRemoveFromGroup leHiRepeatCopy leHiRotate leHiSave leHiSaveACopy leHiSaveAllHighLightMarkNet leHiSaveHier leHiSearch leHiSetAreaViewLevel leHiSetRefPoint leHiSetValidLayer leHiShowAngles leHiShowCoords leHiShowSelSet leHiSize leHiSplit leHiStitchToLayer leHiStretch leHiSubmitPlot leHiSummary leHiTree leHiUngroup leHiUnmarkNet leHiUnmarkNetAll leHiYank leIconifyLSW leIsFigSelectable leIsInstSelectable leIsLSWIconified leIsLayerSelectable leIsLayerValid leIsLayerVisible leIsNewODCInfraEnabled leIsPinSelectable leIsPointInsideFig leIsRefPointActive leLSWGetBlockageSelectable leLSWGetBlockageVisible leLSWGetRoutingGridVisible leLSWSetBlockageSelectable leLSWSetBlockageVisible leLSWSetRoutingGridVisible leLSWSetTrackPatternVisible leLSWShowGrids leLSWShowLayers leLSWShowObjects leLayerAnd leLayerAndNot leLayerOr leLayerSize leLayerXor leLmbCtrlOption leLmbShiftOption leMakeCell leMakeHierReadonlyOrEditableMC leMarkNet leMergeShapes leModifyCorner leMoveCellViewOrigin leMoveCursor leMoveCursorToRefPoint lePasteFigs lePinModelInitFunction lePlot lePrintHierarchyTree leRaiseLSW leRegAreaEstimator leRegClusterBdyEstimator leRegUserLayerSelectionFilter leRegUserObjectSelectionFilter leRemapLSW leRemasterInstances leRemoveUserLayerSelectionFilter leRemoveUserObjectSelectionFilter leReplace leReplaceAnyInstMaster leResizeLSW leReturn leReturnToLevel leRulerCycleDisplayType leSaveMarkNet leSearchHierarchy leSelBoxOrStretch leSetAllGridObjectsVisible leSetAllLayerSelectable leSetAllLayerValid leSetAllLayerVisible leSetAllObjectsSelectable leSetAllObjectsVisible leSetAreaEstimatorParameters leSetEditFigGroup leSetEntryLayer leSetEnv leSetFormSnapMode leSetGlobalGridsVisible leSetInstSelectable leSetLSWBBox leSetLSWFilter leSetLayerAttributes leSetLayerSelectable leSetLayerValid leSetLayerVisible leSetLocalGridsVisible leSetObjectSelectable leSetObjectVisible leSetPinSelectable leSetRefPoint leSetRefPointInactive leSetSnapPatternVisible leSizeShape leSlice leSpaceBarFunc leSplitShape leStartRouter leStretchFig leStretchShape leToggleAllGravity leToggleDrdMode leToggleGravity leToggleKeepFirstName leToggleMagnifier leToggleMaintainConnections leToggleSmartSnap leUnRegAreaEstimator leUnRegClusterBdyEstimator leUnfreezeInst leUniquifyCellView leUnmapLSW leUnmarkNet leUnregUserLayerSelectionFilter leUnregUserObjectSelectionFilter leWECycleControlWire leWECycleSnap leWENoSnap leYankFigs leZoomToPoint leZoomToSelSet leftEdge leftshift leiDiscardEdits length leqp lessp let letrec letseq linRg lindex lineread linereadstring list listAlias listFunctions listToVector listVariables listp lmCheckTerm lmCheckView lmCloseLib lmDefTermProp lmDefViewProp lmDeleteTermProp lmDeleteViewProp lmGetValue lmLoadData lmOpenLib lmPrintLibTermProp lmPrintLibViewProp lmPrintTerm lmPrintTermProp lmPrintViewProp lmReset lmSimView lmgrAddMenuItems lmgrCreateMenu lmgrCreateMenuItem lmgrDefineInits lmgrDeleteMenuItems lmgrDisplayMessage lmgrGetObject lmgrInsertMenuItems lmgrLogShowPopup lmgrManageMenuItems lmgrMenuSubsInPopup lmgrQueryNamedObjects lmgrSensitizeMenuItems lmgrSetObject lmgrVerbose ln loCellSubstitutionMap loHiAbout loLayerMap loLibraryMap loMapParameters loSchematicParams loSetAnnotateLPP loSetVal loSplitViaFunctionMap load loadContext loadPort loadTopContextForms loadi loadpull loadstring log log10 logRg lowerCase lowerLeft lsb lshift lsprintf lxAbutGetNeighbors lxChain lxCheck lxCheckAgainstSource lxCheckLib lxCmdOptions lxCmdShiftOptions lxComputeViaParams lxCreateBndFile lxDeleteSynchronousCloneFamily lxEditPinPlacement lxEditPlacementStyle lxGenFromSource lxGenerateFinish lxGenerateGetAvailablePinLPPs lxGenerateStart lxGetCloneFamilyName lxGetEditedSyncClone lxGetLXInfo lxGetOtherClonesInFamily lxGetPermutedInstTerms lxGetPinNets lxGetSyncClone lxGetValidViaDefs lxHiAbout lxHiAlign lxHiAutoPlace lxHiBackAnnotateAllActiveDummies lxHiBackAnnotateSelectedDummies lxHiChain lxHiCheck lxHiClone lxHiConnectInstPin lxHiCreateInstFromSch lxHiCreateMPP lxHiDefineDeviceCorr lxHiEditComponentTypes lxHiLockSelected lxHiMoveAutomatically lxHiProbe lxHiReInitDesign lxHiSetOptions lxHiStack lxHiSwapComps lxHiUnlockSelected lxHiUpdateBinding lxHiUpdateCellViewPair lxHiUpdateComponentsAndNets lxHiUpdateLayoutConstraints lxHiUpdateLayoutParameters lxHiUpdateSchematicParameters lxHiVerifyDesign lxHiVerifyStatus lxLaunchLayoutGXL lxLaunchLayoutXL lxMakePrBoundarySelectable lxMakePrBoundaryUnselectable lxMovePorts lxPermPermutePins lxPlcAppendPlaceSetupFieldValue lxPlcGetPlaceSetupFieldValue lxPlcIsPlaceSetupFieldEnabled lxPlcReplacePlaceSetupField lxPlcSetPlaceSetupFieldEnableState lxPlcSetPlaceSetupFieldValue lxProbeRemoveAll lxRemoveSynchronousCloneFromFamily lxRunCmdInVXL lxSelectSynchronousFamily lxSelectedDeleteNetRouting lxSelectedExtendChain lxSelectedExtendSelection lxSelectedLock lxSelectedLockNet lxSelectedRemoveIgnore lxSelectedRoute lxSelectedRouteNet lxSelectedSelectAttachedNets lxSelectedSelectExternalNets lxSelectedSelectInternalNets lxSelectedSelectNetsShapes lxSelectedUnlock lxSelectedUnlockNet lxSelectedUpdateFromSource lxSelectedUpdateIgnore lxSetAreaEstimationOptions lxSetBoundaryOptions lxSetCloneFamilyName lxSetConfigRef lxSetConnRef lxSetGenerateOptions lxSetNetPinSpecs lxSetPreserveFloorplanningOptions lxSetUpdateOptions lxShowHideIncompleteNets lxToggleLocalAbutment lxToggleShowAllIncompleteNets lxToggleShowIncompleteNets lxTpTemplateLoadAll lxUpdateAllPhysBinding lxUpdateBinding lxUpdateComponentsAndNets lxUpdateComponentsAndNetsFinish lxUpdateComponentsAndNetsStart lxUpdatePhysBinding lxUpdatePlacementStatus lxVerifyCloneFamily mag makeInstance makeNamespace makeSymbol makeTable makeTempFileName makeVector map mapc mapcan mapcar mapcon mapinto maplist max mbGetAction mbRegisterAction mbRegisterCustomMenu mbRegisterHierMenu mbRegisterMenuItem mbSetContextData mbUnregisterAction measureTime member memoryAllocated memq memv menuTrigger mgAbutAllCB mgAbutCB mgAddBodyContact mgAddCopyDummies mgAddDummyBottomCB mgAddDummyLeftCB mgAddDummyRCBottomCB mgAddDummyRCLeftCB mgAddDummyRCRightCB mgAddDummyRCTopCB mgAddDummyRightCB mgAddDummyTopCB mgAddEmptyRCCB mgAddGuardRingCB mgCreateModgenAsLayout mgCreateOrEdit mgDeleteAllBodyContacts mgDeleteAllDummies mgDeleteCB mgDeleteEmptyRowColumnCB mgEditGuardRingCB mgExecNoConObs mgExitCB mgFlattenModgens mgFlipHorizontalCB mgFlipVerticalCB mgGen mgGetBoxLPPArea mgGetConstraintFromFG mgGetLayerSpacing mgGetModgenFGFromConstraint mgGetRegUserProc mgHilightEmptyRowColumnCB mgIsInBackAnnotation mgPatternCB mgRegUserProc mgRotateLeftCB mgRotateMXCB mgRotateMYCB mgRotateR270CB mgRotateR90CB mgRotateRightCB mgRouteCB mgRoutePToTCB mgRouteStructuredCB mgSelectRowColCB mgSwapCB mgUnAbutCB mgUnRegUserProc mgUnRouteCB mgUpdateCB mgUpdateEmptyRowColumnHilightCB mgUpdateHoriAlignCB mgUpdateVertAlignCB min minus minusp mod modelFile modf modulo monitor mouseAddPt mouseAddSelectPt mouseFinishPt mousePopUp mouseSingleSelectPt mouseSubSelectPt mouseUndoPt mprocedure msgHelp mspDisplaySetPartSetupForm mspEditIEProps mspsMapNetName nc nc_freq nc_gain nclAnalogAdjCellPins nclAnalogAdjCellSides nclAnalogAutoPlaceCB nclAnalogFixDRCs nclAnalogQuickPlace nclAnalogQuickPlaceLikeSchemCB nclCPExit nclCPSaveConstraint nclCPToolBarSelect nclCreateXSym nclRegPostPlacementTrigger nclRegPrePlacementTrigger nclRunConstraintValidation nclSetAspectRatioRange nclToggleCAEMode nclUnregPostPlacementTrigger nclUnregPrePlacementTrigger nconc ncons needNCells negativep neq nequal netlist newWindow newline next nextMethodp nf nfmin nindex nlDisplayOption nlError nlGetCdf nlGetCellName nlGetCurrentSwitchMaster nlGetDesign nlGetFormatter nlGetGlobalNets nlGetId nlGetLibName nlGetModelName nlGetNetlistDir nlGetNetlister nlGetNumberOfBits nlGetOption nlGetOptionNameList nlGetPCellParamSource nlGetParamList nlGetParamStringValue nlGetSignalList nlGetSimName nlGetSimTerminalNets nlGetSwitchViewList nlGetTerminalList nlGetTerminalNets nlGetTerminalSignalName nlGetToolName nlGetTopCellName nlGetTopLibName nlGetTopViewName nlIncludeDbDSPFTextFile nlIncludeSrcFile nlIncludeVerilogFile nlIncludeVerilogaFile nlInfo nlInitialize nlIsModelNameInherited nlMapGlobalNet nlObjError nlPrintComment nlPrintComments nlPrintFooter nlPrintHeader nlPrintHeaderComments nlPrintIndentString nlPrintInst nlPrintInstComments nlPrintInstEnd nlPrintInstName nlPrintInstParameters nlPrintInstSignals nlPrintModelName nlPrintString nlPrintStringNoFold nlPrintSubcktBegin nlPrintSubcktEnd nlPrintSubcktFooter nlPrintSubcktFooterComments nlPrintSubcktHeader nlPrintSubcktHeaderComments nlPrintSubcktName nlPrintSubcktParameters nlPrintSubcktTerminalList nlPrintTopCellFooter nlPrintTopCellFooterComments nlPrintTopCellHeader nlPrintTopCellHeaderComments nlSetOption nlSetPcellName nlTranslateFlatIEPathName nlWarning nlambda nmpAsciiToSysVerilog nmpCDBAFlatToCDBA nmpCDBAToCDBAFlat nmpCDBAToConcept nmpCDBAToDef nmpCDBAToGcf nmpCDBAToGenesis nmpCDBAToIdent nmpCDBAToLef nmpCDBAToPrint nmpCDBAToSdf nmpCDBAToSpectre nmpCDBAToSpectreHDL nmpCDBAToSpef nmpCDBAToSpf nmpCDBAToSpice nmpCDBAToSysVerilog nmpCDBAToVHDL nmpCDBAToVHDL87 nmpCDBAToVHDLAMS nmpCDBAToVerilog nmpCDBAToVerilogA nmpCDBAToVerilogAMS nmpConceptToCDBA nmpConceptToDef nmpConceptToGcf nmpConceptToGenesis nmpConceptToIdent nmpConceptToLef nmpConceptToPrint nmpConceptToSdf nmpConceptToSpectre nmpConceptToSpectreHDL nmpConceptToSpef nmpConceptToSpf nmpConceptToSpice nmpConceptToSysVerilog nmpConceptToVHDL nmpConceptToVHDL87 nmpConceptToVHDLAMS nmpConceptToVerilog nmpConceptToVerilogA nmpConceptToVerilogAMS nmpDefToCDBA nmpDefToConcept nmpDefToGcf nmpDefToGenesis nmpDefToIdent nmpDefToLef nmpDefToPrint nmpDefToSdf nmpDefToSpectre nmpDefToSpectreHDL nmpDefToSpef nmpDefToSpf nmpDefToSpice nmpDefToSysVerilog nmpDefToVHDL nmpDefToVHDL87 nmpDefToVHDLAMS nmpDefToVerilog nmpDefToVerilogA nmpDefToVerilogAMS nmpGcfToCDBA nmpGcfToConcept nmpGcfToDef nmpGcfToGenesis nmpGcfToIdent nmpGcfToLef nmpGcfToPrint nmpGcfToSdf nmpGcfToSpectre nmpGcfToSpectreHDL nmpGcfToSpef nmpGcfToSpf nmpGcfToSpice nmpGcfToSysVerilog nmpGcfToVHDL nmpGcfToVHDL87 nmpGcfToVHDLAMS nmpGcfToVerilog nmpGcfToVerilogA nmpGcfToVerilogAMS nmpGenesisToCDBA nmpGenesisToConcept nmpGenesisToDef nmpGenesisToGcf nmpGenesisToIdent nmpGenesisToLef nmpGenesisToPrint nmpGenesisToSdf nmpGenesisToSpectre nmpGenesisToSpectreHDL nmpGenesisToSpef nmpGenesisToSpf nmpGenesisToSpice nmpGenesisToSysVerilog nmpGenesisToVHDL nmpGenesisToVHDL87 nmpGenesisToVHDLAMS nmpGenesisToVerilog nmpGenesisToVerilogA nmpGenesisToVerilogAMS nmpGetSpaceNames nmpIdentToCDBA nmpIdentToConcept nmpIdentToDef nmpIdentToGcf nmpIdentToGenesis nmpIdentToLef nmpIdentToPrint nmpIdentToSdf nmpIdentToSpectre nmpIdentToSpectreHDL nmpIdentToSpef nmpIdentToSpf nmpIdentToSpice nmpIdentToSysVerilog nmpIdentToVHDL nmpIdentToVHDL87 nmpIdentToVHDLAMS nmpIdentToVerilog nmpIdentToVerilogA nmpIdentToVerilogAMS nmpIsLegalCDBA nmpIsLegalConcept nmpIsLegalDef nmpIsLegalGcf nmpIsLegalGenesis nmpIsLegalLef nmpIsLegalPrint nmpIsLegalSdf nmpIsLegalSpectre nmpIsLegalSpectreHDL nmpIsLegalSpef nmpIsLegalSpf nmpIsLegalSpice nmpIsLegalSysVerilog nmpIsLegalVHDL nmpIsLegalVHDL87 nmpIsLegalVHDLAMS nmpIsLegalVerilog nmpIsLegalVerilogA nmpIsLegalVerilogAMS nmpLefToCDBA nmpLefToConcept nmpLefToDef nmpLefToGcf nmpLefToGenesis nmpLefToIdent nmpLefToPrint nmpLefToSdf nmpLefToSpectre nmpLefToSpectreHDL nmpLefToSpef nmpLefToSpf nmpLefToSpice nmpLefToSysVerilog nmpLefToVHDL nmpLefToVHDL87 nmpLefToVHDLAMS nmpLefToVerilog nmpLefToVerilogA nmpLefToVerilogAMS nmpPrintToCDBA nmpPrintToConcept nmpPrintToDef nmpPrintToGcf nmpPrintToGenesis nmpPrintToIdent nmpPrintToLef nmpPrintToSdf nmpPrintToSpectre nmpPrintToSpectreHDL nmpPrintToSpef nmpPrintToSpf nmpPrintToSpice nmpPrintToSysVerilog nmpPrintToVHDL nmpPrintToVHDL87 nmpPrintToVHDLAMS nmpPrintToVerilog nmpPrintToVerilogA nmpPrintToVerilogAMS nmpSdfToCDBA nmpSdfToConcept nmpSdfToDef nmpSdfToGcf nmpSdfToGenesis nmpSdfToIdent nmpSdfToLef nmpSdfToPrint nmpSdfToSpectre nmpSdfToSpectreHDL nmpSdfToSpef nmpSdfToSpf nmpSdfToSpice nmpSdfToSysVerilog nmpSdfToVHDL nmpSdfToVHDL87 nmpSdfToVHDLAMS nmpSdfToVerilog nmpSdfToVerilogA nmpSdfToVerilogAMS nmpSpectreHDLToCDBA nmpSpectreHDLToConcept nmpSpectreHDLToDef nmpSpectreHDLToGcf nmpSpectreHDLToGenesis nmpSpectreHDLToIdent nmpSpectreHDLToLef nmpSpectreHDLToPrint nmpSpectreHDLToSdf nmpSpectreHDLToSpectre nmpSpectreHDLToSpef nmpSpectreHDLToSpf nmpSpectreHDLToSpice nmpSpectreHDLToSysVerilog nmpSpectreHDLToVHDL nmpSpectreHDLToVHDL87 nmpSpectreHDLToVHDLAMS nmpSpectreHDLToVerilog nmpSpectreHDLToVerilogA nmpSpectreHDLToVerilogAMS nmpSpectreToCDBA nmpSpectreToConcept nmpSpectreToDef nmpSpectreToGcf nmpSpectreToGenesis nmpSpectreToIdent nmpSpectreToLef nmpSpectreToPrint nmpSpectreToSdf nmpSpectreToSpectreHDL nmpSpectreToSpef nmpSpectreToSpf nmpSpectreToSpice nmpSpectreToSysVerilog nmpSpectreToVHDL nmpSpectreToVHDL87 nmpSpectreToVHDLAMS nmpSpectreToVerilog nmpSpectreToVerilogA nmpSpectreToVerilogAMS nmpSpefToCDBA nmpSpefToConcept nmpSpefToDef nmpSpefToGcf nmpSpefToGenesis nmpSpefToIdent nmpSpefToLef nmpSpefToPrint nmpSpefToSdf nmpSpefToSpectre nmpSpefToSpectreHDL nmpSpefToSpf nmpSpefToSpice nmpSpefToSysVerilog nmpSpefToVHDL nmpSpefToVHDL87 nmpSpefToVHDLAMS nmpSpefToVerilog nmpSpefToVerilogA nmpSpefToVerilogAMS nmpSpfToCDBA nmpSpfToConcept nmpSpfToDef nmpSpfToGcf nmpSpfToGenesis nmpSpfToIdent nmpSpfToLef nmpSpfToPrint nmpSpfToSdf nmpSpfToSpectre nmpSpfToSpectreHDL nmpSpfToSpef nmpSpfToSpice nmpSpfToSysVerilog nmpSpfToVHDL nmpSpfToVHDL87 nmpSpfToVHDLAMS nmpSpfToVerilog nmpSpfToVerilogA nmpSpfToVerilogAMS nmpSpiceToCDBA nmpSpiceToConcept nmpSpiceToDef nmpSpiceToGcf nmpSpiceToGenesis nmpSpiceToIdent nmpSpiceToLef nmpSpiceToPrint nmpSpiceToSdf nmpSpiceToSpectre nmpSpiceToSpectreHDL nmpSpiceToSpef nmpSpiceToSpf nmpSpiceToSysVerilog nmpSpiceToVHDL nmpSpiceToVHDL87 nmpSpiceToVHDLAMS nmpSpiceToVerilog nmpSpiceToVerilogA nmpSpiceToVerilogAMS nmpSysVerilogToAscii nmpSysVerilogToCDBA nmpSysVerilogToConcept nmpSysVerilogToDef nmpSysVerilogToGcf nmpSysVerilogToGenesis nmpSysVerilogToIdent nmpSysVerilogToLef nmpSysVerilogToPrint nmpSysVerilogToSdf nmpSysVerilogToSpectre nmpSysVerilogToSpectreHDL nmpSysVerilogToSpef nmpSysVerilogToSpf nmpSysVerilogToSpice nmpSysVerilogToVHDL nmpSysVerilogToVHDL87 nmpSysVerilogToVHDLAMS nmpSysVerilogToVerilog nmpSysVerilogToVerilogA nmpSysVerilogToVerilogAMS nmpVHDL87ToCDBA nmpVHDL87ToConcept nmpVHDL87ToDef nmpVHDL87ToGcf nmpVHDL87ToGenesis nmpVHDL87ToIdent nmpVHDL87ToLef nmpVHDL87ToPrint nmpVHDL87ToSdf nmpVHDL87ToSpectre nmpVHDL87ToSpectreHDL nmpVHDL87ToSpef nmpVHDL87ToSpf nmpVHDL87ToSpice nmpVHDL87ToSysVerilog nmpVHDL87ToVHDL nmpVHDL87ToVHDLAMS nmpVHDL87ToVerilog nmpVHDL87ToVerilogA nmpVHDL87ToVerilogAMS nmpVHDLAMSToCDBA nmpVHDLAMSToConcept nmpVHDLAMSToDef nmpVHDLAMSToGcf nmpVHDLAMSToGenesis nmpVHDLAMSToIdent nmpVHDLAMSToLef nmpVHDLAMSToPrint nmpVHDLAMSToSdf nmpVHDLAMSToSpectre nmpVHDLAMSToSpectreHDL nmpVHDLAMSToSpef nmpVHDLAMSToSpf nmpVHDLAMSToSpice nmpVHDLAMSToSysVerilog nmpVHDLAMSToVHDL nmpVHDLAMSToVHDL87 nmpVHDLAMSToVerilog nmpVHDLAMSToVerilogA nmpVHDLAMSToVerilogAMS nmpVHDLToCDBA nmpVHDLToConcept nmpVHDLToDef nmpVHDLToGcf nmpVHDLToGenesis nmpVHDLToIdent nmpVHDLToLef nmpVHDLToPrint nmpVHDLToSdf nmpVHDLToSpectre nmpVHDLToSpectreHDL nmpVHDLToSpef nmpVHDLToSpf nmpVHDLToSpice nmpVHDLToSysVerilog nmpVHDLToVHDL87 nmpVHDLToVHDLAMS nmpVHDLToVerilog nmpVHDLToVerilogA nmpVHDLToVerilogAMS nmpVerilogAMSToCDBA nmpVerilogAMSToConcept nmpVerilogAMSToDef nmpVerilogAMSToGcf nmpVerilogAMSToGenesis nmpVerilogAMSToIdent nmpVerilogAMSToLef nmpVerilogAMSToPrint nmpVerilogAMSToSdf nmpVerilogAMSToSpectre nmpVerilogAMSToSpectreHDL nmpVerilogAMSToSpef nmpVerilogAMSToSpf nmpVerilogAMSToSpice nmpVerilogAMSToSysVerilog nmpVerilogAMSToVHDL nmpVerilogAMSToVHDL87 nmpVerilogAMSToVHDLAMS nmpVerilogAMSToVerilog nmpVerilogAMSToVerilogA nmpVerilogAToCDBA nmpVerilogAToConcept nmpVerilogAToDef nmpVerilogAToGcf nmpVerilogAToGenesis nmpVerilogAToIdent nmpVerilogAToLef nmpVerilogAToPrint nmpVerilogAToSdf nmpVerilogAToSpectre nmpVerilogAToSpectreHDL nmpVerilogAToSpef nmpVerilogAToSpf nmpVerilogAToSpice nmpVerilogAToSysVerilog nmpVerilogAToVHDL nmpVerilogAToVHDL87 nmpVerilogAToVHDLAMS nmpVerilogAToVerilog nmpVerilogAToVerilogAMS nmpVerilogToCDBA nmpVerilogToConcept nmpVerilogToDef nmpVerilogToGcf nmpVerilogToGenesis nmpVerilogToIdent nmpVerilogToLef nmpVerilogToPrint nmpVerilogToSdf nmpVerilogToSpectre nmpVerilogToSpectreHDL nmpVerilogToSpef nmpVerilogToSpf nmpVerilogToSpice nmpVerilogToSysVerilog nmpVerilogToVHDL nmpVerilogToVHDL87 nmpVerilogToVHDLAMS nmpVerilogToVerilogA nmpVerilogToVerilogAMS nodeset noise noiseSummary normalQQ not nprocedure nrDialogAccept nrListColumnMove nrListColumnSort nrListItemAction nrListItemExpand nrListItemRename nrResizeWindow nrSetCurrentWindow nrSetFileFilter nrSetWindowVisibility nrUpdateMenu nth nthcdr nthelem null numOpenFiles numberp ocnAmsSetOSSNetlister ocnCloseSession ocnDisplay ocnDspfFile ocnGetAdjustedPath ocnGetInstancesModelName ocnHelp ocnPrint ocnPspiceFile ocnResetResults ocnSetAttrib ocnSetSilentMode ocnSetXLMode ocnSpefFile ocnWriteLsspToFile ocnYvsYplot ocnxlAddOrUpdateOutput ocnxlAddRelxSetup ocnxlBeginTest ocnxlConjugateGradientOptions ocnxlCorner ocnxlCornerVars ocnxlDisableCorner ocnxlDisableCornerForTest ocnxlDisableRelxSetup ocnxlDisableSweepParam ocnxlDisableSweepVar ocnxlDisableTest ocnxlEnableCorner ocnxlEnableCornerForTest ocnxlEnableSweepParam ocnxlEnableSweepVar ocnxlEnableTest ocnxlEndTest ocnxlEndXLMode ocnxlExportOutputView ocnxlFeasibilityAnalysisOptions ocnxlGetBestPointParams ocnxlGetCorners ocnxlGetCurrentHistory ocnxlGetCurrentHistoryId ocnxlGetHistory ocnxlGetJobId ocnxlGetOverwriteHistory ocnxlGetOverwriteHistoryName ocnxlGetPointId ocnxlGetReferenceHistory ocnxlGetRunDistributeOptions ocnxlGetSession ocnxlGetSpecs ocnxlGetTests ocnxlGlobalOptimizationOptions ocnxlHistoryPrefix ocnxlJobSetup ocnxlLoadCurrentEnvironment ocnxlLoadSetupState ocnxlLocalOptimizationOptions ocnxlMCIterNum ocnxlMTSBlock ocnxlMTSEnable ocnxlMainSimSession ocnxlModelGroup ocnxlMonteCarloOptions ocnxlOutputAreaGoal ocnxlOutputExpr ocnxlOutputMatlabScript ocnxlOutputOceanScript ocnxlOutputOpRegion ocnxlOutputSignal ocnxlOutputSummary ocnxlOutputTerminal ocnxlParametricSet ocnxlPreRunScript ocnxlProjectDir ocnxlPutGreaterthanSpec ocnxlPutInfoSpec ocnxlPutLessthanSpec ocnxlPutMaxSpec ocnxlPutMinSpec ocnxlPutRangeSpec ocnxlPutTargetSpec ocnxlPutToleranceSpec ocnxlRemoveSpec ocnxlRenameCurrentHistory ocnxlResultsLocation ocnxlRun ocnxlRunCalibration ocnxlRunSetupSummary ocnxlSamplingOptions ocnxlSaveSetupAs ocnxlSelectTest ocnxlSensitivityOptions ocnxlSensitivityVars ocnxlSetAllParameterPSetsDisabled ocnxlSetAllParametersDisabled ocnxlSetAllVariablePSetsDisabled ocnxlSetAllVarsDisabled ocnxlSetCalibration ocnxlSetMCdut ocnxlSetOverwriteHistory ocnxlSetOverwriteHistoryName ocnxlSetPreRunScriptEnabled ocnxlSetReferenceHistory ocnxlSetRelxAnalysisEnabled ocnxlSetRunDistributeOptions ocnxlSetupLocation ocnxlSimResultsLocation ocnxlSizeOverCornersOptions ocnxlStartingPoint ocnxlSweepParam ocnxlSweepVar ocnxlSweepsAndCornersOptions ocnxlTargetCellView ocnxlUpdatePointVariable ocnxlWaitUntilDone ocnxlWorstCaseCornersOptions ocnxlWriteDatasheet ocnxlYieldEstimationOptions ocnxlYieldImprovementOptions odcRegBlockage odcRegBoundary odcRegCPA odcRegInstance odcRegLabel odcRegMarker odcRegModgen odcRegPin odcRegRow odcRegRuler odcRegShapeCircle odcRegShapeDonut odcRegShapeEllipse odcRegShapeMPP odcRegShapePath odcRegShapePathSeg odcRegShapePolygon odcRegShapeRect odcRegTextDisplay odcRegVia odcRegisterCustomFunc oddp off onep openResults openportp option or otherp outfile outportp outputParams outputs outstring outstringp overshoot pairp parCacheFind parCacheGet parCacheListFilters parCacheListModels parCachePurge parCacheSave parDelete parFilterCreate parFind parModelCreateCustom parModelCreateNetC parModelCreateNetK parModelCreateNetL parModelCreateNetR parModelListSimParams parModelListSimSweeps parModelUpdateSimParams parModelUpdateSimSweeps parObjectListFilters parObjectListModels parRemoveMembers parResetAllParams parResetParams parSetNote parUpdateMembers parUpdateParams paramAnalysis paramRun parseString path pavg pcColinearPoints pcConcatOrient pcDefineCondition pcDefineInheritParam pcDefinePCell pcDefineParamCell pcDefineParamLabel pcDefineParamLayer pcDefineParamPath pcDefineParamPolygon pcDefineParamProp pcDefineParamRect pcDefineParamRefPointObject pcDefinePathRefPointObject pcDefineRepeat pcDefineSteppedObject pcDefineStretchLine pcDeleteCondition pcDeleteParam pcDeleteParamLayer pcDeleteParamProp pcDeleteParamShape pcDeleteRefPoint pcDeleteRepeat pcDeleteSteppedObject pcExprToProp pcExprToString pcFilterPoints pcFix pcGetBendAngle pcGetCodeParamNames pcGetCodeParamValue pcGetConditions pcGetInheritParamDefn pcGetInheritParams pcGetOffsetPath pcGetOffsetPolygon pcGetParamLabelDefn pcGetParamLabels pcGetParamLayerDefn pcGetParamLayers pcGetParamProps pcGetParamShapeDefn pcGetParamShapes pcGetParameters pcGetPathRefPoint pcGetRefPointDefn pcGetRefPoints pcGetRepeatDefn pcGetRepeats pcGetStepDirection pcGetSteppedObjectDefn pcGetSteppedObjects pcGetStretchDefn pcGetStretchSummary pcGetStretches pcGrowBox pcGrowPoints pcHICompileToSkill pcHIDefineCondition pcHIDefineInheritedParameter pcHIDefineLabel pcHIDefineLayer pcHIDefineParamCell pcHIDefineParamRefPointObject pcHIDefineParameterizedShape pcHIDefinePathRefPointObject pcHIDefineProp pcHIDefineRepeat pcHIDefineSteppedObject pcHIDefineStretch pcHIDeleteCondition pcHIDeleteLayer pcHIDeleteParameterizedShape pcHIDeleteProp pcHIDeleteRefPointObject pcHIDeleteRepeat pcHIDeleteSteppedObject pcHIDisplayCondition pcHIDisplayInheritedParameter pcHIDisplayLayer pcHIDisplayParameterizedShape pcHIDisplayParams pcHIDisplayProp pcHIDisplayRefPointObject pcHIDisplayRepeat pcHIDisplaySteppedObject pcHIEditParameters pcHIModifyCondition pcHIModifyLabel pcHIModifyLayer pcHIModifyParams pcHIModifyRefPointObject pcHIModifyRepeat pcHIModifySteppedObject pcHIModifyStretchLine pcHIQualifyStretchLine pcHIRedefineStretchLine pcHISummarizeParams pcModifyParam pcRedefineStretchLine pcRestrictStretchToObjects pcRound pcSetFTermWidth pcSkillGen pcStepAlongShape pcTechFile pcUserAdjustParameters pcUserGenerateArray pcUserGenerateInstance pcUserGenerateInstancesOfMaster pcUserGenerateLPP pcUserGeneratePin pcUserGenerateProperty pcUserGenerateShape pcUserGenerateTerminal pcUserInitRepeat pcUserPostProcessCellView pcUserPostProcessObject pcUserPreProcessCellView pcUserSetTermNetName pcdbClose pcdbGetIgnoredInstMasterGen pcdbGetInstGen pcdbGetInstMasterGen pcdbInstMasterCell pcdbInstMasterCellFixed pcdbInstMasterLib pcdbInstMasterLibFixed pcdbInstMasterView pcdbInstMasterViewFixed pcdbInstName pcdbInstWidth pcdbNextInst pcdbNextInstMaster pcdbOpen pcdbSave pcdbViewHasPcdbInfo pcfix pcreCompile pcreExecute pcreGenCompileOptBits pcreGenExecOptBits pcreListCompileOptBits pcreListExecOptBits pcreMatchAssocList pcreMatchList pcreMatchp pcreObjectp pcrePrintLastMatchErr pcreReplace pcreSubstitute pcround peak peakToPeak period_jitter pfile phase phaseDeg phaseDegUnwrapped phaseMargin phaseNoise phaseRad phaseRadUnwrapped piCellNameMap piLayerMap piPostTranslate piPreTranslate piTextMap pipoDisplay pir plist plot plotStyle plus plusp pmNoise pn poCellNameMap poLayerMap poParamCellNameMap poPostTranslate poPreTranslate poTextMap popf portp postArrayDec postArrayInc postArraySet postInstallTrigger postdecrement postincrement pow pp pprint preArrayDec preArrayInc preArraySet preXY predecrement preincrement prependInstallPath prependPath print printFunctions printGraph printObject printVariables printViolations printf printlev println printself printstruct prms probeTrigger procedure procedurep profile profileReset profileSummary prog prog1 prog2 progn psConfigLoaded psLoadCdsPlotInit psQueryPaperSize psQueryPaperSizes psQueryPlotters psQueueStatus psd psdbb pstddev pteCancelForm pteClearSearchHistory pteCloseLayerSetEdition pteCollapse pteCollapseAll pteContextMenu pteDeleteLayerSet pteDeselect pteDeselectAll pteDiscardLayerSetEdition pteDockWindow pteEditLayerSet pteEditLayerSetValidity pteExpand pteExpandAll pteExportLayerSet pteFindNext pteFindPrev pteGetCurrentPanel pteGetLSAtPosition pteGetLayerPath pteGetNextLayerSets pteGetPrevLayerSets pteGetSelection pteHideAllTools pteImportLayerSet pteIsSelectable pteIsVisible pteLoadConfig pteLoadFromTechFile pteLoadGDSNumber pteLoadLSWInfo pteMapWindow pteMoveLayerSelection pteOpenForm ptePropagateSelectability ptePropagateVisibility pteRegisterUserLSManagerTrigger pteRegisterUserSelectionTrigger pteReloadLayerSet pteSaveAsLayerSet pteSaveConfig pteSaveGDSNumber pteSaveLSWInfo pteSaveLayerSet pteSaveLayerSetList pteSaveToTechFile pteSelect pteSelectAll pteSetActiveLpp pteSetAllLSEnable pteSetAllLayerSetMember pteSetAllSelectable pteSetAllStipple pteSetAllValidity pteSetAllVisible pteSetBindkeys pteSetConfig pteSetLSActive pteSetLSEnable pteSetLSPosition pteSetLSSelectable pteSetLSVisible pteSetLayerSetMember pteSetNoneLayerSetMember pteSetNoneSelectable pteSetNoneStipple pteSetNoneValidity pteSetNoneVisible pteSetOnlySelectable pteSetOnlyVisible pteSetOption pteSetOptionString pteSetRoutingDirection pteSetSearchMatchCase pteSetSearchMatchType pteSetSearchOperator pteSetSearchText pteSetSelectable pteSetStipple pteSetValidity pteSetVisible pteSetWindowSynchro pteShowAllTools pteShowRoutingLPP pteShowUsedLPP pteShowValidLPP pteToggleAllLayerSetMember pteToggleAllSelectable pteToggleAllStipple pteToggleAllTools pteToggleAllValidity pteToggleAllVisible pteToggleLSActive pteToggleLayerSetEdition pteToggleLayerSetValidityEdition pteTogglePanels pteTogglePropagateAllSelectable pteTogglePropagateAllVisible pteToggleShowRoutingLPP pteToggleShowUsedLPP pteToggleShowValidLPP pteToggleToolbars pteToggleWindowSynchro pteUnRegisterUserLSManagerTrigger pteUnRegisterUserSelectionTrigger pteUndockWindow pteUnmapWindow pteUnsetLSActive pushf putc putd putprop putpropq putpropqq pv pvi pvr pzFrequencyAndRealFilter pzPlot pzSummary pzbode pzfilter quote quotient random range rapidIIPN rapidIPNCurves rdbLoadResults rdbReloadResults rdbSetCurrentDirectory rdbShowDialog rdbUnloadResults rdbWriteToFormat rdeCreateChamferFill rdeCreateWireChamfer rdeDone rdeEval rdeGetVar rdeHide rdeInspect rdeOpenCurrentDesign rdeReplay rdeSequencer rdeSetVar rdeShow rdeSource read readTable readstring real realp regExitAfter regExitBefore relxOption remExitProc remainder remd remdq remoteDir remove removeDependent removeFromExportList removeLabel removeMethod removeShadowImport remprop remq renameFile report restore restoreFloat resultParam results resultsDir resume resumeJob return reverse rexCompile rexExecute rexMagic rexMatchAssocList rexMatchList rexMatchp rexReplace rexSubstitute rightEdge rightshift rindex riseTime risetime rms rmsNoise rmsVoltage rn rodAddMPPChopHole rodAddPoints rodAddSubPart rodAddToX rodAddToY rodAlign rodAssignHandleToParameter rodCheck rodCheckAllMPPsInCellView rodCheckMPPs rodCoordBisect rodCoordCreate rodCoordDefineGrid rodCoordFix rodCoordGetGrid rodCoordIsOnGrid rodCoordPartition rodCoordSnap rodCoordToFloat rodCoordToInt rodCoordToString rodCreateHandle rodCreatePath rodCreatePolygon rodCreateRect rodDeleteHandle rodDeleteSubPart rodFillBBoxWithRects rodFillWithRects rodGetBBox rodGetHandle rodGetNamedShapes rodGetObj rodGetSubPart rodIsFigNameUnused rodIsHandle rodIsObj rodNameObject rodNameShape rodPointX rodPointY rodSubPoints rodUnAlign rodUnNameShape root rotatef round round2 rplaca rplacd rshift rteCheckAntenna rteCheckDataForRouting rteCheckRoutability rteComposeTrunks rteCoverObstructionHilite rteCoverObstructionUnHilite rteCreateBlockRingScheme rteCreateCellRowsScheme rteCreateCoreRingScheme rteCreatePadRingScheme rteCreatePinToTrunkScheme rteCreateStripesScheme rteCreateViasScheme rteDecomposeTrunks rteDeleteRoutedNets rteFixAntenna rteFixViolations rteGeomAnd rteGeomAndNot rteGeomNot rteGeomOr rteGeomSize rteGeomXor rteOptimizeRoute rtePowerRouteBlockRing rtePowerRouteCellRow rtePowerRouteCoreRing rtePowerRoutePadRing rtePowerRoutePinToTrunk rtePowerRouteStripes rtePowerRouteTieShield rtePowerRouteTrimStripes rtePowerRouteViaInsertion rteSearchAndRepair rteSetvar run runsim s11 s12 s21 s22 sample save saveContext saveFloat saveGraphImage saveOption saveSubckt scanf schAddSelectPt schCheck schCheckHier schCheckHierConfig schCloneSymbol schCmdOption schComputePinRef schCopy schCreateInst schCreateInstBox schCreateNetExpression schCreateNoteLabel schCreateNoteShape schCreatePin schCreateSheet schCreateSymbolLabel schCreateSymbolPin schCreateSymbolShape schCreateWire schCreateWireLabel schDelete schDeleteIndex schDeleteSheet schDeselectAllFig schDirectEdit schDrawSymbolPin schEditPinOrder schEditSheetSize schExistsEditCap schExtendSelSet schExtendSelectPt schExtractConn schExtractStatus schGetBundleDisplayMode schGetCellViewListInSearchScope schGetCheckGroups schGetEnv schGetMatchingObjects schGetPinOrder schGetPostCheckTriggers schGetPreCheckTriggers schGetSignalTypeIntegrity schGetWireColor schGetWireLineStyle schGlueLabel schHDLReturn schHdlPrintFile schHdlPrintVars schHiAbout schHiAddCPFNetSets schHiAlternateView schHiCellViewProperty schHiChangeEditMode schHiCheck schHiCheckAndSave schHiCheckHier schHiCloneSymbol schHiComputePinRef schHiCopy schHiCreateBlockInst schHiCreateInst schHiCreateInstBox schHiCreateKanjiSymbol schHiCreateMappingSchematic schHiCreateNetExpression schHiCreateNoteLabel schHiCreateNoteShape schHiCreatePatchcord schHiCreatePin schHiCreateSheet schHiCreateSymbolLabel schHiCreateSymbolPin schHiCreateSymbolShape schHiCreateWire schHiCreateWireLabel schHiCreateWireStubs schHiDefaultAction schHiDelete schHiDeleteIndex schHiDeleteSheet schHiDescend schHiDescendEdit schHiDescendRead schHiDisplayOptions schHiDrawSymbolPin schHiEditInPlace schHiEditPinOrder schHiEditSheetSize schHiEditText schHiEditTitleBlock schHiEditorOptions schHiEnvSaveLoad schHiExtractConn schHiFind schHiFindMarker schHiFollowPin schHiFontUpdate schHiGotoSheet schHiGridOptions schHiHiliteLabel schHiInstToView schHiMousePopUp schHiMove schHiNetExprAvailProps schHiNetExprEvalNames schHiNewCellView schHiObjectProperty schHiOpenCellView schHiOpenOtherView schHiOpenSymbolOrSchematicView schHiPinListToView schHiPlot schHiPlotQueueStatus schHiRegisterWireStubs schHiRemoveCPFNetSets schHiRenumberAllSheet schHiRenumberInstances schHiRenumberSheet schHiReplace schHiResetInvisibleLabels schHiReturn schHiReturnToTop schHiRotate schHiRouteFlightLine schHiSRC schHiSaveCellView schHiSelectAll schHiSelectByProperty schHiSetSymbolOrigin schHiShowScope schHiSolder schHiStretch schHiSymStretch schHiTree schHiUpdatePinOrder schHiUpdatePinsFromView schHiVHDLProperty schHiVIC schHiVICAndSave schHiViewToView schHiZoomToSelSet schInhConFind schInhConSet schInstToView schInstallHDL schIsHDLCapEnabled schIsIndexCV schIsSchEditOk schIsSheetCV schIsSymEditOk schIsTextEditable schIsViewCapEnabled schIsWireLabel schLayoutToPinList schMouseApplyOrFinish schMove schNetExprAvailProps schNetExprEvalNames schPinListToSchem schPinListToSchemGen schPinListToSymbol schPinListToSymbolGen schPinListToVerilog schPinListToView schPlot schRegPostCheckTrigger schRegPreCheckTrigger schRegisterCheckGroup schRegisterCheckRule schRegisterFixedMenu schRegisterPopUpMenu schRenumberAllSheet schRenumberInstances schRenumberSheet schReplaceProperty schReportCheckFailure schSRC schSaveCurrentPlotOptions schSchemToPinList schSelectAllFig schSelectPoint schSetAndLoadTsgTemplateType schSetBundleDisplayMode schSetCmdOption schSetEnv schSetSelectOptions schSetSignalTypeIntegrity schSetSymbolOrigin schSetTextDisplayBBox schSetWireColor schSetWireLineStyle schShiftCmdOption schSingleSelectBox schSingleSelectPt schSnapToConn schSolder schStretch schSubSelectBox schSymbolToPinList schSync schUnregPostCheckTrigger schUnregPreCheckTrigger schUnregisterFixedMenu schUnregisterPopUpMenu schUpdateUserSRCErrorAndWarn schVIC schVerilogToPinList schViewToView schZoomFit schemeTopLevelEnv selectResult set setContext setCurrentWindow setDevCheckOptions setFnWriteProtect setPrompts setSG setSaveContextVersion setShellEnvVar setSkillPath setSlotValue setVarWriteProtect setarray setcar setcdr setf setf_arrayref setf_bottomEdge setf_caaar setf_caadr setf_caar setf_cadar setf_caddr setf_cadr setf_car setf_cdaar setf_cdadr setf_cdar setf_cddar setf_cdddr setf_cddr setf_cdr setf_get setf_getSG setf_getSGq setf_getShellEnvVar setf_getd setf_getq setf_last setf_leftEdge setf_lowerLeft setf_nth setf_nthcdr setf_nthedr setf_nthelem setf_rightEdge setf_slotValue setf_topEdge setf_upperRight setf_xCoord setf_yCoord setguard setof setofs setplist setq setqbitfield setqbitfield1 settlingTime setup sevAboutTool sevActivateSelectedAnas sevActiveSelectedAna sevAddExpression sevAddMenuItemLists sevAnnotateResults sevBALMTool sevBPMTool sevChangeOutsOnSchematic sevChooseDesign sevChooseEnvironmentOptions sevChooseSimulator sevChooseTemperature sevCircuitCond sevConvergence sevCopyCellViewVariables sevCopyVariablesToCellView sevCornersTool sevCreateMainWindow sevDebug sevDeleteResults sevDeleteSelectedAnas sevDeleteSelectedOuts sevDeleteSelectedSubckts sevDeleteSelectedVars sevDeleteSelections sevDevChecking sevDirectPlotMenu sevDisplayViolations sevEditModels sevEditOptions sevEditPlottingOptions sevEditSelectedAnas sevEditSelectedOuts sevEditSelectedVars sevEditSimulationFile sevEditStimulus sevEnvironment sevEvaluateAndPlotExpressions sevExportOutputsToCSV sevExportOutputsToFile sevExportOutputsToTxt sevFindSelectedVars sevGetExpressions sevIcon sevImportOutputsFromCSV sevImportOutputsFromFile sevImportOutputsFromTxt sevInvokeNCBrowse sevInvokeSimvision sevInvokeSimvisionDebugger sevIsContinuable sevKmodelTool sevLMGTool sevLoadState sevMTSMode sevMTSOptions sevMenuItems sevMonteCarloTool sevMpuTool sevNetlistAndDebug sevNetlistAndRun sevNetlistFile sevNoAnaSelections sevNoDesign sevNoEnvironment sevNoLog sevNoOutSelections sevNoOutputLog sevNoPlottableExpressions sevNoPlottableOutputs sevNoPlottableSignals sevNoResults sevNoVarSelections sevNoViolationsFound sevNonActiveSelectedAna sevNonMixedSignal sevOpenCalculator sevOpenDRLBrowser sevOpenEncap sevOpenJobMonitor sevOpenPlotWindow sevOpenPrintWindow sevOpenSchematic sevOptimizationTool sevPCMTool sevPKGTool sevParametricTool sevParasiticsDisplayed sevParasiticsNotDisplayed sevPlotAllOutputs sevPlotSignals sevPrintResults sevQuit sevReset sevReturnVariablesWithEmptyValues sevRun sevRunEngine sevSaveOceanScript sevSaveOptions sevSaveResults sevSaveState sevSelectResults sevSession sevSetConnectModules sevSetEngineOptions sevSetMTSMode sevSetMainWindowPulldownMenus sevSetMenuItemLists sevSetPropertyForSelectedOuts sevSetSchematicPulldownMenus sevSetSimDataDir sevSetSolver sevSetTopSaveDir sevSetTypeInWindowPulldownMenus sevSetupSimulationFiles sevSetupStimuli sevSimulator sevStartSession sevStopEngine sevTopSaveDir sevViewCompilerLog sevViewElabLog sevViewNcVerilogLog sevViewNetlisterLog sevViewSimLog sevViewSimulatorOutput sevWhatsNew sh shadow shadowImport sharedInitialize shell simAddProbeCapByName simAddProbeCapByScreen simAddProbeCapForBusBit simCheckExist simCheckHeader simCheckVariables simCheckViewConfig simCleanRun simDateStamp simDeleteRunDirFile simDesignVarCdsNameExtName simDesignVarExtNameCdsName simDrain simEditFileWithName simExecute simFindFile simFlattenWithArgs simGetLoginName simGetTermList simIfNoProcedure simIlSleep simInWithArgs simInitControl simInitEnv simInitEnvWithArgs simInitRaw simInitRunDir simInitSimulator simInstCdsNameExtName simInstExtNameCdsName simJobMonitor simLoadNetlisterFiles simLoadSimulatorFiles simNetCdsNameExtName simNetExtNameCdsName simNetlistWithArgs simNoNetlist simOutWithArgs simPostNameConvert simPreNameConvert simPrintEnvironment simPrintError simPrintErrorLine simPrintMessage simPrintTermList simReadNetCapFile simRep simRunDirInfile simRunDirLoad simRunDirOutfile simRunNetAndSim simRunNetAndSimWithArgs simRunNetAndSimWithCmd simSetDef simSetDefWithNoWarn simStringsToList simSubProbeCapByName simSubProbeCapByScreen simVertToHoriz simViewFileWithArgs simWaveOpen simin simout simplifyFilename simulator sin sinh skDisableMessage skDisableMessageBlock skEnableMessageBlock skIgnoreMessage skTabulate skTabulateSKILL skUnignoreMessage skillDebugger skillDevStatus sklint slewRate slewrate slotBoundp slotUnbound slotValue smgStart soiEnableDrcDfm solver sort sortcar sp spcinGuiDisplay spectralPower spectrumMeas spectrumMeas spectrumMeasurement spm sprintf sqrt srandom ssb sscanf sstatus stacktrace startFinder status stddev step stepend stepout stimulusFile store strcat strcmp stringToFunction stringToSymbol stringToTime stringp strlen strncat strncmp strpbrk sub1 subclassesOf subclassp subst substring superclassesOf suspendJob sweepNames sweepValues sweepVarValues swindow swindowp sxtd symbolToString symbolp symeval symstrp system tableToList tablep tailp tan tangent tanh tcDisplayAttachTechForm tcDisplayCompTechForm tcDisplayDiscardTechForm tcDisplayDumpTechForm tcDisplayLoadTechForm tcDisplayNewTechForm tcDisplaySaveTechForm tcDisplayTechGraphForm tcDumpTechFile tcLoadTechFile tcNewLibDisplayRefTechForm tcQcInstallDevices tcRegPostDumpTrigger tcRegPostLoadTrigger tcRegPostSetRefTrigger tcRegPreDumpTrigger tcRegPreLoadTrigger tcUnregPostDumpTrigger tcUnregPostLoadTrigger tcUnregPostSetRefTrigger tcUnregPreDumpTrigger tcUnregPreLoadTrigger tconc techBindTechFile techCloseTechFile techCopyTechFile techCreateArraySiteDef techCreateCustomViaDef techCreateCustomViaDefByName techCreateCustomViaVariant techCreateDerivedLayer techCreateElectricalRuleTable techCreateLP techCreateLayer techCreatePurpose techCreatePurposeDef techCreateScalarSiteDef techCreateSnapPatternDef techCreateSpacingRuleTable techCreateStdViaDef techCreateStdViaVariant techCreateViaSpec techDeleteDeviceClass techDeleteLP techDeleteLayer techDeletePurpose techDeletePurposeDef techDeleteSiteDef techDeleteTechFile techDeleteTechLibName techDeleteTwoLayerProp techDeleteViaDef techDeleteViaSpec techFindLayer techFindPurposeDef techFindSiteDefByName techFindSnapPatternDefByLP techFindSnapPatternDefByName techFindViaDefByName techFindViaSpec techFindViaVariantByName techGetCellViewSiteDefs techGetCurrentDensityRuleTable techGetCurrentDensityRuleTables techGetCurrentDensityRules techGetDBUPerUU techGetDefaultTechName techGetDerivedLayer techGetDeviceCParam techGetDeviceCellView techGetDeviceClass techGetDeviceClassProp techGetDeviceClassViewList techGetDeviceFParam techGetDeviceInClass techGetDeviceProp techGetDeviceTechFile techGetElectricalRule techGetElectricalRuleTable techGetElectricalRuleTableEntry techGetElectricalRuleTables techGetElectricalRules techGetEquivLayers techGetExtractCAP techGetExtractDIODE techGetExtractDevices techGetExtractMOS techGetExtractRES techGetInstDeviceClass techGetIntegrationColorModel techGetLP techGetLPAttr techGetLPPacketName techGetLPPriorityInContext techGetLabelLayers techGetLayerAbbrev techGetLayerFunction techGetLayerFunctions techGetLayerMaskNumber techGetLayerMfgResolution techGetLayerMfgResolutions techGetLayerName techGetLayerNum techGetLayerNumColorMasks techGetLayerProp techGetLayerRoutingDirections techGetLayerRoutingGrid techGetLayerRoutingGrids techGetLeLswLayers techGetLxExtractLayers techGetLxNoOverlapLayers techGetMPPTemplateByName techGetMPPTemplateNames techGetMfgGridResolution techGetOpenTechFiles techGetOrderedElectricalRule techGetOrderedElectricalRules techGetOrderedSpacingRule techGetOrderedSpacingRules techGetOuterViaLayers techGetParam techGetParams techGetPermission techGetPermissions techGetPrGenViaParams techGetPrGenViaRules techGetPrMastersliceLayers techGetPrNonDefaultParams techGetPrNonDefaultRules techGetPrRoutingDirection techGetPrRoutingLayers techGetPrRoutingOffset techGetPrRoutingPitch techGetPrStackVias techGetPrViaParams techGetPrViaRules techGetPrViaType techGetPrViaTypes techGetPurposeAbbrev techGetPurposeName techGetPurposeNum techGetSpacingRule techGetSpacingRuleTable techGetSpacingRuleTableEntry techGetSpacingRuleTables techGetSpacingRules techGetStampLabelLayers techGetStdViaDefCutColoring techGetTechCutColoring techGetTechFile techGetTechFileDdId techGetTechFileName techGetTechLibName techGetTimeStamp techGetTrimLayerPairs techGetTwoLayerProp techGetUserUnit techGetViaLayers techGetViaSpecTableEntries techGetViaSpecTableEntriesByName techGetViaSpecTableEntry techGetViaStackLimit techGetViaStackLimits techGetViewTypeUnits techIsDBUPerUUSet techIsDevice techIsLPValidBase techIsLeLswLayer techIsLxExtractLayer techIsLxNoOverlapLayer techIsMfgGridResolutionSet techIsPrMastersliceLayer techIsPrRoutingLayer techIsPrStackVia techIsPrViaDevice techIsReadPermission techIsStdViaDefCutColoringSet techIsUserUnitSet techIsViaLayer techMakeVirtuosoIccInfo techManagerOpenDisplayToolBox techManagerOpenTechToolBox techManagerToolBox techOpenDefaultTechFile techOpenTechFile techPurgeTechFile techRefreshTechFile techReopenTechFile techSaveTechFile techSetDBUPerUU techSetDeviceClassProp techSetDeviceProp techSetElectricalRule techSetElectricalRuleTableEntry techSetEquivLayer techSetEquivLayers techSetEvaluate techSetExtractCAP techSetExtractDIODE techSetExtractMOS techSetExtractRES techSetIntegrationColorModel techSetLPAttr techSetLPPacketName techSetLPPriorityInContext techSetLabelLayer techSetLabelLayers techSetLayerAbbrev techSetLayerFunction techSetLayerFunctions techSetLayerMaskNumber techSetLayerMfgResolution techSetLayerMfgResolutions techSetLayerName techSetLayerNumColorMasks techSetLayerProp techSetLayerRoutingGrid techSetLayerRoutingGrids techSetLeLswLayer techSetLeLswLayers techSetLxExtractLayer techSetLxExtractLayers techSetLxNoOverlapLayer techSetLxNoOverlapLayers techSetMPPTemplate techSetMfgGridResolution techSetOrderedElectricalRule techSetOrderedSpacingRule techSetParam techSetPrGenViaRule techSetPrMastersliceLayer techSetPrMastersliceLayers techSetPrNonDefaultRule techSetPrRoutingLayer techSetPrRoutingLayers techSetPrRoutingOffset techSetPrRoutingPitch techSetPrStackVia techSetPrStackVias techSetPrViaRule techSetPrViaType techSetPrViaTypes techSetPrecision techSetPurposeAbbrev techSetPurposeName techSetReadPermission techSetReadWritePermission techSetSpacingRule techSetSpacingRuleTableEntry techSetStampLabelLayer techSetStampLabelLayers techSetStdViaDefCutColoring techSetTechCutColoring techSetTechLibName techSetTimeStamp techSetTwoLayerProp techSetUserUnit techSetViaDefResistancePerCut techSetViaSpecTableEntry techSetViaStackLimit techSetViaStackLimits techTruncateTechFile techUnattachTechFile techVerifyTechFileId temp textFontMap thd theEnvironment throw timeToString timeToTm times tmToTime tokenPrintCapabilities topEdge toplevel totalNoise tracef tracelevlimit tracelevunlimit tracep tracev tran transCdlOutDisplay treeSaveHierarchy treeSaveScreen truename truncate tsg type typep unalias unbreakpt unbreakptMethod uncount undrawEnterFun unimportSymbol uninstallDebugger unityGainFreq unless unprofile unsetShellEnvVar untrace untracep untracev unuseNamespace unwatch unwindProtect updateDependent updateInstanceForDifferentClass updateInstanceForRedefinedClass updateReturnPopupMenuItem upperCase upperRight useNamespace userAppTrigger userMenuTrigger userPostInstallTriggers v value vcdFile vcdInfoFile vcpfeCreateEstimatedRows vcpfePlaceConstraintGroup vcpfeRunCustomDigitalPlacer vdb vdrCreateVoltageLabel vdrCreateVoltageLabelOnNets vdrDeleteLabels vdrGenerateLabelsGUI vecFile vector vectorToList vectorp vfoAbut vfoAllocateProtocolObj vfoAllocateShapeData vfoChopInstance vfoConvertToPolygon vfoCreateObstruction vfoCreateShapeData vfoDeleteObstruction vfoDrawFluidShape vfoGRCreateDeviceClass vfoGRGeometry vfoGRGetCommonQPtr vfoGRGetCreateFormFieldProp vfoGRGetCreateFormIdentifier vfoGRGetCreateFormPointer vfoGRGetExtraArgument vfoGRGetQueuePointer vfoGRMaximizeShapes vfoGRNewCreateForm vfoGRRegCreateFormUpdateCallback vfoGRSetCreateFormAllFieldsInvisible vfoGRSetCreateFormFieldProp vfoGRSetExtraArgument vfoGRSmoothen vfoGetDeviceClassParam vfoGetDeviceFormalParam vfoGetFileListWithLoadSequence vfoGetImplementationClassName vfoGetParam vfoGetProtocolClassName vfoGetVersion vfoGrCreateCDF vfoInstallFluidDeviceFiles vfoMergeInstances vfoReInstallAllFluidGuardRingDevices vfoReInstallGuardRingDevice vfoSetParam vfoSetParams vfoSetProtocolClassName vfoSfDraw vfoSfFinalize vfoSfInitialize vfoSfOuterEdgeCornerContRemoval vfoSmoothen vfoSupportsAbut? vfoSupportsChop? vfoSupportsConvertToPolygon? vfoSupportsCreateObstruction? vfoSupportsDeleteObstruction? vfoSupportsMerge? vfoSupportsUpdateModelShape? vfoTransformFluidShape vfoUpdateModelShape vfpAlignPins vfpCPHGenPhysicalHier vfpCPHGenPhysicalHierNoPropFile vfpCPHLoadFloorplanFile vfpCreateBoundaryPinsForSelectedShapes vfpHiPushPreRoutesDown vfpLoadPhysicalView vfpPinConnectivitySetting vfpPushPreRoutesDown vfpReportIOPadLocation vfpSbDefineObstruction vfpSbDeleteObstruction vfpSbEditIOPin vfpSbEditSoftBlockType vfpSbSetPolygonalBoundary vfpSbSetRectangularBoundary vfreq vh vhdlHiImport vhdlHiInvokeToolBox vhdlImport vhdlPinListToVHDL vhdlRegisterSimulator vhdlToPinList vhmsCompilationFailure vhmsDefaultEdit vhmsGetCellParameters vhmsPinListToVHDLAMS vhmsSaveFile vhmsSymbolToPinListGen vhmsToPinList vhmsUpdateCellCDFParams vi viaRegisterCreateViaInitCallback viaRegisterPostViaEngineCallback viaRegisterPreViaEngineCallback viaSetDefaultCutClasses viaUnregisterCreateViaInitCallback viaUnregisterPostViaEngineCallback viaUnregisterPreViaEngineCallback vicOpenVlogCallBack view vii vil vim vivaInitBindkeys vm vmsUpdateCellViews vosHiDisplayNetlist vosLaunchIrunSimulation vp vpaOptimizePins vr vsaDbType vsaDefVariable vsaEMGetQRCDirAndRunName vsaEMGetSimDirAndAnalysisType vsaEMInitUserCallBack vsaEMUserCallBack vsaError vsaGetNode vsaGetR vsaGetVariable vsaIRGetSimDirAndAnalysisType vsaIRUserCallBack vsaNetlistProc vsaNodeGetIR vsaRegisterEMDataFile vsaRegisterLayerMapFile vsaRegisterQrcTechFile vsaResGetIavg vsaResGetIpeak vsaResGetIrms vsaResGetLayer vsaResGetX vsaResGetY vsaWarn vswr vtime vvDisplayBrowser vvDisplayCalculator wait warn watch waveVsWave weCWHoldWidth weGatherBusWires weGetPathSegWidth weHiEditBus weScaleMagnifierOrDecreaseWidth weScaleMagnifierOrIncreaseWidth weScrollOrCycleDownWireViaAlignment weScrollOrCycleUpWireViaAlignment weSetPathSegWidth when where whereIs which while window windowp write writeTable wtypep xCoord xLimit xcons xdifference xmax xmin xoasInDoTranslate xoasInGetField xoasInSetField xoasOutDoTranslate xoasOutGetField xoasOutSetField xoasisInOnCancel xoasisInOnCompletion xoasisInOnTranslate xoasisOutOnCancel xoasisOutOnCompletion xoasisOutOnTranslate xor xpcDumpCache xpcEnableExpressPcell xplus xquotient xstGetField xstInDoTranslate xstInGetField xstInGetVMLibs xstInOnCancel xstInOnCompletion xstInOnTranslate xstInSaveVMLib xstInSetField xstOutDoTranslate xstOutOnCancel xstOutOnCompletion xstOutOnTranslate xstSetField xtimes xval yCoord yLimit ymax ymin ypm zerop zm zpm zref zxtd");
+ var indentKeys = makeKeywords("then else");
+ var atomKeys = makeKeywords("t nil");
+
+ function stateStack(indent, type, prev) { // represents a state stack object
+ this.indent = indent;
+ this.type = type;
+ this.prev = prev;
+ }
+
+ function pushStack(state, indent, type) {
+ state.indentStack = new stateStack(indent, type, state.indentStack);
+ }
+
+ function popStack(state) {
+ state.indentStack = state.indentStack.prev;
+ }
+
+ return {
+ startState: function () {
+ return {
+ indentStack: null,
+ indentation: 0,
+ multiline: false
+ };
+ },
+
+ token: function (stream, state) {
+ if (state.indentStack == null && stream.sol()) {
+ // update indentation, but only if indentStack is empty
+ state.indentation = stream.indentation();
+ }
+
+ // skip spaces
+ if (stream.eatSpace()) {
+ return null;
+ }
+ var returnType = null;
+ var ch = stream.next();
+
+ if (state.multiline){
+ if(ch == "*" && stream.peek() == "/"){
+ state.multiline = false;
+ stream.next();
+ }
+ returnType = COMMENT;
+ }else if (ch == "\"") {
+ var next, escaped = false;
+ while ((next = stream.next()) != null) {
+ if (next == "\"" && !escaped) {
+ break;
+ }
+ escaped = !escaped && next == "\\";
+ }
+ returnType = STRING;
+ }else if (ch == "/") {
+ if(stream.peek() == "*"){
+ state.multiline = true;
+ stream.next();
+ returnType = COMMENT;
+ }else{
+ returnType = "operator";
+ }
+ }else if (ch == ";") {
+ stream.skipToEnd();
+ returnType = COMMENT;
+ }else if (ch == "'") {
+ if(!stream.eatWhile(/\w/)){ // 'symbol
+ stream.eatWhile(/[^\)]/); // '(...)
+ stream.next();
+ }
+ returnType = ATOM;
+ }else if (ch == "?") {
+ stream.eatWhile(/\w/);
+ returnType = "operator";
+ }else if (/\d/.test(ch)) {
+ stream.eatWhile(/[\d\.]/);
+ returnType = NUMBER;
+ }else if (isOperatorChar.test(ch)) {
+ stream.eatWhile(isOperatorChar);
+ returnType = "operator";
+ }else if (ch == "(" || ch == "[" || ch == "{") {
+ returnType = BRACKET;
+ pushStack(state, stream.column() + 1, ch);
+ } else if (ch == ")" || ch == "]" || ch == "}") {
+ returnType = BRACKET;
+ if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : (ch == "]" ? "[" : "{"))) {
+ popStack(state);
+ }
+ }else {
+ stream.eatWhile(/\w/);
+ if (keywords && keywords.propertyIsEnumerable(stream.current())) {
+ returnType = BUILTIN;
+ } else if (atomKeys && atomKeys.propertyIsEnumerable(stream.current())) {
+ returnType = ATOM;
+ } else if (indentKeys && indentKeys.propertyIsEnumerable(stream.current())) {
+ returnType = BUILTIN;
+ } else returnType = "variable";
+ }
+ return returnType;
+ },
+
+ indent: function (state, textAfter) {
+ var offset = 0;
+ if(/^[\)\]\}]/.test(textAfter)){
+ offset = -1;
+ }
+
+ for(var val of Object.keys(indentKeys)){
+ var _regex = RegExp("^" + val);
+ if(_regex.test(textAfter)){
+ offset = state.indentStack.prev.indent - state.indentStack.indent;
+ break;
+ }
+ }
+
+ if (state.indentStack == null) return state.indentation + offset;
+ return state.indentStack.indent + offset;
+ },
+
+ closeBrackets: {pairs: "()[]{}\"\""},
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/",
+ lineComment: ";",
+ fold: "brace"
+ };
+});
+
+CodeMirror.defineMIME("text/x-skill", {name: "Skill", mime: "text/x-skill", mode: "skill", ext: [".il"]});
+});
diff --git a/.local/share/jupyter/nbextensions/snippets/snippets.yaml b/.local/share/jupyter/nbextensions/snippets/snippets.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b95198c0a24da0ccc7408dc4ecb94bbff3b8907b
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets/snippets.yaml
@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Compatibility: 4.x, 5.x
+Name: Snippets
+Main: main.js
+Description: Adds a drop-down menu to insert snippet cells into the current notebook.
+Link: README.md
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/astropy.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/astropy.js
new file mode 100644
index 0000000000000000000000000000000000000000..810cbc27819cf2389fc7e50b13088fb4ffba15ad
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/astropy.js
@@ -0,0 +1,164 @@
+define({
+ 'name' : 'Astropy',
+ 'sub-menu' : [
+ {
+ 'name' : 'Constants',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : ['import astropy.constants'],
+ },
+ '---',
+ {
+ 'name' : 'Extracting value',
+ 'snippet' : ['astropy.constants.G.value'],
+ },
+ {
+ 'name' : 'Extracting units',
+ 'snippet' : ['astropy.constants.G.unit'],
+ },
+ {
+ 'name' : 'Extracting uncertainty',
+ 'snippet' : ['astropy.constants.G.uncertainty'],
+ },
+ {
+ 'name' : 'Converting to SI',
+ 'snippet' : ['astropy.constants.G.si'],
+ },
+ {
+ 'name' : 'Converting to cgs',
+ 'snippet' : ['astropy.constants.G.cgs'],
+ },
+ '---',
+ {
+ 'name' : 'Gravitational constant [\\(\\mathrm{m}^3 / (\\mathrm{kg}\\, \\mathrm{s}^2)\\)]',
+ 'snippet' : ['astropy.constants.G',],
+ },
+ {
+ 'name' : 'Solar luminosity [\\(\\mathrm{W}\\)]',
+ 'snippet' : ['astropy.constants.L_sun',],
+ },
+ {
+ 'name' : 'Earth mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.M_earth',],
+ },
+ {
+ 'name' : 'Jupiter mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.M_jup',],
+ },
+ {
+ 'name' : 'Solar mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.M_sun',],
+ },
+ {
+ 'name' : 'Avogadro’s number [\\(1 / \\mathrm{mol}\\)]',
+ 'snippet' : ['astropy.constants.N_A',],
+ },
+ {
+ 'name' : 'Gas constant [\\(\\mathrm{J} / (\\mathrm{K}\\, \\mathrm{mol})\\)]',
+ 'snippet' : ['astropy.constants.R',],
+ },
+ {
+ 'name' : 'Earth equatorial radius [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.R_earth',],
+ },
+ {
+ 'name' : 'Jupiter equatorial radius [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.R_jup',],
+ },
+ {
+ 'name' : 'Solar radius [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.R_sun',],
+ },
+ {
+ 'name' : 'Rydberg constant [\\(1 / \\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.Ryd',],
+ },
+ {
+ 'name' : 'Bohr radius [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.a0',],
+ },
+ {
+ 'name' : 'Fine-structure constant (dimensionless)',
+ 'snippet' : ['astropy.constants.alpha',],
+ },
+ {
+ 'name' : 'Atmosphere [\\(\\mathrm{Pa}\\)]',
+ 'snippet' : ['astropy.constants.atmosphere',],
+ },
+ {
+ 'name' : 'Astronomical Unit [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.au',],
+ },
+ {
+ 'name' : 'Wien wavelength displacement law constant [\\(\\mathrm{m}\\, \\mathrm{K}\\)]',
+ 'snippet' : ['astropy.constants.b_wien',],
+ },
+ {
+ 'name' : 'Speed of light in vacuum [\\(\\mathrm{m} / \\mathrm{s}\\)]',
+ 'snippet' : ['astropy.constants.c',],
+ },
+ {
+ 'name' : 'Electron charge [\\(\\mathrm{C}\\)]',
+ 'snippet' : ['astropy.constants.e',],
+ },
+ {
+ 'name' : 'Electric constant [\\(\\mathrm{F}/\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.eps0',],
+ },
+ {
+ 'name' : 'Standard acceleration of gravity [\\(\\mathrm{m} / \\mathrm{s}^2\\)]',
+ 'snippet' : ['astropy.constants.g0',],
+ },
+ {
+ 'name' : 'Planck constant [\\(\\mathrm{J}\\, \\mathrm{s}\\)]',
+ 'snippet' : ['astropy.constants.h',],
+ },
+ {
+ 'name' : 'Reduced Planck constant [\\(\\mathrm{J}\\, \\mathrm{s}\\)]',
+ 'snippet' : ['astropy.constants.hbar',],
+ },
+ {
+ 'name' : 'Boltzmann constant [\\(\\mathrm{J} / \\mathrm{K}\\)]',
+ 'snippet' : ['astropy.constants.k_B',],
+ },
+ {
+ 'name' : 'Kiloparsec [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.kpc',],
+ },
+ {
+ 'name' : 'Electron mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.m_e',],
+ },
+ {
+ 'name' : 'Neutron mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.m_n',],
+ },
+ {
+ 'name' : 'Proton mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.m_p',],
+ },
+ {
+ 'name' : 'Magnetic constant [\\(\\mathrm{N}/\\mathrm{A}^2\\)]',
+ 'snippet' : ['astropy.constants.mu0',],
+ },
+ {
+ 'name' : 'Bohr magneton [\\(\\mathrm{J}/\\mathrm{T}\\)]',
+ 'snippet' : ['astropy.constants.muB',],
+ },
+ {
+ 'name' : 'Parsec [\\(\\mathrm{m}\\)]',
+ 'snippet' : ['astropy.constants.pc',],
+ },
+ {
+ 'name' : 'Stefan-Boltzmann constant [\\(\\mathrm{W} / (\\mathrm{K}^4\\, \\mathrm{m}^2)\\)]',
+ 'snippet' : ['astropy.constants.sigma_sb',],
+ },
+ {
+ 'name' : 'Atomic mass [\\(\\mathrm{kg}\\)]',
+ 'snippet' : ['astropy.constants.u',],
+ },
+ ],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/matplotlib.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/matplotlib.js
new file mode 100644
index 0000000000000000000000000000000000000000..790d7bffbe213f81fec59017dcbf45e3fa479d07
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/matplotlib.js
@@ -0,0 +1,186 @@
+define({
+ 'name' : 'Matplotlib',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup for notebook',
+ 'snippet' : [
+ 'from __future__ import print_function, division',
+ 'import numpy as np',
+ 'import matplotlib as mpl',
+ 'import matplotlib.pyplot as plt',
+ '%matplotlib inline',
+ ],
+ },
+ {
+ 'name' : 'Setup for scripts',
+ 'snippet' : [
+ 'import matplotlib as mpl',
+ 'mpl.use("Agg") # Must come after importing mpl, but before importing plt',
+ 'import matplotlib.pyplot as plt',
+ ],
+ },
+ {
+ 'name' : 'Documentation',
+ 'external-link' : 'http://matplotlib.org/contents.html',
+ },
+ '---',
+ {
+ 'name' : 'Example plots',
+ 'sub-menu' : [
+ {
+ 'name' : 'Basic line plot',
+ 'snippet' : [
+ '# Silly example data',
+ 'bp_x = np.linspace(0, 2*np.pi, num=40, endpoint=True)',
+ 'bp_y = np.sin(bp_x)',
+ '',
+ '# Make the plot',
+ 'plt.plot(bp_x, bp_y, linewidth=3, linestyle="--",',
+ ' color="blue", label=r"Legend label $\\sin(x)$")',
+ 'plt.xlabel(r"Description of $x$ coordinate (units)")',
+ 'plt.ylabel(r"Description of $y$ coordinate (units)")',
+ 'plt.title(r"Title here (remove for papers)")',
+ 'plt.xlim(0, 2*np.pi)',
+ 'plt.ylim(-1.1, 1.1)',
+ 'plt.legend(loc="lower left")',
+ 'plt.show()',
+ ],
+ },
+
+ {
+ 'name' : 'Histogram',
+ 'snippet' : [
+ 'x = np.random.randn(10000) # example data, random normal distribution',
+ 'num_bins = 50',
+ 'n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor="green", alpha=0.5)',
+ 'plt.xlabel(r"Description of $x$ coordinate (units)")',
+ 'plt.ylabel(r"Description of $y$ coordinate (units)")',
+ 'plt.title(r"Histogram title here (remove for papers)")',
+ 'plt.show();',
+ ],
+ },
+
+ {
+ 'name' : 'Contour plot',
+ 'snippet' : [
+ '# Silly example data',
+ 'x_min, x_max, y_min, y_max = 0.0, 2*np.pi, 0.0, 2*np.pi',
+ 'f = [[np.sin(x**2 + y**2) for x in np.linspace(x_min, x_max, num=200)]',
+ ' for y in np.linspace(y_min, y_max, num=200)]',
+ '',
+ '# Make the plot',
+ 'plt.figure()',
+ 'plt.imshow(f, interpolation="bicubic", origin="lower",',
+ ' extent=[x_min, x_max, y_min, y_max])',
+ 'plt.colorbar()',
+ 'plt.title(r"Title here (remove for papers)")',
+ 'plt.xlabel(r"Description of $x$ coordinate (units)")',
+ 'plt.ylabel(r"Description of $y$ coordinate (units)")',
+ 'plt.show()',
+ ],
+ },
+
+ {
+ 'name' : '3-d plot',
+ 'snippet' : [
+ 'from mpl_toolkits.mplot3d import Axes3D',
+ 'from matplotlib import cm',
+ '',
+ '# Silly example data',
+ 'X = np.arange(-5, 5, 0.25)',
+ 'Y = np.arange(-5, 5, 0.25)',
+ 'X, Y = np.meshgrid(X, Y)',
+ 'R = np.sqrt(X**2 + Y**2)',
+ 'Z = np.sin(R)',
+ '',
+ '# Make the plot',
+ 'fig = plt.figure()',
+ 'ax = fig.gca(projection="3d")',
+ 'surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,',
+ ' linewidth=0, antialiased=False)',
+ 'ax.set_zlim(-1.01, 1.01)',
+ 'fig.colorbar(surf, shrink=0.5, aspect=5)',
+ 'plt.show()',
+ ],
+ },
+
+ {
+ 'name' : 'Error bars',
+ 'snippet' : [
+ '# Silly example data',
+ 'x = np.linspace(0.1, 4, num=10)',
+ 'y = np.exp(-x)',
+ 'dx = 0.1 - x/25.0',
+ 'dy = 0.2 + x/15.0',
+ '',
+ '# Make the plot',
+ 'plt.figure()',
+ 'plt.errorbar(x, y, xerr=dx, yerr=dy)',
+ 'plt.title(r"Title here (remove for papers)")',
+ 'plt.xlabel(r"Description of $x$ coordinate (units)")',
+ 'plt.ylabel(r"Description of $y$ coordinate (units)")',
+ 'plt.show()',
+ ],
+ },
+
+ {
+ 'name' : 'Grouped plots',
+ 'snippet' : [
+ '# Silly example data',
+ 'bp_x1 = np.linspace(0, 2*np.pi, num=40, endpoint=True)',
+ 'bp_y1 = np.sin(bp_x1)',
+ 'bp_x2 = np.linspace(0, np.pi, num=40, endpoint=True)',
+ 'bp_y2 = np.cos(bp_x2)',
+ '',
+ '# Make the plot',
+ 'fig, (ax1, ax2) = plt.subplots(ncols=2)',
+ 'ax1.plot(bp_x1, bp_y1, linewidth=3, linestyle="--",',
+ ' color="blue", label=r"Legend label $\\sin(x)$")',
+ 'ax1.set_xlabel(r"Description of $x_{1}$ coordinate (units)")',
+ 'ax1.set_ylabel(r"Description of $y_{1}$ coordinate (units)")',
+ 'ax1.set_title(r"Title 1 here (remove for papers)")',
+ 'ax1.set_xlim(0, 2*np.pi)',
+ 'ax1.set_ylim(-1.1, 1.1)',
+ 'ax1.legend(loc="lower left")',
+ 'ax2.plot(bp_x2, bp_y2, linewidth=3, linestyle="--",',
+ ' color="blue", label=r"Legend label $\\cos(x)$")',
+ 'ax2.set_xlabel(r"Description of $x_{2}$ coordinate (units)")',
+ 'ax2.set_ylabel(r"Description of $y_{2}$ coordinate (units)")',
+ 'ax2.set_title(r"Title 2 here (remove for papers)")',
+ 'ax2.set_xlim(0, np.pi)',
+ 'ax2.set_ylim(-1.1, 1.1)',
+ 'ax2.legend(loc="lower left")',
+ 'plt.show()',
+ ],
+ },
+ ],
+ },
+ {
+ 'name' : 'Save the current figure',
+ 'snippet' : ['plt.savefig("figure_file_name.pdf")'],
+ 'sub-menu' : [
+ {
+ 'name' : 'Save as PDF',
+ 'snippet' : ['plt.savefig("figure_file_name.pdf")'],
+ },
+ {
+ 'name' : 'Save as PNG',
+ 'snippet' : ['plt.savefig("figure_file_name.png", transparent=True, dpi=300)'],
+ },
+ {
+ 'name' : 'Save as SVG',
+ 'snippet' : ['plt.savefig("figure_file_name.svg")'],
+ },
+ {
+ 'name' : 'Save as EPS',
+ 'snippet' : ['plt.savefig("figure_file_name.eps")'],
+ },
+ {
+ 'name' : 'Save as PS',
+ 'snippet' : ['plt.savefig("figure_file_name.ps")'],
+ },
+
+ ],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/pandas.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/pandas.js
new file mode 100644
index 0000000000000000000000000000000000000000..74994ba0eef8533f5f7f9ede646349ea7ff328eb
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/pandas.js
@@ -0,0 +1,182 @@
+define({
+ 'name' :'pandas',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : [
+ 'from __future__ import print_function, division',
+ 'import pandas as pd',
+ ],
+ },
+ {
+ 'name' : 'Documentation',
+ 'external-link' : 'http://pandas.pydata.org/pandas-docs/stable/',
+ },
+ '---',
+ {
+ 'name' : 'Set options',
+ 'snippet' : [
+ 'pd.set_option(""display.height"", 10)',
+ 'pd.set_option(""display.max_rows"", 20)',
+ 'pd.set_option(""display.max_columns"", 500)',
+ 'pd.set_option(""display.width"", 1000)',
+ ],
+ },
+
+ {
+ 'name' : 'To/from file',
+ 'sub-menu' : [
+ {
+ 'name' : 'Read from CSV',
+ 'snippet' : [
+ 'bp_data = pd.read_csv("path/to/file.csv", header=1, delim_whitespace=True)',
+ ],
+ },
+
+ {
+ 'name' : 'Write to CSV',
+ 'snippet' : ['bp_data.to_csv("path/to/new_file.csv", sep=" ", header=False, index=False)',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Deal with NaNs',
+ 'sub-menu' : [
+ {
+ 'name' : 'Filter out NaNs',
+ 'snippet' : ['bp_data = bp_data.dropna()',],
+ },
+
+ {
+ 'name' : 'Replace NaNs with number',
+ 'snippet' : ['bp_data = bp_data.fillna(0.0)',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Select rows',
+ 'snippet' : ['bp_data[:5]',],
+ },
+
+ {
+ 'name' : 'Select by column',
+ 'snippet' : ['bp_column = bp_data[["Column name"]]',],
+ 'sub-menu' : [
+ {
+ 'name' : 'Select single column',
+ 'snippet' : ['bp_column = bp_data[["Column name"]]',],
+ },
+
+ {
+ 'name' : 'Select multiple columns',
+ 'snippet' : [
+ 'bp_columns = bp_data[["Column name 1", "Column name 2", "Column name 3"]]',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Get numerical values from selection',
+ 'sub-menu' : [
+ {
+ 'name' : 'Select single column',
+ 'snippet' : ['bp_num_value = bp_data[["Numerical column"]].values',],
+ },
+ {
+ 'name' : 'Select multiple columns',
+ 'snippet' : [
+ 'bp_num_values = bp_data[["Numerical column 1", "Numerical column 2"]].values',],
+ },
+ {
+ 'name' : 'Select rows',
+ 'snippet' : ['bp_num_value = bp_data[:5].values',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Iteration',
+ 'snippet' : ['',],
+ },
+
+ {
+ 'name' : 'Grouping',
+ 'snippet' : ['',],
+ },
+
+ {
+ 'name' : 'Sorting',
+ 'snippet' : ['',],
+ },
+
+ {
+ 'name' : 'Combining',
+ 'sub-menu' : [
+ {
+ 'name' : 'Split-apply-combine (sum)',
+ 'snippet' : ['df['label_count'] = df.groupby('label', as_index=False)['label'].transform(lambda x: x.count())',],
+ },
+ {
+ 'name' : 'Split-apply-combine (mean)',
+ 'snippet' : ['df['label_mean'] = df.groupby('label', as_index=False)['label'].transform(lambda x: x.mean())',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Basic stats',
+ 'sub-menu' : [
+ {
+ 'name' : 'Mean',
+ 'snippet' : ['bp_mean = bp_data[["Numerical column 1"]].mean()',],
+ },
+ {
+ 'name' : 'Mode',
+ 'snippet' : ['bp_mode = bp_data[["Numerical column 1"]].mode()',],
+ },
+ {
+ 'name' : 'Median',
+ 'snippet' : ['bp_median = bp_data[["Numerical column 1"]].median()',],
+ },
+ {
+ 'name' : 'Standard deviation (unbiased)',
+ 'snippet' : ['bp_std = bp_data[["Numerical column 1"]].std()',],
+ },
+ {
+ 'name' : 'Variance (unbiased)',
+ 'snippet' : ['bp_var = bp_data[["Numerical column 1"]].var()',],
+ },
+ {
+ 'name' : 'Skew (unbiased)',
+ 'snippet' : ['bp_skew = bp_data[["Numerical column 1"]].skew()',],
+ },
+ {
+ 'name' : 'Kurtosis (unbiased)',
+ 'snippet' : ['bp_kurtosis = bp_data[["Numerical column 1"]].kurt()',],
+ },
+ {
+ 'name' : 'Min',
+ 'snippet' : ['bp_min = bp_data[["Numerical column 1"]].min()',],
+ },
+ {
+ 'name' : 'Max',
+ 'snippet' : ['bp_max = bp_data[["Numerical column 1"]].max()',],
+ },
+ {
+ 'name' : 'Sum',
+ 'snippet' : ['bp_sum = bp_data[["Numerical column 1"]].sum()',],
+ },
+ {
+ 'name' : 'Product',
+ 'snippet' : ['bp_product = bp_data[["Numerical column 1"]].product()',],
+ },
+ {
+ 'name' : 'Number of elements',
+ 'snippet' : ['bp_count = bp_data[["Numerical column 1"]].count()',],
+ },
+ ],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d28c855e03f9c7fcc9632699b4fabac2727995a
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python.js
@@ -0,0 +1,209 @@
+define([
+ "require",
+ "./python_regex",
+], function (requirejs, python_regex) {
+ return {
+ 'name' : 'Python',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : ['from __future__ import print_function, division',],
+ },
+ {
+ 'name' : 'Documentation',
+ 'external-link' : 'https://docs.python.org/',
+ },
+ '---',
+
+ {
+ 'name' : 'Lists',
+ 'sub-menu' : [
+ {
+ 'name' : 'List comprehension',
+ 'snippet' : ['[x**2 for x in range(-10, 11)]',],
+ },
+ {
+ 'name' : 'Conditional list comprehension',
+ 'snippet' : ['[x**2 for x in range(-10, 11) if (x%3)==0]',],
+ },
+ {
+ 'name' : 'Conditional alternative list comprehension',
+ 'snippet' : ['[x**2 if (x%3)==0 else x**3 for x in range(-10, 11)]',],
+ },
+ {
+ 'name' : 'Reversed list',
+ 'snippet' : ['reversed(l)'],
+ },
+ {
+ 'name' : 'Sorted list',
+ 'snippet' : ['sorted(l)'],
+ },
+ {
+ 'name' : 'Sort two lists at the same time',
+ 'snippet' : ['x, y = [list(tmp) for tmp in zip(*sorted(zip(x,y), key=lambda pair: pair[0]))]'],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Basic file input/output',
+ 'sub-menu' : [
+ {
+ 'name' : 'Read file into string',
+ 'snippet' : [
+ 'with open("some/file.txt", "r") as file_handle:',
+ ' file_contents = file_handle.read()',
+ ],
+ },
+ {
+ 'name' : 'Read file into string, operating on each line',
+ 'snippet' : [
+ 'file_contents = ""',
+ 'with open("some/file.txt", "r") as file_handle:',
+ ' for line in file_handle.readlines():',
+ ' file_contents += line.replace("-", "_")',
+ ],
+ }
+ ],
+ },
+
+ {
+ 'name' : 'Defining functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Simple function',
+ 'snippet' : [
+ 'def bp_some_func(x):',
+ ' r"""Brief description of the function"""',
+ ' return x**2',
+ ],
+ },
+ {
+ 'name' : 'Complicated function',
+ 'snippet' : [
+ 'def bp_some_func(x, y, z=3.14, **kwargs):',
+ ' r"""Some function',
+ ' ',
+ ' Does some stuff.',
+ ' ',
+ ' Parameters',
+ ' ----------',
+ ' x : int',
+ ' Description of x',
+ ' y : str',
+ ' Description of y',
+ ' z : float, optional',
+ ' Description of z. Defaults to 3.14',
+ ' **kwargs',
+ ' Arbitrary optional keyword arguments.',
+ ' w : float',
+ ' Defaults to 6.28',
+ ' ',
+ ' Returns',
+ ' -------',
+ ' double',
+ ' Some nonsensical number computed from some ugly formula',
+ ' ',
+ ' """',
+ ' w = kwargs.pop("w", 6.28)',
+ ' if kwargs:',
+ ' print("Got {0} unused kwargs".format(len(kwargs)))',
+ ' return (x**2 + len(y)) * (w + z)',
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Defining classes',
+ 'sub-menu' : [
+ {
+ 'name' : 'Simple class',
+ 'snippet' : [
+ 'class BPSomeClass(object):',
+ ' r"""Describe the class"""',
+ ' def __init__(self, arg1, arg2):',
+ ' self.attr1 = arg1',
+ ' self.attr2 = arg2',
+ ' ',
+ ' def attribute1(self):',
+ ' return self.attr1',
+ 'bp_obj = BPSomeClass("a", 2.7182)',
+ 'bp_obj.attribute1()',
+ ],
+ },
+ {
+ 'name' : 'Complicated class',
+ 'snippet' : [
+ 'class BPSomeClass(object):',
+ ' """Brief class description',
+ ' ',
+ ' Some more extensive description',
+ ' ',
+ ' Attributes',
+ ' ----------',
+ ' attr1 : string',
+ ' Purpose of attr1.',
+ ' attr2 : float',
+ ' Purpose of attr2.',
+ ' ',
+ ' """',
+ ' ',
+ ' def __init__(self, param1, param2, param3=0):',
+ ' """Example of docstring on the __init__ method.',
+ ' ',
+ ' Parameters',
+ ' ----------',
+ ' param1 : str',
+ ' Description of `param1`.',
+ ' param2 : float',
+ ' Description of `param2`.',
+ ' param3 : int, optional',
+ ' Description of `param3`, defaults to 0.',
+ ' ',
+ ' """',
+ ' self.attr1 = param1',
+ ' self.attr2 = param2',
+ ' print(param3 // 4)',
+ ' ',
+ ' @property',
+ ' def attribute2(self):',
+ ' return self.attr2',
+ ' ',
+ ' @attribute2.setter',
+ ' def attribute2(self, new_attr2):',
+ ' if not isinstance(float, new_attr2):',
+ ' raise ValueError("attribute2 must be a float, not {0}".format(new_attr2))',
+ ' self.attr2 = new_attr2',
+ '',
+ '',
+ 'bp_obj = BPSomeClass("a", 1.618)',
+ 'print(bp_obj.attribute2)',
+ 'bp_obj.attribute2 = 3.236',
+ '',
+ ],
+ },
+ {
+ 'name' : 'Subclass',
+ 'snippet' : [
+ 'class BP_A(object):',
+ ' def __init__(self, param1):',
+ ' self.attr1 = param1',
+ '',
+ 'class BP_B(BP_A):',
+ ' def __init__(self, param1, param2):',
+ ' super(BP_B, self).__init__(param1)',
+ ' self.attr2 = param2',
+ '',
+ '',
+ 'bp_b = BP_B("a", "b")',
+ 'print(bp_b.attr1, bp_b.attr2)',
+ ],
+ },
+ ],
+ },
+
+ python_regex,
+ ],
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python_regex.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python_regex.js
new file mode 100644
index 0000000000000000000000000000000000000000..a7d18e2a385d8afc65ba33559c22c4ff163b543f
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python_regex.js
@@ -0,0 +1,309 @@
+define({
+ 'name' : 'Regular expressions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : [
+ 'import re',
+ ],
+ },
+ '---',
+ {
+ 'name' : 'Basic search for pattern anywhere in string',
+ 'snippet' : [
+ 'string = " abc def "',
+ 'pattern = re.compile(r"[a-z]+")',
+ 'result = re.search(pattern, string)',
+ 'if result is not None:',
+ ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+ ],
+ },
+ {
+ 'name' : 'Basic search (match) for exact pattern at beginning of string',
+ 'snippet' : [
+ 'string = " abc def "',
+ 'pattern = re.compile(r".*[a-z]+")',
+ 'result = re.match(pattern, string)',
+ 'if result is not None:',
+ ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+ ],
+ },
+ {
+ 'name' : 'Basic substitution',
+ 'snippet' : [
+ 'string = " abc def "',
+ 'pattern = re.compile(r"[a-z]+")',
+ 'new_string = re.sub(pattern, "something", string)',
+ 'print("New string is \'{0}\'".format(new_string))',
+ ],
+ },
+ {
+ 'name' : 'Substitution with backreferences',
+ 'snippet' : [
+ 'string = "John Doe lives at 221B Baker Street."',
+ 'pattern = re.compile(r"""',
+ ' ([a-zA-Z ]+) # Save as many letters and spaces as possible to group 1',
+ ' \\ lives\\ at\\ # Match " lives at "',
+ ' (?P.*) # Save everything in between as a group named `address`',
+ ' \\. # Match the period at the end',
+ '""", re.VERBOSE)',
+ 'new_string = re.sub(pattern, r"\\g is occupied by \\1.", string)',
+ 'print("New string is \'{0}\'".format(new_string))',
+ ],
+ },
+ '---',
+ {
+ 'name' : 'Escaped special characters',
+ 'sub-menu' : [
+ {
+ 'name' : '.',
+ 'snippet' : ['\\.',],
+ },
+ {
+ 'name' : '^',
+ 'snippet' : ['\\^',],
+ },
+ {
+ 'name' : '$',
+ 'snippet' : ['\\$',],
+ },
+ {
+ 'name' : '*',
+ 'snippet' : ['\\*',],
+ },
+ {
+ 'name' : '+',
+ 'snippet' : ['\\+',],
+ },
+ {
+ 'name' : '?',
+ 'snippet' : ['\\?',],
+ },
+ {
+ 'name' : '{',
+ 'snippet' : ['\\{',],
+ },
+ {
+ 'name' : '}',
+ 'snippet' : ['\\}',],
+ },
+ {
+ 'name' : '[',
+ 'snippet' : ['\\[',],
+ },
+ {
+ 'name' : ']',
+ 'snippet' : ['\\]',],
+ },
+ {
+ 'name' : '\\',
+ 'snippet' : ['\\\\',],
+ },
+ {
+ 'name' : '|',
+ 'snippet' : ['\\|',],
+ },
+ {
+ 'name' : '(',
+ 'snippet' : ['\\(',],
+ },
+ {
+ 'name' : ')',
+ 'snippet' : ['\\)',],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Character classes and alternatives',
+ 'sub-menu' : [
+ {
+ 'name' : 'Standard character-class abbreviations',
+ 'sub-menu' : [
+ {
+ 'name' : 'Any decimal digit',
+ 'snippet' : ['\\d',],
+ },
+ {
+ 'name' : 'Any non-digit character',
+ 'snippet' : ['\\D',],
+ },
+ {
+ 'name' : 'Any whitespace character',
+ 'snippet' : ['\\s',],
+ },
+ {
+ 'name' : 'Any non-whitespace character',
+ 'snippet' : ['\\S',],
+ },
+ {
+ 'name' : 'Any alphanumeric character',
+ 'snippet' : ['\\w',],
+ },
+ {
+ 'name' : 'Any non-alphanumeric character',
+ 'snippet' : ['\\W',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Inclusive character classes',
+ 'snippet' : [
+ '[a-zA-Z0-9 \\t\\n\\r\\f\\v]',
+ ],
+ },
+ {
+ 'name' : 'Exclusive character classes',
+ 'snippet' : [
+ '[^a-zA-Z0-9]',
+ ],
+ },
+ {
+ 'name' : 'Alternatives',
+ 'snippet' : [
+ '(?:abc|def)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Repetition',
+ 'sub-menu' : [
+ {
+ 'name' : 'Match 0 or more repetitions of the preceding, greedily',
+ 'snippet' : ['*',],
+ },
+ {
+ 'name' : 'Match 1 or more repetitions of the preceding, greedily',
+ 'snippet' : ['+',],
+ },
+ {
+ 'name' : 'Match 0 or 1 repetitions of the preceding, greedily',
+ 'snippet' : ['?',],
+ },
+ '---',
+ {
+ 'name' : 'Match 0 or more repetitions of the preceding, non-greedily',
+ 'snippet' : ['*?',],
+ },
+ {
+ 'name' : 'Match 1 or more repetitions of the preceding, non-greedily',
+ 'snippet' : ['+?',],
+ },
+ {
+ 'name' : 'Match 0 or 1 repetitions of the preceding, non-greedily',
+ 'snippet' : ['??',],
+ },
+ '---',
+ {
+ 'name' : 'Match exactly n repeititions of the preceding',
+ 'snippet' : ['{3}',],
+ },
+ {
+ 'name' : 'Match between m and n repetions of the preceding, greedily',
+ 'snippet' : ['{3,5}',],
+ },
+ {
+ 'name' : 'Match between m and n repetions of the preceding, non-greedily',
+ 'snippet' : ['{3,5}?',],
+ },
+ ],
+ },
+
+ // {
+ // 'name' : '',
+ // 'sub-menu' : [
+
+ // ],
+ // },
+
+ // {
+ // 'name' : '',
+ // 'sub-menu' : [
+
+ // ],
+ // },
+
+ {
+ 'name' : 'Lookahead/behind',
+ 'sub-menu' : [
+ {
+ 'name' : 'Positive lookahead',
+ 'snippet' : [
+ 'string = "Isaac Asimov"',
+ 'pattern = re.compile(r"Isaac(?= Asimov)") # Only match "Isaac Asimov", but drop the " Asimov"',
+ 'result = re.match(pattern, string)',
+ 'if result is not None:',
+ ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+ ],
+ },
+ {
+ 'name' : 'Negative lookahead',
+ 'snippet' : [
+ 'string = "Isaac Newton"',
+ 'pattern = re.compile(r"Isaac(?! Asimov)") # Match any Isaac except Asimov, and only keep the "Isaac"',
+ 'result = re.match(pattern, string)',
+ 'if result is not None:',
+ ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+ ],
+ },
+ {
+ 'name' : 'Positive lookbehind',
+ 'snippet' : [
+ 'string = "Janet Asimov"',
+ 'pattern = re.compile(r"(?<=Janet )Asimov") # Only match "Janet Asimov", but drop the "Janet "',
+ 'result = re.search(pattern, string)',
+ 'if result is not None:',
+ ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+ ],
+ },
+ {
+ 'name' : 'Negative lookbehind',
+ 'snippet' : [
+ 'string = "Janet Asimov"',
+ 'pattern = re.compile(r"(?=0, respectively',
+ "cons = ({'type': 'eq',",
+ " 'fun' : lambda x: np.array([x[0]**3 - x[1]]),",
+ " 'jac' : lambda x: np.array([3.0*(x[0]**2.0), -1.0])},",
+ " {'type': 'ineq',",
+ " 'fun' : lambda x: np.array([x[1] - 1]),",
+ " 'jac' : lambda x: np.array([0.0, 1.0])})",
+ "res = optimize.minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv,",
+ " constraints=cons, method='SLSQP', options={'disp': True})",
+ 'print(res.x)',
+ ],
+ },
+ ],
+ },
+ {
+ 'name' : 'Fitting (see also numpy.polynomial)',
+ 'sub-menu' : [
+ {
+ 'name' : 'Basic function fitting',
+ 'snippet' : [
+ 'def fitting_function(x, a, b, c):',
+ ' return a * np.exp(-b * x) + c',
+ 'xdata = np.linspace(0, 4, 50)',
+ 'ydata = fitting_function(xdata, 2.5, 1.3, 0.5) + 0.2 * np.random.normal(size=len(xdata))',
+ 'optimal_parameters, estimated_covariance = optimize.curve_fit(fitting_function, xdata, ydata)',
+ 'estimated_std_dev = np.sqrt(np.diag(estimated_covariance))',
+ ],
+ },
+ ],
+ },
+ ],
+ },
+
+ // {
+ // 'name' : 'Signal processing',
+ // 'sub-menu' : [
+ // {
+ // 'name' : 'Setup',
+ // 'snippet' : ['from scipy import signal',],
+ // },
+ // '---',
+ // ],
+ // },
+
+ // {
+ // 'name' : 'Sparse matrices and associated routines',
+ // 'sub-menu' : [
+ // {
+ // 'name' : 'Setup',
+ // 'snippet' : ['from scipy import sparse',],
+ // },
+ // '---',
+ // ],
+ // },
+
+ // {
+ // 'name' : 'Spatial data structures and algorithms',
+ // 'sub-menu' : [
+ // {
+ // 'name' : 'Setup',
+ // 'snippet' : ['from scipy import spatial',],
+ // },
+ // '---',
+ // ],
+ // },
+
+ scipy_special,
+
+ {
+ 'name' : 'Statistical distributions and functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : ['from scipy import stats',],
+ },
+ '---',
+ {
+ 'name' : 'Docs',
+ 'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/stats.html'
+ },
+ ],
+ },
+
+ // {
+ // 'name' : 'C/C++ integration',
+ // 'sub-menu' : [
+ // {
+ // 'name' : 'Setup',
+ // 'snippet' : ['from scipy import weave',],
+ // },
+ // '---',
+ // ],
+ // },
+ ],
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_constants.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_constants.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2fa04aa76dd6b65f36d132d7b583a54210a9273
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_constants.js
@@ -0,0 +1,2047 @@
+define({
+ 'name' : 'Physical and mathematical constants',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : [
+ 'from scipy import constants',
+ ],
+ },
+ '---',
+ {
+ 'name' : 'Mathematical constants',
+ 'sub-menu' : [
+ {
+ 'name' : 'Geometric constant \\(\\pi\\)',
+ 'snippet' : ['constants.pi',]
+ },
+ {
+ 'name' : 'Golden ratio \\(\\phi\\)',
+ 'snippet' : ['constants.golden',]
+ },
+ ],
+ },
+ {
+ 'name' : 'Common physical constants',
+ 'sub-menu' : [
+ {
+ 'name' : 'Speed of light in vacuum \\(c\\)',
+ 'snippet' : ['constants.c',],
+ },
+ {
+ 'name' : 'Magnetic constant \\(\\mu_0\\)',
+ 'snippet' : ['constants.mu_0',],
+ },
+ {
+ 'name' : 'Electric constant (vacuum permittivity), \\(\\varepsilon_0\\)',
+ 'snippet' : ['constants.epsilon_0',],
+ },
+ {
+ 'name' : 'Planck\'s constant \\(h\\)',
+ 'snippet' : ['constants.h',],
+ },
+ {
+ 'name' : 'Planck\'s reduced constant \\(\\hbar\\)',
+ 'snippet' : ['constants.hbar',],
+ },
+ {
+ 'name' : 'Newton\'s constant of gravitation \\(G_\\mathrm{N}\\)',
+ 'snippet' : ['constants.G',],
+ },
+ {
+ 'name' : 'Standard acceleration of gravity \\(g\\)',
+ 'snippet' : ['constants.g',],
+ },
+ {
+ 'name' : 'Elementary charge \\(e\\)',
+ 'snippet' : ['constants.e',],
+ },
+ {
+ 'name' : 'Molar gas constant \\(R\\)',
+ 'snippet' : ['constants.R',],
+ },
+ {
+ 'name' : 'Fine-structure constant \\(\\alpha\\)',
+ 'snippet' : ['constants.alpha',],
+ },
+ {
+ 'name' : 'Avogadro constant \\(N_\\mathrm{A}\\)',
+ 'snippet' : ['constants.N_A',],
+ },
+ {
+ 'name' : 'Boltzmann constant \\(k_\\mathrm{B}\\)',
+ 'snippet' : ['constants.k',],
+ },
+ {
+ 'name' : 'Stefan-Boltzmann constant \\(\\sigma\\)',
+ 'snippet' : ['constants.sigma',],
+ },
+ {
+ 'name' : 'Wien displacement law constant \\(b\\)',
+ 'snippet' : ['constants.Wien',],
+ },
+ {
+ 'name' : 'Rydberg constant \\(R_\\infty\\)',
+ 'snippet' : ['constants.Rydberg',],
+ },
+ {
+ 'name' : 'Electron mass \\(m_\\mathrm{e}\\)',
+ 'snippet' : ['constants.m_e',],
+ },
+ {
+ 'name' : 'Proton mass \\(m_\\mathrm{p}\\)',
+ 'snippet' : ['constants.m_p',],
+ },
+ {
+ 'name' : 'Neutron mass \\(m_\\mathrm{n}\\)',
+ 'snippet' : ['constants.m_n',],
+ },
+ ],
+ },
+ {
+ 'name' : 'CODATA physical constants',
+ 'sub-menu' : [
+ {
+ 'name' : 'Example',
+ 'snippet' : ['value,units,uncertainty = constants.physical_constants["alpha particle mass"]'],
+ },
+ '---',
+ {
+ 'name' : 'A',
+ 'sub-menu' : [
+ {
+ 'name' : 'alpha particle mass',
+ 'snippet' : ['constants.physical_constants["alpha particle mass"]',],
+ },
+ {
+ 'name' : 'alpha particle mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["alpha particle mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'alpha particle mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["alpha particle mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'alpha particle mass in u',
+ 'snippet' : ['constants.physical_constants["alpha particle mass in u"]',],
+ },
+ {
+ 'name' : 'alpha particle molar mass',
+ 'snippet' : ['constants.physical_constants["alpha particle molar mass"]',],
+ },
+ {
+ 'name' : 'alpha particle-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["alpha particle-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'alpha particle-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["alpha particle-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'Angstrom star',
+ 'snippet' : ['constants.physical_constants["Angstrom star"]',],
+ },
+ {
+ 'name' : 'atomic mass constant',
+ 'snippet' : ['constants.physical_constants["atomic mass constant"]',],
+ },
+ {
+ 'name' : 'atomic mass constant energy equivalent',
+ 'snippet' : ['constants.physical_constants["atomic mass constant energy equivalent"]',],
+ },
+ {
+ 'name' : 'atomic mass constant energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["atomic mass constant energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-hartree relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-hartree relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-hertz relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-hertz relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-joule relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-joule relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'atomic mass unit-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["atomic mass unit-kilogram relationship"]',],
+ },
+ {
+ 'name' : 'atomic unit of 1st hyperpolarizability',
+ 'snippet' : ['constants.physical_constants["atomic unit of 1st hyperpolarizability"]',],
+ },
+ {
+ 'name' : 'atomic unit of 2nd hyperpolarizability',
+ 'snippet' : ['constants.physical_constants["atomic unit of 2nd hyperpolarizability"]',],
+ },
+ {
+ 'name' : 'atomic unit of action',
+ 'snippet' : ['constants.physical_constants["atomic unit of action"]',],
+ },
+ {
+ 'name' : 'atomic unit of charge',
+ 'snippet' : ['constants.physical_constants["atomic unit of charge"]',],
+ },
+ {
+ 'name' : 'atomic unit of charge density',
+ 'snippet' : ['constants.physical_constants["atomic unit of charge density"]',],
+ },
+ {
+ 'name' : 'atomic unit of current',
+ 'snippet' : ['constants.physical_constants["atomic unit of current"]',],
+ },
+ {
+ 'name' : 'atomic unit of electric dipole mom.',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric dipole mom."]',],
+ },
+ {
+ 'name' : 'atomic unit of electric field',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric field"]',],
+ },
+ {
+ 'name' : 'atomic unit of electric field gradient',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric field gradient"]',],
+ },
+ {
+ 'name' : 'atomic unit of electric polarizability',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric polarizability"]',],
+ },
+ {
+ 'name' : 'atomic unit of electric potential',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric potential"]',],
+ },
+ {
+ 'name' : 'atomic unit of electric quadrupole mom.',
+ 'snippet' : ['constants.physical_constants["atomic unit of electric quadrupole mom."]',],
+ },
+ {
+ 'name' : 'atomic unit of energy',
+ 'snippet' : ['constants.physical_constants["atomic unit of energy"]',],
+ },
+ {
+ 'name' : 'atomic unit of force',
+ 'snippet' : ['constants.physical_constants["atomic unit of force"]',],
+ },
+ {
+ 'name' : 'atomic unit of length',
+ 'snippet' : ['constants.physical_constants["atomic unit of length"]',],
+ },
+ {
+ 'name' : 'atomic unit of mag. dipole mom.',
+ 'snippet' : ['constants.physical_constants["atomic unit of mag. dipole mom."]',],
+ },
+ {
+ 'name' : 'atomic unit of mag. flux density',
+ 'snippet' : ['constants.physical_constants["atomic unit of mag. flux density"]',],
+ },
+ {
+ 'name' : 'atomic unit of magnetizability',
+ 'snippet' : ['constants.physical_constants["atomic unit of magnetizability"]',],
+ },
+ {
+ 'name' : 'atomic unit of mass',
+ 'snippet' : ['constants.physical_constants["atomic unit of mass"]',],
+ },
+ {
+ 'name' : 'atomic unit of mom.um',
+ 'snippet' : ['constants.physical_constants["atomic unit of mom.um"]',],
+ },
+ {
+ 'name' : 'atomic unit of permittivity',
+ 'snippet' : ['constants.physical_constants["atomic unit of permittivity"]',],
+ },
+ {
+ 'name' : 'atomic unit of time',
+ 'snippet' : ['constants.physical_constants["atomic unit of time"]',],
+ },
+ {
+ 'name' : 'atomic unit of velocity',
+ 'snippet' : ['constants.physical_constants["atomic unit of velocity"]',],
+ },
+ {
+ 'name' : 'Avogadro constant',
+ 'snippet' : ['constants.physical_constants["Avogadro constant"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'B',
+ 'sub-menu' : [
+ {
+ 'name' : 'Bohr magneton',
+ 'snippet' : ['constants.physical_constants["Bohr magneton"]',],
+ },
+ {
+ 'name' : 'Bohr magneton in eV/T',
+ 'snippet' : ['constants.physical_constants["Bohr magneton in eV/T"]',],
+ },
+ {
+ 'name' : 'Bohr magneton in Hz/T',
+ 'snippet' : ['constants.physical_constants["Bohr magneton in Hz/T"]',],
+ },
+ {
+ 'name' : 'Bohr magneton in inverse meters per tesla',
+ 'snippet' : ['constants.physical_constants["Bohr magneton in inverse meters per tesla"]',],
+ },
+ {
+ 'name' : 'Bohr magneton in K/T',
+ 'snippet' : ['constants.physical_constants["Bohr magneton in K/T"]',],
+ },
+ {
+ 'name' : 'Bohr radius',
+ 'snippet' : ['constants.physical_constants["Bohr radius"]',],
+ },
+ {
+ 'name' : 'Boltzmann constant',
+ 'snippet' : ['constants.physical_constants["Boltzmann constant"]',],
+ },
+ {
+ 'name' : 'Boltzmann constant in eV/K',
+ 'snippet' : ['constants.physical_constants["Boltzmann constant in eV/K"]',],
+ },
+ {
+ 'name' : 'Boltzmann constant in Hz/K',
+ 'snippet' : ['constants.physical_constants["Boltzmann constant in Hz/K"]',],
+ },
+ {
+ 'name' : 'Boltzmann constant in inverse meters per kelvin',
+ 'snippet' : ['constants.physical_constants["Boltzmann constant in inverse meters per kelvin"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'C',
+ 'sub-menu' : [
+ {
+ 'name' : 'characteristic impedance of vacuum',
+ 'snippet' : ['constants.physical_constants["characteristic impedance of vacuum"]',],
+ },
+ {
+ 'name' : 'classical electron radius',
+ 'snippet' : ['constants.physical_constants["classical electron radius"]',],
+ },
+ {
+ 'name' : 'Compton wavelength',
+ 'snippet' : ['constants.physical_constants["Compton wavelength"]',],
+ },
+ {
+ 'name' : 'Compton wavelength over \\(2\\pi\\)',
+ 'snippet' : ['constants.physical_constants["Compton wavelength over 2 pi"]',],
+ },
+ {
+ 'name' : 'conductance quantum',
+ 'snippet' : ['constants.physical_constants["conductance quantum"]',],
+ },
+ {
+ 'name' : 'conventional value of Josephson constant',
+ 'snippet' : ['constants.physical_constants["conventional value of Josephson constant"]',],
+ },
+ {
+ 'name' : 'conventional value of von Klitzing constant',
+ 'snippet' : ['constants.physical_constants["conventional value of von Klitzing constant"]',],
+ },
+ {
+ 'name' : 'Cu x unit',
+ 'snippet' : ['constants.physical_constants["Cu x unit"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'D',
+ 'sub-menu' : [
+ {
+ 'name' : 'deuteron g factor',
+ 'snippet' : ['constants.physical_constants["deuteron g factor"]',],
+ },
+ {
+ 'name' : 'deuteron mag. mom.',
+ 'snippet' : ['constants.physical_constants["deuteron mag. mom."]',],
+ },
+ {
+ 'name' : 'deuteron mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["deuteron mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'deuteron mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["deuteron mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'deuteron mass',
+ 'snippet' : ['constants.physical_constants["deuteron mass"]',],
+ },
+ {
+ 'name' : 'deuteron mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["deuteron mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'deuteron mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["deuteron mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'deuteron mass in u',
+ 'snippet' : ['constants.physical_constants["deuteron mass in u"]',],
+ },
+ {
+ 'name' : 'deuteron molar mass',
+ 'snippet' : ['constants.physical_constants["deuteron molar mass"]',],
+ },
+ {
+ 'name' : 'deuteron rms charge radius',
+ 'snippet' : ['constants.physical_constants["deuteron rms charge radius"]',],
+ },
+ {
+ 'name' : 'deuteron-electron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["deuteron-electron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'deuteron-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["deuteron-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'deuteron-neutron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["deuteron-neutron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'deuteron-proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["deuteron-proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'deuteron-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["deuteron-proton mass ratio"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'E',
+ 'sub-menu' : [
+ {
+ 'name' : 'electric constant',
+ 'snippet' : ['constants.physical_constants["electric constant"]',],
+ },
+ {
+ 'name' : 'electron charge to mass quotient',
+ 'snippet' : ['constants.physical_constants["electron charge to mass quotient"]',],
+ },
+ {
+ 'name' : 'electron g factor',
+ 'snippet' : ['constants.physical_constants["electron g factor"]',],
+ },
+ {
+ 'name' : 'electron gyromag. ratio',
+ 'snippet' : ['constants.physical_constants["electron gyromag. ratio"]',],
+ },
+ {
+ 'name' : 'electron gyromag. ratio over 2 pi',
+ 'snippet' : ['constants.physical_constants["electron gyromag. ratio over 2 pi"]',],
+ },
+ {
+ 'name' : 'electron mag. mom.',
+ 'snippet' : ['constants.physical_constants["electron mag. mom."]',],
+ },
+ {
+ 'name' : 'electron mag. mom. anomaly',
+ 'snippet' : ['constants.physical_constants["electron mag. mom. anomaly"]',],
+ },
+ {
+ 'name' : 'electron mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["electron mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'electron mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["electron mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'electron mass',
+ 'snippet' : ['constants.physical_constants["electron mass"]',],
+ },
+ {
+ 'name' : 'electron mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["electron mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'electron mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["electron mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'electron mass in u',
+ 'snippet' : ['constants.physical_constants["electron mass in u"]',],
+ },
+ {
+ 'name' : 'electron molar mass',
+ 'snippet' : ['constants.physical_constants["electron molar mass"]',],
+ },
+ {
+ 'name' : 'electron to alpha particle mass ratio',
+ 'snippet' : ['constants.physical_constants["electron to alpha particle mass ratio"]',],
+ },
+ {
+ 'name' : 'electron to shielded helion mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron to shielded helion mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron to shielded proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron to shielded proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron volt',
+ 'snippet' : ['constants.physical_constants["electron volt"]',],
+ },
+ {
+ 'name' : 'electron volt-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-hartree relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-hartree relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-hertz relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-hertz relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-joule relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-joule relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'electron volt-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["electron volt-kilogram relationship"]',],
+ },
+ {
+ 'name' : 'electron-deuteron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron-deuteron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron-deuteron mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-deuteron mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-helion mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-helion mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-muon mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron-muon mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron-muon mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-muon mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-neutron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron-neutron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron-neutron mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-neutron mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["electron-proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'electron-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-tau mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-tau mass ratio"]',],
+ },
+ {
+ 'name' : 'electron-triton mass ratio',
+ 'snippet' : ['constants.physical_constants["electron-triton mass ratio"]',],
+ },
+ {
+ 'name' : 'elementary charge',
+ 'snippet' : ['constants.physical_constants["elementary charge"]',],
+ },
+ {
+ 'name' : 'elementary charge over h',
+ 'snippet' : ['constants.physical_constants["elementary charge over h"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'F',
+ 'sub-menu' : [
+ {
+ 'name' : 'Faraday constant',
+ 'snippet' : ['constants.physical_constants["Faraday constant"]',],
+ },
+ {
+ 'name' : 'Faraday constant for conventional electric current',
+ 'snippet' : ['constants.physical_constants["Faraday constant for conventional electric current"]',],
+ },
+ {
+ 'name' : 'Fermi coupling constant',
+ 'snippet' : ['constants.physical_constants["Fermi coupling constant"]',],
+ },
+ {
+ 'name' : 'fine-structure constant',
+ 'snippet' : ['constants.physical_constants["fine-structure constant"]',],
+ },
+ {
+ 'name' : 'first radiation constant',
+ 'snippet' : ['constants.physical_constants["first radiation constant"]',],
+ },
+ {
+ 'name' : 'first radiation constant for spectral radiance',
+ 'snippet' : ['constants.physical_constants["first radiation constant for spectral radiance"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'H',
+ 'sub-menu' : [
+ {
+ 'name' : 'Hartree energy',
+ 'snippet' : ['constants.physical_constants["Hartree energy"]',],
+ },
+ {
+ 'name' : 'Hartree energy in eV',
+ 'snippet' : ['constants.physical_constants["Hartree energy in eV"]',],
+ },
+ {
+ 'name' : 'hartree-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["hartree-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'hartree-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["hartree-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'hartree-hertz relationship',
+ 'snippet' : ['constants.physical_constants["hartree-hertz relationship"]',],
+ },
+ {
+ 'name' : 'hartree-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["hartree-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'hartree-joule relationship',
+ 'snippet' : ['constants.physical_constants["hartree-joule relationship"]',],
+ },
+ {
+ 'name' : 'hartree-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["hartree-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'hartree-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["hartree-kilogram relationship"]',],
+ },
+ {
+ 'name' : 'helion g factor',
+ 'snippet' : ['constants.physical_constants["helion g factor"]',],
+ },
+ {
+ 'name' : 'helion mag. mom.',
+ 'snippet' : ['constants.physical_constants["helion mag. mom."]',],
+ },
+ {
+ 'name' : 'helion mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["helion mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'helion mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["helion mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'helion mass',
+ 'snippet' : ['constants.physical_constants["helion mass"]',],
+ },
+ {
+ 'name' : 'helion mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["helion mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'helion mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["helion mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'helion mass in u',
+ 'snippet' : ['constants.physical_constants["helion mass in u"]',],
+ },
+ {
+ 'name' : 'helion molar mass',
+ 'snippet' : ['constants.physical_constants["helion molar mass"]',],
+ },
+ {
+ 'name' : 'helion-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["helion-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'helion-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["helion-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'hertz-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["hertz-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'hertz-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["hertz-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'hertz-hartree relationship',
+ 'snippet' : ['constants.physical_constants["hertz-hartree relationship"]',],
+ },
+ {
+ 'name' : 'hertz-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["hertz-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'hertz-joule relationship',
+ 'snippet' : ['constants.physical_constants["hertz-joule relationship"]',],
+ },
+ {
+ 'name' : 'hertz-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["hertz-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'hertz-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["hertz-kilogram relationship"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'I',
+ 'sub-menu' : [
+ {
+ 'name' : 'inverse fine-structure constant',
+ 'snippet' : ['constants.physical_constants["inverse fine-structure constant"]',],
+ },
+ {
+ 'name' : 'inverse meter-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-hartree relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-hartree relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-hertz relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-hertz relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-joule relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-joule relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'inverse meter-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["inverse meter-kilogram relationship"]',],
+ },
+ {
+ 'name' : 'inverse of conductance quantum',
+ 'snippet' : ['constants.physical_constants["inverse of conductance quantum"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'J',
+ 'sub-menu' : [
+ {
+ 'name' : 'Josephson constant',
+ 'snippet' : ['constants.physical_constants["Josephson constant"]',],
+ },
+ {
+ 'name' : 'joule-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["joule-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'joule-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["joule-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'joule-hartree relationship',
+ 'snippet' : ['constants.physical_constants["joule-hartree relationship"]',],
+ },
+ {
+ 'name' : 'joule-hertz relationship',
+ 'snippet' : ['constants.physical_constants["joule-hertz relationship"]',],
+ },
+ {
+ 'name' : 'joule-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["joule-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'joule-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["joule-kelvin relationship"]',],
+ },
+ {
+ 'name' : 'joule-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["joule-kilogram relationship"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'K',
+ 'sub-menu' : [
+ {
+ 'name' : 'kelvin-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-hartree relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-hartree relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-hertz relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-hertz relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-joule relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-joule relationship"]',],
+ },
+ {
+ 'name' : 'kelvin-kilogram relationship',
+ 'snippet' : ['constants.physical_constants["kelvin-kilogram relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-atomic mass unit relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-atomic mass unit relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-electron volt relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-electron volt relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-hartree relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-hartree relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-hertz relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-hertz relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-inverse meter relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-inverse meter relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-joule relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-joule relationship"]',],
+ },
+ {
+ 'name' : 'kilogram-kelvin relationship',
+ 'snippet' : ['constants.physical_constants["kilogram-kelvin relationship"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'L',
+ 'sub-menu' : [
+ {
+ 'name' : 'lattice parameter of silicon',
+ 'snippet' : ['constants.physical_constants["lattice parameter of silicon"]',],
+ },
+ {
+ 'name' : 'Loschmidt constant (273.15 K, 100 kPa)',
+ 'snippet' : ['constants.physical_constants["Loschmidt constant (273.15 K, 100 kPa)"]',],
+ },
+ {
+ 'name' : 'Loschmidt constant (273.15 K, 101.325 kPa)',
+ 'snippet' : ['constants.physical_constants["Loschmidt constant (273.15 K, 101.325 kPa)"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'M',
+ 'sub-menu' : [
+ {
+ 'name' : 'mag. constant',
+ 'snippet' : ['constants.physical_constants["mag. constant"]',],
+ },
+ {
+ 'name' : 'mag. flux quantum',
+ 'snippet' : ['constants.physical_constants["mag. flux quantum"]',],
+ },
+ {
+ 'name' : 'Mo x unit',
+ 'snippet' : ['constants.physical_constants["Mo x unit"]',],
+ },
+ {
+ 'name' : 'molar gas constant',
+ 'snippet' : ['constants.physical_constants["molar gas constant"]',],
+ },
+ {
+ 'name' : 'molar mass constant',
+ 'snippet' : ['constants.physical_constants["molar mass constant"]',],
+ },
+ {
+ 'name' : 'molar mass of carbon-12',
+ 'snippet' : ['constants.physical_constants["molar mass of carbon-12"]',],
+ },
+ {
+ 'name' : 'molar Planck constant',
+ 'snippet' : ['constants.physical_constants["molar Planck constant"]',],
+ },
+ {
+ 'name' : 'molar Planck constant times c',
+ 'snippet' : ['constants.physical_constants["molar Planck constant times c"]',],
+ },
+ {
+ 'name' : 'molar volume of ideal gas (273.15 K, 100 kPa)',
+ 'snippet' : ['constants.physical_constants["molar volume of ideal gas (273.15 K, 100 kPa)"]',],
+ },
+ {
+ 'name' : 'molar volume of ideal gas (273.15 K, 101.325 kPa)',
+ 'snippet' : ['constants.physical_constants["molar volume of ideal gas (273.15 K, 101.325 kPa)"]',],
+ },
+ {
+ 'name' : 'molar volume of silicon',
+ 'snippet' : ['constants.physical_constants["molar volume of silicon"]',],
+ },
+ {
+ 'name' : 'muon Compton wavelength',
+ 'snippet' : ['constants.physical_constants["muon Compton wavelength"]',],
+ },
+ {
+ 'name' : 'muon Compton wavelength over 2 pi',
+ 'snippet' : ['constants.physical_constants["muon Compton wavelength over 2 pi"]',],
+ },
+ {
+ 'name' : 'muon g factor',
+ 'snippet' : ['constants.physical_constants["muon g factor"]',],
+ },
+ {
+ 'name' : 'muon mag. mom.',
+ 'snippet' : ['constants.physical_constants["muon mag. mom."]',],
+ },
+ {
+ 'name' : 'muon mag. mom. anomaly',
+ 'snippet' : ['constants.physical_constants["muon mag. mom. anomaly"]',],
+ },
+ {
+ 'name' : 'muon mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["muon mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'muon mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["muon mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'muon mass',
+ 'snippet' : ['constants.physical_constants["muon mass"]',],
+ },
+ {
+ 'name' : 'muon mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["muon mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'muon mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["muon mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'muon mass in u',
+ 'snippet' : ['constants.physical_constants["muon mass in u"]',],
+ },
+ {
+ 'name' : 'muon molar mass',
+ 'snippet' : ['constants.physical_constants["muon molar mass"]',],
+ },
+ {
+ 'name' : 'muon-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["muon-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'muon-neutron mass ratio',
+ 'snippet' : ['constants.physical_constants["muon-neutron mass ratio"]',],
+ },
+ {
+ 'name' : 'muon-proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["muon-proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'muon-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["muon-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'muon-tau mass ratio',
+ 'snippet' : ['constants.physical_constants["muon-tau mass ratio"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'N',
+ 'sub-menu' : [
+ {
+ 'name' : 'natural unit of action',
+ 'snippet' : ['constants.physical_constants["natural unit of action"]',],
+ },
+ {
+ 'name' : 'natural unit of action in eV s',
+ 'snippet' : ['constants.physical_constants["natural unit of action in eV s"]',],
+ },
+ {
+ 'name' : 'natural unit of energy',
+ 'snippet' : ['constants.physical_constants["natural unit of energy"]',],
+ },
+ {
+ 'name' : 'natural unit of energy in MeV',
+ 'snippet' : ['constants.physical_constants["natural unit of energy in MeV"]',],
+ },
+ {
+ 'name' : 'natural unit of length',
+ 'snippet' : ['constants.physical_constants["natural unit of length"]',],
+ },
+ {
+ 'name' : 'natural unit of mass',
+ 'snippet' : ['constants.physical_constants["natural unit of mass"]',],
+ },
+ {
+ 'name' : 'natural unit of mom.um',
+ 'snippet' : ['constants.physical_constants["natural unit of mom.um"]',],
+ },
+ {
+ 'name' : 'natural unit of mom.um in MeV/c',
+ 'snippet' : ['constants.physical_constants["natural unit of mom.um in MeV/c"]',],
+ },
+ {
+ 'name' : 'natural unit of time',
+ 'snippet' : ['constants.physical_constants["natural unit of time"]',],
+ },
+ {
+ 'name' : 'natural unit of velocity',
+ 'snippet' : ['constants.physical_constants["natural unit of velocity"]',],
+ },
+ {
+ 'name' : 'neutron Compton wavelength',
+ 'snippet' : ['constants.physical_constants["neutron Compton wavelength"]',],
+ },
+ {
+ 'name' : 'neutron Compton wavelength over 2 pi',
+ 'snippet' : ['constants.physical_constants["neutron Compton wavelength over 2 pi"]',],
+ },
+ {
+ 'name' : 'neutron g factor',
+ 'snippet' : ['constants.physical_constants["neutron g factor"]',],
+ },
+ {
+ 'name' : 'neutron gyromag. ratio',
+ 'snippet' : ['constants.physical_constants["neutron gyromag. ratio"]',],
+ },
+ {
+ 'name' : 'neutron gyromag. ratio over 2 pi',
+ 'snippet' : ['constants.physical_constants["neutron gyromag. ratio over 2 pi"]',],
+ },
+ {
+ 'name' : 'neutron mag. mom.',
+ 'snippet' : ['constants.physical_constants["neutron mag. mom."]',],
+ },
+ {
+ 'name' : 'neutron mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["neutron mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'neutron mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["neutron mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'neutron mass',
+ 'snippet' : ['constants.physical_constants["neutron mass"]',],
+ },
+ {
+ 'name' : 'neutron mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["neutron mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'neutron mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["neutron mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'neutron mass in u',
+ 'snippet' : ['constants.physical_constants["neutron mass in u"]',],
+ },
+ {
+ 'name' : 'neutron molar mass',
+ 'snippet' : ['constants.physical_constants["neutron molar mass"]',],
+ },
+ {
+ 'name' : 'neutron to shielded proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["neutron to shielded proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'neutron-electron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["neutron-electron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'neutron-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["neutron-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'neutron-muon mass ratio',
+ 'snippet' : ['constants.physical_constants["neutron-muon mass ratio"]',],
+ },
+ {
+ 'name' : 'neutron-proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["neutron-proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'neutron-proton mass difference',
+ 'snippet' : ['constants.physical_constants["neutron-proton mass difference"]',],
+ },
+ {
+ 'name' : 'neutron-proton mass difference energy equivalent',
+ 'snippet' : ['constants.physical_constants["neutron-proton mass difference energy equivalent"]',],
+ },
+ {
+ 'name' : 'neutron-proton mass difference energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["neutron-proton mass difference energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'neutron-proton mass difference in u',
+ 'snippet' : ['constants.physical_constants["neutron-proton mass difference in u"]',],
+ },
+ {
+ 'name' : 'neutron-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["neutron-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'neutron-tau mass ratio',
+ 'snippet' : ['constants.physical_constants["neutron-tau mass ratio"]',],
+ },
+ {
+ 'name' : 'Newtonian constant of gravitation',
+ 'snippet' : ['constants.physical_constants["Newtonian constant of gravitation"]',],
+ },
+ {
+ 'name' : 'Newtonian constant of gravitation over h-bar c',
+ 'snippet' : ['constants.physical_constants["Newtonian constant of gravitation over h-bar c"]',],
+ },
+ {
+ 'name' : 'nuclear magneton',
+ 'snippet' : ['constants.physical_constants["nuclear magneton"]',],
+ },
+ {
+ 'name' : 'nuclear magneton in eV/T',
+ 'snippet' : ['constants.physical_constants["nuclear magneton in eV/T"]',],
+ },
+ {
+ 'name' : 'nuclear magneton in inverse meters per tesla',
+ 'snippet' : ['constants.physical_constants["nuclear magneton in inverse meters per tesla"]',],
+ },
+ {
+ 'name' : 'nuclear magneton in K/T',
+ 'snippet' : ['constants.physical_constants["nuclear magneton in K/T"]',],
+ },
+ {
+ 'name' : 'nuclear magneton in MHz/T',
+ 'snippet' : ['constants.physical_constants["nuclear magneton in MHz/T"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'P',
+ 'sub-menu' : [
+ {
+ 'name' : 'Planck constant',
+ 'snippet' : ['constants.physical_constants["Planck constant"]',],
+ },
+ {
+ 'name' : 'Planck constant in eV s',
+ 'snippet' : ['constants.physical_constants["Planck constant in eV s"]',],
+ },
+ {
+ 'name' : 'Planck constant over 2 pi',
+ 'snippet' : ['constants.physical_constants["Planck constant over 2 pi"]',],
+ },
+ {
+ 'name' : 'Planck constant over 2 pi in eV s',
+ 'snippet' : ['constants.physical_constants["Planck constant over 2 pi in eV s"]',],
+ },
+ {
+ 'name' : 'Planck constant over 2 pi times c in MeV fm',
+ 'snippet' : ['constants.physical_constants["Planck constant over 2 pi times c in MeV fm"]',],
+ },
+ {
+ 'name' : 'Planck length',
+ 'snippet' : ['constants.physical_constants["Planck length"]',],
+ },
+ {
+ 'name' : 'Planck mass',
+ 'snippet' : ['constants.physical_constants["Planck mass"]',],
+ },
+ {
+ 'name' : 'Planck mass energy equivalent in GeV',
+ 'snippet' : ['constants.physical_constants["Planck mass energy equivalent in GeV"]',],
+ },
+ {
+ 'name' : 'Planck temperature',
+ 'snippet' : ['constants.physical_constants["Planck temperature"]',],
+ },
+ {
+ 'name' : 'Planck time',
+ 'snippet' : ['constants.physical_constants["Planck time"]',],
+ },
+ {
+ 'name' : 'proton charge to mass quotient',
+ 'snippet' : ['constants.physical_constants["proton charge to mass quotient"]',],
+ },
+ {
+ 'name' : 'proton Compton wavelength',
+ 'snippet' : ['constants.physical_constants["proton Compton wavelength"]',],
+ },
+ {
+ 'name' : 'proton Compton wavelength over 2 pi',
+ 'snippet' : ['constants.physical_constants["proton Compton wavelength over 2 pi"]',],
+ },
+ {
+ 'name' : 'proton g factor',
+ 'snippet' : ['constants.physical_constants["proton g factor"]',],
+ },
+ {
+ 'name' : 'proton gyromag. ratio',
+ 'snippet' : ['constants.physical_constants["proton gyromag. ratio"]',],
+ },
+ {
+ 'name' : 'proton gyromag. ratio over 2 pi',
+ 'snippet' : ['constants.physical_constants["proton gyromag. ratio over 2 pi"]',],
+ },
+ {
+ 'name' : 'proton mag. mom.',
+ 'snippet' : ['constants.physical_constants["proton mag. mom."]',],
+ },
+ {
+ 'name' : 'proton mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["proton mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'proton mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["proton mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'proton mag. shielding correction',
+ 'snippet' : ['constants.physical_constants["proton mag. shielding correction"]',],
+ },
+ {
+ 'name' : 'proton mass',
+ 'snippet' : ['constants.physical_constants["proton mass"]',],
+ },
+ {
+ 'name' : 'proton mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["proton mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'proton mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["proton mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'proton mass in u',
+ 'snippet' : ['constants.physical_constants["proton mass in u"]',],
+ },
+ {
+ 'name' : 'proton molar mass',
+ 'snippet' : ['constants.physical_constants["proton molar mass"]',],
+ },
+ {
+ 'name' : 'proton rms charge radius',
+ 'snippet' : ['constants.physical_constants["proton rms charge radius"]',],
+ },
+ {
+ 'name' : 'proton-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["proton-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'proton-muon mass ratio',
+ 'snippet' : ['constants.physical_constants["proton-muon mass ratio"]',],
+ },
+ {
+ 'name' : 'proton-neutron mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["proton-neutron mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'proton-neutron mass ratio',
+ 'snippet' : ['constants.physical_constants["proton-neutron mass ratio"]',],
+ },
+ {
+ 'name' : 'proton-tau mass ratio',
+ 'snippet' : ['constants.physical_constants["proton-tau mass ratio"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Q',
+ 'sub-menu' : [
+ {
+ 'name' : 'quantum of circulation',
+ 'snippet' : ['constants.physical_constants["quantum of circulation"]',],
+ },
+ {
+ 'name' : 'quantum of circulation times 2',
+ 'snippet' : ['constants.physical_constants["quantum of circulation times 2"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'R',
+ 'sub-menu' : [
+ {
+ 'name' : 'Rydberg constant',
+ 'snippet' : ['constants.physical_constants["Rydberg constant"]',],
+ },
+ {
+ 'name' : 'Rydberg constant times c in Hz',
+ 'snippet' : ['constants.physical_constants["Rydberg constant times c in Hz"]',],
+ },
+ {
+ 'name' : 'Rydberg constant times hc in eV',
+ 'snippet' : ['constants.physical_constants["Rydberg constant times hc in eV"]',],
+ },
+ {
+ 'name' : 'Rydberg constant times hc in J',
+ 'snippet' : ['constants.physical_constants["Rydberg constant times hc in J"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'S',
+ 'sub-menu' : [
+ {
+ 'name' : 'Sackur-Tetrode constant (1 K, 100 kPa)',
+ 'snippet' : ['constants.physical_constants["Sackur-Tetrode constant (1 K, 100 kPa)"]',],
+ },
+ {
+ 'name' : 'Sackur-Tetrode constant (1 K, 101.325 kPa)',
+ 'snippet' : ['constants.physical_constants["Sackur-Tetrode constant (1 K, 101.325 kPa)"]',],
+ },
+ {
+ 'name' : 'second radiation constant',
+ 'snippet' : ['constants.physical_constants["second radiation constant"]',],
+ },
+ {
+ 'name' : 'shielded helion gyromag. ratio',
+ 'snippet' : ['constants.physical_constants["shielded helion gyromag. ratio"]',],
+ },
+ {
+ 'name' : 'shielded helion gyromag. ratio over 2 pi',
+ 'snippet' : ['constants.physical_constants["shielded helion gyromag. ratio over 2 pi"]',],
+ },
+ {
+ 'name' : 'shielded helion mag. mom.',
+ 'snippet' : ['constants.physical_constants["shielded helion mag. mom."]',],
+ },
+ {
+ 'name' : 'shielded helion mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["shielded helion mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'shielded helion mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["shielded helion mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'shielded helion to proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["shielded helion to proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'shielded helion to shielded proton mag. mom. ratio',
+ 'snippet' : ['constants.physical_constants["shielded helion to shielded proton mag. mom. ratio"]',],
+ },
+ {
+ 'name' : 'shielded proton gyromag. ratio',
+ 'snippet' : ['constants.physical_constants["shielded proton gyromag. ratio"]',],
+ },
+ {
+ 'name' : 'shielded proton gyromag. ratio over 2 pi',
+ 'snippet' : ['constants.physical_constants["shielded proton gyromag. ratio over 2 pi"]',],
+ },
+ {
+ 'name' : 'shielded proton mag. mom.',
+ 'snippet' : ['constants.physical_constants["shielded proton mag. mom."]',],
+ },
+ {
+ 'name' : 'shielded proton mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["shielded proton mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'shielded proton mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["shielded proton mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'speed of light in vacuum',
+ 'snippet' : ['constants.physical_constants["speed of light in vacuum"]',],
+ },
+ {
+ 'name' : 'standard acceleration of gravity',
+ 'snippet' : ['constants.physical_constants["standard acceleration of gravity"]',],
+ },
+ {
+ 'name' : 'standard atmosphere',
+ 'snippet' : ['constants.physical_constants["standard atmosphere"]',],
+ },
+ {
+ 'name' : 'standard-state pressure',
+ 'snippet' : ['constants.physical_constants["standard-state pressure"]',],
+ },
+ {
+ 'name' : 'Stefan-Boltzmann constant',
+ 'snippet' : ['constants.physical_constants["Stefan-Boltzmann constant"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'T',
+ 'sub-menu' : [
+ {
+ 'name' : 'tau Compton wavelength',
+ 'snippet' : ['constants.physical_constants["tau Compton wavelength"]',],
+ },
+ {
+ 'name' : 'tau Compton wavelength over 2 pi',
+ 'snippet' : ['constants.physical_constants["tau Compton wavelength over 2 pi"]',],
+ },
+ {
+ 'name' : 'tau mass',
+ 'snippet' : ['constants.physical_constants["tau mass"]',],
+ },
+ {
+ 'name' : 'tau mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["tau mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'tau mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["tau mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'tau mass in u',
+ 'snippet' : ['constants.physical_constants["tau mass in u"]',],
+ },
+ {
+ 'name' : 'tau molar mass',
+ 'snippet' : ['constants.physical_constants["tau molar mass"]',],
+ },
+ {
+ 'name' : 'tau-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["tau-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'tau-muon mass ratio',
+ 'snippet' : ['constants.physical_constants["tau-muon mass ratio"]',],
+ },
+ {
+ 'name' : 'tau-neutron mass ratio',
+ 'snippet' : ['constants.physical_constants["tau-neutron mass ratio"]',],
+ },
+ {
+ 'name' : 'tau-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["tau-proton mass ratio"]',],
+ },
+ {
+ 'name' : 'Thomson cross section',
+ 'snippet' : ['constants.physical_constants["Thomson cross section"]',],
+ },
+ {
+ 'name' : 'triton g factor',
+ 'snippet' : ['constants.physical_constants["triton g factor"]',],
+ },
+ {
+ 'name' : 'triton mag. mom.',
+ 'snippet' : ['constants.physical_constants["triton mag. mom."]',],
+ },
+ {
+ 'name' : 'triton mag. mom. to Bohr magneton ratio',
+ 'snippet' : ['constants.physical_constants["triton mag. mom. to Bohr magneton ratio"]',],
+ },
+ {
+ 'name' : 'triton mag. mom. to nuclear magneton ratio',
+ 'snippet' : ['constants.physical_constants["triton mag. mom. to nuclear magneton ratio"]',],
+ },
+ {
+ 'name' : 'triton mass',
+ 'snippet' : ['constants.physical_constants["triton mass"]',],
+ },
+ {
+ 'name' : 'triton mass energy equivalent',
+ 'snippet' : ['constants.physical_constants["triton mass energy equivalent"]',],
+ },
+ {
+ 'name' : 'triton mass energy equivalent in MeV',
+ 'snippet' : ['constants.physical_constants["triton mass energy equivalent in MeV"]',],
+ },
+ {
+ 'name' : 'triton mass in u',
+ 'snippet' : ['constants.physical_constants["triton mass in u"]',],
+ },
+ {
+ 'name' : 'triton molar mass',
+ 'snippet' : ['constants.physical_constants["triton molar mass"]',],
+ },
+ {
+ 'name' : 'triton-electron mass ratio',
+ 'snippet' : ['constants.physical_constants["triton-electron mass ratio"]',],
+ },
+ {
+ 'name' : 'triton-proton mass ratio',
+ 'snippet' : ['constants.physical_constants["triton-proton mass ratio"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'U',
+ 'sub-menu' : [
+ {
+ 'name' : 'unified atomic mass unit',
+ 'snippet' : ['constants.physical_constants["unified atomic mass unit"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'V',
+ 'sub-menu' : [
+ {
+ 'name' : 'von Klitzing constant',
+ 'snippet' : ['constants.physical_constants["von Klitzing constant"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'W',
+ 'sub-menu' : [
+ {
+ 'name' : 'weak mixing angle',
+ 'snippet' : ['constants.physical_constants["weak mixing angle"]',],
+ },
+ {
+ 'name' : 'Wien frequency displacement law constant',
+ 'snippet' : ['constants.physical_constants["Wien frequency displacement law constant"]',],
+ },
+ {
+ 'name' : 'Wien wavelength displacement law constant',
+ 'snippet' : ['constants.physical_constants["Wien wavelength displacement law constant"]',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Other',
+ 'sub-menu' : [
+ {
+ 'name' : '{220} lattice spacing of silicon',
+ 'snippet' : ['constants.physical_constants["{220} lattice spacing of silicon"]',],
+ },
+ ],
+ },
+ ],
+ },
+ {
+ 'name' : 'Units',
+ 'sub-menu' : [
+ {
+ 'name' : 'SI prefixes',
+ 'sub-menu' : [
+ {
+ 'name' : 'yotta \\(10^{24}\\)',
+ 'snippet' : ['constants.yotta',],
+ },
+ {
+ 'name' : 'zetta \\(10^{21}\\)',
+ 'snippet' : ['constants.zetta',],
+ },
+ {
+ 'name' : 'exa \\(10^{18}\\)',
+ 'snippet' : ['constants.exa',],
+ },
+ {
+ 'name' : 'peta \\(10^{15}\\)',
+ 'snippet' : ['constants.peta',],
+ },
+ {
+ 'name' : 'tera \\(10^{12}\\)',
+ 'snippet' : ['constants.tera',],
+ },
+ {
+ 'name' : 'giga \\(10^{9}\\)',
+ 'snippet' : ['constants.giga',],
+ },
+ {
+ 'name' : 'mega \\(10^{6}\\)',
+ 'snippet' : ['constants.mega',],
+ },
+ {
+ 'name' : 'kilo \\(10^{3}\\)',
+ 'snippet' : ['constants.kilo',],
+ },
+ {
+ 'name' : 'hecto \\(10^{2}\\)',
+ 'snippet' : ['constants.hecto',],
+ },
+ {
+ 'name' : 'deka \\(10^{1}\\)',
+ 'snippet' : ['constants.deka',],
+ },
+ {
+ 'name' : 'deci \\(10^{−1}\\)',
+ 'snippet' : ['constants.deci',],
+ },
+ {
+ 'name' : 'centi \\(10^{−2}\\)',
+ 'snippet' : ['constants.centi',],
+ },
+ {
+ 'name' : 'milli \\(10^{−3}\\)',
+ 'snippet' : ['constants.milli',],
+ },
+ {
+ 'name' : 'micro \\(10^{−6}\\)',
+ 'snippet' : ['constants.micro',],
+ },
+ {
+ 'name' : 'nano \\(10^{−9}\\)',
+ 'snippet' : ['constants.nano',],
+ },
+ {
+ 'name' : 'pico \\(10^{−12}\\)',
+ 'snippet' : ['constants.pico',],
+ },
+ {
+ 'name' : 'femto \\(10^{−15}\\)',
+ 'snippet' : ['constants.femto',],
+ },
+ {
+ 'name' : 'atto \\(10^{−18}\\)',
+ 'snippet' : ['constants.atto',],
+ },
+ {
+ 'name' : 'zepto \\(10^{−21}\\)',
+ 'snippet' : ['constants.zepto',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Binary prefixes',
+ 'sub-menu' : [
+ {
+ 'name' : 'kibi \\(2^{10}\\)',
+ 'snippet' : ['constants.kibi',],
+ },
+ {
+ 'name' : 'mebi \\(2^{20}\\)',
+ 'snippet' : ['constants.mebi',],
+ },
+ {
+ 'name' : 'gibi \\(2^{30}\\)',
+ 'snippet' : ['constants.gibi',],
+ },
+ {
+ 'name' : 'tebi \\(2^{40}\\)',
+ 'snippet' : ['constants.tebi',],
+ },
+ {
+ 'name' : 'pebi \\(2^{50}\\)',
+ 'snippet' : ['constants.pebi',],
+ },
+ {
+ 'name' : 'exbi \\(2^{60}\\)',
+ 'snippet' : ['constants.exbi',],
+ },
+ {
+ 'name' : 'zebi \\(2^{70}\\)',
+ 'snippet' : ['constants.zebi',],
+ },
+ {
+ 'name' : 'yobi \\(2^{80}\\)',
+ 'snippet' : ['constants.yobi',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Weight',
+ 'sub-menu' : [
+ {
+ 'name' : 'One gram in kg',
+ 'snippet' : ['constants.gram',],
+ },
+ {
+ 'name' : 'One metric ton in kg (\\(10^{3}\\))',
+ 'snippet' : ['constants.metric_ton',],
+ },
+ {
+ 'name' : 'One grain in kg',
+ 'snippet' : ['constants.grain',],
+ },
+ {
+ 'name' : 'One pound (avoirdupois) in kg',
+ 'snippet' : ['constants.lb',],
+ },
+ {
+ 'name' : 'One ounce in kg',
+ 'snippet' : ['constants.oz',],
+ },
+ {
+ 'name' : 'One stone in kg',
+ 'snippet' : ['constants.stone',],
+ },
+ {
+ 'name' : 'One grain in kg',
+ 'snippet' : ['constants.grain',],
+ },
+ {
+ 'name' : 'One long ton in kg',
+ 'snippet' : ['constants.long_ton',],
+ },
+ {
+ 'name' : 'One short ton in kg',
+ 'snippet' : ['constants.short_ton',],
+ },
+ {
+ 'name' : 'One Troy ounce in kg',
+ 'snippet' : ['constants.troy_ounce',],
+ },
+ {
+ 'name' : 'One Troy pound in kg',
+ 'snippet' : ['constants.troy_pound',],
+ },
+ {
+ 'name' : 'One carat in kg',
+ 'snippet' : ['constants.carat',],
+ },
+ {
+ 'name' : 'Atomic mass constant in kg',
+ 'snippet' : ['constants.m_u',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Angle',
+ 'sub-menu' : [
+ {
+ 'name' : 'Degree in radians',
+ 'snippet' : ['constants.degree',],
+ },
+ {
+ 'name' : 'Arc minute in radians',
+ 'snippet' : ['constants.arcmin',],
+ },
+ {
+ 'name' : 'Arc second in radians',
+ 'snippet' : ['constants.arcsec',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Time',
+ 'sub-menu' : [
+ {
+ 'name' : 'One minute in seconds',
+ 'snippet' : ['constants.minute',],
+ },
+ {
+ 'name' : 'One hour in seconds',
+ 'snippet' : ['constants.hour',],
+ },
+ {
+ 'name' : 'One day in seconds',
+ 'snippet' : ['constants.day',],
+ },
+ {
+ 'name' : 'One week in seconds',
+ 'snippet' : ['constants.week',],
+ },
+ {
+ 'name' : 'One year (365 days) in seconds',
+ 'snippet' : ['constants.year',],
+ },
+ {
+ 'name' : 'One Julian year (365.25 days) in seconds',
+ 'snippet' : ['constants.Julian_year',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Length',
+ 'sub-menu' : [
+ {
+ 'name' : 'One inch in meters',
+ 'snippet' : ['constants.inch',],
+ },
+ {
+ 'name' : 'One foot in meters',
+ 'snippet' : ['constants.foot',],
+ },
+ {
+ 'name' : 'One yard in meters',
+ 'snippet' : ['constants.yard',],
+ },
+ {
+ 'name' : 'One mile in meters',
+ 'snippet' : ['constants.mile',],
+ },
+ {
+ 'name' : 'One mil in meters',
+ 'snippet' : ['constants.mil',],
+ },
+ {
+ 'name' : 'One point in meters',
+ 'snippet' : ['constants.pt',],
+ },
+ {
+ 'name' : 'One survey foot in meters',
+ 'snippet' : ['constants.survey_foot',],
+ },
+ {
+ 'name' : 'One survey mile in meters',
+ 'snippet' : ['constants.survey_mile',],
+ },
+ {
+ 'name' : 'One nautical mile in meters',
+ 'snippet' : ['constants.nautical_mile',],
+ },
+ {
+ 'name' : 'One Fermi in meters',
+ 'snippet' : ['constants.fermi',],
+ },
+ {
+ 'name' : 'One Angstrom in meters',
+ 'snippet' : ['constants.angstrom',],
+ },
+ {
+ 'name' : 'One micron in meters',
+ 'snippet' : ['constants.micron',],
+ },
+ {
+ 'name' : 'One astronomical unit in meters',
+ 'snippet' : ['constants.au',],
+ },
+ {
+ 'name' : 'One light year in meters',
+ 'snippet' : ['constants.light_year',],
+ },
+ {
+ 'name' : 'One parsec in meters',
+ 'snippet' : ['constants.parsec',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Pressure',
+ 'sub-menu' : [
+ {
+ 'name' : 'Standard atmosphere in pascals',
+ 'snippet' : ['constants.atm',],
+ },
+ {
+ 'name' : 'One bar in pascals',
+ 'snippet' : ['constants.bar',],
+ },
+ {
+ 'name' : 'One torr (mmHg) in pascals',
+ 'snippet' : ['constants.torr',],
+ },
+ {
+ 'name' : 'One psi in pascals',
+ 'snippet' : ['constants.psi',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Area',
+ 'sub-menu' : [
+ {
+ 'name' : 'One hectare in square meters',
+ 'snippet' : ['constants.hectare',],
+ },
+ {
+ 'name' : 'One acre in square meters',
+ 'snippet' : ['constants.acre',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Volume',
+ 'sub-menu' : [
+ {
+ 'name' : 'One liter in cubic meters',
+ 'snippet' : ['constants.liter',],
+ },
+ {
+ 'name' : 'One gallon (US) in cubic meters',
+ 'snippet' : ['constants.gallon',],
+ },
+ {
+ 'name' : 'One gallon (UK) in cubic meters',
+ 'snippet' : ['constants.gallon_imp',],
+ },
+ {
+ 'name' : 'One fluid ounce (US) in cubic meters',
+ 'snippet' : ['constants.fluid_ounce',],
+ },
+ {
+ 'name' : 'One fluid ounce (UK) in cubic meters',
+ 'snippet' : ['constants.fluid_ounce_imp',],
+ },
+ {
+ 'name' : 'One barrel in cubic meters',
+ 'snippet' : ['constants.bbl',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Speed',
+ 'sub-menu' : [
+ {
+ 'name' : 'Kilometers per hour in meters per second',
+ 'snippet' : ['constants.kmh',],
+ },
+ {
+ 'name' : 'Miles per hour in meters per second',
+ 'snippet' : ['constants.mph',],
+ },
+ {
+ 'name' : 'One Mach (approx., at 15 C, 1 atm) in meters per second',
+ 'snippet' : ['constants.mach',],
+ },
+ {
+ 'name' : 'One knot in meters per second',
+ 'snippet' : ['constants.knot',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Temperature',
+ 'sub-menu' : [
+ {
+ 'name' : 'Zero of Celsius scale in Kelvin',
+ 'snippet' : ['constants.zero_Celsius',],
+ },
+ {
+ 'name' : 'One Fahrenheit (only differences) in Kelvins',
+ 'snippet' : ['constants.degree_Fahrenheit',],
+ },
+ {
+ 'name' : 'Convert Celsius to Kelvin',
+ 'snippet' : ['constants.C2K(C)',],
+ },
+ {
+ 'name' : 'Convert Kelvin to Celsius',
+ 'snippet' : ['constants.K2C(K)',],
+ },
+ {
+ 'name' : 'Convert Fahrenheit to Celsius',
+ 'snippet' : ['constants.F2C(F)',],
+ },
+ {
+ 'name' : 'Convert Celsius to Fahrenheit',
+ 'snippet' : ['constants.C2F(C)',],
+ },
+ {
+ 'name' : 'Convert Fahrenheit to Kelvin',
+ 'snippet' : ['constants.F2K(F)',],
+ },
+ {
+ 'name' : 'Convert Kelvin to Fahrenheit',
+ 'snippet' : ['constants.K2F(K)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Energy',
+ 'sub-menu' : [
+ {
+ 'name' : 'One electron volt in Joules',
+ 'snippet' : ['constants.eV',],
+ },
+ {
+ 'name' : 'One calorie (thermochemical) in Joules',
+ 'snippet' : ['constants.calorie',],
+ },
+ {
+ 'name' : 'One calorie (International Steam Table calorie, 1956) in Joules',
+ 'snippet' : ['constants.calorie_IT',],
+ },
+ {
+ 'name' : 'One erg in Joules',
+ 'snippet' : ['constants.erg',],
+ },
+ {
+ 'name' : 'One British thermal unit (International Steam Table) in Joules',
+ 'snippet' : ['constants.Btu',],
+ },
+ {
+ 'name' : 'One British thermal unit (thermochemical) in Joules',
+ 'snippet' : ['constants.Btu_th',],
+ },
+ {
+ 'name' : 'One ton of TNT in Joules',
+ 'snippet' : ['constants.ton_TNT',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Power',
+ 'sub-menu' : [
+ {
+ 'name' : 'One horsepower in watts',
+ 'snippet' : ['constants.hp',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Force',
+ 'sub-menu' : [
+ {
+ 'name' : 'One dyne in newtons',
+ 'snippet' : ['constants.dyn',],
+ },
+ {
+ 'name' : 'One pound force in newtons',
+ 'snippet' : ['constants.lbf',],
+ },
+ {
+ 'name' : 'One kilogram force in newtons',
+ 'snippet' : ['constants.kgf',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Optics',
+ 'sub-menu' : [
+ {
+ 'name' : 'Convert wavelength \\(\\lambda\\) to optical frequency \\(\\nu\\)',
+ 'snippet' : ['constants.lambda2nu(lambda_)',],
+ },
+ {
+ 'name' : 'Convert optical frequency \\(\\nu\\) to wavelength \\(\\lambda\\)',
+ 'snippet' : ['constants.nu2lambda(nu)',],
+ },
+
+ ],
+ },
+ ],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_special.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_special.js
new file mode 100644
index 0000000000000000000000000000000000000000..14bed404e846395d807fbfd3554a955a0b377c99
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_special.js
@@ -0,0 +1,2198 @@
+define({
+ 'name' : 'Special functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Setup',
+ 'snippet' : ['from scipy import special',],
+ },
+ '---',
+
+ {
+ 'name' : 'Airy functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'airy: Airy functions and their derivatives',
+ 'snippet' : [
+ 'special.airy(z)',
+ ],
+ },
+
+ {
+ 'name' : 'airye: Exponentially scaled Airy functions and their derivatives',
+ 'snippet' : [
+ 'special.airye(z)',
+ ],
+ },
+
+ {
+ 'name' : 'ai_zeros: Compute $n$ zeros $a$ and $a\'$ of $\\mathrm{Ai}(x)$ and $\\mathrm{Ai}\'(x)$, and $\\mathrm{Ai}(a\')$ and $\\mathrm{Ai}\'(a)$',
+ 'snippet' : [
+ 'special.ai_zeros(n)',
+ ],
+ },
+
+ {
+ 'name' : 'bi_zeros: Compute $n$ zeros $b$ and $b\'$ of $\\mathrm{Bi}(x)$ and $\\mathrm{Bi}\'(x)$, and $\\mathrm{Bi}(b\')$ and $\\mathrm{Bi}\'(b)$',
+ 'snippet' : [
+ 'special.bi_zeros(n)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Elliptic Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'ellipj: Jacobian elliptic functions',
+ 'snippet' : [
+ 'special.ellipj(u, m)',
+ ],
+ },
+
+ {
+ 'name' : 'ellipk: Computes the complete elliptic integral of the first kind',
+ 'snippet' : [
+ 'special.ellipk(m)',
+ ],
+ },
+
+ {
+ 'name' : 'ellipkm1: The complete elliptic integral of the first kind around m=1',
+ 'snippet' : [
+ 'special.ellipkm1(p)',
+ ],
+ },
+
+ {
+ 'name' : 'ellipkinc: Incomplete elliptic integral of the first kind',
+ 'snippet' : [
+ 'special.ellipkinc(phi, m)',
+ ],
+ },
+
+ {
+ 'name' : 'ellipe: Complete elliptic integral of the second kind',
+ 'snippet' : [
+ 'special.ellipe(m)',
+ ],
+ },
+
+ {
+ 'name' : 'ellipeinc: Incomplete elliptic integral of the second kind',
+ 'snippet' : [
+ 'special.ellipeinc(phi,m)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Bessel Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'Bessel Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'jv: Bessel function of the first kind of real order $v$, $J_v(z)$',
+ 'snippet' : [
+ 'special.jv(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'jve: Exponentially scaled Bessel function of the first kind of order $v$, $J_v(z)\\, e^{-|\\Im{z}|}$',
+ 'snippet' : [
+ 'special.jve(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'yn: Bessel function of the second kind of integer order $n$, $Y_n(x)$',
+ 'snippet' : [
+ 'special.yn(n,x)',
+ ],
+ },
+
+ {
+ 'name' : 'yv: Bessel function of the second kind of real order $v$, $Y_v(z)$',
+ 'snippet' : [
+ 'special.yv(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'yve: Exponentially scaled Bessel function of the second kind of real order, $Y_v(z)\\, e^{-|\\Im{z}|}$',
+ 'snippet' : [
+ 'special.yve(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'kn: Modified Bessel function of the second kind of integer order $n$, $K_n(x)$',
+ 'snippet' : [
+ 'special.kn(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'kv: Modified Bessel function of the second kind of real order $v$, $K_v(z)$',
+ 'snippet' : [
+ 'special.kv(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'kve: Exponentially scaled modified Bessel function of the second kind, $K_v(z)\\, e^{z}$',
+ 'snippet' : [
+ 'special.kve(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'iv: Modified Bessel function of the first kind of real order $v$, $I_v(z)$',
+ 'snippet' : [
+ 'special.iv(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'ive: Exponentially scaled modified Bessel function of the first kind of real order $v$, $I_v(z)\\, e^{-|\\Re{z}|}$',
+ 'snippet' : [
+ 'special.ive(v,z)',
+ ],
+ },
+
+ {
+ 'name' : 'hankel1: Hankel function of the first kind, $H^{(1)}_v(z)$',
+ 'snippet' : [
+ 'special.hankel1(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'hankel1e: Exponentially scaled Hankel function of the first kind, $H^{(1)}_v(z)\\, e^{-i\\, z}$',
+ 'snippet' : [
+ 'special.hankel1e(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'hankel2: Hankel function of the second kind, $H^{(2)}_v(z)$',
+ 'snippet' : [
+ 'special.hankel2(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'hankel2e: Exponentially scaled Hankel function of the second kind, $H^{(2)}_v(z)\\, e^{i\\, z}$',
+ 'snippet' : [
+ 'special.hankel2e(v, z)',
+ ],
+ },
+
+ // The following is not an universal function:
+
+ {
+ 'name' : 'lmbda: Compute sequence of lambda functions with arbitrary order $v$ and their derivatives',
+ 'snippet' : [
+ 'special.lmbda(v, x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Zeros of Bessel Functions',
+ 'sub-menu' : [
+
+ // These are not universal functions:
+
+ {
+ 'name' : 'jnjnp_zeros: Compute nt (<=1200) zeros of the Bessel functions $J_n$ and $J_n\'$ and arange them in order of their magnitudes',
+ 'snippet' : [
+ 'special.jnjnp_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'jnyn_zeros: Compute nt zeros of the Bessel functions $J_n(x)$, $J_n\'(x)$, $Y_n(x)$, and $Y_n\'(x)$, respectively',
+ 'snippet' : [
+ 'special.jnyn_zeros(n, nt)',
+ ],
+ },
+
+ {
+ 'name' : 'jn_zeros: Compute nt zeros of the Bessel function $J_n(x)$',
+ 'snippet' : [
+ 'special.jn_zeros(n, nt)',
+ ],
+ },
+
+ {
+ 'name' : 'jnp_zeros: Compute nt zeros of the Bessel function $J_n\'(x)$',
+ 'snippet' : [
+ 'special.jnp_zeros(n, nt)',
+ ],
+ },
+
+ {
+ 'name' : 'yn_zeros: Compute nt zeros of the Bessel function $Y_n(x)$',
+ 'snippet' : [
+ 'special.yn_zeros(n, nt)',
+ ],
+ },
+
+ {
+ 'name' : 'ynp_zeros: Compute nt zeros of the Bessel function $Y_n\'(x)$',
+ 'snippet' : [
+ 'special.ynp_zeros(n, nt)',
+ ],
+ },
+
+ {
+ 'name' : 'y0_zeros: Returns nt (complex or real) zeros of $Y_0(z)$, $z_0$, and the value of $Y_0\'(z_0) = -Y_1(z_0)$ at each zero',
+ 'snippet' : [
+ 'special.y0_zeros(nt, complex=0)',
+ ],
+ },
+
+ {
+ 'name' : 'y1_zeros: Returns nt (complex or real) zeros of $Y_1(z)$, $z_1$, and the value of $Y_1\'(z_1) = Y_0(z_1)$ at each zero',
+ 'snippet' : [
+ 'special.y1_zeros(nt, complex=0)',
+ ],
+ },
+
+ {
+ 'name' : 'y1p_zeros: Returns nt (complex or real) zeros of $Y_1\'(z)$, $z_1\'$, and the value of $Y_1(z_1\')$ at each zero',
+ 'snippet' : [
+ 'special.y1p_zeros(nt, complex=0)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Faster versions of common Bessel Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'j0: Bessel function the first kind of order 0, $J_0(x)$',
+ 'snippet' : [
+ 'special.j0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'j1: Bessel function of the first kind of order 1, $J_1(x)$',
+ 'snippet' : [
+ 'special.j1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'y0: Bessel function of the second kind of order 0, $Y_0(x)$',
+ 'snippet' : [
+ 'special.y0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'y1: Bessel function of the second kind of order 1, $Y_1(x)$',
+ 'snippet' : [
+ 'special.y1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'i0: Modified Bessel function of order 0, $I_0(x)$',
+ 'snippet' : [
+ 'special.i0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'i0e: Exponentially scaled modified Bessel function of order 0, $I_0(x)\\, e^{-|x|}$',
+ 'snippet' : [
+ 'special.i0e(x)',
+ ],
+ },
+
+ {
+ 'name' : 'i1: Modified Bessel function of order 1, $I_1(x)$',
+ 'snippet' : [
+ 'special.i1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'i1e: Exponentially scaled modified Bessel function of order 1, $I_1(x)\\, e^{-|x|}$',
+ 'snippet' : [
+ 'special.i1e(x)',
+ ],
+ },
+
+ {
+ 'name' : 'k0: Modified Bessel function K of order 0, $K_0(x)$',
+ 'snippet' : [
+ 'special.k0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'k0e: Exponentially scaled modified Bessel function K of order 0, $K_0(x)\\, e^{x}$',
+ 'snippet' : [
+ 'special.k0e(x)',
+ ],
+ },
+
+ {
+ 'name' : 'k1: Modified Bessel function of the first kind of order 1, $K_1(x)$',
+ 'snippet' : [
+ 'special.k1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'k1e: Exponentially scaled modified Bessel function K of order 1, $K_1(x)\\, e^{x}$',
+ 'snippet' : [
+ 'special.k1e(x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Integrals of Bessel Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'itj0y0: Integrals of Bessel functions of order 0: $\\int_0^x J_0(t)\\, dt$, $\\int_0^x Y_0(t)\\, dt$',
+ 'snippet' : [
+ 'special.itj0y0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'it2j0y0: Integrals related to Bessel functions of order 0: $\\int_0^x \\frac{1-J_0(t)}{t}\\, dt$, $\\int_x^\\infty \\frac{Y_0(t)}{t}\\, dt$',
+ 'snippet' : [
+ 'special.it2j0y0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'iti0k0: Integrals of modified Bessel functions of order 0: $\\int_0^x I_0(t)\\, dt$, $\\int_0^x K_0(t)\\, dt$',
+ 'snippet' : [
+ 'special.iti0k0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'it2i0k0: Integrals related to modified Bessel functions of order 0: $\\int_0^x \\frac{I_0(t)-1}{t}\\, dt$, $\\int_x^\\infty \\frac{K_0(t)}{t}\\, dt$',
+ 'snippet' : [
+ 'special.it2i0k0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'besselpoly: Weighted integral of a Bessel function, $\\int_0^1 x^\\lambda J_\\nu(2 a x) \\, dx$',
+ 'snippet' : [
+ 'special.besselpoly(a, lmb, nu)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Derivatives of Bessel Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'jvp: Return the $n$th derivative of $J_v(z)$ with respect to $z$',
+ 'snippet' : [
+ 'special.jvp(v, z, n=1)',
+ ],
+ },
+
+ {
+ 'name' : 'yvp: Return the $n$th derivative of $Y_v(z)$ with respect to $z$',
+ 'snippet' : [
+ 'special.yvp(v, z, n=1)',
+ ],
+ },
+
+ {
+ 'name' : 'kvp: Return the $n$th derivative of $K_v(z)$ with respect to $z$',
+ 'snippet' : [
+ 'special.kvp(v, z, n=1)',
+ ],
+ },
+
+ {
+ 'name' : 'ivp: Return the $n$th derivative of $I_v(z)$ with respect to $z$',
+ 'snippet' : [
+ 'special.ivp(v, z, n=1)',
+ ],
+ },
+
+ {
+ 'name' : 'h1vp: Return the $n$th derivative of $H^{(1)}_v(z)$ with respect to $z$',
+ 'snippet' : [
+ 'special.h1vp(v, z, n=1)',
+ ],
+ },
+
+ {
+ 'name' : 'h2vp: Return the $n$th derivative of $H^{(2)}_v(z)$ with respect to z',
+ 'snippet' : [
+ 'special.h2vp(v, z, n=1)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Spherical Bessel Functions',
+ 'sub-menu' : [
+
+ // These are not universal functions:
+
+ {
+ 'name' : 'sph_jn: Compute the spherical Bessel function $j_n(z)$ and its derivative for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_jn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_yn: Compute the spherical Bessel function $y_n(z)$ and its derivative for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_yn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_jnyn: Compute the spherical Bessel functions, $j_n(z)$ and $y_n(z)$ and their derivatives for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_jnyn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_in: Compute the spherical Bessel function $i_n(z)$ and its derivative for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_in(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_kn: Compute the spherical Bessel function $k_n(z)$ and its derivative for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_kn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_inkn: Compute the spherical Bessel functions, $i_n(z)$ and $k_n(z)$ and their derivatives for all orders up to and including $n$',
+ 'snippet' : [
+ 'special.sph_inkn(n, z)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Riccati-Bessel Functions',
+ 'sub-menu' : [
+
+ // These are not universal functions:
+
+ {
+ 'name' : 'riccati_jn: Compute the Ricatti-Bessel function of the first kind and its derivative for all orders up to and including n',
+ 'snippet' : [
+ 'special.riccati_jn(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'riccati_yn: Compute the Ricatti-Bessel function of the second kind and its derivative for all orders up to and including n',
+ 'snippet' : [
+ 'special.riccati_yn(n, x)',
+ ],
+ },
+
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Struve Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'struve: Struve function',
+ 'snippet' : [
+ 'special.struve(v,x)',
+ ],
+ },
+
+ {
+ 'name' : 'modstruve: Modified Struve function',
+ 'snippet' : [
+ 'special.modstruve(v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'itstruve0: Integral of the Struve function of order 0',
+ 'snippet' : [
+ 'special.itstruve0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'it2struve0: Integral related to Struve function of order 0',
+ 'snippet' : [
+ 'special.it2struve0(x)',
+ ],
+ },
+
+ {
+ 'name' : 'itmodstruve0: Integral of the modified Struve function of order 0',
+ 'snippet' : [
+ 'special.itmodstruve0(x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Statistical Functions (see also scipy.stats)',
+ 'sub-menu' : [
+
+// See also
+// scipy.stats: Friendly versions of these functions.
+
+ {
+ 'name' : 'bdtr: Binomial distribution cumulative distribution function',
+ 'snippet' : [
+ 'special.bdtr(k, n, p)',
+ ],
+ },
+
+ {
+ 'name' : 'bdtrc: Binomial distribution survival function',
+ 'snippet' : [
+ 'special.bdtrc(k, n, p)',
+ ],
+ },
+
+ {
+ 'name' : 'bdtri: Inverse function to bdtr vs',
+ 'snippet' : [
+ 'special.bdtri(k, n, y)',
+ ],
+ },
+
+ {
+ 'name' : 'btdtr: Cumulative beta distribution',
+ 'snippet' : [
+ 'special.btdtr(a,b,x)',
+ ],
+ },
+
+ {
+ 'name' : 'btdtri: p-th quantile of the beta distribution',
+ 'snippet' : [
+ 'special.btdtri(a,b,p)',
+ ],
+ },
+
+ {
+ 'name' : 'fdtr: F cumulative distribution function',
+ 'snippet' : [
+ 'special.fdtr(dfn, dfd, x)',
+ ],
+ },
+
+ {
+ 'name' : 'fdtrc: F survival function',
+ 'snippet' : [
+ 'special.fdtrc(dfn, dfd, x)',
+ ],
+ },
+
+ {
+ 'name' : 'fdtri: Inverse to fdtr vs x',
+ 'snippet' : [
+ 'special.fdtri(dfn, dfd, p)',
+ ],
+ },
+
+ {
+ 'name' : 'gdtr: Gamma distribution cumulative density function',
+ 'snippet' : [
+ 'special.gdtr(a,b,x)',
+ ],
+ },
+
+ {
+ 'name' : 'gdtrc: Gamma distribution survival function',
+ 'snippet' : [
+ 'special.gdtrc(a,b,x)',
+ ],
+ },
+
+ {
+ 'name' : 'gdtria: Inverse of gdtr vs a',
+ 'snippet' : [
+ 'special.gdtria(p, b, x)',
+ ],
+ },
+
+ {
+ 'name' : 'gdtrib: Inverse of gdtr vs b',
+ 'snippet' : [
+ 'special.gdtrib(a, p, x)',
+ ],
+ },
+
+ {
+ 'name' : 'gdtrix: Inverse of gdtr vs x',
+ 'snippet' : [
+ 'special.gdtrix(a, b, p)',
+ ],
+ },
+
+ {
+ 'name' : 'nbdtr: Negative binomial cumulative distribution function',
+ 'snippet' : [
+ 'special.nbdtr(k, n, p)',
+ ],
+ },
+
+ {
+ 'name' : 'nbdtrc: Negative binomial survival function',
+ 'snippet' : [
+ 'special.nbdtrc(k,n,p)',
+ ],
+ },
+
+ {
+ 'name' : 'nbdtri: Inverse of nbdtr vs p',
+ 'snippet' : [
+ 'special.nbdtri(k, n, y)',
+ ],
+ },
+
+ {
+ 'name' : 'ncfdtr: Cumulative distribution function of the non-central $F$ distribution.',
+ 'snippet' : [
+ 'special.ncfdtr(dfn, dfd, nc, f)',
+ ],
+ },
+
+ {
+ 'name' : 'ncfdtridfd: Calculate degrees of freedom (denominator) for the noncentral $F$ distribution.',
+ 'snippet' : [
+ 'special.ncfdtridfd(p, f, dfn, nc)',
+ ],
+ },
+
+ {
+ 'name' : 'ncfdtridfn: Calculate degrees of freedom (numerator) for the noncentral $F$ distribution.',
+ 'snippet' : [
+ 'special.ncfdtridfn(p, f, dfd, nc)',
+ ],
+ },
+
+ {
+ 'name' : 'ncfdtri: Inverse cumulative distribution function of the non-central $F$ distribution.',
+ 'snippet' : [
+ 'special.ncfdtri(p, dfn, dfd, nc)',
+ ],
+ },
+
+ {
+ 'name' : 'ncfdtrinc: Calculate non-centrality parameter for non-central $F$ distribution.',
+ 'snippet' : [
+ 'special.ncfdtrinc(p, f, dfn, dfd)',
+ ],
+ },
+
+ {
+ 'name' : 'nctdtr: Cumulative distribution function of the non-central $t$ distribution.',
+ 'snippet' : [
+ 'special.nctdtr(df, nc, t)',
+ ],
+ },
+
+ {
+ 'name' : 'nctdtridf: Calculate degrees of freedom for non-central $t$ distribution.',
+ 'snippet' : [
+ 'special.nctdtridf(p, nc, t)',
+ ],
+ },
+
+ {
+ 'name' : 'nctdtrit: Inverse cumulative distribution function of the non-central $t$ distribution.',
+ 'snippet' : [
+ 'special.nctdtrit(df, nc, p)',
+ ],
+ },
+
+ {
+ 'name' : 'nctdtrinc: Calculate non-centrality parameter for non-central $t$ distribution.',
+ 'snippet' : [
+ 'special.nctdtrinc(df, p, t)',
+ ],
+ },
+
+ {
+ 'name' : 'nrdtrimn: Calculate mean of normal distribution given other params.',
+ 'snippet' : [
+ 'special.nrdtrimn(p, x, std)',
+ ],
+ },
+
+ {
+ 'name' : 'nrdtrisd: Calculate standard deviation of normal distribution given other params.',
+ 'snippet' : [
+ 'special.nrdtrisd(p, x, mn)',
+ ],
+ },
+
+ {
+ 'name' : 'pdtr: Poisson cumulative distribution function',
+ 'snippet' : [
+ 'special.pdtr(k, m)',
+ ],
+ },
+
+ {
+ 'name' : 'pdtrc: Poisson survival function',
+ 'snippet' : [
+ 'special.pdtrc(k, m)',
+ ],
+ },
+
+ {
+ 'name' : 'pdtri: Inverse to pdtr vs m',
+ 'snippet' : [
+ 'special.pdtri(k,y)',
+ ],
+ },
+
+ {
+ 'name' : 'stdtr: Student $t$ distribution cumulative density function',
+ 'snippet' : [
+ 'special.stdtr(df,t)',
+ ],
+ },
+
+ {
+ 'name' : 'stdtridf: Inverse of stdtr vs df',
+ 'snippet' : [
+ 'special.stdtridf(p,t)',
+ ],
+ },
+
+ {
+ 'name' : 'stdtrit: Inverse of stdtr vs t',
+ 'snippet' : [
+ 'special.stdtrit(df,p)',
+ ],
+ },
+
+ {
+ 'name' : 'chdtr: Chi square cumulative distribution function',
+ 'snippet' : [
+ 'special.chdtr(v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'chdtrc: Chi square survival function',
+ 'snippet' : [
+ 'special.chdtrc(v,x)',
+ ],
+ },
+
+ {
+ 'name' : 'chdtri: Inverse to chdtrc',
+ 'snippet' : [
+ 'special.chdtri(v,p)',
+ ],
+ },
+
+ {
+ 'name' : 'ndtr: Gaussian cumulative distribution function',
+ 'snippet' : [
+ 'special.ndtr(x)',
+ ],
+ },
+
+ {
+ 'name' : 'ndtri: Inverse of ndtr vs x',
+ 'snippet' : [
+ 'special.ndtri(y)',
+ ],
+ },
+
+ {
+ 'name' : 'smirnov: Kolmogorov-Smirnov complementary cumulative distribution function',
+ 'snippet' : [
+ 'special.smirnov(n,e)',
+ ],
+ },
+
+ {
+ 'name' : 'smirnovi: Inverse to smirnov',
+ 'snippet' : [
+ 'special.smirnovi(n,y)',
+ ],
+ },
+
+ {
+ 'name' : 'kolmogorov: Complementary cumulative distribution function of Kolmogorov distribution',
+ 'snippet' : [
+ 'special.kolmogorov(y)',
+ ],
+ },
+
+ {
+ 'name' : 'kolmogi: Inverse function to kolmogorov',
+ 'snippet' : [
+ 'special.kolmogi(p)',
+ ],
+ },
+
+ {
+ 'name' : 'tklmbda: Tukey-Lambda cumulative distribution function',
+ 'snippet' : [
+ 'special.tklmbda(x, lmbda)',
+ ],
+ },
+
+ {
+ 'name' : 'logit: Logit ufunc for ndarrays',
+ 'snippet' : [
+ 'special.logit(x)',
+ ],
+ },
+
+ {
+ 'name' : 'expit: Expit ufunc for ndarrays',
+ 'snippet' : [
+ 'special.expit(x)',
+ ],
+ },
+
+ {
+ 'name' : 'boxcox: Compute the Box-Cox transformation',
+ 'snippet' : [
+ 'special.boxcox(x, lmbda)',
+ ],
+ },
+
+ {
+ 'name' : 'boxcox1p: Compute the Box-Cox transformation of 1 + x',
+ 'snippet' : [
+ 'special.boxcox1p(x, lmbda)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Information Theory Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'entr: Elementwise function for computing entropy.',
+ 'snippet' : [
+ 'special.entr(x)',
+ ],
+ },
+
+ {
+ 'name' : 'rel_entr: Elementwise function for computing relative entropy.',
+ 'snippet' : [
+ 'special.rel_entr(x, y)',
+ ],
+ },
+
+ {
+ 'name' : 'kl_div: Elementwise function for computing Kullback-Leibler divergence.',
+ 'snippet' : [
+ 'special.kl_div(x, y)',
+ ],
+ },
+
+ {
+ 'name' : 'huber: Huber loss function.',
+ 'snippet' : [
+ 'special.huber(delta, r)',
+ ],
+ },
+
+ {
+ 'name' : 'pseudo_huber: Pseudo-Huber loss function.',
+ 'snippet' : [
+ 'special.pseudo_huber(delta, r)',
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Gamma and Related Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'gamma: Gamma function',
+ 'snippet' : [
+ 'special.gamma(z)',
+ ],
+ },
+
+ {
+ 'name' : 'gammaln: Logarithm of absolute value of gamma function',
+ 'snippet' : [
+ 'special.gammaln(z)',
+ ],
+ },
+
+ {
+ 'name' : 'gammasgn: Sign of the gamma function',
+ 'snippet' : [
+ 'special.gammasgn(x)',
+ ],
+ },
+
+ {
+ 'name' : 'gammainc: Incomplete gamma function',
+ 'snippet' : [
+ 'special.gammainc(a, x)',
+ ],
+ },
+
+ {
+ 'name' : 'gammaincinv: Inverse to gammainc',
+ 'snippet' : [
+ 'special.gammaincinv(a, y)',
+ ],
+ },
+
+ {
+ 'name' : 'gammaincc: Complemented incomplete gamma integral',
+ 'snippet' : [
+ 'special.gammaincc(a,x)',
+ ],
+ },
+
+ {
+ 'name' : 'gammainccinv: Inverse to gammaincc',
+ 'snippet' : [
+ 'special.gammainccinv(a,y)',
+ ],
+ },
+
+ {
+ 'name' : 'beta: Beta function',
+ 'snippet' : [
+ 'special.beta(a, b)',
+ ],
+ },
+
+ {
+ 'name' : 'betaln: Natural logarithm of absolute value of beta function',
+ 'snippet' : [
+ 'special.betaln(a, b)',
+ ],
+ },
+
+ {
+ 'name' : 'betainc: Incomplete beta integral',
+ 'snippet' : [
+ 'special.betainc(a, b, x)',
+ ],
+ },
+
+ {
+ 'name' : 'betaincinv: Inverse function to beta integral',
+ 'snippet' : [
+ 'special.betaincinv(a, b, y)',
+ ],
+ },
+
+ {
+ 'name' : 'psi: Digamma function',
+ 'snippet' : [
+ 'special.psi(z)',
+ ],
+ },
+
+ {
+ 'name' : 'rgamma: Gamma function inverted',
+ 'snippet' : [
+ 'special.rgamma(z)',
+ ],
+ },
+
+ {
+ 'name' : 'polygamma: Polygamma function which is the $n$th derivative of the digamma (psi) function',
+ 'snippet' : [
+ 'special.polygamma(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'multigammaln: Returns the log of multivariate gamma, also sometimes called the generalized gamma',
+ 'snippet' : [
+ 'special.multigammaln(a, d)',
+ ],
+ },
+
+ {
+ 'name' : 'digamma: Digamma function',
+ 'snippet' : [
+ 'special.digamma(z)',
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Error Function and Fresnel Integrals',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'erf: Returns the error function of complex argument',
+ 'snippet' : [
+ 'special.erf(z)',
+ ],
+ },
+
+ {
+ 'name' : 'erfc: Complementary error function, $1 - \\mathrm{erf}(x)$',
+ 'snippet' : [
+ 'special.erfc(x)',
+ ],
+ },
+
+ {
+ 'name' : 'erfcx: Scaled complementary error function, $\\exp(x^2)\\, \\mathrm{erfc}(x)$',
+ 'snippet' : [
+ 'special.erfcx(x)',
+ ],
+ },
+
+ {
+ 'name' : 'erfi: Imaginary error function, $-i\\, \\mathrm{erf}(i\\, z)$',
+ 'snippet' : [
+ 'special.erfi(z)',
+ ],
+ },
+
+ {
+ 'name' : 'erfinv: Inverse function for erf',
+ 'snippet' : [
+ 'special.erfinv(y)',
+ ],
+ },
+
+ {
+ 'name' : 'erfcinv: Inverse function for erfc',
+ 'snippet' : [
+ 'special.erfcinv(y)',
+ ],
+ },
+
+ {
+ 'name' : 'wofz: Faddeeva function',
+ 'snippet' : [
+ 'special.wofz(z)',
+ ],
+ },
+
+ {
+ 'name' : 'dawsn: Dawson’s integral',
+ 'snippet' : [
+ 'special.dawsn(x)',
+ ],
+ },
+
+ {
+ 'name' : 'fresnel: Fresnel sin and cos integrals',
+ 'snippet' : [
+ 'special.fresnel(z)',
+ ],
+ },
+
+ {
+ 'name' : 'fresnel_zeros: Compute nt complex zeros of the sine and cosine Fresnel integrals S(z) and C(z)',
+ 'snippet' : [
+ 'special.fresnel_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'modfresnelp: Modified Fresnel positive integrals',
+ 'snippet' : [
+ 'special.modfresnelp(x)',
+ ],
+ },
+
+ {
+ 'name' : 'modfresnelm: Modified Fresnel negative integrals',
+ 'snippet' : [
+ 'special.modfresnelm(x)',
+ ],
+ },
+
+// These are not universal functions:
+
+ {
+ 'name' : 'erf_zeros: Compute nt complex zeros of the error function erf(z)',
+ 'snippet' : [
+ 'special.erf_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'fresnelc_zeros: Compute nt complex zeros of the cosine Fresnel integral C(z)',
+ 'snippet' : [
+ 'special.fresnelc_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'fresnels_zeros: Compute nt complex zeros of the sine Fresnel integral S(z)',
+ 'snippet' : [
+ 'special.fresnels_zeros(nt)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Legendre Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'lpmv: Associated legendre function of integer order',
+ 'snippet' : [
+ 'special.lpmv(m, v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'sph_harm: Spherical harmonic of degree $n \\geq 0$ and order $|m| \\leq n$',
+ 'snippet' : [
+ '# Note: n >= 0 and |m| <= n; azimuthal angle in [0, 2pi) and polar in [0, pi]',
+ 'special.sph_harm(order_m, degree_n, azimuthal_angle, polar_angle)',
+ ],
+ },
+
+// These are not universal functions:
+
+ {
+ 'name' : 'clpmn: Associated Legendre function of the first kind, $P_{m,n}(z)$',
+ 'snippet' : [
+ 'special.clpmn(m, n, z[, type])',
+ ],
+ },
+
+ {
+ 'name' : 'lpn: Compute sequence of Legendre functions of the first kind (polynomials), $P_n(z)$ and derivatives for all degrees from 0 to $n$ (inclusive)',
+ 'snippet' : [
+ 'special.lpn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'lqn: Compute sequence of Legendre functions of the second kind, $Q_n(z)$ and derivatives for all degrees from 0 to $n$ (inclusive)',
+ 'snippet' : [
+ 'special.lqn(n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'lpmn: Associated Legendre function of the first kind, $P_{m,n}(z)$',
+ 'snippet' : [
+ 'special.lpmn(m, n, z)',
+ ],
+ },
+
+ {
+ 'name' : 'lqmn: Associated Legendre functions of the second kind, $Q_{m,n}(z)$ and its derivative, $Q_{m,n}\'(z)$ of order $m$ and degree $n$',
+ 'snippet' : [
+ 'special.lqmn(m, n, z)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Ellipsoidal Harmonics',
+ 'sub-menu' : [
+ {
+ 'name' : 'ellip_harm: Ellipsoidal harmonic functions $E^p_n(l)$',
+ 'snippet' : [
+ 'special.ellip_harm(h2, k2, n, p, s[, signm, signn])',
+ ],
+ },
+
+ {
+ 'name' : 'ellip_harm_2: Ellipsoidal harmonic functions $F^p_n(l)$',
+ 'snippet' : [
+ 'special.ellip_harm_2(h2, k2, n, p, s)',
+ ],
+ },
+
+ {
+ 'name' : 'ellip_normal: Ellipsoidal harmonic normalization constants $\\gamma^p_n$',
+ 'snippet' : [
+ 'special.ellip_normal(h2, k2, n, p)',
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Orthogonal polynomials',
+ 'sub-menu' : [
+
+// The following functions evaluate values of orthogonal polynomials:
+ {
+ 'name' : 'assoc_laguerre: Returns the $n$th order generalized (associated) Laguerre polynomial.',
+ 'snippet' : [
+ 'special.assoc_laguerre(x, n)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_legendre: Evaluate Legendre polynomial at a point',
+ 'snippet' : [
+ 'special.eval_legendre(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_chebyt: Evaluate Chebyshev $T$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_chebyt(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_chebyu: Evaluate Chebyshev $U$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_chebyu(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_chebyc: Evaluate Chebyshev $C$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_chebyc(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_chebys: Evaluate Chebyshev $S$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_chebys(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_jacobi: Evaluate Jacobi polynomial at a point',
+ 'snippet' : [
+ 'special.eval_jacobi(n, alpha, beta, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_laguerre: Evaluate Laguerre polynomial at a point',
+ 'snippet' : [
+ 'special.eval_laguerre(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_genlaguerre: Evaluate generalized Laguerre polynomial at a point',
+ 'snippet' : [
+ 'special.eval_genlaguerre(n, alpha, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_hermite: Evaluate Hermite polynomial at a point',
+ 'snippet' : [
+ 'special.eval_hermite(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_hermitenorm: Evaluate normalized Hermite polynomial at a point',
+ 'snippet' : [
+ 'special.eval_hermitenorm(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_gegenbauer: Evaluate Gegenbauer polynomial at a point',
+ 'snippet' : [
+ 'special.eval_gegenbauer(n, alpha, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_sh_legendre: Evaluate shifted Legendre polynomial at a point',
+ 'snippet' : [
+ 'special.eval_sh_legendre(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_sh_chebyt: Evaluate shifted Chebyshev $T$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_sh_chebyt(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_sh_chebyu: Evaluate shifted Chebyshev $U$ polynomial at a point',
+ 'snippet' : [
+ 'special.eval_sh_chebyu(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'eval_sh_jacobi: Evaluate shifted Jacobi polynomial at a point',
+ 'snippet' : [
+ 'special.eval_sh_jacobi(n, p, q, x)',
+ ],
+ },
+
+ {
+ 'name' : 'legendre: Coefficients of the $n$th order Legendre polynomial, $P_n(x)$',
+ 'snippet' : [
+ 'special.legendre(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'chebyt: Coefficients of the $n$th order Chebyshev polynomial of first kind, $T_n(x)$',
+ 'snippet' : [
+ 'special.chebyt(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'chebyu: Coefficients of the $n$th order Chebyshev polynomial of second kind, $U_n(x)$',
+ 'snippet' : [
+ 'special.chebyu(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'chebyc: Coefficients of the $n$th order Chebyshev polynomial of first kind, $C_n(x)$',
+ 'snippet' : [
+ 'special.chebyc(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'chebys: Coefficients of the $n$th order Chebyshev polynomial of second kind, $S_n$(x)',
+ 'snippet' : [
+ 'special.chebys(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'jacobi: Coefficients of the $n$th order Jacobi polynomial, $P^(\\alpha,\\beta)_n(x)$ orthogonal over [-1,1] with weighting function $(1-x)^\\alpha (1+x)^\\beta$ with $\\alpha,\\beta > -1$',
+ 'snippet' : [
+ 'special.jacobi(n, alpha, beta[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'laguerre: Coefficients of the $n$th order Laguerre polynoimal, $L_n(x)$',
+ 'snippet' : [
+ 'special.laguerre(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'genlaguerre: Coefficients of the $n$th order generalized (associated) Laguerre polynomial,',
+ 'snippet' : [
+ 'special.genlaguerre(n, alpha[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'hermite: Coefficients of the $n$th order Hermite polynomial, $H_n(x)$, orthogonal over',
+ 'snippet' : [
+ 'special.hermite(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'hermitenorm: Coefficients of the $n$th order normalized Hermite polynomial, $He_n(x)$, orthogonal',
+ 'snippet' : [
+ 'special.hermitenorm(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'gegenbauer: Coefficients of the $n$th order Gegenbauer (ultraspherical) polynomial,',
+ 'snippet' : [
+ 'special.gegenbauer(n, alpha[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'sh_legendre: Coefficients of the $n$th order shifted Legendre polynomial, $P^\\ast_n(x)$',
+ 'snippet' : [
+ 'special.sh_legendre(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'sh_chebyt: Coefficients of $n$th order shifted Chebyshev polynomial of first kind, $T_n(x)$',
+ 'snippet' : [
+ 'special.sh_chebyt(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'sh_chebyu: Coefficients of the $n$th order shifted Chebyshev polynomial of second kind, $U_n(x)$',
+ 'snippet' : [
+ 'special.sh_chebyu(n[, monic])',
+ ],
+ },
+
+ {
+ 'name' : 'sh_jacobi: Coefficients of the $n$th order Jacobi polynomial, $G_n(p,q,x)$ orthogonal over [0,1] with weighting function $(1-x)^{p-q} x^{q-1}$ with $p>q-1$ and $q > 0$',
+ 'snippet' : [
+ 'special.sh_jacobi(n, p, q[, monic])',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Hypergeometric Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'hyp2f1: Gauss hypergeometric function ${}_2F_1(a, b; c; z)$',
+ 'snippet' : [
+ 'special.hyp2f1(a, b, c, z)',
+ ],
+ },
+
+ {
+ 'name' : 'hyp1f1: Confluent hypergeometric function ${}_1F_1(a, b; x)$',
+ 'snippet' : [
+ 'special.hyp1f1(a, b, x)',
+ ],
+ },
+
+ {
+ 'name' : 'hyperu: Confluent hypergeometric function $U(a, b, x)$ of the second kind',
+ 'snippet' : [
+ 'special.hyperu(a, b, x)',
+ ],
+ },
+
+ {
+ 'name' : 'hyp0f1: Confluent hypergeometric limit function ${}_0F_1$',
+ 'snippet' : [
+ 'special.hyp0f1(v, z)',
+ ],
+ },
+
+ {
+ 'name' : 'hyp2f0: Hypergeometric function ${}_2F_0$ in $y$ and an error estimate',
+ 'snippet' : [
+ 'special.hyp2f0(a, b, x, type)',
+ ],
+ },
+
+ {
+ 'name' : 'hyp1f2: Hypergeometric function ${}_1F_2$ and error estimate',
+ 'snippet' : [
+ 'special.hyp1f2(a, b, c, x)',
+ ],
+ },
+
+ {
+ 'name' : 'hyp3f0: Hypergeometric function ${}_3F_0$ in $y$ and an error estimate',
+ 'snippet' : [
+ 'special.hyp3f0(a, b, c, x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Parabolic Cylinder Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'pbdv: Parabolic cylinder function $D$',
+ 'snippet' : [
+ 'special.pbdv(v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'pbvv: Parabolic cylinder function $V$',
+ 'snippet' : [
+ 'special.pbvv(v,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pbwa: Parabolic cylinder function $W$',
+ 'snippet' : [
+ 'special.pbwa(a,x)',
+ ],
+ },
+
+// These are not universal functions:
+
+ {
+ 'name' : 'pbdv_seq: $D_{v_0}(x), ..., D_v(x)$ and $D_{v_0}\'(x), ..., D_v\'(x)$ with $v_0=v-\\lfloor v \\rfloor$',
+ 'snippet' : [
+ 'special.pbdv_seq(v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'pbvv_seq: $V_{v_0}(x), ..., V_v(x)$ and $V_{v_0}\'(x), ..., V_v\'(x)$ with $v_0=v-\\lfloor v \\rfloor$',
+ 'snippet' : [
+ 'special.pbvv_seq(v, x)',
+ ],
+ },
+
+ {
+ 'name' : 'pbdn_seq: $D_0(x), ..., D_n(x)$ and $D_0\'(x), ..., D_n\'(x)$',
+ 'snippet' : [
+ 'special.pbdn_seq(n, z)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Mathieu and Related Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'mathieu_a: Characteristic value of even Mathieu functions',
+ 'snippet' : [
+ 'special.mathieu_a(m,q)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_b: Characteristic value of odd Mathieu functions',
+ 'snippet' : [
+ 'special.mathieu_b(m,q)',
+ ],
+ },
+
+// These are not universal functions:
+
+ {
+ 'name' : 'mathieu_even_coef: Compute expansion coefficients for even Mathieu functions and modified Mathieu functions',
+ 'snippet' : [
+ 'special.mathieu_even_coef(m, q)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_odd_coef: Compute expansion coefficients for even Mathieu functions and modified Mathieu functions',
+ 'snippet' : [
+ 'special.mathieu_odd_coef(m, q)',
+ ],
+ },
+
+// The following return both function and first derivative:
+
+ {
+ 'name' : 'mathieu_cem: Even Mathieu function and its derivative',
+ 'snippet' : [
+ 'special.mathieu_cem(m,q,x)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_sem: Odd Mathieu function and its derivative',
+ 'snippet' : [
+ 'special.mathieu_sem(m, q, x)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_modcem1: Even modified Mathieu function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.mathieu_modcem1(m, q, x)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_modcem2: Even modified Mathieu function of the second kind and its derivative',
+ 'snippet' : [
+ 'special.mathieu_modcem2(m, q, x)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_modsem1: Odd modified Mathieu function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.mathieu_modsem1(m,q,x)',
+ ],
+ },
+
+ {
+ 'name' : 'mathieu_modsem2: Odd modified Mathieu function of the second kind and its derivative',
+ 'snippet' : [
+ 'special.mathieu_modsem2(m, q, x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Spheroidal Wave Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'pro_ang1: Prolate spheroidal angular function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.pro_ang1(m,n,c,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_rad1: Prolate spheroidal radial function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.pro_rad1(m,n,c,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_rad2: Prolate spheroidal radial function of the secon kind and its derivative',
+ 'snippet' : [
+ 'special.pro_rad2(m,n,c,x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_ang1: Oblate spheroidal angular function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.obl_ang1(m, n, c, x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_rad1: Oblate spheroidal radial function of the first kind and its derivative',
+ 'snippet' : [
+ 'special.obl_rad1(m,n,c,x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_rad2: Oblate spheroidal radial function of the second kind and its derivative',
+ 'snippet' : [
+ 'special.obl_rad2(m,n,c,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_cv: Characteristic value of prolate spheroidal function',
+ 'snippet' : [
+ 'special.pro_cv(m,n,c)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_cv: Characteristic value of oblate spheroidal function',
+ 'snippet' : [
+ 'special.obl_cv(m, n, c)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_cv_seq: Compute a sequence of characteristic values for the prolate spheroidal wave functions for mode m and n’=m..n and spheroidal parameter c',
+ 'snippet' : [
+ 'special.pro_cv_seq(m, n, c)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_cv_seq: Compute a sequence of characteristic values for the oblate spheroidal wave functions for mode m and n’=m..n and spheroidal parameter c',
+ 'snippet' : [
+ 'special.obl_cv_seq(m, n, c)',
+ ],
+ },
+
+// The following functions require pre-computed characteristic value:
+
+ {
+ 'name' : 'pro_ang1_cv: Prolate spheroidal angular function pro_ang1 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.pro_ang1_cv(m,n,c,cv,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_rad1_cv: Prolate spheroidal radial function pro_rad1 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.pro_rad1_cv(m,n,c,cv,x)',
+ ],
+ },
+
+ {
+ 'name' : 'pro_rad2_cv: Prolate spheroidal radial function pro_rad2 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.pro_rad2_cv(m,n,c,cv,x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_ang1_cv: Oblate spheroidal angular function obl_ang1 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.obl_ang1_cv(m, n, c, cv, x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_rad1_cv: Oblate spheroidal radial function obl_rad1 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.obl_rad1_cv(m,n,c,cv,x)',
+ ],
+ },
+
+ {
+ 'name' : 'obl_rad2_cv: Oblate spheroidal radial function obl_rad2 for precomputed characteristic value',
+ 'snippet' : [
+ 'special.obl_rad2_cv(m,n,c,cv,x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Kelvin Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'kelvin: Kelvin functions as complex numbers',
+ 'snippet' : [
+ 'special.kelvin(x)',
+ ],
+ },
+
+ {
+ 'name' : 'kelvin_zeros: Compute nt zeros of all the Kelvin functions returned in a length 8 tuple of arrays of length nt',
+ 'snippet' : [
+ 'special.kelvin_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'ber: Kelvin function ber',
+ 'snippet' : [
+ 'special.ber(x)',
+ ],
+ },
+
+ {
+ 'name' : 'bei: Kelvin function bei',
+ 'snippet' : [
+ 'special.bei(x)',
+ ],
+ },
+
+ {
+ 'name' : 'berp: Derivative of the Kelvin function ber',
+ 'snippet' : [
+ 'special.berp(x)',
+ ],
+ },
+
+ {
+ 'name' : 'beip: Derivative of the Kelvin function bei',
+ 'snippet' : [
+ 'special.beip(x)',
+ ],
+ },
+
+ {
+ 'name' : 'ker: Kelvin function ker',
+ 'snippet' : [
+ 'special.ker(x)',
+ ],
+ },
+
+ {
+ 'name' : 'kei: Kelvin function ker',
+ 'snippet' : [
+ 'special.kei(x)',
+ ],
+ },
+
+ {
+ 'name' : 'kerp: Derivative of the Kelvin function ker',
+ 'snippet' : [
+ 'special.kerp(x)',
+ ],
+ },
+
+ {
+ 'name' : 'keip: Derivative of the Kelvin function kei',
+ 'snippet' : [
+ 'special.keip(x)',
+ ],
+ },
+
+// These are not universal functions:
+
+ {
+ 'name' : 'ber_zeros: Compute nt zeros of the Kelvin function ber x',
+ 'snippet' : [
+ 'special.ber_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'bei_zeros: Compute nt zeros of the Kelvin function bei x',
+ 'snippet' : [
+ 'special.bei_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'berp_zeros: Compute nt zeros of the Kelvin function ber’ x',
+ 'snippet' : [
+ 'special.berp_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'beip_zeros: Compute nt zeros of the Kelvin function bei’ x',
+ 'snippet' : [
+ 'special.beip_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'ker_zeros: Compute nt zeros of the Kelvin function ker x',
+ 'snippet' : [
+ 'special.ker_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'kei_zeros: Compute nt zeros of the Kelvin function kei x',
+ 'snippet' : [
+ 'special.kei_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'kerp_zeros: Compute nt zeros of the Kelvin function ker’ x',
+ 'snippet' : [
+ 'special.kerp_zeros(nt)',
+ ],
+ },
+
+ {
+ 'name' : 'keip_zeros: Compute nt zeros of the Kelvin function kei’ x',
+ 'snippet' : [
+ 'special.keip_zeros(nt)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Combinatorics',
+ 'sub-menu' : [
+ {
+ 'name' : 'comb: The number of combinations of N things taken k at a time',
+ 'snippet' : [
+ 'special.comb(N, k, exact=False, repetition=False)',
+ ],
+ },
+
+ {
+ 'name' : 'perm: Permutations of N things taken k at a time, i.e., k-permutations of N',
+ 'snippet' : [
+ 'special.perm(N, k, exact=False)',
+ ],
+ },
+ ],
+ },
+
+ {
+ 'name' : 'Other Special Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'agm: Arithmetic, Geometric Mean',
+ 'snippet' : [
+ 'special.agm(a, b)',
+ ],
+ },
+
+ {
+ 'name' : 'bernoulli: Return an array of the Bernoulli numbers $B_0$, ..., $B_n$ (inclusive)',
+ 'snippet' : [
+ 'special.bernoulli(n)',
+ ],
+ },
+
+ {
+ 'name' : 'binom: Binomial coefficient',
+ 'snippet' : [
+ 'special.binom(n, k)',
+ ],
+ },
+
+ {
+ 'name' : 'diric: Returns the periodic sinc function, also called the Dirichlet function',
+ 'snippet' : [
+ 'special.diric(x, n)',
+ ],
+ },
+
+ {
+ 'name' : 'euler: Return an array of the Euler numbers $E_0$, ..., $E_n$ (inclusive)',
+ 'snippet' : [
+ 'special.euler(n)',
+ ],
+ },
+
+ {
+ 'name' : 'expn: Exponential integral $E_n$',
+ 'snippet' : [
+ 'special.expn(n, x)',
+ ],
+ },
+
+ {
+ 'name' : 'exp1: Exponential integral $E_1$ of complex argument $z$',
+ 'snippet' : [
+ 'special.exp1(z)',
+ ],
+ },
+
+ {
+ 'name' : 'expi: Exponential integral $\\mathrm{Ei}$',
+ 'snippet' : [
+ 'special.expi(x)',
+ ],
+ },
+
+ {
+ 'name' : 'factorial: The factorial function, $n! = \\Gamma(n+1)$',
+ 'snippet' : [
+ 'special.factorial(n, exact=False)',
+ ],
+ },
+
+ {
+ 'name' : 'factorial2: Double factorial $n!!$',
+ 'snippet' : [
+ 'special.factorial2(n, exact=False)',
+ ],
+ },
+
+ {
+ 'name' : 'factorialk: $n(!!...!)$ = multifactorial of order $k$',
+ 'snippet' : [
+ 'special.factorialk(n, k, exact=False)',
+ ],
+ },
+
+ {
+ 'name' : 'shichi: Hyperbolic sine and cosine integrals',
+ 'snippet' : [
+ 'special.shichi(x)',
+ ],
+ },
+
+ {
+ 'name' : 'sici: Sine and cosine integrals',
+ 'snippet' : [
+ 'special.sici(x)',
+ ],
+ },
+
+ {
+ 'name' : 'spence: Dilogarithm integral',
+ 'snippet' : [
+ 'special.spence(x)',
+ ],
+ },
+
+ {
+ 'name' : 'lambertw: Lambert $W$ function [R497]',
+ 'snippet' : [
+ 'special.lambertw(z[, k, tol])',
+ ],
+ },
+
+ {
+ 'name' : 'zeta: Hurwitz $\\zeta$ function',
+ 'snippet' : [
+ 'special.zeta(x, q)',
+ ],
+ },
+
+ {
+ 'name' : 'zetac: Riemann $\\zeta$ function minus 1',
+ 'snippet' : [
+ 'special.zetac(x)',
+ ],
+ },
+
+ ],
+ },
+
+ {
+ 'name' : 'Convenience Functions',
+ 'sub-menu' : [
+
+ {
+ 'name' : 'cbrt: $\\sqrt[3]{x}$',
+ 'snippet' : [
+ 'special.cbrt(x)',
+ ],
+ },
+
+ {
+ 'name' : 'exp10: $10^x$',
+ 'snippet' : [
+ 'special.exp10(x)',
+ ],
+ },
+
+ {
+ 'name' : 'exp2: $2^x$',
+ 'snippet' : [
+ 'special.exp2(x)',
+ ],
+ },
+
+ {
+ 'name' : 'radian: Convert from degrees to radians',
+ 'snippet' : [
+ 'special.radian(d, m, s)',
+ ],
+ },
+
+ {
+ 'name' : 'cosdg: Cosine of the angle given in degrees',
+ 'snippet' : [
+ 'special.cosdg(x)',
+ ],
+ },
+
+ {
+ 'name' : 'sindg: Sine of angle given in degrees',
+ 'snippet' : [
+ 'special.sindg(x)',
+ ],
+ },
+
+ {
+ 'name' : 'tandg: Tangent of angle given in degrees',
+ 'snippet' : [
+ 'special.tandg(x)',
+ ],
+ },
+
+ {
+ 'name' : 'cotdg: Cotangent of the angle given in degrees',
+ 'snippet' : [
+ 'special.cotdg(x)',
+ ],
+ },
+
+ {
+ 'name' : 'log1p: Calculates $\\log(1+x)$ for use when $x$ is near zero',
+ 'snippet' : [
+ 'special.log1p(x)',
+ ],
+ },
+
+ {
+ 'name' : 'expm1: $\\exp(x) - 1$ for use when $x$ is near zero',
+ 'snippet' : [
+ 'special.expm1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'cosm1: $\\cos(x) - 1$ for use when $x$ is near zero',
+ 'snippet' : [
+ 'special.cosm1(x)',
+ ],
+ },
+
+ {
+ 'name' : 'round: Round to nearest integer',
+ 'snippet' : [
+ 'special.round(x)',
+ ],
+ },
+
+ {
+ 'name' : 'xlogy: Compute $x\\, \\log(y)$ so that the result is 0 if $x$ = 0',
+ 'snippet' : [
+ 'special.xlogy(x, y)',
+ ],
+ },
+
+ {
+ 'name' : 'xlog1py: Compute $x\\, \\log(1+y)$ so that the result is 0 if $x$ = 0',
+ 'snippet' : [
+ 'special.xlog1py(x, y)',
+ ],
+ },
+ ],
+ },
+
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_assumptions.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_assumptions.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa354d390559afa374e188358ce4479cc76ee7f4
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_assumptions.js
@@ -0,0 +1,109 @@
+define({
+ 'name' : 'List of assumptions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Bounded',
+ 'snippet' : ['Q.bounded(x)',],
+ },
+ {
+ 'name' : 'Commutative',
+ 'snippet' : ['Q.commutative(x)',],
+ },
+ {
+ 'name' : 'Complex',
+ 'snippet' : ['Q.complex(x)',],
+ },
+ {
+ 'name' : 'Imaginary',
+ 'snippet' : ['Q.imaginary(x)',],
+ },
+ {
+ 'name' : 'Real',
+ 'snippet' : ['Q.real(x)',],
+ },
+ {
+ 'name' : 'Extended real',
+ 'snippet' : ['Q.extended_real(x)',],
+ },
+ {
+ 'name' : 'Integer',
+ 'snippet' : ['Q.integer(x)',],
+ },
+ {
+ 'name' : 'Odd',
+ 'snippet' : ['Q.odd(x)',],
+ },
+ {
+ 'name' : 'Even',
+ 'snippet' : ['Q.even(x)',],
+ },
+ {
+ 'name' : 'Prime',
+ 'snippet' : ['Q.prime(x)',],
+ },
+ {
+ 'name' : 'Composite',
+ 'snippet' : ['Q.composite(x)',],
+ },
+ {
+ 'name' : 'Zero',
+ 'snippet' : ['Q.zero(x)',],
+ },
+ {
+ 'name' : 'Nonzero',
+ 'snippet' : ['Q.nonzero(x)',],
+ },
+ {
+ 'name' : 'Rational',
+ 'snippet' : ['Q.rational(x)',],
+ },
+ {
+ 'name' : 'Algebraic',
+ 'snippet' : ['Q.algebraic(x)',],
+ },
+ {
+ 'name' : 'Transcendental',
+ 'snippet' : ['Q.transcendental(x)',],
+ },
+ {
+ 'name' : 'Irrational',
+ 'snippet' : ['Q.irrational(x)',],
+ },
+ {
+ 'name' : 'Finite',
+ 'snippet' : ['Q.finite(x)',],
+ },
+ {
+ 'name' : 'Infinite',
+ 'snippet' : ['Q.infinite(x)',],
+ },
+ {
+ 'name' : 'Infinitesimal',
+ 'snippet' : ['Q.infinitesimal(x)',],
+ },
+ {
+ 'name' : 'Negative',
+ 'snippet' : ['Q.negative(x)',],
+ },
+ {
+ 'name' : 'Nonnegative',
+ 'snippet' : ['Q.nonnegative(x)',],
+ },
+ {
+ 'name' : 'Positive',
+ 'snippet' : ['Q.positive(x)',],
+ },
+ {
+ 'name' : 'Nonpositive',
+ 'snippet' : ['Q.nonpositive(x)',],
+ },
+ {
+ 'name' : 'Hermitian',
+ 'snippet' : ['Q.hermitian(x)',],
+ },
+ {
+ 'name' : 'Antihermitian',
+ 'snippet' : ['Q.antihermitian(x)',],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_functions.js b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_functions.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4beb035cf230cec9e8c55caa6de24b0e59e8402
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy_functions.js
@@ -0,0 +1,640 @@
+define({
+ // See for a full list
+ 'name' : 'Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Elementary functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Abs',
+ 'snippet' : ['Abs(-1)',],
+ },
+ {
+ 'name' : 'acos',
+ 'snippet' : ['acos(S(1)/2)',],
+ },
+ {
+ 'name' : 'acosh',
+ 'snippet' : ['acosh(S(1)/2)',],
+ },
+ {
+ 'name' : 'acot',
+ 'snippet' : ['acot(1)',],
+ },
+ {
+ 'name' : 'acoth',
+ 'snippet' : ['acoth(I)',],
+ },
+ {
+ 'name' : 'arg',
+ 'snippet' : ['arg(exp(pi*I))',],
+ },
+ {
+ 'name' : 'asin',
+ 'snippet' : ['asin(S(1)/2)',],
+ },
+ {
+ 'name' : 'asinh',
+ 'snippet' : ['asinh(I)',],
+ },
+ {
+ 'name' : 'atan',
+ 'snippet' : ['atan(1)',],
+ },
+ {
+ 'name' : 'atan2',
+ 'snippet' : ['atan2(1,sqrt(3))',],
+ },
+ {
+ 'name' : 'atanh',
+ 'snippet' : ['atanh(I)',],
+ },
+ {
+ 'name' : 'ceiling',
+ 'snippet' : ['ceiling(S(3)/2)',],
+ },
+ {
+ 'name' : 'conjugate',
+ 'snippet' : ['conjugate(1+I)',],
+ },
+ {
+ 'name' : 'cos',
+ 'snippet' : ['cos(2*pi/3)',],
+ },
+ {
+ 'name' : 'cosh',
+ 'snippet' : ['cosh(pi*I/3)',],
+ },
+ {
+ 'name' : 'cot',
+ 'snippet' : ['cot(pi/4)',],
+ },
+ {
+ 'name' : 'coth',
+ 'snippet' : ['coth(pi*I/4)',],
+ },
+ {
+ 'name' : 'exp',
+ 'snippet' : ['exp(1+I)',],
+ },
+ {
+ 'name' : 'floor',
+ 'snippet' : ['floor(S(3)/2)',],
+ },
+ {
+ 'name' : 'Identity function',
+ 'snippet' : ['Id(x)',],
+ },
+ {
+ 'name' : 'im',
+ 'snippet' : ['im(2+3*I)',],
+ },
+ {
+ 'name' : 'Lambert W (a.k.a. product logarithm)',
+ 'snippet' : ['LambertW(x, n)',],
+ },
+ {
+ 'name' : 'log',
+ 'snippet' : ['log(x)',],
+ },
+ {
+ 'name' : 'Min',
+ 'snippet' : [
+ 'p = Symbol("p", negative=True)',
+ 'q = Symbol("q", positive=True)',
+ 'Min(p, q)',
+ ],
+ },
+ {
+ 'name' : 'Max',
+ 'snippet' : [
+ 'p = Symbol("p", negative=True)',
+ 'q = Symbol("q", positive=True)',
+ 'Max(p, q)',
+ ],
+ },
+ {
+ 'name' : 'Piecewise',
+ 'snippet' : ['Piecewise((0, x<1), (x**2, x>=5), (log(x), True))',],
+ },
+ {
+ 'name' : 'Product logarithm',
+ 'snippet' : ['LambertW(x)',],
+ },
+ {
+ 'name' : 're',
+ 'snippet' : ['re(2+I)',],
+ },
+ {
+ 'name' : 'root',
+ 'snippet' : ['root(-8, 3)',],
+ },
+ {
+ 'name' : 'sin',
+ 'snippet' : ['sin(pi/4)',],
+ },
+ {
+ 'name' : 'sinh',
+ 'snippet' : ['sinh(pi*I/2)',],
+ },
+ {
+ 'name' : 'sqrt',
+ 'snippet' : ['sqrt(4)',],
+ },
+ {
+ 'name' : 'sign',
+ 'snippet' : ['sign(-3)',],
+ },
+ {
+ 'name' : 'tan',
+ 'snippet' : ['tan(pi/4)',],
+ },
+ {
+ 'name' : 'tanh',
+ 'snippet' : ['tanh(pi*I/4)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Combinatorial functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Bell number',
+ 'snippet' : ['bell(n)',],
+ },
+ {
+ 'name' : 'Bell polynomial',
+ 'snippet' : ['bell(n, k)',],
+ },
+ {
+ 'name' : 'Bell polynomial of the second kind',
+ 'snippet' : [
+ 'n = 6',
+ 'k = 2',
+ 'x_j = symbols("x:{0}".format(n-k+1))',
+ 'bell(n, k, x_j)',
+ ],
+ },
+ {
+ 'name' : 'Bernoulli number',
+ 'snippet' : ['bernoulli(n)',],
+ },
+ {
+ 'name' : 'Bernoulli polynomial',
+ 'snippet' : ['bernoulli(n, x)',],
+ },
+ {
+ 'name' : 'Binomial coefficient (nCk)',
+ 'snippet' : ['binomial(n, k)',],
+ },
+ {
+ 'name' : 'Catalan number',
+ 'snippet' : ['catalan(n)',],
+ },
+ {
+ 'name' : 'Euler number',
+ 'snippet' : ['euler(n)',],
+ },
+ {
+ 'name' : 'Factorial',
+ 'snippet' : ['factorial(n)',],
+ },
+ {
+ 'name' : 'Double factorial',
+ 'snippet' : ['factorial2(n)',],
+ },
+ {
+ 'name' : 'Falling factorial',
+ 'snippet' : ['ff(x, k)',],
+ },
+ {
+ 'name' : 'Fibonacci number',
+ 'snippet' : ['fibonacci(n)',],
+ },
+ {
+ 'name' : 'Fibonacci polynomial',
+ 'snippet' : ['fibonacci(n, x)',],
+ },
+ {
+ 'name' : 'Harmonic number',
+ 'snippet' : ['harmonic(n)',],
+ },
+ {
+ 'name' : 'Generalized harmonic number',
+ 'snippet' : ['harmonic(n, m)',],
+ },
+ {
+ 'name' : 'Lucas number',
+ 'snippet' : ['lucas(n)',],
+ },
+ {
+ 'name' : 'Rising factorial',
+ 'snippet' : ['rf(x, k)',],
+ },
+ {
+ 'name' : 'Stirling number of the second kind',
+ 'snippet' : ['stirling(n, k)',],
+ },
+ {
+ 'name' : 'Stirling number of the first kind',
+ 'snippet' : ['stirling(n, k, kind=1, signed=False)',],
+ },
+ {
+ 'name' : 'Reduced Stirling number of the second kind',
+ 'snippet' : ['stirling(n, k, d)',],
+ },
+ {
+ 'name' : 'Number of combinations of length k among n items',
+ 'snippet' : ['nC(n, k)',],
+ },
+ {
+ 'name' : 'Number of permutations of length k among n items',
+ 'snippet' : ['nP(n, k)',],
+ },
+ {
+ 'name' : 'Number of partitions of length k among n items',
+ 'snippet' : ['nT(n, k)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Special functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Dirac delta function',
+ 'snippet' : ['DiracDelta(x)',],
+ },
+ {
+ 'name' : 'Derivative of Dirac delta function',
+ 'snippet' : ['DiracDelta(x, k)',],
+ },
+ {
+ 'name' : 'Heaviside function',
+ 'snippet' : ['Heaviside(X)',],
+ },
+ {
+ 'name' : 'Gamma, Beta and related Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Gamma function',
+ 'snippet' : ['gamma(x)',],
+ },
+ {
+ 'name' : 'Lower incomplete gamma function',
+ 'snippet' : ['lowergamma(s, x)',],
+ },
+ {
+ 'name' : 'Upper incomplete gamma function',
+ 'snippet' : ['uppergamma(s, x)',],
+ },
+ {
+ 'name' : 'Polygamma function',
+ 'snippet' : ['polygamma(n, z)',],
+ },
+ {
+ 'name' : 'Log Gamma function',
+ 'snippet' : ['loggamma(x)',],
+ },
+ {
+ 'name' : 'Digamma function',
+ 'snippet' : ['digamma(x)',],
+ },
+ {
+ 'name' : 'Trigamma function',
+ 'snippet' : ['trigamma(x)',],
+ },
+ {
+ 'name' : 'Euler Beta function',
+ 'snippet' : ['beta(x, y)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Error Functions and Fresnel Integrals',
+ 'sub-menu' : [
+ {
+ 'name' : 'Gauss error function',
+ 'snippet' : ['erf(x)',],
+ },
+ {
+ 'name' : 'Complementary error function',
+ 'snippet' : ['erfc(x)',],
+ },
+ {
+ 'name' : 'Imaginary error function',
+ 'snippet' : ['erfi(x)',],
+ },
+ {
+ 'name' : 'Two-argument error function',
+ 'snippet' : ['erf2(x, y)',],
+ },
+ {
+ 'name' : 'Inverse error function',
+ 'snippet' : ['erfinv(y)',],
+ },
+ {
+ 'name' : 'Inverse complementary error function',
+ 'snippet' : ['erfcinv(y)',],
+ },
+ {
+ 'name' : 'Inverse two-argument error function',
+ 'snippet' : ['erf2inv(x, y)',],
+ },
+ {
+ 'name' : 'Fresnel integral S',
+ 'snippet' : ['fresnels(z)',],
+ },
+ {
+ 'name' : 'Fresnel integral C',
+ 'snippet' : ['fresnelc(z)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Exponential, Logarithmic and Trigonometric Integrals',
+ 'sub-menu' : [
+ {
+ 'name' : 'Exponential integral',
+ 'snippet' : ['Ei(x)',],
+ },
+ {
+ 'name' : 'Generalised exponential integral',
+ 'snippet' : ['expint(x, z)',],
+ },
+ {
+ 'name' : 'Special case of the generalised exponential integral',
+ 'snippet' : ['E1(z)',],
+ },
+ {
+ 'name' : 'Classical logarithmic integral',
+ 'snippet' : ['li(x)',],
+ },
+ {
+ 'name' : 'Offset logarithmic integral',
+ 'snippet' : ['Li(x)',],
+ },
+ {
+ 'name' : 'Sine integral',
+ 'snippet' : ['Si(z)',],
+ },
+ {
+ 'name' : 'Cosine integral',
+ 'snippet' : ['Ci(z)',],
+ },
+ {
+ 'name' : 'Hyperbolic sine integral',
+ 'snippet' : ['Shi(z)',],
+ },
+ {
+ 'name' : 'Hyperbolic cosine integral',
+ 'snippet' : ['Chi(z)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Bessel Type Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Bessel function of the first kind',
+ 'snippet' : ['besselj(n, z)',],
+ },
+ {
+ 'name' : 'Bessel function of the second kind',
+ 'snippet' : ['bessely(n, z)',],
+ },
+ {
+ 'name' : 'Modified Bessel function of the first kind',
+ 'snippet' : ['besseli(n, z)',],
+ },
+ {
+ 'name' : 'Modified Bessel function of the second kind',
+ 'snippet' : ['besselk(n, z)',],
+ },
+ {
+ 'name' : 'Hankel function of the first kind',
+ 'snippet' : ['hankel1(n, z)',],
+ },
+ {
+ 'name' : 'Hankel function of the second kind',
+ 'snippet' : ['hankel2(n, z)',],
+ },
+ {
+ 'name' : 'Spherical Bessel function of the first kind',
+ 'snippet' : ['jn(n, z)',],
+ },
+ {
+ 'name' : 'Spherical Bessel function of the second kind',
+ 'snippet' : ['yn(n, z)',],
+ },
+ {
+ 'name' : 'Zeros of the spherical Bessel function of the first kind',
+ 'snippet' : ['jn_zeros(n, k)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Airy Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Airy function of the first kind',
+ 'snippet' : ['airyai(z)',],
+ },
+ {
+ 'name' : 'Airy function of the second kind',
+ 'snippet' : ['airybi(z)',],
+ },
+ {
+ 'name' : 'Derivative of the Airy function of the first kind',
+ 'snippet' : ['airyaiprime(z)',],
+ },
+ {
+ 'name' : 'Derivative of the Airy function of the second kind',
+ 'snippet' : ['airybiprime(z)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'B-Splines',
+ 'sub-menu' : [
+ {
+ 'name' : 'The n-th B-spline at x of degree d with given knots',
+ 'snippet' : [
+ 'd = 3',
+ 'knots = range(5)',
+ 'n = 0',
+ 'bspline_basis(d, knots, n, x, close=True)',
+ ],
+ },
+ {
+ 'name' : 'The B-splines at x of degree d with given knots',
+ 'snippet' : ['bspline_basis_set(d, knots, x)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Riemann Zeta and Related Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Riemann zeta function',
+ 'snippet' : ['zeta(s, 1)',],
+ },
+ {
+ 'name' : 'Hurwitz zeta function',
+ 'snippet' : ['zeta(s, a)',],
+ },
+ {
+ 'name' : 'Dirichlet eta function',
+ 'snippet' : ['eta(s)',],
+ },
+ {
+ 'name' : 'Polylogarithm function',
+ 'snippet' : ['polylog(s, z)',],
+ },
+ {
+ 'name' : 'Lerch transcendent (Lerch phi function)',
+ 'snippet' : ['lerchphi(z, s, a)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Hypergeometric Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Generalized hypergeometric function',
+ 'snippet' : [
+ 'p = 3',
+ 'q = 2',
+ 'a_j = symbols("a:{0}".format(p)) # numerator parameters',
+ 'b_k = symbols("b:{0}".format(q)) # denominator parameters',
+ 'hyper(a_j, b_k)',
+ ],
+ },
+ {
+ 'name' : 'Meijer G-function',
+ 'snippet' : [
+ 'm,n = 1,2',
+ 'p,q = 4,1',
+ 'a_j = symbols("a:{0}".format(p)) # numerator parameters',
+ 'b_k = symbols("b:{0}".format(q)) # denominator parameters',
+ 'meijerg(a_j[:n], a_j[n:p], b_k[:m], b_k[m:q], x)',
+ ],
+ },
+ ],
+ },
+ {
+ 'name' : 'Elliptic integrals',
+ 'sub-menu' : [
+ {
+ 'name' : 'Complete elliptic integral of the first kind',
+ 'snippet' : ['elliptic_k(z)',],
+ },
+ {
+ 'name' : 'Legendre incomplete elliptic integral of the first kind',
+ 'snippet' : ['elliptic_f(z, m)',],
+ },
+ {
+ 'name' : 'Legendre incomplete elliptic integral of the second kind',
+ 'snippet' : ['elliptic_e(z, m)',],
+ },
+ {
+ 'name' : 'Legendre incomplete elliptic integral of the third kind',
+ 'snippet' : ['elliptic_pi(n, z, m)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Orthogonal Polynomials',
+ 'sub-menu' : [
+ {
+ 'name' : 'Jacobi polynomial',
+ 'snippet' : ['jacobi(n, a, b, x)',],
+ },
+ {
+ 'name' : 'Normalized Jacobi polynomial',
+ 'snippet' : ['jacobi_normalized(n, a, b, x)',],
+ },
+ {
+ 'name' : 'Gegenbauer polynomial',
+ 'snippet' : ['gegenbauer(n, a, x)',],
+ },
+ {
+ 'name' : 'Chebyshev polynomial of the first kind',
+ 'snippet' : ['chebyshevt(n, x)',],
+ },
+ {
+ 'name' : 'Chebyshev polynomial of the second kind',
+ 'snippet' : ['chebyshevu(n, x)',],
+ },
+ {
+ 'name' : 'Root k of the nth Chebyshev polynomial of the first kind',
+ 'snippet' : ['chebyshevt_root(n, k)',],
+ },
+ {
+ 'name' : 'Root k of the nth Chebyshev polynomial of the second kind',
+ 'snippet' : ['chebyshevu_root(n, k)',],
+ },
+ {
+ 'name' : 'Legendre polynomial',
+ 'snippet' : ['legendre(n, x)',],
+ },
+ {
+ 'name' : 'Associated Legendre polynomial',
+ 'snippet' : ['assoc_legendre(n, m, x)',],
+ },
+ {
+ 'name' : 'Hermite polynomial',
+ 'snippet' : ['hermite(n, x)',],
+ },
+ {
+ 'name' : 'Laguerre polynomial',
+ 'snippet' : ['laguerre(n, x)',],
+ },
+ {
+ 'name' : 'Generalized (associated) Laguerre polynomial',
+ 'snippet' : ['assoc_laguerre(n, a, x)',],
+ },
+ ],
+ },
+ {
+ 'name' : 'Spherical Harmonics',
+ 'sub-menu' : [
+ {
+ 'name' : 'Spherical harmonics',
+ 'snippet' : [
+ 'vartheta, varphi = symbols("vartheta, varphi", real=True)',
+ 'Ynm(n, m, vartheta, varphi)',
+ ],
+ },
+ {
+ 'name' : 'Conjugate spherical harmonics',
+ 'snippet' : [
+ 'vartheta, varphi = symbols("vartheta, varphi", real=True)',
+ 'Ynm_c(n, m, vartheta, varphi)',
+ ],
+ },
+ {
+ 'name' : 'Real spherical harmonics',
+ 'snippet' : [
+ 'vartheta, varphi = symbols("vartheta, varphi", real=True)',
+ 'Znm(n, m, vartheta, varphi)',
+ ],
+ },
+ ],
+ },
+ {
+ 'name' : 'Tensor Functions',
+ 'sub-menu' : [
+ {
+ 'name' : 'Levi-Civita symbol',
+ 'snippet' : ['LeviCivita(0,1,2,3)',],
+ },
+ {
+ 'name' : 'Kronecker delta',
+ 'snippet' : ['KroneckerDelta(1,2)',],
+ },
+ ],
+ },
+ ],
+ },
+ ],
+});
diff --git a/.local/share/jupyter/nbextensions/spellchecker/README.md b/.local/share/jupyter/nbextensions/spellchecker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d1aaefc82854481c2e0a80489dc7b6ec2acdc87
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/README.md
@@ -0,0 +1,125 @@
+Spellchecker
+============
+
+This nbextension provides a CodeMirror overlay mode to highlight incorrectly
+spelled words in Markdown and Raw cells:
+
+
+
+It was inspired in part by
+[sparksuite/codemirror-spell-checker](https://github.com/sparksuite/codemirror-spell-checker/blob/78773ebdd6c8cf8acd043342023636ae345ca0f3/src/js/spell-checker.js)
+at the
+[suggestion](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/521)
+of [@jankatins](https://github.com/jankatins).
+
+
+Spellchecking
+-------------
+
+The actual spellchecking is performed by the
+[Typo.js](https://github.com/cfinke/Typo.js) library, which is included as a
+dependency, with its own license.
+Typo.js allows the use of
+[hunspell](https://en.wikipedia.org/wiki/Hunspell)-style dictionaries in a
+javascript-based spellchecker.
+
+
+Dictionaries
+------------
+
+The dictionaries used by the nbextension are fetched according to the
+parameters stored in config. To keep this repository lightweight, no
+dictionaries are incuded, and by default the nbextension fetches an `en_US`
+dictionary from the [jsdelivr.net cdn](https://www.jsdelivr.com/).
+However, you can also add your own dictionaries for other languages, or to
+remove dependency on the cdn (and thus make the nbextension usable offline).
+To use your own dictionary, you'll need to alter the `.aff` and `.dic` urls in
+the nbextension's config.
+The urls can be relative (for files on your jupyter server) or absolute (for
+files hosted elsewhere, e.g. on a cdn, like the defaults).
+
+This is probably easiest to understand with some explicit examples.
+Let's say I want to install a `de_DE` dictionary.
+I can get the hunspell files from anywhere I like, but in this example I'm
+going to download copies of the ones listed in the
+[chromium source distribution](https://chromium.googlesource.com/chromium/deps/hunspell_dictionaries/+/master),
+which includes quite a lot of different languages.
+I place my downloaded dictionary `.aff` and `.dic` files inside the
+nbextension in the jupyter data directory, such that the directory structure
+looks like the following:
+
+ spellchecker/
+ README.md
+ config.yaml
+ main.css
+ main.js
+ screenshot.png
+ typo/
+ LICENSE.txt
+ typo.js
+ dictionaries/
+ de_DE.aff
+ de_DE.dic
+
+
+Then, I need to set the urls in the config to give the location of the
+dictinaries relative to the `spellchecker/main.js` file and starting with `./`.
+So, in this case, I would use `./typo/dictionaries/de_DE.aff` and
+`./typo/dictionaries/de_DE.dic`.
+
+To install the dictionaries into the per-user `jupyter_data_dir()`, you can use
+the following python snippet with the appropriate language code to fetch and
+save the appropriate files, and configure the nbextension to use the
+newly-installed language:
+
+```python
+from __future__ import print_function
+
+import base64
+import os.path
+
+from jupyter_core.paths import jupyter_data_dir
+from notebook.services.config import ConfigManager
+
+try:
+ from urllib.request import urlopen # Py3
+except ImportError:
+ from urllib import urlopen # Py2
+
+remote_base_url = (
+ 'https://chromium.googlesource.com/' +
+ 'chromium/deps/hunspell_dictionaries/+/master'
+)
+local_base_url = os.path.join(
+ jupyter_data_dir(),
+ 'nbextensions', 'spellchecker', 'typo', 'dictionaries')
+
+lang_code = 'de_DE'
+
+if not os.path.exists(local_base_url):
+ print('creating directory {!r}'.format(local_base_url))
+ os.makedirs(os.path.realpath(local_base_url))
+
+cm = ConfigManager()
+for ext in ('dic', 'aff'):
+ dict_fname = lang_code + '.' + ext
+ remote_path = remote_base_url + '/' + dict_fname + '?format=TEXT'
+ local_path = os.path.join(local_base_url, dict_fname)
+ print('saving {!r}\n to {!r}'.format(remote_path, local_path))
+ with open(local_path, 'wb') as loc_file:
+ base64.decode(urlopen(remote_path), loc_file)
+ rel_path = './typo/dictionaries/' + dict_fname
+ cm.update('notebook', {'spellchecker': {ext + '_url': rel_path}})
+
+cm.update('notebook', {'spellchecker': {'lang_code': lang_code}})
+```
+
+The above is also included as part of the nbextension, and should be
+[available here](./download_new_dict.py).
+
+
+Internals
+---------
+
+Any mispelled word has the css class `cm-spell-error` applied to it, so you can
+customize their styling in your `custom.css` file if you'd like.
diff --git a/.local/share/jupyter/nbextensions/spellchecker/config.yaml b/.local/share/jupyter/nbextensions/spellchecker/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9931bad6f83353af3e213ac439cc5c08044b0ca1
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/config.yaml
@@ -0,0 +1,27 @@
+Type: IPython Notebook Extension
+Compatibility: 4.x, 5.x
+Name: spellchecker
+Main: main.js
+Description: 'Adds a CodeMirror overlay mode for Typo.js spellchecking'
+Link: README.md
+Parameters:
+- name: spellchecker.enable_on_load
+ input_type: checkbox
+ description: enable spellchecker for all Markdown/Raw cells on notebook load
+ default: true
+- name: spellchecker.add_toolbar_button
+ input_type: checkbox
+ description: add a toolbar button to toggle spellchecker on and off for all Markdown/Raw cells
+ default: true
+- name: spellchecker.lang_code
+ intput_type: text
+ description: language code to use with typo.js
+ default: 'en_US'
+- name: spellchecker.dic_url
+ intput_type: url
+ description: url for the dictionary .dic file to use
+ default: 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.dic'
+- name: spellchecker.aff_url
+ intput_type: url
+ description: url for the dictionary .aff file to use
+ default: 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.aff'
diff --git a/.local/share/jupyter/nbextensions/spellchecker/download_new_dict.py b/.local/share/jupyter/nbextensions/spellchecker/download_new_dict.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ef52850aa5ffcd904b9fdd197d2dd25326de790
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/download_new_dict.py
@@ -0,0 +1,39 @@
+from __future__ import print_function
+
+import base64
+import os.path
+
+from jupyter_core.paths import jupyter_data_dir
+from notebook.services.config import ConfigManager
+
+try:
+ from urllib.request import urlopen # Py3
+except ImportError:
+ from urllib import urlopen # Py2
+
+remote_base_url = (
+ 'https://chromium.googlesource.com/' +
+ 'chromium/deps/hunspell_dictionaries/+/master'
+)
+local_base_url = os.path.join(
+ jupyter_data_dir(),
+ 'nbextensions', 'spellchecker', 'typo', 'dictionaries')
+
+lang_code = 'de_DE'
+
+if not os.path.exists(local_base_url):
+ print('creating directory {!r}'.format(local_base_url))
+ os.makedirs(os.path.realpath(local_base_url))
+
+cm = ConfigManager()
+for ext in ('dic', 'aff'):
+ dict_fname = lang_code + '.' + ext
+ remote_path = remote_base_url + '/' + dict_fname + '?format=TEXT'
+ local_path = os.path.join(local_base_url, dict_fname)
+ print('saving {!r}\n to {!r}'.format(remote_path, local_path))
+ with open(local_path, 'wb') as loc_file:
+ base64.decode(urlopen(remote_path), loc_file)
+ rel_path = './typo/dictionaries/' + dict_fname
+ cm.update('notebook', {'spellchecker': {ext + '_url': rel_path}})
+
+cm.update('notebook', {'spellchecker': {'lang_code': lang_code}})
diff --git a/.local/share/jupyter/nbextensions/spellchecker/main.css b/.local/share/jupyter/nbextensions/spellchecker/main.css
new file mode 100644
index 0000000000000000000000000000000000000000..b66e019c685cdda635a6a7c8a1f7052e099d969c
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/main.css
@@ -0,0 +1,12 @@
+.CodeMirror .cm-spell-error:not(.cm-url):not(.cm-tag):not(.cm-word) {
+ background: rgba(255, 0, 0, .15);
+}
+
+#spellchecker_btn > .fa:after {
+ content: 'abc';
+ position: absolute;
+ top: 2px;
+ left: 4px;
+ text-align: left;
+ font-size: 0.5em;
+}
diff --git a/.local/share/jupyter/nbextensions/spellchecker/main.js b/.local/share/jupyter/nbextensions/spellchecker/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..2829366ab606188a0f7c87155d5e1a316edd2a27
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/main.js
@@ -0,0 +1,201 @@
+define([
+ 'require',
+ 'jquery',
+ 'base/js/events',
+ 'base/js/namespace',
+ 'notebook/js/textcell',
+ 'codemirror/lib/codemirror',
+ './typo/typo'
+], function (
+ requirejs,
+ $,
+ events,
+ Jupyter,
+ textcell,
+ CodeMirror,
+ Typo
+) {
+ 'use strict';
+
+ // parameters (potentially) stored in config. This object gets updated on config load.
+ var params = {
+ enable_on_load : true,
+ add_toolbar_button : true,
+ lang_code : 'en_US',
+ dic_url : 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.dic',
+ aff_url : 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.aff',
+ };
+
+ // Initialize data globally to reduce memory consumption
+ var log_prefix = '[spellchecker]';
+ var dict_load_promise;
+ var typo_dict;
+
+ /**
+ * Load the dictionaries from the param-specified urls
+ *
+ * @return {Promise} - a promise which fulfils when the dictionaries have
+ * been ajax-loaded
+ */
+ function load_dictionary () {
+ if (dict_load_promise === undefined) {
+ dict_load_promise = Promise.all([
+ params.aff_url ? $.ajax({
+ url: requirejs.toUrl(params.aff_url),
+ dataType: 'text'
+ }) : Promise.resolve(''),
+ params.dic_url ? $.ajax({
+ url: requirejs.toUrl(params.dic_url),
+ dataType: 'text'
+ }) : Promise.resolve('')
+ ]).then(function (values) {
+ if (typo_dict === undefined) {
+ typo_dict = new Typo(params.lang_code, values[0], values[1], {
+ platform: 'any'
+ });
+ }
+ return typo_dict;
+ });
+ }
+ return dict_load_promise;
+ }
+
+ /**
+ * rx_word_char defines characters in words,
+ * rx_non_word_char defines the opposite.
+ * Defining both allows a simplified mode token function.
+ * The single quote can be in words, as an apostrophe for contractions like
+ * "isn't", so it's treated as a word character, then stripped from the
+ * start & finish before checking the word against the dictionary.
+ */
+ var rx_word_char = /[^-\[\]{}():\/!;&@$£%§<>"*+=?.,~\\^|_`#±\s\t]/;
+ var rx_non_word_char = /[-\[\]{}():\/!;&@$£%§<>"*+=?.,~\\^|_`#±\s\t]/;
+
+ function define_mode (original_mode_spec) {
+ if (original_mode_spec.indexOf('spellcheck_') === 0) {
+ return original_mode_spec;
+ }
+
+ var new_mode_spec = 'spellcheck_' + original_mode_spec;
+ CodeMirror.defineMode(new_mode_spec, function (config) {
+ var spellchecker_overlay = {
+ name: new_mode_spec,
+ token: function (stream, state) {
+ if (stream.eatWhile(rx_word_char)) {
+ // strip leading and trailing single quotes
+ var word = stream.current().replace(/(^')|('$)/g, '');
+ // we don't consider a set of digits as a word to spellcheck
+ if (!word.match(/^\d+$/) && (typo_dict !== undefined) && !typo_dict.check(word)) {
+ return 'spell-error';
+ }
+ }
+ stream.eatWhile(rx_non_word_char);
+ return null;
+ }
+ };
+ return CodeMirror.overlayMode(
+ CodeMirror.getMode(config, original_mode_spec), spellchecker_overlay, true);
+ });
+ return new_mode_spec;
+ }
+
+ /**
+ * Given a codemirror mode specification string, return the corresponding
+ * string with spellcheck enabled/disabled by adding/removing 'spellcheck_'
+ * from the beginning where necessary
+ *
+ * @param {String} mode - a CodeMirror mode specification string
+ * @param {Boolean} spellcheck_on - whether a spellcheck mode should be returned
+ * @return {String} - the appropriate CodeMirror mode string
+ */
+ function toggle_mode (mode, spellcheck_on) {
+ var new_mode = mode.substr(Boolean(mode.match('^spellcheck_')) ? 11 : 0);
+ if (spellcheck_on) {
+ return define_mode(new_mode);
+ }
+ else {
+ return new_mode;
+ }
+ }
+
+ /**
+ * Toggle spelling checking overlay usage for all text cells
+ *
+ * @param {Boolean} set_on - whether spellcheck mode should be toggled on.
+ * If undefined, it's just toggled from current state
+ * @return {Boolean} - whether the mode was set on
+ */
+ function toggle_spellcheck (set_on) {
+ set_on = (set_on !== undefined) ? set_on : (params.enable_on_load = !params.enable_on_load);
+ // Change defaults for new cells:
+ textcell.MarkdownCell.options_default.cm_config.mode = toggle_mode(
+ textcell.MarkdownCell.options_default.cm_config.mode, set_on
+ );
+ // And change any existing cells:
+ Jupyter.notebook.get_cells().forEach(function (cell, idx, array) {
+ if (cell instanceof textcell.TextCell) {
+ var new_mode = toggle_mode(cell.code_mirror.getOption('mode'), set_on);
+ cell.code_mirror.setOption('mode', new_mode);
+ }
+ });
+ // update button class
+ $('#spellchecker_btn').toggleClass('active', set_on);
+ console.log(log_prefix, 'toggled ' + (set_on ? 'on' : 'off'));
+ return set_on;
+ }
+
+ /**
+ * Add a button to the jupyter toolbar for toggling spellcheck overlay
+ */
+ function add_toolbar_buttons () {
+ return $(Jupyter.toolbar.add_buttons_group([
+ Jupyter.keyboard_manager.actions.register ({
+ help : 'Toggle spell checking on markdown cells',
+ icon : 'fa-check',
+ handler: function (evt) {
+ toggle_spellcheck();
+ setTimeout(function () {
+ evt.currentTarget.blur();
+ }, 100);
+ }
+ }, 'toggle-spellchecking', 'spellchecker')
+ ])).find('.btn').attr('id', 'spellchecker_btn');
+ }
+
+ /**
+ * Add a for a css file to the document head
+ *
+ * @param {String} url - the url of the css file, which will be passed
+ * through requirejs.toUrl, to enable relative urls
+ * @return {jQuery} - a jQuery object containing the link which was added
+ */
+ function add_css (url) {
+ return $('').attr({
+ type : 'text/css',
+ rel : 'stylesheet',
+ href : requirejs.toUrl(url)
+ }).appendTo('head');
+ }
+
+ /**
+ * Initializes the extension
+ */
+ function load_jupyter_extension () {
+ add_css('./main.css');
+
+ return Jupyter.notebook.config.loaded
+ .then(function () {
+ $.extend(true, params, Jupyter.notebook.config.data.spellchecker); // update params
+ if (params.add_toolbar_button) {
+ add_toolbar_buttons();
+ }
+ toggle_spellcheck(params.enable_on_load);
+ })
+ .then(load_dictionary);
+ }
+
+ return {
+ load_jupyter_extension : load_jupyter_extension,
+ load_ipython_extension : load_jupyter_extension,
+ };
+});
diff --git a/.local/share/jupyter/nbextensions/spellchecker/screenshot.png b/.local/share/jupyter/nbextensions/spellchecker/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a6df77a0a50d84892458159a822d58f5b2409d7
Binary files /dev/null and b/.local/share/jupyter/nbextensions/spellchecker/screenshot.png differ
diff --git a/.local/share/jupyter/nbextensions/spellchecker/typo/LICENSE.txt b/.local/share/jupyter/nbextensions/spellchecker/typo/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f1d2f8f095ffaa5bcbe0a25f482a314a87e800c4
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/typo/LICENSE.txt
@@ -0,0 +1,28 @@
+The typo.js file included as part of this nbextension is a requirejs-compatible
+adaptation of typo.js from
+ https://github.com/cfinke/Typo.js/
+essentially just wrapping it in a define call. The license for typo.js follows:
+
+Copyright (c) 2011, Christopher Finke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * The name of the author may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR FINKE BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.local/share/jupyter/nbextensions/spellchecker/typo/typo.js b/.local/share/jupyter/nbextensions/spellchecker/typo/typo.js
new file mode 100644
index 0000000000000000000000000000000000000000..d58a1b99f8d245bd9ffb348d5c914376c84462fe
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/spellchecker/typo/typo.js
@@ -0,0 +1,801 @@
+/**
+this is a requirejs-compatible adaptation of typo.js from
+ https://github.com/cfinke/Typo.js/
+essentially just wrapping it in a define call.
+*/
+
+define(['require'], function (requirejs) {
+'use strict';
+
+/**
+ * Typo is a JavaScript implementation of a spellchecker using hunspell-style
+ * dictionaries.
+ */
+
+/**
+ * Typo constructor.
+ *
+ * @param {String} [dictionary] The locale code of the dictionary being used. e.g.,
+ * "en_US". This is only used to auto-load dictionaries.
+ * @param {String} [affData] The data from the dictionary's .aff file. If omitted
+ * and Typo.js is being used in a Chrome extension, the .aff
+ * file will be loaded automatically from
+ * lib/typo/dictionaries/[dictionary]/[dictionary].aff
+ * In other environments, it will be loaded from
+ * [settings.dictionaryPath]/dictionaries/[dictionary]/[dictionary].aff
+ * @param {String} [wordsData] The data from the dictionary's .dic file. If omitted
+ * and Typo.js is being used in a Chrome extension, the .dic
+ * file will be loaded automatically from
+ * lib/typo/dictionaries/[dictionary]/[dictionary].dic
+ * In other environments, it will be loaded from
+ * [settings.dictionaryPath]/dictionaries/[dictionary]/[dictionary].dic
+ * @param {Object} [settings] Constructor settings. Available properties are:
+ * {String} [dictionaryPath]: path to load dictionary from in non-chrome
+ * environment.
+ * {Object} [flags]: flag information.
+ *
+ *
+ * @returns {Typo} A Typo object.
+ */
+
+var Typo = function (dictionary, affData, wordsData, settings) {
+ settings = settings || {};
+
+ this.dictionary = null;
+
+ this.rules = {};
+ this.dictionaryTable = {};
+
+ this.compoundRules = [];
+ this.compoundRuleCodes = {};
+
+ this.replacementTable = [];
+
+ this.flags = settings.flags || {};
+
+ if (dictionary) {
+ this.dictionary = dictionary;
+
+ if (typeof window !== 'undefined' && 'chrome' in window && 'extension' in window.chrome && 'getURL' in window.chrome.extension) {
+ if (!affData) affData = this._readFile(chrome.extension.getURL("lib/typo/dictionaries/" + dictionary + "/" + dictionary + ".aff"));
+ if (!wordsData) wordsData = this._readFile(chrome.extension.getURL("lib/typo/dictionaries/" + dictionary + "/" + dictionary + ".dic"));
+ } else {
+ if (settings.dictionaryPath) {
+ var path = settings.dictionaryPath;
+ }
+ else if (typeof __dirname !== 'undefined') {
+ var path = __dirname + '/dictionaries';
+ }
+ else {
+ var path = './dictionaries';
+ }
+
+ if (!affData) affData = this._readFile(path + "/" + dictionary + "/" + dictionary + ".aff");
+ if (!wordsData) wordsData = this._readFile(path + "/" + dictionary + "/" + dictionary + ".dic");
+ }
+
+ this.rules = this._parseAFF(affData);
+
+ // Save the rule codes that are used in compound rules.
+ this.compoundRuleCodes = {};
+
+ for (var i = 0, _len = this.compoundRules.length; i < _len; i++) {
+ var rule = this.compoundRules[i];
+
+ for (var j = 0, _jlen = rule.length; j < _jlen; j++) {
+ this.compoundRuleCodes[rule[j]] = [];
+ }
+ }
+
+ // If we add this ONLYINCOMPOUND flag to this.compoundRuleCodes, then _parseDIC
+ // will do the work of saving the list of words that are compound-only.
+ if ("ONLYINCOMPOUND" in this.flags) {
+ this.compoundRuleCodes[this.flags.ONLYINCOMPOUND] = [];
+ }
+
+ this.dictionaryTable = this._parseDIC(wordsData);
+
+ // Get rid of any codes from the compound rule codes that are never used
+ // (or that were special regex characters). Not especially necessary...
+ for (var i in this.compoundRuleCodes) {
+ if (this.compoundRuleCodes[i].length == 0) {
+ delete this.compoundRuleCodes[i];
+ }
+ }
+
+ // Build the full regular expressions for each compound rule.
+ // I have a feeling (but no confirmation yet) that this method of
+ // testing for compound words is probably slow.
+ for (var i = 0, _len = this.compoundRules.length; i < _len; i++) {
+ var ruleText = this.compoundRules[i];
+
+ var expressionText = "";
+
+ for (var j = 0, _jlen = ruleText.length; j < _jlen; j++) {
+ var character = ruleText[j];
+
+ if (character in this.compoundRuleCodes) {
+ expressionText += "(" + this.compoundRuleCodes[character].join("|") + ")";
+ }
+ else {
+ expressionText += character;
+ }
+ }
+
+ this.compoundRules[i] = new RegExp(expressionText, "i");
+ }
+ }
+
+ return this;
+};
+
+Typo.prototype = {
+ /**
+ * Loads a Typo instance from a hash of all of the Typo properties.
+ *
+ * @param object obj A hash of Typo properties, probably gotten from a JSON.parse(JSON.stringify(typo_instance)).
+ */
+
+ load : function (obj) {
+ for (var i in obj) {
+ this[i] = obj[i];
+ }
+
+ return this;
+ },
+
+ /**
+ * Read the contents of a file.
+ *
+ * @param {String} path The path (relative) to the file.
+ * @param {String} [charset="ISO8859-1"] The expected charset of the file
+ * @returns string The file data.
+ */
+
+ _readFile : function (path, charset) {
+ if (!charset) charset = "utf8";
+
+ path = requirejs.toUrl(path);
+
+ if (typeof XMLHttpRequest !== 'undefined') {
+ var req = new XMLHttpRequest();
+ req.open("GET", path, false);
+
+ if (req.overrideMimeType)
+ req.overrideMimeType("text/plain; charset=" + charset);
+
+ req.send(null);
+
+ return req.responseText;
+ }
+ else if (typeof requirejs !== 'undefined') {
+ // Node.js
+ var fs = requirejs("fs");
+
+ try {
+ if (fs.existsSync(path)) {
+ var stats = fs.statSync(path);
+
+ var fileDescriptor = fs.openSync(path, 'r');
+
+ var buffer = new Buffer(stats.size);
+
+ fs.readSync(fileDescriptor, buffer, 0, buffer.length, null);
+
+ return buffer.toString(charset, 0, buffer.length);
+ }
+ else {
+ console.log("Path " + path + " does not exist.");
+ }
+ } catch (e) {
+ console.log(e);
+ return '';
+ }
+ }
+ },
+
+ /**
+ * Parse the rules out from a .aff file.
+ *
+ * @param {String} data The contents of the affix file.
+ * @returns object The rules from the file.
+ */
+
+ _parseAFF : function (data) {
+ var rules = {};
+
+ // Remove comment lines
+ data = this._removeAffixComments(data);
+
+ var lines = data.split("\n");
+
+ for (var i = 0, _len = lines.length; i < _len; i++) {
+ var line = lines[i];
+
+ var definitionParts = line.split(/\s+/);
+
+ var ruleType = definitionParts[0];
+
+ if (ruleType == "PFX" || ruleType == "SFX") {
+ var ruleCode = definitionParts[1];
+ var combineable = definitionParts[2];
+ var numEntries = parseInt(definitionParts[3], 10);
+
+ var entries = [];
+
+ for (var j = i + 1, _jlen = i + 1 + numEntries; j < _jlen; j++) {
+ var line = lines[j];
+
+ var lineParts = line.split(/\s+/);
+ var charactersToRemove = lineParts[2];
+
+ var additionParts = lineParts[3].split("/");
+
+ var charactersToAdd = additionParts[0];
+ if (charactersToAdd === "0") charactersToAdd = "";
+
+ var continuationClasses = this.parseRuleCodes(additionParts[1]);
+
+ var regexToMatch = lineParts[4];
+
+ var entry = {};
+ entry.add = charactersToAdd;
+
+ if (continuationClasses.length > 0) entry.continuationClasses = continuationClasses;
+
+ if (regexToMatch !== ".") {
+ if (ruleType === "SFX") {
+ entry.match = new RegExp(regexToMatch + "$");
+ }
+ else {
+ entry.match = new RegExp("^" + regexToMatch);
+ }
+ }
+
+ if (charactersToRemove != "0") {
+ if (ruleType === "SFX") {
+ entry.remove = new RegExp(charactersToRemove + "$");
+ }
+ else {
+ entry.remove = charactersToRemove;
+ }
+ }
+
+ entries.push(entry);
+ }
+
+ rules[ruleCode] = { "type" : ruleType, "combineable" : (combineable == "Y"), "entries" : entries };
+
+ i += numEntries;
+ }
+ else if (ruleType === "COMPOUNDRULE") {
+ var numEntries = parseInt(definitionParts[1], 10);
+
+ for (var j = i + 1, _jlen = i + 1 + numEntries; j < _jlen; j++) {
+ var line = lines[j];
+
+ var lineParts = line.split(/\s+/);
+ this.compoundRules.push(lineParts[1]);
+ }
+
+ i += numEntries;
+ }
+ else if (ruleType === "REP") {
+ var lineParts = line.split(/\s+/);
+
+ if (lineParts.length === 3) {
+ this.replacementTable.push([ lineParts[1], lineParts[2] ]);
+ }
+ }
+ else {
+ // ONLYINCOMPOUND
+ // COMPOUNDMIN
+ // FLAG
+ // KEEPCASE
+ // NEEDAFFIX
+
+ this.flags[ruleType] = definitionParts[1];
+ }
+ }
+
+ return rules;
+ },
+
+ /**
+ * Removes comment lines and then cleans up blank lines and trailing whitespace.
+ *
+ * @param {String} data The data from an affix file.
+ * @return {String} The cleaned-up data.
+ */
+
+ _removeAffixComments : function (data) {
+ // Remove comments
+ data = data.replace(/#.*$/mg, "");
+
+ // Trim each line
+ data = data.replace(/^\s\s*/m, '').replace(/\s\s*$/m, '');
+
+ // Remove blank lines.
+ data = data.replace(/\n{2,}/g, "\n");
+
+ // Trim the entire string
+ data = data.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+
+ return data;
+ },
+
+ /**
+ * Parses the words out from the .dic file.
+ *
+ * @param {String} data The data from the dictionary file.
+ * @returns object The lookup table containing all of the words and
+ * word forms from the dictionary.
+ */
+
+ _parseDIC : function (data) {
+ data = this._removeDicComments(data);
+
+ var lines = data.split("\n");
+ var dictionaryTable = {};
+
+ function addWord(word, rules) {
+ // Some dictionaries will list the same word multiple times with different rule sets.
+ if (!(word in dictionaryTable) || typeof dictionaryTable[word] != 'object') {
+ dictionaryTable[word] = [];
+ }
+
+ dictionaryTable[word].push(rules);
+ }
+
+ // The first line is the number of words in the dictionary.
+ for (var i = 1, _len = lines.length; i < _len; i++) {
+ var line = lines[i];
+
+ var parts = line.split("/", 2);
+
+ var word = parts[0];
+
+ // Now for each affix rule, generate that form of the word.
+ if (parts.length > 1) {
+ var ruleCodesArray = this.parseRuleCodes(parts[1]);
+
+ // Save the ruleCodes for compound word situations.
+ if (!("NEEDAFFIX" in this.flags) || ruleCodesArray.indexOf(this.flags.NEEDAFFIX) == -1) {
+ addWord(word, ruleCodesArray);
+ }
+
+ for (var j = 0, _jlen = ruleCodesArray.length; j < _jlen; j++) {
+ var code = ruleCodesArray[j];
+
+ var rule = this.rules[code];
+
+ if (rule) {
+ var newWords = this._applyRule(word, rule);
+
+ for (var ii = 0, _iilen = newWords.length; ii < _iilen; ii++) {
+ var newWord = newWords[ii];
+
+ addWord(newWord, []);
+
+ if (rule.combineable) {
+ for (var k = j + 1; k < _jlen; k++) {
+ var combineCode = ruleCodesArray[k];
+
+ var combineRule = this.rules[combineCode];
+
+ if (combineRule) {
+ if (combineRule.combineable && (rule.type != combineRule.type)) {
+ var otherNewWords = this._applyRule(newWord, combineRule);
+
+ for (var iii = 0, _iiilen = otherNewWords.length; iii < _iiilen; iii++) {
+ var otherNewWord = otherNewWords[iii];
+ addWord(otherNewWord, []);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (code in this.compoundRuleCodes) {
+ this.compoundRuleCodes[code].push(word);
+ }
+ }
+ }
+ else {
+ addWord(word.trim(), []);
+ }
+ }
+
+ return dictionaryTable;
+ },
+
+
+ /**
+ * Removes comment lines and then cleans up blank lines and trailing whitespace.
+ *
+ * @param {String} data The data from a .dic file.
+ * @return {String} The cleaned-up data.
+ */
+
+ _removeDicComments : function (data) {
+ // I can't find any official documentation on it, but at least the de_DE
+ // dictionary uses tab-indented lines as comments.
+
+ // Remove comments
+ data = data.replace(/^\t.*$/mg, "");
+
+ return data;
+ },
+
+ parseRuleCodes : function (textCodes) {
+ if (!textCodes) {
+ return [];
+ }
+ else if (!("FLAG" in this.flags)) {
+ return textCodes.split("");
+ }
+ else if (this.flags.FLAG === "long") {
+ var flags = [];
+
+ for (var i = 0, _len = textCodes.length; i < _len; i += 2) {
+ flags.push(textCodes.substr(i, 2));
+ }
+
+ return flags;
+ }
+ else if (this.flags.FLAG === "num") {
+ return textCode.split(",");
+ }
+ },
+
+ /**
+ * Applies an affix rule to a word.
+ *
+ * @param {String} word The base word.
+ * @param {Object} rule The affix rule.
+ * @returns {String[]} The new words generated by the rule.
+ */
+
+ _applyRule : function (word, rule) {
+ var entries = rule.entries;
+ var newWords = [];
+
+ for (var i = 0, _len = entries.length; i < _len; i++) {
+ var entry = entries[i];
+
+ if (!entry.match || word.match(entry.match)) {
+ var newWord = word;
+
+ if (entry.remove) {
+ newWord = newWord.replace(entry.remove, "");
+ }
+
+ if (rule.type === "SFX") {
+ newWord = newWord + entry.add;
+ }
+ else {
+ newWord = entry.add + newWord;
+ }
+
+ newWords.push(newWord);
+
+ if ("continuationClasses" in entry) {
+ for (var j = 0, _jlen = entry.continuationClasses.length; j < _jlen; j++) {
+ var continuationRule = this.rules[entry.continuationClasses[j]];
+
+ if (continuationRule) {
+ newWords = newWords.concat(this._applyRule(newWord, continuationRule));
+ }
+ /*
+ else {
+ // This shouldn't happen, but it does, at least in the de_DE dictionary.
+ // I think the author mistakenly supplied lower-case rule codes instead
+ // of upper-case.
+ }
+ */
+ }
+ }
+ }
+ }
+
+ return newWords;
+ },
+
+ /**
+ * Checks whether a word or a capitalization variant exists in the current dictionary.
+ * The word is trimmed and several variations of capitalizations are checked.
+ * If you want to check a word without any changes made to it, call checkExact()
+ *
+ * @see http://blog.stevenlevithan.com/archives/faster-trim-javascript re:trimming function
+ *
+ * @param {String} aWord The word to check.
+ * @returns {Boolean}
+ */
+
+ check : function (aWord) {
+ // Remove leading and trailing whitespace
+ var trimmedWord = aWord.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+
+ if (this.checkExact(trimmedWord)) {
+ return true;
+ }
+
+ // The exact word is not in the dictionary.
+ if (trimmedWord.toUpperCase() === trimmedWord) {
+ // The word was supplied in all uppercase.
+ // Check for a capitalized form of the word.
+ var capitalizedWord = trimmedWord[0] + trimmedWord.substring(1).toLowerCase();
+
+ if (this.hasFlag(capitalizedWord, "KEEPCASE")) {
+ // Capitalization variants are not allowed for this word.
+ return false;
+ }
+
+ if (this.checkExact(capitalizedWord)) {
+ return true;
+ }
+ }
+
+ var lowercaseWord = trimmedWord.toLowerCase();
+
+ if (lowercaseWord !== trimmedWord) {
+ if (this.hasFlag(lowercaseWord, "KEEPCASE")) {
+ // Capitalization variants are not allowed for this word.
+ return false;
+ }
+
+ // Check for a lowercase form
+ if (this.checkExact(lowercaseWord)) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ /**
+ * Checks whether a word exists in the current dictionary.
+ *
+ * @param {String} word The word to check.
+ * @returns {Boolean}
+ */
+
+ checkExact : function (word) {
+ var ruleCodes = this.dictionaryTable[word];
+
+ if (typeof ruleCodes === 'undefined') {
+ // Check if this might be a compound word.
+ if ("COMPOUNDMIN" in this.flags && word.length >= this.flags.COMPOUNDMIN) {
+ for (var i = 0, _len = this.compoundRules.length; i < _len; i++) {
+ if (word.match(this.compoundRules[i])) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+ else if (typeof ruleCodes === 'object') { // this.dictionary['hasOwnProperty'] will be a function.
+ for (var i = 0, _len = ruleCodes.length; i < _len; i++) {
+ if (!this.hasFlag(word, "ONLYINCOMPOUND", ruleCodes[i])) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+ },
+
+ /**
+ * Looks up whether a given word is flagged with a given flag.
+ *
+ * @param {String} word The word in question.
+ * @param {String} flag The flag in question.
+ * @return {Boolean}
+ */
+
+ hasFlag : function (word, flag, wordFlags) {
+ if (flag in this.flags) {
+ if (typeof wordFlags === 'undefined') {
+ var wordFlags = Array.prototype.concat.apply([], this.dictionaryTable[word]);
+ }
+
+ if (wordFlags && wordFlags.indexOf(this.flags[flag]) !== -1) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ /**
+ * Returns a list of suggestions for a misspelled word.
+ *
+ * @see http://www.norvig.com/spell-correct.html for the basis of this suggestor.
+ * This suggestor is primitive, but it works.
+ *
+ * @param {String} word The misspelling.
+ * @param {Number} [limit=5] The maximum number of suggestions to return.
+ * @returns {String[]} The array of suggestions.
+ */
+
+ alphabet : "",
+
+ suggest : function (word, limit) {
+ if (!limit) limit = 5;
+
+ if (this.check(word)) return [];
+
+ // Check the replacement table.
+ for (var i = 0, _len = this.replacementTable.length; i < _len; i++) {
+ var replacementEntry = this.replacementTable[i];
+
+ if (word.indexOf(replacementEntry[0]) !== -1) {
+ var correctedWord = word.replace(replacementEntry[0], replacementEntry[1]);
+
+ if (this.check(correctedWord)) {
+ return [ correctedWord ];
+ }
+ }
+ }
+
+ var self = this;
+ self.alphabet = "abcdefghijklmnopqrstuvwxyz";
+
+ /*
+ if (!self.alphabet) {
+ // Use the alphabet as implicitly defined by the words in the dictionary.
+ var alphaHash = {};
+
+ for (var i in self.dictionaryTable) {
+ for (var j = 0, _len = i.length; j < _len; j++) {
+ alphaHash[i[j]] = true;
+ }
+ }
+
+ for (var i in alphaHash) {
+ self.alphabet += i;
+ }
+
+ var alphaArray = self.alphabet.split("");
+ alphaArray.sort();
+ self.alphabet = alphaArray.join("");
+ }
+ */
+
+ function edits1(words) {
+ var rv = [];
+
+ for (var ii = 0, _iilen = words.length; ii < _iilen; ii++) {
+ var word = words[ii];
+
+ var splits = [];
+
+ for (var i = 0, _len = word.length + 1; i < _len; i++) {
+ splits.push([ word.substring(0, i), word.substring(i, word.length) ]);
+ }
+
+ var deletes = [];
+
+ for (var i = 0, _len = splits.length; i < _len; i++) {
+ var s = splits[i];
+
+ if (s[1]) {
+ deletes.push(s[0] + s[1].substring(1));
+ }
+ }
+
+ var transposes = [];
+
+ for (var i = 0, _len = splits.length; i < _len; i++) {
+ var s = splits[i];
+
+ if (s[1].length > 1) {
+ transposes.push(s[0] + s[1][1] + s[1][0] + s[1].substring(2));
+ }
+ }
+
+ var replaces = [];
+
+ for (var i = 0, _len = splits.length; i < _len; i++) {
+ var s = splits[i];
+
+ if (s[1]) {
+ for (var j = 0, _jlen = self.alphabet.length; j < _jlen; j++) {
+ replaces.push(s[0] + self.alphabet[j] + s[1].substring(1));
+ }
+ }
+ }
+
+ var inserts = [];
+
+ for (var i = 0, _len = splits.length; i < _len; i++) {
+ var s = splits[i];
+
+ if (s[1]) {
+ for (var j = 0, _jlen = self.alphabet.length; j < _jlen; j++) {
+ replaces.push(s[0] + self.alphabet[j] + s[1]);
+ }
+ }
+ }
+
+ rv = rv.concat(deletes);
+ rv = rv.concat(transposes);
+ rv = rv.concat(replaces);
+ rv = rv.concat(inserts);
+ }
+
+ return rv;
+ }
+
+ function known(words) {
+ var rv = [];
+
+ for (var i = 0; i < words.length; i++) {
+ if (self.check(words[i])) {
+ rv.push(words[i]);
+ }
+ }
+
+ return rv;
+ }
+
+ function correct(word) {
+ // Get the edit-distance-1 and edit-distance-2 forms of this word.
+ var ed1 = edits1([word]);
+ var ed2 = edits1(ed1);
+
+ var corrections = known(ed1).concat(known(ed2));
+
+ // Sort the edits based on how many different ways they were created.
+ var weighted_corrections = {};
+
+ for (var i = 0, _len = corrections.length; i < _len; i++) {
+ if (!(corrections[i] in weighted_corrections)) {
+ weighted_corrections[corrections[i]] = 1;
+ }
+ else {
+ weighted_corrections[corrections[i]] += 1;
+ }
+ }
+
+ var sorted_corrections = [];
+
+ for (var i in weighted_corrections) {
+ sorted_corrections.push([ i, weighted_corrections[i] ]);
+ }
+
+ function sorter(a, b) {
+ if (a[1] < b[1]) {
+ return -1;
+ }
+
+ return 1;
+ }
+
+ sorted_corrections.sort(sorter).reverse();
+
+ var rv = [];
+
+ for (var i = 0, _len = Math.min(limit, sorted_corrections.length); i < _len; i++) {
+ if (!self.hasFlag(sorted_corrections[i][0], "NOSUGGEST")) {
+ rv.push(sorted_corrections[i][0]);
+ }
+ }
+
+ return rv;
+ }
+
+ return correct(word);
+ }
+};
+
+// Support for use as a node.js module.
+if (typeof module !== 'undefined') {
+ module.exports = Typo;
+}
+
+return Typo;
+});
diff --git a/.local/share/jupyter/nbextensions/splitcell/splitcell.js b/.local/share/jupyter/nbextensions/splitcell/splitcell.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c6522c2ac824ca14d8c6e518e3cbe58724de660
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/splitcell/splitcell.js
@@ -0,0 +1,101 @@
+// Allow for split cells in jupyter notebooks
+
+define([
+ 'base/js/namespace',
+ 'base/js/events'
+], function (
+ Jupyter,
+ events
+) {
+ "use strict";
+
+ //define default config parameter values
+ var params = {
+ toggle_cell_style_keybinding : 'shift-s'
+ };
+
+ //updates default params with any specified in the server's config
+ var update_params = function(){
+ var config = Jupyter.notebook.config;
+ for (var key in params){
+ if (config.data.hasOwnProperty(key)){
+ params[key] = config.data[key];
+ }
+ }
+ };
+
+ var setup = function (){
+ // update defaults
+ update_params();
+
+ //register actions with ActionHandler instance
+ var prefix = 'auto';
+ var name = 'toggle-cell-style';
+ var action = {
+ icon : 'fa-arrows-h',
+ help : 'Toggle split/centered cell style',
+ help_index : 'eb',
+ id : 'split_cells',
+ handler : toggle_cell_style
+ };
+
+ var action_full_name = Jupyter.keyboard_manager.actions.register(action, name, prefix);
+
+ //define keyboard shortucts
+ var command_mode_shortcuts = {};
+ command_mode_shortcuts[params.toggle_cell_style_keybinding] = action_full_name;
+
+ //register keyboard shortucts with keyboard_manager
+ Jupyter.notebook.keyboard_manager.command_shortcuts.add_shortcuts(command_mode_shortcuts);
+ Jupyter.toolbar.add_buttons_group([action_full_name]);
+ };
+
+
+ var toggle_cell_style = function(){
+ var cell = Jupyter.notebook.get_selected_cell();
+ if (!("cell_style" in cell.metadata)){cell.metadata.cell_style = 'split';}
+ else if (cell.metadata.cell_style == 'center'){cell.metadata.cell_style = 'split';}
+ else {cell.metadata.cell_style = 'center';}
+
+ update_cell_style_element(cell);
+ };
+
+ var get_cell_style_html = function(cell_style){
+ console.log(cell_style);
+ if (cell_style == "split")
+ {return "float:left; width:50%;";}
+ return "width:100%;";
+ };
+
+ var update_cell_style_element = function(cell){
+ var cell_style_html = get_cell_style_html(cell.metadata.cell_style);
+ cell.element.attr('style', cell_style_html);
+ };
+
+ function initialize () {
+ // On Load lets set the cell styles correctly
+ var cells = Jupyter.notebook.get_cells();
+ var ncells = Jupyter.notebook.ncells();
+
+ for (var i=0; i 0) {
+ console.log('beautified', $tables.length, 'tables' + wherefound + '...');
+ }
+ }
+
+ function bootstrapify_all (){
+ bootstrapify_tables($('.rendered_html table'));
+ }
+
+ function bootstrapify_output (event, type, value, metadata, $toinsert){
+ bootstrapify_tables($toinsert.find('table'), 'output');
+ }
+
+ function bootstrapify_mdcell (event, mdcell){
+ bootstrapify_tables(mdcell.cell.element.find('table'), 'md');
+ }
+
+ function load_css (name) {
+ $('').attr({
+ type: 'text/css',
+ rel: 'stylesheet',
+ href: requirejs.toUrl(name)
+ }).appendTo('head');
+ }
+
+ var load_jupyter_extension = function () {
+ load_css('./main.css');
+ events.on("notebook_loaded.Notebook", bootstrapify_all);
+ events.on("kernel_ready.Kernel", bootstrapify_all);
+ events.on("output_appended.OutputArea", bootstrapify_output);
+ events.on("rendered.MarkdownCell", bootstrapify_mdcell);
+ };
+
+ return {
+ 'load_jupyter_extension': load_jupyter_extension,
+ 'load_ipython_extension': load_jupyter_extension
+ };
+
+});
diff --git a/.local/share/jupyter/nbextensions/toc2/README.md b/.local/share/jupyter/nbextensions/toc2/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..62db78cddb9d9b889d6eca7afd0aad713f4705f7
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/toc2/README.md
@@ -0,0 +1,149 @@
+# Table of Contents (2)
+
+## Description and main features
+
+The toc2 extension enables to collect all running headers and display them in a floating window, as a sidebar or with a navigation menu. The extension is also draggable, resizable, collapsable, dockable and features automatic numerotation with unique links ids, and an optional toc cell. Sections of currently selected/edited or running cells are highlighted in the toc. Some minor diplay tweaks are also available (moving header tile/menus, widening cells); Finally, the toc can preserved when exporting to html.
+
+### First demo: Floating toc window and SideBar, toc auto-update, section numbering
+
+
+### Second demo: Save as html with toc / Navigation menu
+
+
+### Third demo: Notebook scrolling and Collapsing sections
+
+
+The table of contents is automatically updated when modifications occur in the notebook. The toc window can be moved and resized. It can be docked as a sidebar or dragged from the sidebar into a floating window. The table of contents can be collapsed or the window can be completely hidden. The navigation menu can be enabled/disabled via the nbextensions configuration utility. It can also be resized. The position, dimensions, and states (that is 'collapsed' and 'hidden' states) are remembered (actually stored in the notebook's metadata) and restored on the next session.
+
+There is a configurable option to skip h1 headers from the ToC, to allow their use as a notebook
+title. However, this cause issues in latex exports, where h1 are converted to sections.
+Alternatively, headers of any level can be omitted from being the toc by adding an html tag with the
+css class `tocSkip` at the end of the header line; e.g. as in
+
+```
+## title
+```
+
+The toc window also provides two links in its header for further functionalities:
+
+- the "n" link toggles automatic numerotation of all header lines
+- the "t" link toggles a toc cell in the notebook, which contains the actual table of contents, possibly with the numerotation of the different sections. The position of the toc cell in the notebook can be configured by creating a cell with metadata (View > Cell Toolbar > Edit Metadata): { "toc": 1 }, this cell will then be replaced by the table of contents.
+
+The state of these two toggles is memorized and restored on reload.
+
+
+
+
+## Configuration
+
+The initial configuration can be set using the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator)
+facility, included with
+[jupyter_contrib_nbextnensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions).
+Configurable options include:
+
+- Display Table of Contents as a sidebar (otherwise as a floating window; default: true)
+- Title of the sidebar/window (default: `Contents`)
+- The maximum depth of headers to display on toc (with a default of 4)
+- The state of the toc cell (default: false, ie not present)
+- Title of the toc cell sidebar/window (default: `Table of Contents`)
+- Add a navigation menu (default: true)
+- Widening the display area to fit the browser window (may be useful with sidebar option; default: true)
+- The numbering of headers (true by default)
+- Moving header title and menus on the left (default: true)
+- Marking toc item of first header displayed on viewport when scrolling the notebook (default: true)
+- Skipping h1 headers, useful if you want to use h1 as unnumbered notebook title (default: false)
+- Customization of highlighting the title of currently selected/running sections.
+- Customization of background, fonts, border and highlighting colors in the toc window and navigation menus (as third demo).
+- Collapse/uncollapse ToC2 sections when collapsible_headings is used to collapse/uncollapse notebook sections (default: false).
+
+Some config settings are stored in notebook metadata, so that they can be
+altered per-notebook, as well as setting the default in the configurator.
+The differents states and position of the floating window have reasonable
+defaults and can be modfied per notebook.
+
+
+#### Demo with dark theme
+
+
+## Export
+It is possible to export (most of) table of contents functionalities to html. The idea is to link a relevant part of the javascript
+extension and the css, and add a small script in the html file. This is done using a template by
+```
+jupyter nbconvert FILE.ipynb --template toc
+```
+or
+```
+jupyter nbconvert FILE.ipynb --template toc2
+```
+An exporter is also available. It is now possible to export to html with toc by
+```
+jupyter nbconvert --to html_toc FILE.ipynb
+```
+If you also use latex_envs, you can embed both functionalities while exporting with
+```
+jupyter nbconvert --to html_with_toclenvs FILE.ipynb
+```
+
+For the first template (toc), the files toc2.js and main.css (originally located in `/jupyter_contrib_nbextensions/nbextensions/toc2`)
+must reside in the same directory as intended for the html file.
+In the second template, these files are linked to the
+`ipython-contrib/jupyter_contrib_nbextensions` github website.
+Export configuration (parameters) shall be edited directly in the template
+files (in templates directory `/jupyter_contrib_nbextensions/templates`).
+An option "Save as HTML (with toc)" is also provided in the File menu and
+enables the direct conversion of the actual notebook.
+This option requires the IPython kernel and is not present with other kernels.
+
+
+## Testing
+- At loading of the notebook, configuration and initial rendering of the table of contents were fired on the event "notebook_loaded.Notebook". It happens that the extension is sometimes loaded *after* this event. I now rely on a direct rendering at load and on a combination of "notebook_loaded.Notebook" and "kernel_ready.Kernel".
+
+- This extension also includes a quick workaround as described in [#429](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/pull/429)
+
+## History
+
+- This extension was adapted by minrk in [minrk/ipython_extensions](https://github.com/minrk/ipython_extensions)
+ from [gist.github.com/magican/5574556](https://gist.github.com/magican/5574556)
+- Added to the ipython-contrib/jupyter_contrib_nbextensions repo by @JanSchulz
+- @juhasch, automatic update on markdown rendering,
+- @JanSchulz, enable maths in headers links
+- @jfbercher december 06, 2015 -- Big update: automatic numbering, toc cell, window dragging, configuration parameters
+- @jfbercher december 24, 2015 -- nested numbering in toc-window, following the fix by [@paulovn](https://github.com/minrk/ipython_extensions/pull/53) in @minrk's repo. December 30-31, updated config in toc2.yaml to enable choosing the initial visible state of toc_window via a checkbox ; and now resizable.
+- @slonik-az february 13, 2016. Rewritten toc numberings (more robust version), fixed problems with skipped heading levels, some code cleanup
+- @jfbercher february 21, 2016. Fixed some issues when resizing the toc window. Now avoid overflows, clip the text and add a scrollbar.
+- @jfbercher february 22, 2016. Add current toc number to headings anchors. This enable to get unique anchors for recurring headings with the same text. An anchor with the original ID is still created and can be used (but toc uses the new ones!). It is also possible to directly add an html anchor within the heading text. This is taken into account when building toc links (see comments in code).
+- @jfbercher april 29, 2016. Triggered by @cqcn1991, cf [discussion here](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/532), add a sidebar option. The floating toc window can be dragged and docked as a left sidebar. The sidebar can be dragged out as a floating window. These different states are stored and restored when reloading the notebook. Add html export capability via templates toc.tpl and toc2.tpl (see above).
+- @jfbercher may 04, 2016. Added a "Save as HTML with toc" menu. Added a new "Navigate" menu with presents the contents of the toc. Changed default styling for links in tocs.
+- @jfbercher july 28, 2016. A dedicated exporter was added. It is now possible to export to html with toc by `jupyter nbconvert --to html_toc FILE.ipynb`
+- @jfbercher september 21, 2016. Fixed empty size of navigation menu (if no resize had occur). Changed system/notebook configuration parameters storing, loading and merging.
+- @jfbercher november 16, 2016.
+ - Fixed saving issue due to a race condition in loading/writing metadata; see issues [#1882](https://github.com/jupyter/notebook/issues/1882#issuecomment-260671282) and [#762](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/762)
+ - As suggested by @dinya in [#791](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/791), added highlighting of the section that contains the currently edited/selected/executing cell. Colors can be customized by changing `.toc-item-highlight-select` and `.toc-item-highlight-execute` classes in css.
+ -[update nov 23]. As suggested by @jcb91, the highlight colors can now be configured via the nbextensions--configurator, instead of changing the css.
+- @jfbercher, february 2017.
+ - Threshold (number of headings levels in toc)taken globally as requested in #646 (if it exists, otherwise default)
+ - Make toc2 template inherits from nbextensions template, as mentioned in #847
+ - On header/menu/toolbar resize (resize-header.Page event), resize toc2 sidebar
+ - On 'toggle-all-headers' event from `hide_menubar` extension, resize toc2 sidebar
+ - Remove MathJax preview in headers and links -- addresses (issue 14 in latex_envs)[https://github.com/jfbercher/jupyter_latex_envs/issues/14]
+ - Added a parameter to enable/disable cell widening (which is useful when sideBar is on) - default is to widen - address #871
+ - Updated README to please @KadeG in #871
+- @hiiwave, april 2017.
+ - Support customization of background, fonts, border and highlighting colors in the toc window and navigation menus with PR [#969](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/pull/969)
+- @jfbercher, @louisabraham, @jcb91 July 2017. Add support for skipping h1
+ headings, enabling their use as unnumbered notebook titles
+- @jcb91 with minor contributions by @jfbercher. August 2017. Make toc entries collapsible #1031 with optional synchronization with `collapsible_headings` + some small other tweaks.
+- @jcb91 August 2017. Use amd structure for toc2.js
+- @jfbercher August 2017. Add a mark to the currently displayed section in the table of contents window as user scrolls the notebook, cf #944.
+- @jcb91 October 2017,
+ + correct toc tree construction
+ + simplify toc cell processing
+ + constrain draggable toc to the body
+ + various bits of cleanup
+ + add settings dialog for per-notebook metadata-stored settings
+- @jfbercher Feb 2018, Option to define a number to begin numbering with.
+- @jcb91 March 2018, Add controls for all per-notebook metadata options
+- @jfbercher December 2018, toc2 history. Moves into the toc2 history of jumps into the notebook, using the forward-back browser buttons.
+- @zthxxx, April 2018, fix toc2.js load failed with working in non-live notebook (with navigation menu enabled)
+- @jfbercher April 2018, Some export tuning
diff --git a/.local/share/jupyter/nbextensions/toc2/demo2.gif b/.local/share/jupyter/nbextensions/toc2/demo2.gif
new file mode 100644
index 0000000000000000000000000000000000000000..302fc54208edab663d5ea295a3bb65dcaa0eb0ea
Binary files /dev/null and b/.local/share/jupyter/nbextensions/toc2/demo2.gif differ
diff --git a/.local/share/jupyter/nbextensions/toc2/demo_dark.png b/.local/share/jupyter/nbextensions/toc2/demo_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..8151db9814ddf1575054e26f8158e03df3fc30d4
Binary files /dev/null and b/.local/share/jupyter/nbextensions/toc2/demo_dark.png differ
diff --git a/.local/share/jupyter/nbextensions/toc2/icon.png b/.local/share/jupyter/nbextensions/toc2/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..827f9184f0160d2f80518b78cd33363e5450bc5c
Binary files /dev/null and b/.local/share/jupyter/nbextensions/toc2/icon.png differ
diff --git a/.local/share/jupyter/nbextensions/toc2/image.png b/.local/share/jupyter/nbextensions/toc2/image.png
new file mode 100644
index 0000000000000000000000000000000000000000..7fe1e36a24d0c274d8c7bff36435aff1526328de
Binary files /dev/null and b/.local/share/jupyter/nbextensions/toc2/image.png differ
diff --git a/.local/share/jupyter/nbextensions/toc2/main.js b/.local/share/jupyter/nbextensions/toc2/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..e44ba54434f308ec81acbb4d9e834981f6063197
--- /dev/null
+++ b/.local/share/jupyter/nbextensions/toc2/main.js
@@ -0,0 +1,207 @@
+// Adapted from https://gist.github.com/magican/5574556
+// by minrk https://github.com/minrk/ipython_extensions
+// See the history of contributions in README.md
+
+define([
+ 'require',
+ 'jquery',
+ 'base/js/namespace',
+ 'base/js/events',
+ 'notebook/js/codecell',
+ 'nbextensions/toc2/toc2'
+], function(
+ requirejs,
+ $,
+ Jupyter,
+ events,
+ codecell,
+ toc2
+) {
+ "use strict";
+
+ // imports
+ var highlight_toc_item = toc2.highlight_toc_item;
+ var table_of_contents = toc2.table_of_contents;
+ var toggle_toc = toc2.toggle_toc;
+ var IPython = Jupyter;
+
+ // extra download as html with toc menu
+ function addSaveAsWithToc() {
+
+ if (parseFloat(Jupyter.version.substr(0, 3)) >= 5.1) {
+ if ($("#download_html_toc").length === 0) {
+ /* Add an entry in the download menu */
+ var downloadEntry = $('HTML with toc (.html) ')
+ $("#download_html").after(downloadEntry)
+ downloadEntry.click(function () {
+ Jupyter.menubar._nbconvert('html_toc', true);
+ });
+ }
+ }
+ else { /* Add a "save a" menu entry for pre 5.1 versions (needs python kernel) */
+ if (IPython.notebook.metadata.kernelspec.language == 'python') {
+ if ($('#save_html_with_toc').length == 0) {
+ $('#save_checkpoint').after("")
+ $('#save_html_with_toc')
+ .append($('').text('Save as HTML (with toc)').attr("href", "#"))
+ .on('click', function (evt) {
+ if (IPython.notebook.metadata.kernelspec.language == 'python') {
+ var code = "!jupyter nbconvert '" + IPython.notebook.notebook_name + "' --template toc2";
+ console.log('[toc2] running:', code);
+ IPython.notebook.kernel.execute(code);
+ }
+ else {
+ alert('Sorry; this only works with a IPython kernel');
+ $('#save_html_with_toc').remove();
+ }
+ });
+ }
+ }
+ else {
+ $('#save_html_with_toc').remove()
+ }
+ }
+ }
+
+ var toc_button = function(cfg) {
+ if (!IPython.toolbar) {
+ events.on("app_initialized.NotebookApp", function (evt) {
+ toc_button(cfg);
+ });
+ return;
+ }
+ if ($("#toc_button").length === 0) {
+ $(IPython.toolbar.add_buttons_group([
+ Jupyter.keyboard_manager.actions.register ({
+ 'help' : 'Table of Contents',
+ 'icon' : 'fa-list',
+ 'handler': function() { toggle_toc(cfg); },
+ }, 'toggle-toc', 'toc2')
+ ])).find('.btn').attr('id', 'toc_button');
+ }
+ };
+
+ var load_css = function() {
+ var link = document.createElement("link");
+ link.type = "text/css";
+ link.rel = "stylesheet";
+ link.href = requirejs.toUrl("./main.css");
+ document.getElementsByTagName("head")[0].appendChild(link);
+ };
+
+ function create_additional_css(cfg) {
+ var sheet = document.createElement('style')
+ sheet.innerHTML = "#toc li > span:hover { background-color: " + cfg.colors.hover_highlight + " }\n" +
+ ".toc-item-highlight-select {background-color: " + cfg.colors.selected_highlight + "}\n" +
+ ".toc-item-highlight-execute {background-color: " + cfg.colors.running_highlight + "}\n" +
+ ".toc-item-highlight-execute.toc-item-highlight-select {background-color: " + cfg.colors.selected_highlight + "}"
+ if (cfg.moveMenuLeft) {
+ sheet.innerHTML += "div#menubar-container, div#header-container {\n" +
+ "width: auto;\n" +
+ "padding-left: 20px; }"
+ }
+ // Using custom colors
+ sheet.innerHTML += "#toc-wrapper { background-color: " + cfg.colors.wrapper_background + "}\n";
+ sheet.innerHTML += "#toc a, #navigate_menu a, .toc { color: " + cfg.colors.navigate_text + "}";
+ sheet.innerHTML += "#toc-wrapper .toc-item-num { color: " + cfg.colors.navigate_num + "}";
+ sheet.innerHTML += ".sidebar-wrapper { border-color: " + cfg.colors.sidebar_border + "}";
+ sheet.innerHTML += ".highlight_on_scroll { border-left: solid 4px " + cfg.colors.on_scroll + '}';
+ document.body.appendChild(sheet);
+ }
+
+
+ var CodeCell = codecell.CodeCell;
+
+ function patch_CodeCell_get_callbacks() {
+
+ var previous_get_callbacks = CodeCell.prototype.get_callbacks;
+ CodeCell.prototype.get_callbacks = function() {
+ var callbacks = previous_get_callbacks.apply(this, arguments);
+ var prev_reply_callback = callbacks.shell.reply;
+ callbacks.shell.reply = function(msg) {
+ if (msg.msg_type === 'execute_reply') {
+ setTimeout(function() {
+ $('.toc .toc-item-highlight-execute').removeClass('toc-item-highlight-execute');
+ rehighlight_running_cells() // re-highlight running cells
+ }, 100);
+ var c = IPython.notebook.get_selected_cell();
+ highlight_toc_item({
+ type: 'selected'
+ }, {
+ cell: c
+ })
+ }
+ return prev_reply_callback(msg);
+ };
+ return callbacks;
+ };
+ }
+
+ function rehighlight_running_cells() {
+ $.each($('.running'), // re-highlight running cells
+ function(idx, elt) {
+ highlight_toc_item({
+ type: "execute"
+ }, $(elt).data())
+ }
+ )
+ }
+
+ var toc_init = function() {
+ // read configuration, then call toc
+ IPython.notebook.config.loaded.then(function () {
+ var cfg = toc2.read_config();
+ // create highlights style section in document
+ create_additional_css(cfg);
+ // add toc toggle button (now that cfg has loaded)
+ toc_button(cfg);
+ // call main function with newly loaded config
+ table_of_contents(cfg);
+ // event: render toc for each markdown cell modification
+ events.on("rendered.MarkdownCell", function(evt, data) {
+ table_of_contents(cfg); // recompute the toc
+ rehighlight_running_cells() // re-highlight running cells
+ highlight_toc_item(evt, data); // and of course the one currently rendered
+ });
+ });
+
+ // event: on cell selection, highlight the corresponding item
+ events.on('select.Cell', highlight_toc_item);
+ // event: if kernel_ready (kernel change/restart): add/remove a menu item
+ events.on("kernel_ready.Kernel", function() {
+ addSaveAsWithToc();
+ })
+
+ // add a save as HTML with toc included
+ addSaveAsWithToc();
+ // Highlight cell on execution
+ patch_CodeCell_get_callbacks()
+ events.on('execute.CodeCell', highlight_toc_item);
+ }
+
+ var load_ipython_extension = function() {
+ load_css(); //console.log("Loading css")
+
+ // Wait for the notebook to be fully loaded
+ if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+ // this tests if the notebook is fully loaded
+ console.log("[toc2] Notebook fully loaded -- toc2 initialized ")
+ toc_init();
+ } else {
+ console.log("[toc2] Waiting for notebook availability")
+ events.on("notebook_loaded.Notebook", function() {
+ console.log("[toc2] toc2 initialized (via notebook_loaded)")
+ toc_init();
+ })
+ }
+
+ };
+
+
+ return {
+ load_ipython_extension: load_ipython_extension,
+ toggle_toc: toggle_toc,
+ table_of_contents: table_of_contents
+ };
+
+});
diff --git a/.local/share/jupyter/nbextensions/toggle_all_line_numbers/icon.png b/.local/share/jupyter/nbextensions/toggle_all_line_numbers/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..606efcd1b5e92aa641b5c3c6178bf907da7cb2b2
Binary files /dev/null and b/.local/share/jupyter/nbextensions/toggle_all_line_numbers/icon.png differ
diff --git a/.triton/dump/1e922bbbab749da355e4bad9c6b245e6/triton_.ttir b/.triton/dump/1e922bbbab749da355e4bad9c6b245e6/triton_.ttir
new file mode 100644
index 0000000000000000000000000000000000000000..dba5072301c93a1b7f84b3d298b47b46546ec357
--- /dev/null
+++ b/.triton/dump/1e922bbbab749da355e4bad9c6b245e6/triton_.ttir
@@ -0,0 +1,25 @@
+module {
+ tt.func public @triton__0d1de(%arg0: !tt.ptr {tt.divisibility = 16 : i32}, %arg1: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}) attributes {noinline = false} {
+ %cst = arith.constant dense<1.000000e+00> : tensor<512xf32>
+ %cst_0 = arith.constant dense<0.707106769> : tensor<512xf32>
+ %cst_1 = arith.constant dense<5.000000e-01> : tensor<512xf32>
+ %c512_i32 = arith.constant 512 : i32
+ %0 = tt.get_program_id x : i32
+ %1 = arith.muli %0, %c512_i32 : i32
+ %2 = tt.make_range {end = 512 : i32, start = 0 : i32} : tensor<512xi32>
+ %3 = tt.splat %1 : (i32) -> tensor<512xi32>
+ %4 = arith.addi %3, %2 : tensor<512xi32>
+ %5 = tt.splat %arg0 : (!tt.ptr) -> tensor<512x!tt.ptr>
+ %6 = tt.addptr %5, %4 : tensor<512x!tt.ptr>, tensor<512xi32>
+ %7 = tt.load %6 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<512xbf16>
+ %8 = arith.extf %7 : tensor<512xbf16> to tensor<512xf32>
+ %9 = arith.mulf %8, %cst_1 : tensor<512xf32>
+ %10 = arith.mulf %8, %cst_0 : tensor<512xf32>
+ %11 = tt.extern_elementwise %10 {libname = "libdevice", libpath = "/usr/local/lib/python3.10/dist-packages/triton/language/../third_party/cuda/lib/libdevice.10.bc", pure = true, symbol = "__nv_erff"} : (tensor<512xf32>) -> tensor<512xf32>
+ %12 = arith.addf %11, %cst : tensor<512xf32>
+ %13 = arith.mulf %9, %12 : tensor<512xf32>
+ %14 = arith.truncf %13 : tensor<512xf32> to tensor<512xbf16>
+ tt.store %6, %14 {cache = 1 : i32, evict = 1 : i32} : tensor<512xbf16>
+ tt.return
+ }
+}
diff --git a/.triton/dump/305a9479aab997a3a16bfe46bb303a50/triton_.ptx b/.triton/dump/305a9479aab997a3a16bfe46bb303a50/triton_.ptx
new file mode 100644
index 0000000000000000000000000000000000000000..efa91b05467a04a32c2a4e9f6c762a4965249519
--- /dev/null
+++ b/.triton/dump/305a9479aab997a3a16bfe46bb303a50/triton_.ptx
@@ -0,0 +1,1041 @@
+//
+// Generated by LLVM NVPTX Back-End
+//
+
+.version 8.2
+.target sm_89
+.address_size 64
+
+ // .globl triton__0d1d2d3d4d5d6de7de
+.extern .func __assertfail
+(
+ .param .b64 __assertfail_param_0,
+ .param .b64 __assertfail_param_1,
+ .param .b32 __assertfail_param_2,
+ .param .b64 __assertfail_param_3,
+ .param .b64 __assertfail_param_4
+)
+;
+.global .align 1 .b8 assertFunc_1[25] = {95, 99, 97, 108, 108, 95, 119, 105, 116, 104, 95, 102, 114, 97, 109, 101, 115, 95, 114, 101, 109, 111, 118, 101, 100};
+.global .align 1 .b8 assertFile_1[38] = {60, 102, 114, 111, 122, 101, 110, 32, 105, 109, 112, 111, 114, 116, 108, 105, 98, 46, 95, 98, 111, 111, 116, 115, 116, 114, 97, 112, 95, 101, 120, 116, 101, 114, 110, 97, 108, 62};
+.global .align 1 .b8 assertMessage_1[39] = {105, 110, 100, 101, 120, 32, 111, 117, 116, 32, 111, 102, 32, 98, 111, 117, 110, 100, 115, 58, 32, 48, 32, 60, 61, 32, 116, 109, 112, 49, 54, 32, 60, 32, 53, 48, 50, 53, 55};
+.global .align 1 .b8 assertFunc_0[25] = {95, 99, 97, 108, 108, 95, 119, 105, 116, 104, 95, 102, 114, 97, 109, 101, 115, 95, 114, 101, 109, 111, 118, 101, 100};
+.global .align 1 .b8 assertFile_0[38] = {60, 102, 114, 111, 122, 101, 110, 32, 105, 109, 112, 111, 114, 116, 108, 105, 98, 46, 95, 98, 111, 111, 116, 115, 116, 114, 97, 112, 95, 101, 120, 116, 101, 114, 110, 97, 108, 62};
+.global .align 1 .b8 assertMessage_0[38] = {105, 110, 100, 101, 120, 32, 111, 117, 116, 32, 111, 102, 32, 98, 111, 117, 110, 100, 115, 58, 32, 48, 32, 60, 61, 32, 116, 109, 112, 51, 32, 60, 32, 53, 48, 50, 53, 55};
+.extern .shared .align 1 .b8 global_smem[];
+.global .align 1 .b8 _$_str[11] = {95, 95, 67, 85, 68, 65, 95, 70, 84, 90, 0};
+
+.visible .entry triton__0d1d2d3d4d5d6de7de(
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_0,
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_1,
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_2,
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_3,
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_4,
+ .param .u64 triton__0d1d2d3d4d5d6de7de_param_5,
+ .param .u32 triton__0d1d2d3d4d5d6de7de_param_6,
+ .param .u32 triton__0d1d2d3d4d5d6de7de_param_7
+)
+.maxntid 64, 1, 1
+{
+ .reg .pred %p<59>;
+ .reg .b16 %rs<13>;
+ .reg .b32 %r<176>;
+ .reg .f32 %f<169>;
+ .reg .b64 %rd<58>;
+ .loc 1 18 0
+$L__func_begin0:
+ .loc 1 18 0
+
+ ld.param.u64 %rd8, [triton__0d1d2d3d4d5d6de7de_param_4];
+ ld.param.u64 %rd7, [triton__0d1d2d3d4d5d6de7de_param_1];
+ ld.param.u64 %rd22, [triton__0d1d2d3d4d5d6de7de_param_0];
+$L__tmp0:
+ .loc 1 24 33
+ mov.u32 %r1, %tid.x;
+ and.b32 %r2, %r1, 31;
+ ld.param.u64 %rd23, [triton__0d1d2d3d4d5d6de7de_param_2];
+ ld.param.u64 %rd24, [triton__0d1d2d3d4d5d6de7de_param_3];
+ bfe.u32 %r3, %r1, 5, 1;
+ shl.b32 %r30, %r1, 2;
+ and.b32 %r4, %r30, 252;
+ .loc 1 21 28
+ mov.u32 %r13, %ctaid.x;
+ .loc 1 26 30
+ mul.wide.s32 %rd25, %r13, 8;
+ add.s64 %rd11, %rd22, %rd25;
+ mov.pred %p53, -1;
+ .loc 1 26 35
+ mov.u64 %rd10, 0x0;
+ @%p53 ld.global.L1::evict_last.b64 { %rd10 }, [ %rd11 + 0 ];
+ mov.u64 %rd12, 0x0;
+ @%p53 ld.global.L1::evict_last.b64 { %rd12 }, [ %rd11 + 0 ];
+ mov.u64 %rd14, 0x0;
+ @%p53 ld.global.L1::evict_last.b64 { %rd14 }, [ %rd11 + 0 ];
+ mov.u64 %rd16, 0x0;
+ @%p53 ld.global.L1::evict_last.b64 { %rd16 }, [ %rd11 + 0 ];
+ mov.u64 %rd18, 0x0;
+ @%p53 ld.global.L1::evict_last.b64 { %rd18 }, [ %rd11 + 0 ];
+ .loc 1 27 18
+ shr.s32 %r31, %r13, 31;
+ shr.u32 %r32, %r31, 23;
+ add.s32 %r33, %r13, %r32;
+ and.b32 %r34, %r33, 16776704;
+ sub.s32 %r35, %r13, %r34;
+ .loc 1 35 44
+ shl.b32 %r36, %r35, 8;
+ .loc 1 35 40
+ or.b32 %r37, %r36, %r4;
+ .loc 1 35 34
+ mul.wide.s32 %rd26, %r37, 4;
+ add.s64 %rd37, %rd23, %rd26;
+ mov.b32 %r151, 0;
+ .loc 1 35 50
+ mov.u32 %r14, 0x0;
+ mov.u32 %r15, 0x0;
+ mov.u32 %r16, 0x0;
+ mov.u32 %r17, 0x0;
+ @%p53 ld.global.L1::evict_last.v4.b32 { %r14, %r15, %r16, %r17 }, [ %rd37 + 0 ];
+ @!%p53 mov.u32 %r14, %r151;
+ @!%p53 mov.u32 %r15, %r151;
+ @!%p53 mov.u32 %r16, %r151;
+ @!%p53 mov.u32 %r17, %r151;
+ mov.b32 %f2, %r14;
+ mov.b32 %f1, %r15;
+ mov.b32 %f3, %r16;
+ mov.b32 %f4, %r17;
+ .loc 1 36 44
+ shl.b32 %r38, %r13, 8;
+ .loc 1 36 40
+ or.b32 %r39, %r38, %r4;
+ .loc 1 36 34
+ mul.wide.s32 %rd27, %r39, 2;
+ add.s64 %rd38, %rd24, %rd27;
+ .loc 1 36 50
+ mov.u32 %r22, 0x0;
+ mov.u32 %r23, 0x0;
+ @%p53 ld.global.L1::evict_last.v2.b32 { %r22, %r23 }, [ %rd38 + 0 ];
+ @!%p53 mov.u32 %r22, %r151;
+ @!%p53 mov.u32 %r23, %r151;
+ cvt.u16.u32 %rs1, %r22;
+ { .reg .b16 tmp; mov.b32 {tmp, %rs2}, %r22; }
+ cvt.u16.u32 %rs3, %r23;
+ { .reg .b16 tmp; mov.b32 {tmp, %rs4}, %r23; }
+ .loc 1 36 101
+ cvt.f32.bf16 %r26, %rs1;
+ mov.b32 %f5, %r26;
+ cvt.f32.bf16 %r27, %rs2;
+ mov.b32 %f6, %r27;
+ cvt.f32.bf16 %r28, %rs3;
+ mov.b32 %f7, %r28;
+ cvt.f32.bf16 %r29, %rs4;
+ mov.b32 %f8, %r29;
+ .loc 1 37 22
+ add.s64 %rd28, %rd18, 50257;
+ .loc 1 38 22
+ setp.lt.s64 %p14, %rd18, 0;
+ .loc 1 39 36
+ selp.b64 %rd5, %rd28, %rd18, %p14;
+ .loc 1 40 40
+ setp.lt.u64 %p15, %rd5, 50257;
+ mov.b32 %r175, 883;
+ mov.u64 %rd57, 1;
+ .loc 1 40 55
+ @%p15 bra $L__BB0_2;
+ mov.u64 %rd29, assertMessage_0;
+ cvta.global.u64 %rd30, %rd29;
+ mov.u64 %rd31, assertFile_0;
+ cvta.global.u64 %rd32, %rd31;
+ mov.u64 %rd33, assertFunc_0;
+ cvta.global.u64 %rd34, %rd33;
+ { // callseq 0, 0
+ .reg .b32 temp_param_reg;
+ .param .b64 param0;
+ st.param.b64 [param0+0], %rd30;
+ .param .b64 param1;
+ st.param.b64 [param1+0], %rd32;
+ .param .b32 param2;
+ st.param.b32 [param2+0], %r175;
+ .param .b64 param3;
+ st.param.b64 [param3+0], %rd34;
+ .param .b64 param4;
+ st.param.b64 [param4+0], %rd57;
+ call.uni
+ __assertfail,
+ (
+ param0,
+ param1,
+ param2,
+ param3,
+ param4
+ );
+ } // callseq 0
+$L__BB0_2:
+ .loc 1 0 55
+ ld.param.u64 %rd9, [triton__0d1d2d3d4d5d6de7de_param_5];
+ cvt.s64.s32 %rd3, %r39;
+ .loc 1 38 22
+ setp.lt.s64 %p44, %rd10, 0;
+ .loc 1 41 44
+ shl.b64 %rd40, %rd10, 8;
+ add.s64 %rd41, %rd40, 12865792;
+ selp.b64 %rd42, %rd41, %rd40, %p44;
+ cvt.u64.u32 %rd43, %r4;
+ .loc 1 41 40
+ or.b64 %rd44, %rd42, %rd43;
+ .loc 1 41 34
+ shl.b64 %rd45, %rd44, 2;
+ add.s64 %rd54, %rd7, %rd45;
+ .loc 1 41 52
+ mov.u32 %r41, 0x0;
+ mov.u32 %r42, 0x0;
+ mov.u32 %r43, 0x0;
+ mov.u32 %r44, 0x0;
+ @%p53 ld.global.L1::evict_last.v4.b32 { %r41, %r42, %r43, %r44 }, [ %rd54 + 0 ];
+ @!%p53 mov.u32 %r41, %r151;
+ @!%p53 mov.u32 %r42, %r151;
+ @!%p53 mov.u32 %r43, %r151;
+ @!%p53 mov.u32 %r44, %r151;
+ mov.b32 %f15, %r43;
+ mov.b32 %f16, %r44;
+ .loc 1 42 22
+ add.f32 %f17, %f3, %f15;
+ add.f32 %f18, %f4, %f16;
+ .loc 1 44 22
+ add.f32 %f19, %f7, %f17;
+ add.f32 %f20, %f8, %f18;
+ .loc 1 41 52
+ mov.b32 %f21, %r41;
+ mov.b32 %f22, %r42;
+ .loc 1 42 22
+ add.f32 %f23, %f1, %f22;
+ add.f32 %f24, %f2, %f21;
+ .loc 1 44 22
+ add.f32 %f25, %f5, %f24;
+ add.f32 %f26, %f6, %f23;
+$L__tmp1:
+ .loc 2 98 22
+ add.f32 %f27, %f26, 0f00000000;
+ add.f32 %f28, %f25, 0f00000000;
+ add.f32 %f29, %f19, 0f00000000;
+ add.f32 %f30, %f20, 0f00000000;
+ .loc 2 101 30
+ sub.f32 %f31, %f25, %f28;
+ sub.f32 %f32, %f26, %f27;
+ sub.f32 %f33, %f19, %f29;
+ sub.f32 %f34, %f20, %f30;
+ .loc 2 101 13
+ fma.rn.f32 %f35, %f25, %f31, 0f00000000;
+ fma.rn.f32 %f36, %f26, %f32, 0f00000000;
+ fma.rn.f32 %f37, %f19, %f33, 0f00000000;
+ fma.rn.f32 %f38, %f20, %f34, 0f00000000;
+$L__tmp2:
+ .loc 2 108 21
+ sub.f32 %f39, %f27, %f28;
+ mov.b32 %r50, 1065353216;
+ mov.b32 %r51, 1073741824;
+ .loc 2 110 60
+ div.full.f32 %r49, %r50, %r51;
+ mov.b32 %f40, %r49;
+ .loc 2 112 17
+ fma.rn.f32 %f41, %f40, %f39, %f28;
+ .loc 2 113 15
+ add.f32 %f42, %f35, %f36;
+ .loc 2 113 30
+ mul.f32 %f43, %f39, %f39;
+ .loc 2 113 22
+ fma.rn.f32 %f44, %f40, %f43, %f42;
+ .loc 2 108 21
+ sub.f32 %f45, %f29, %f41;
+ mov.b32 %r54, 1077936128;
+ .loc 2 110 60
+ div.full.f32 %r52, %r50, %r54;
+ mov.b32 %f46, %r52;
+ .loc 2 112 17
+ fma.rn.f32 %f47, %f46, %f45, %f41;
+ .loc 2 113 15
+ add.f32 %f48, %f37, %f44;
+ .loc 2 113 30
+ mul.f32 %f49, %f45, %f45;
+ .loc 2 113 38
+ fma.rn.f32 %f50, %f45, %f45, %f49;
+ .loc 2 113 22
+ fma.rn.f32 %f51, %f46, %f50, %f48;
+ .loc 2 108 21
+ sub.f32 %f52, %f30, %f47;
+ mov.b32 %r57, 1082130432;
+ .loc 2 110 60
+ div.full.f32 %r55, %r50, %r57;
+ mov.b32 %f53, %r55;
+ .loc 2 112 17
+ fma.rn.f32 %f54, %f53, %f52, %f47;
+ .loc 2 113 15
+ add.f32 %f55, %f38, %f51;
+ .loc 2 113 30
+ mul.f32 %f56, %f52, %f52;
+ .loc 2 113 38
+ mul.f32 %f57, %f56, 0f40400000;
+ .loc 2 113 22
+ fma.rn.f32 %f58, %f53, %f57, %f55;
+$L__tmp3:
+ .loc 2 120 46
+ mov.b32 %r118, %f54;
+ shfl.sync.bfly.b32 %r119, %r118, 16, 31, -1;
+ mov.b32 %f59, %r119;
+ mov.b32 %r120, %f58;
+ shfl.sync.bfly.b32 %r121, %r120, 16, 31, -1;
+ mov.b32 %f60, %r121;
+ shfl.sync.bfly.b32 %r59, %r57, 16, 31, -1;
+ mov.b32 %f61, %r59;
+$L__tmp4:
+ .loc 2 108 21
+ sub.f32 %f62, %f59, %f54;
+ .loc 2 109 28
+ add.f32 %f63, %f61, 0f40800000;
+ .loc 2 110 39
+ setp.eq.f32 %p45, %f63, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r60, %f63;
+ div.full.f32 %r58, %r59, %r60;
+ mov.b32 %f64, %r58;
+ .loc 2 110 49
+ selp.f32 %f65, 0f00000000, %f64, %p45;
+ .loc 2 112 17
+ fma.rn.f32 %f66, %f65, %f62, %f54;
+ .loc 2 113 15
+ add.f32 %f67, %f58, %f60;
+ .loc 2 113 30
+ mul.f32 %f68, %f62, %f62;
+ .loc 2 113 38
+ mul.f32 %f69, %f68, 0f40800000;
+ .loc 2 113 22
+ fma.rn.f32 %f70, %f65, %f69, %f67;
+$L__tmp5:
+ .loc 2 120 46
+ mov.b32 %r122, %f66;
+ shfl.sync.bfly.b32 %r123, %r122, 8, 31, -1;
+ mov.b32 %f71, %r123;
+ mov.b32 %r124, %f70;
+ shfl.sync.bfly.b32 %r125, %r124, 8, 31, -1;
+ mov.b32 %f72, %r125;
+ shfl.sync.bfly.b32 %r62, %r60, 8, 31, -1;
+ mov.b32 %f73, %r62;
+$L__tmp6:
+ .loc 2 108 21
+ sub.f32 %f74, %f71, %f66;
+ .loc 2 109 28
+ add.f32 %f75, %f63, %f73;
+ .loc 2 110 39
+ setp.eq.f32 %p46, %f75, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r63, %f75;
+ div.full.f32 %r61, %r62, %r63;
+ mov.b32 %f76, %r61;
+ .loc 2 110 49
+ selp.f32 %f77, 0f00000000, %f76, %p46;
+ .loc 2 112 17
+ fma.rn.f32 %f78, %f77, %f74, %f66;
+ .loc 2 113 15
+ add.f32 %f79, %f70, %f72;
+ .loc 2 113 30
+ mul.f32 %f80, %f74, %f74;
+ .loc 2 113 38
+ mul.f32 %f81, %f63, %f80;
+ .loc 2 113 22
+ fma.rn.f32 %f82, %f77, %f81, %f79;
+$L__tmp7:
+ .loc 2 120 46
+ mov.b32 %r126, %f78;
+ shfl.sync.bfly.b32 %r127, %r126, 4, 31, -1;
+ mov.b32 %f83, %r127;
+ mov.b32 %r128, %f82;
+ shfl.sync.bfly.b32 %r129, %r128, 4, 31, -1;
+ mov.b32 %f84, %r129;
+ shfl.sync.bfly.b32 %r65, %r63, 4, 31, -1;
+ mov.b32 %f85, %r65;
+$L__tmp8:
+ .loc 2 108 21
+ sub.f32 %f86, %f83, %f78;
+ .loc 2 109 28
+ add.f32 %f87, %f75, %f85;
+ .loc 2 110 39
+ setp.eq.f32 %p47, %f87, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r66, %f87;
+ div.full.f32 %r64, %r65, %r66;
+ mov.b32 %f88, %r64;
+ .loc 2 110 49
+ selp.f32 %f89, 0f00000000, %f88, %p47;
+ .loc 2 112 17
+ fma.rn.f32 %f90, %f89, %f86, %f78;
+ .loc 2 113 15
+ add.f32 %f91, %f82, %f84;
+ .loc 2 113 30
+ mul.f32 %f92, %f86, %f86;
+ .loc 2 113 38
+ mul.f32 %f93, %f75, %f92;
+ .loc 2 113 22
+ fma.rn.f32 %f94, %f89, %f93, %f91;
+$L__tmp9:
+ .loc 2 120 46
+ mov.b32 %r130, %f90;
+ shfl.sync.bfly.b32 %r131, %r130, 2, 31, -1;
+ mov.b32 %f95, %r131;
+ mov.b32 %r132, %f94;
+ shfl.sync.bfly.b32 %r133, %r132, 2, 31, -1;
+ mov.b32 %f96, %r133;
+ shfl.sync.bfly.b32 %r68, %r66, 2, 31, -1;
+ mov.b32 %f97, %r68;
+$L__tmp10:
+ .loc 2 108 21
+ sub.f32 %f98, %f95, %f90;
+ .loc 2 109 28
+ add.f32 %f99, %f87, %f97;
+ .loc 2 110 39
+ setp.eq.f32 %p48, %f99, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r69, %f99;
+ div.full.f32 %r67, %r68, %r69;
+ mov.b32 %f100, %r67;
+ .loc 2 110 49
+ selp.f32 %f101, 0f00000000, %f100, %p48;
+ .loc 2 112 17
+ fma.rn.f32 %f102, %f101, %f98, %f90;
+ .loc 2 113 15
+ add.f32 %f103, %f94, %f96;
+ .loc 2 113 30
+ mul.f32 %f104, %f98, %f98;
+ .loc 2 113 38
+ mul.f32 %f105, %f87, %f104;
+ .loc 2 113 22
+ fma.rn.f32 %f106, %f101, %f105, %f103;
+$L__tmp11:
+ .loc 2 120 46
+ mov.b32 %r134, %f102;
+ shfl.sync.bfly.b32 %r135, %r134, 1, 31, -1;
+ mov.b32 %f107, %r135;
+ mov.b32 %r136, %f106;
+ shfl.sync.bfly.b32 %r137, %r136, 1, 31, -1;
+ mov.b32 %f108, %r137;
+ shfl.sync.bfly.b32 %r71, %r69, 1, 31, -1;
+ mov.b32 %f109, %r71;
+$L__tmp12:
+ .loc 2 108 21
+ sub.f32 %f110, %f107, %f102;
+ .loc 2 109 28
+ add.f32 %f111, %f99, %f109;
+ .loc 2 110 39
+ setp.eq.f32 %p49, %f111, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r72, %f111;
+ div.full.f32 %r70, %r71, %r72;
+ mov.b32 %f112, %r70;
+ .loc 2 110 49
+ selp.f32 %f113, 0f00000000, %f112, %p49;
+ .loc 2 112 17
+ fma.rn.f32 %f114, %f113, %f110, %f102;
+ .loc 2 113 15
+ add.f32 %f115, %f106, %f108;
+ .loc 2 113 30
+ mul.f32 %f116, %f110, %f110;
+ .loc 2 113 38
+ mul.f32 %f117, %f99, %f116;
+ .loc 2 113 22
+ fma.rn.f32 %f118, %f113, %f117, %f115;
+$L__tmp13:
+ .loc 2 120 46
+ setp.eq.s32 %p21, %r2, 0;
+ shl.b32 %r138, %r3, 2;
+ mov.u32 %r139, global_smem;
+ add.s32 %r73, %r139, %r138;
+ mov.b32 %r74, %f114;
+ @%p21 st.shared.b32 [ %r73 + 0 ], %r74;
+ add.s32 %r140, %r139, 8;
+ add.s32 %r75, %r140, %r138;
+ mov.b32 %r76, %f118;
+ @%p21 st.shared.b32 [ %r75 + 0 ], %r76;
+ add.s32 %r141, %r139, 16;
+ add.s32 %r77, %r141, %r138;
+ @%p21 st.shared.b32 [ %r77 + 0 ], %r72;
+ bar.sync 0;
+ setp.lt.s32 %p24, %r1, 2;
+ add.s32 %r80, %r139, %r30;
+ @%p24 ld.shared.b32 %r79, [ %r80 + 0 ];
+ mov.b32 %f119, %r79;
+ add.s32 %r82, %r140, %r30;
+ @%p24 ld.shared.b32 %r81, [ %r82 + 0 ];
+ mov.b32 %f120, %r81;
+ add.s32 %r84, %r141, %r30;
+ @%p24 ld.shared.b32 %r83, [ %r84 + 0 ];
+ mov.b32 %f121, %r83;
+ shfl.sync.bfly.b32 %r143, %r79, 1, 31, -1;
+ mov.b32 %f122, %r143;
+ shfl.sync.bfly.b32 %r144, %r81, 1, 31, -1;
+ mov.b32 %f123, %r144;
+ shfl.sync.bfly.b32 %r86, %r83, 1, 31, -1;
+ mov.b32 %f124, %r86;
+$L__tmp14:
+ .loc 2 108 21
+ sub.f32 %f125, %f122, %f119;
+ .loc 2 109 28
+ add.f32 %f126, %f121, %f124;
+ .loc 2 110 39
+ setp.eq.f32 %p50, %f126, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r87, %f126;
+ div.full.f32 %r85, %r86, %r87;
+ mov.b32 %f127, %r85;
+ .loc 2 110 49
+ selp.f32 %f128, 0f00000000, %f127, %p50;
+ .loc 2 112 17
+ fma.rn.f32 %f129, %f125, %f128, %f119;
+ .loc 2 113 15
+ add.f32 %f130, %f120, %f123;
+ .loc 2 113 30
+ mul.f32 %f131, %f125, %f125;
+ .loc 2 113 38
+ mul.f32 %f132, %f121, %f131;
+ .loc 2 113 22
+ fma.rn.f32 %f133, %f132, %f128, %f130;
+$L__tmp15:
+ .loc 2 120 46
+ and.b32 %r145, %r1, 1;
+ setp.eq.b32 %p51, %r145, 1;
+ not.pred %p52, %p51;
+ and.pred %p27, %p24, %p52;
+ mov.b32 %r89, %f129;
+ @%p27 st.shared.b32 [ %r80 + 0 ], %r89;
+ mov.b32 %r91, %f133;
+ @%p27 st.shared.b32 [ %r82 + 0 ], %r91;
+ @%p27 st.shared.b32 [ %r84 + 0 ], %r87;
+ bar.sync 0;
+ ld.shared.f32 %f9, [global_smem];
+ ld.shared.f32 %f10, [global_smem+8];
+$L__tmp16:
+ .loc 1 62 51
+ mov.u32 %r94, 0x0;
+ mov.u32 %r95, 0x0;
+ mov.u32 %r96, 0x0;
+ mov.u32 %r97, 0x0;
+ @%p53 ld.global.L1::evict_last.v4.b32 { %r94, %r95, %r96, %r97 }, [ %rd37 + 0 ];
+ @!%p53 mov.u32 %r94, %r151;
+ @!%p53 mov.u32 %r95, %r151;
+ @!%p53 mov.u32 %r96, %r151;
+ @!%p53 mov.u32 %r97, %r151;
+ .loc 1 63 51
+ mov.u32 %r102, 0x0;
+ mov.u32 %r103, 0x0;
+ @%p53 ld.global.L1::evict_first.v2.b32 { %r102, %r103 }, [ %rd38 + 0 ];
+ @!%p53 mov.u32 %r102, %r151;
+ @!%p53 mov.u32 %r103, %r151;
+ cvt.u16.u32 %rs5, %r102;
+ { .reg .b16 tmp; mov.b32 {tmp, %rs6}, %r102; }
+ cvt.u16.u32 %rs7, %r103;
+ { .reg .b16 tmp; mov.b32 {tmp, %rs8}, %r103; }
+ .loc 1 63 103
+ cvt.f32.bf16 %r106, %rs5;
+ mov.b32 %f11, %r106;
+ cvt.f32.bf16 %r107, %rs6;
+ mov.b32 %f12, %r107;
+ cvt.f32.bf16 %r108, %rs7;
+ mov.b32 %f13, %r108;
+ cvt.f32.bf16 %r109, %rs8;
+ mov.b32 %f14, %r109;
+ .loc 1 64 35
+ mul.wide.u32 %rd46, %r4, 4;
+ add.s64 %rd39, %rd8, %rd46;
+ .loc 1 64 40
+ mov.u32 %r110, 0x0;
+ mov.u32 %r111, 0x0;
+ mov.u32 %r112, 0x0;
+ mov.u32 %r113, 0x0;
+ @%p53 ld.global.L1::evict_last.v4.b32 { %r110, %r111, %r112, %r113 }, [ %rd39 + 0 ];
+ @!%p53 mov.u32 %r110, %r151;
+ @!%p53 mov.u32 %r111, %r151;
+ @!%p53 mov.u32 %r112, %r151;
+ @!%p53 mov.u32 %r113, %r151;
+ .loc 1 68 57
+ @%p15 bra $L__BB0_4;
+ mov.u64 %rd47, assertMessage_1;
+ cvta.global.u64 %rd48, %rd47;
+ mov.u64 %rd49, assertFile_1;
+ cvta.global.u64 %rd50, %rd49;
+ mov.u64 %rd51, assertFunc_1;
+ cvta.global.u64 %rd52, %rd51;
+ { // callseq 1, 0
+ .reg .b32 temp_param_reg;
+ .param .b64 param0;
+ st.param.b64 [param0+0], %rd48;
+ .param .b64 param1;
+ st.param.b64 [param1+0], %rd50;
+ .param .b32 param2;
+ st.param.b32 [param2+0], %r175;
+ .param .b64 param3;
+ st.param.b64 [param3+0], %rd52;
+ .param .b64 param4;
+ st.param.b64 [param4+0], %rd57;
+ call.uni
+ __assertfail,
+ (
+ param0,
+ param1,
+ param2,
+ param3,
+ param4
+ );
+ } // callseq 1
+$L__BB0_4:
+ .loc 1 69 54
+ mov.u32 %r147, 0x0;
+ mov.u32 %r148, 0x0;
+ mov.u32 %r149, 0x0;
+ mov.u32 %r150, 0x0;
+ @%p53 ld.global.L1::evict_first.v4.b32 { %r147, %r148, %r149, %r150 }, [ %rd54 + 0 ];
+ @!%p53 mov.u32 %r147, %r151;
+ @!%p53 mov.u32 %r148, %r151;
+ @!%p53 mov.u32 %r149, %r151;
+ @!%p53 mov.u32 %r150, %r151;
+ .loc 1 75 24
+ mov.b32 %r156, %f10;
+ mov.b32 %r157, 1132462080;
+ div.full.f32 %r155, %r156, %r157;
+ mov.b32 %f134, %r155;
+ .loc 1 77 24
+ add.f32 %f135, %f134, 0f3727C5AC;
+ .loc 1 78 30
+ rsqrt.approx.ftz.f32 %f136, %f135;
+ .loc 1 69 54
+ mov.b32 %f137, %r150;
+ .loc 1 62 51
+ mov.b32 %f138, %r97;
+ .loc 1 70 24
+ add.f32 %f139, %f138, %f137;
+ .loc 1 72 24
+ add.f32 %f140, %f14, %f139;
+ .loc 1 73 24
+ sub.f32 %f141, %f140, %f9;
+ .loc 1 69 54
+ mov.b32 %f142, %r149;
+ .loc 1 62 51
+ mov.b32 %f143, %r96;
+ .loc 1 70 24
+ add.f32 %f144, %f143, %f142;
+ .loc 1 72 24
+ add.f32 %f145, %f13, %f144;
+ .loc 1 73 24
+ sub.f32 %f146, %f145, %f9;
+ .loc 1 69 54
+ mov.b32 %f147, %r148;
+ .loc 1 62 51
+ mov.b32 %f148, %r95;
+ .loc 1 70 24
+ add.f32 %f149, %f148, %f147;
+ .loc 1 72 24
+ add.f32 %f150, %f12, %f149;
+ .loc 1 73 24
+ sub.f32 %f151, %f150, %f9;
+ .loc 1 69 54
+ mov.b32 %f152, %r147;
+ .loc 1 62 51
+ mov.b32 %f153, %r94;
+ .loc 1 70 24
+ add.f32 %f154, %f153, %f152;
+ .loc 1 72 24
+ add.f32 %f155, %f11, %f154;
+ .loc 1 73 24
+ sub.f32 %f156, %f155, %f9;
+ .loc 1 64 40
+ mov.b32 %f157, %r110;
+ mov.b32 %f158, %r111;
+ mov.b32 %f159, %r112;
+ mov.b32 %f160, %r113;
+ .loc 1 79 24
+ mul.f32 %f161, %f156, %f136;
+ mul.f32 %f162, %f151, %f136;
+ mul.f32 %f163, %f146, %f136;
+ mul.f32 %f164, %f141, %f136;
+ .loc 1 80 24
+ mul.f32 %f165, %f161, %f157;
+ mul.f32 %f166, %f162, %f158;
+ mul.f32 %f167, %f163, %f159;
+ mul.f32 %f168, %f164, %f160;
+ .loc 1 82 29
+ shl.b64 %rd56, %rd3, 1;
+ add.s64 %rd55, %rd9, %rd56;
+ .loc 1 82 52
+ mov.b32 %r167, %f165;
+ cvt.rn.bf16.f32 %rs9, %r167;
+ mov.b32 %r168, %f166;
+ cvt.rn.bf16.f32 %rs10, %r168;
+ mov.b32 %r169, %f167;
+ cvt.rn.bf16.f32 %rs11, %r169;
+ mov.b32 %r170, %f168;
+ cvt.rn.bf16.f32 %rs12, %r170;
+ mov.b32 %r173, {%rs9, %rs10};
+ mov.b32 %r174, {%rs11, %rs12};
+ @%p53 st.global.v2.b32 [ %rd55 + 0 ], { %r173, %r174 };
+ .loc 1 58 4
+ ret;
+$L__tmp17:
+$L__func_end0:
+
+}
+ // .globl __nv_rsqrtf
+.visible .func (.param .b32 func_retval0) __nv_rsqrtf(
+ .param .b32 __nv_rsqrtf_param_0
+)
+{
+ .reg .f32 %f<3>;
+$L__func_begin1:
+
+ ld.param.f32 %f1, [__nv_rsqrtf_param_0];
+ rsqrt.approx.ftz.f32 %f2, %f1;
+ st.param.f32 [func_retval0+0], %f2;
+ ret;
+$L__func_end1:
+
+}
+ .file 1 "/tmp/torchinductor_root/ci/ccig6fki6p4lxrdmgg6eudahiexcvueeol2p4qp532pvve2y463y.py"
+ .file 2 "/usr/local/lib/python3.10/dist-packages/torch/_inductor/triton_helpers.py"
+ .section .debug_abbrev
+ {
+.b8 1
+.b8 17
+.b8 1
+.b8 37
+.b8 8
+.b8 19
+.b8 5
+.b8 3
+.b8 8
+.b8 16
+.b8 6
+.b8 27
+.b8 8
+.b8 180
+.b8 66
+.b8 12
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+.b8 0
+.b8 2
+.b8 46
+.b8 0
+.b8 135
+.b8 64
+.b8 8
+.b8 3
+.b8 8
+.b8 58
+.b8 11
+.b8 59
+.b8 11
+.b8 63
+.b8 12
+.b8 32
+.b8 11
+.b8 0
+.b8 0
+.b8 3
+.b8 46
+.b8 1
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 64
+.b8 10
+.b8 49
+.b8 19
+.b8 0
+.b8 0
+.b8 4
+.b8 29
+.b8 0
+.b8 49
+.b8 19
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 88
+.b8 11
+.b8 89
+.b8 11
+.b8 87
+.b8 11
+.b8 0
+.b8 0
+.b8 5
+.b8 29
+.b8 1
+.b8 49
+.b8 19
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 88
+.b8 11
+.b8 89
+.b8 11
+.b8 87
+.b8 11
+.b8 0
+.b8 0
+.b8 0
+ }
+ .section .debug_info
+ {
+.b32 302
+.b8 2
+.b8 0
+.b32 .debug_abbrev
+.b8 8
+.b8 1
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 0
+.b8 2
+.b8 0
+.b8 99
+.b8 99
+.b8 105
+.b8 103
+.b8 54
+.b8 102
+.b8 107
+.b8 105
+.b8 54
+.b8 112
+.b8 52
+.b8 108
+.b8 120
+.b8 114
+.b8 100
+.b8 109
+.b8 103
+.b8 103
+.b8 54
+.b8 101
+.b8 117
+.b8 100
+.b8 97
+.b8 104
+.b8 105
+.b8 101
+.b8 120
+.b8 99
+.b8 118
+.b8 117
+.b8 101
+.b8 101
+.b8 111
+.b8 108
+.b8 50
+.b8 112
+.b8 52
+.b8 113
+.b8 112
+.b8 53
+.b8 51
+.b8 50
+.b8 112
+.b8 118
+.b8 118
+.b8 101
+.b8 50
+.b8 121
+.b8 52
+.b8 54
+.b8 51
+.b8 121
+.b8 46
+.b8 112
+.b8 121
+.b8 0
+.b32 .debug_line
+.b8 47
+.b8 116
+.b8 109
+.b8 112
+.b8 47
+.b8 116
+.b8 111
+.b8 114
+.b8 99
+.b8 104
+.b8 105
+.b8 110
+.b8 100
+.b8 117
+.b8 99
+.b8 116
+.b8 111
+.b8 114
+.b8 95
+.b8 114
+.b8 111
+.b8 111
+.b8 116
+.b8 47
+.b8 99
+.b8 105
+.b8 0
+.b8 1
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 2
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 54
+.b8 100
+.b8 101
+.b8 55
+.b8 100
+.b8 101
+.b8 0
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 54
+.b8 100
+.b8 101
+.b8 55
+.b8 100
+.b8 101
+.b8 0
+.b8 1
+.b8 18
+.b8 1
+.b8 1
+.b8 3
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 1
+.b8 156
+.b32 125
+.b8 4
+.b32 125
+.b64 $L__tmp1
+.b64 $L__tmp2
+.b8 2
+.b8 47
+.b8 41
+.b8 5
+.b32 125
+.b64 $L__tmp2
+.b64 $L__tmp15
+.b8 2
+.b8 53
+.b8 44
+.b8 4
+.b32 125
+.b64 $L__tmp2
+.b64 $L__tmp15
+.b8 2
+.b8 120
+.b8 46
+.b8 0
+.b8 4
+.b32 125
+.b64 $L__tmp3
+.b64 $L__tmp16
+.b8 2
+.b8 53
+.b8 44
+.b8 0
+.b8 0
+ }
+ .section .debug_pubnames
+ {
+.b32 $L__pubNames_end0-$L__pubNames_start0
+$L__pubNames_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 306
+.b32 125
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 54
+.b8 100
+.b8 101
+.b8 55
+.b8 100
+.b8 101
+.b8 0
+.b32 0
+$L__pubNames_end0:
+ }
+ .section .debug_pubtypes
+ {
+.b32 $L__pubTypes_end0-$L__pubTypes_start0
+$L__pubTypes_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 306
+.b32 0
+$L__pubTypes_end0:
+ }
+ .section .debug_loc { }
diff --git a/.triton/dump/be2ceddb05ebae326eeb754fc508b131/triton_.ptx b/.triton/dump/be2ceddb05ebae326eeb754fc508b131/triton_.ptx
new file mode 100644
index 0000000000000000000000000000000000000000..02453f3e79cfacb6ad40d4608fb398f024b83245
--- /dev/null
+++ b/.triton/dump/be2ceddb05ebae326eeb754fc508b131/triton_.ptx
@@ -0,0 +1,975 @@
+//
+// Generated by LLVM NVPTX Back-End
+//
+
+.version 8.2
+.target sm_89
+.address_size 64
+
+ // .globl triton__0d1d2d3d4d5de6de
+.extern .func __assertfail
+(
+ .param .b64 __assertfail_param_0,
+ .param .b64 __assertfail_param_1,
+ .param .b32 __assertfail_param_2,
+ .param .b64 __assertfail_param_3,
+ .param .b64 __assertfail_param_4
+)
+;
+.global .align 1 .b8 assertFunc_1[25] = {95, 99, 97, 108, 108, 95, 119, 105, 116, 104, 95, 102, 114, 97, 109, 101, 115, 95, 114, 101, 109, 111, 118, 101, 100};
+.global .align 1 .b8 assertFile_1[38] = {60, 102, 114, 111, 122, 101, 110, 32, 105, 109, 112, 111, 114, 116, 108, 105, 98, 46, 95, 98, 111, 111, 116, 115, 116, 114, 97, 112, 95, 101, 120, 116, 101, 114, 110, 97, 108, 62};
+.global .align 1 .b8 assertMessage_1[39] = {105, 110, 100, 101, 120, 32, 111, 117, 116, 32, 111, 102, 32, 98, 111, 117, 110, 100, 115, 58, 32, 48, 32, 60, 61, 32, 116, 109, 112, 49, 51, 32, 60, 32, 53, 48, 50, 53, 55};
+.global .align 1 .b8 assertFunc_0[25] = {95, 99, 97, 108, 108, 95, 119, 105, 116, 104, 95, 102, 114, 97, 109, 101, 115, 95, 114, 101, 109, 111, 118, 101, 100};
+.global .align 1 .b8 assertFile_0[38] = {60, 102, 114, 111, 122, 101, 110, 32, 105, 109, 112, 111, 114, 116, 108, 105, 98, 46, 95, 98, 111, 111, 116, 115, 116, 114, 97, 112, 95, 101, 120, 116, 101, 114, 110, 97, 108, 62};
+.global .align 1 .b8 assertMessage_0[38] = {105, 110, 100, 101, 120, 32, 111, 117, 116, 32, 111, 102, 32, 98, 111, 117, 110, 100, 115, 58, 32, 48, 32, 60, 61, 32, 116, 109, 112, 51, 32, 60, 32, 53, 48, 50, 53, 55};
+.extern .shared .align 1 .b8 global_smem[];
+.global .align 1 .b8 _$_str[11] = {95, 95, 67, 85, 68, 65, 95, 70, 84, 90, 0};
+
+.visible .entry triton__0d1d2d3d4d5de6de(
+ .param .u64 triton__0d1d2d3d4d5de6de_param_0,
+ .param .u64 triton__0d1d2d3d4d5de6de_param_1,
+ .param .u64 triton__0d1d2d3d4d5de6de_param_2,
+ .param .u64 triton__0d1d2d3d4d5de6de_param_3,
+ .param .u64 triton__0d1d2d3d4d5de6de_param_4,
+ .param .u32 triton__0d1d2d3d4d5de6de_param_5,
+ .param .u32 triton__0d1d2d3d4d5de6de_param_6
+)
+.maxntid 64, 1, 1
+{
+ .reg .pred %p<53>;
+ .reg .b16 %rs<5>;
+ .reg .b32 %r<161>;
+ .reg .f32 %f<153>;
+ .reg .b64 %rd<52>;
+ .loc 1 18 0
+$L__func_begin0:
+ .loc 1 18 0
+
+ ld.param.u64 %rd6, [triton__0d1d2d3d4d5de6de_param_3];
+ ld.param.u64 %rd5, [triton__0d1d2d3d4d5de6de_param_1];
+ ld.param.u64 %rd19, [triton__0d1d2d3d4d5de6de_param_0];
+$L__tmp0:
+ .loc 1 24 33
+ mov.u32 %r1, %tid.x;
+ and.b32 %r2, %r1, 31;
+ ld.param.u64 %rd20, [triton__0d1d2d3d4d5de6de_param_2];
+ bfe.u32 %r3, %r1, 5, 1;
+ shl.b32 %r23, %r1, 2;
+ and.b32 %r4, %r23, 252;
+ .loc 1 21 28
+ mov.u32 %r14, %ctaid.x;
+ .loc 1 26 30
+ mul.wide.s32 %rd21, %r14, 8;
+ add.s64 %rd9, %rd19, %rd21;
+ mov.pred %p47, -1;
+ .loc 1 26 35
+ mov.u64 %rd8, 0x0;
+ @%p47 ld.global.L1::evict_last.b64 { %rd8 }, [ %rd9 + 0 ];
+ mov.u64 %rd10, 0x0;
+ @%p47 ld.global.L1::evict_last.b64 { %rd10 }, [ %rd9 + 0 ];
+ mov.u64 %rd12, 0x0;
+ @%p47 ld.global.L1::evict_last.b64 { %rd12 }, [ %rd9 + 0 ];
+ mov.u64 %rd14, 0x0;
+ @%p47 ld.global.L1::evict_last.b64 { %rd14 }, [ %rd9 + 0 ];
+ mov.u64 %rd16, 0x0;
+ @%p47 ld.global.L1::evict_last.b64 { %rd16 }, [ %rd9 + 0 ];
+ .loc 1 27 18
+ shr.s32 %r24, %r14, 31;
+ shr.u32 %r25, %r24, 23;
+ add.s32 %r26, %r14, %r25;
+ and.b32 %r27, %r26, 16776704;
+ sub.s32 %r28, %r14, %r27;
+ .loc 1 35 44
+ shl.b32 %r29, %r28, 8;
+ .loc 1 35 40
+ or.b32 %r30, %r29, %r4;
+ .loc 1 35 34
+ mul.wide.s32 %rd22, %r30, 4;
+ add.s64 %rd32, %rd20, %rd22;
+ mov.b32 %r134, 0;
+ .loc 1 35 50
+ mov.u32 %r15, 0x0;
+ mov.u32 %r16, 0x0;
+ mov.u32 %r17, 0x0;
+ mov.u32 %r18, 0x0;
+ @%p47 ld.global.L1::evict_last.v4.b32 { %r15, %r16, %r17, %r18 }, [ %rd32 + 0 ];
+ @!%p47 mov.u32 %r15, %r134;
+ @!%p47 mov.u32 %r16, %r134;
+ @!%p47 mov.u32 %r17, %r134;
+ @!%p47 mov.u32 %r18, %r134;
+ mov.b32 %f1, %r15;
+ mov.b32 %f2, %r16;
+ mov.b32 %f3, %r17;
+ mov.b32 %f4, %r18;
+ .loc 1 36 22
+ add.s64 %rd23, %rd16, 50257;
+ .loc 1 37 22
+ setp.lt.s64 %p11, %rd16, 0;
+ .loc 1 38 36
+ selp.b64 %rd3, %rd23, %rd16, %p11;
+ .loc 1 39 40
+ setp.lt.u64 %p12, %rd3, 50257;
+ mov.b32 %r160, 883;
+ mov.u64 %rd51, 1;
+ .loc 1 39 55
+ @%p12 bra $L__BB0_2;
+ mov.u64 %rd24, assertMessage_0;
+ cvta.global.u64 %rd25, %rd24;
+ mov.u64 %rd26, assertFile_0;
+ cvta.global.u64 %rd27, %rd26;
+ mov.u64 %rd28, assertFunc_0;
+ cvta.global.u64 %rd29, %rd28;
+ { // callseq 0, 0
+ .reg .b32 temp_param_reg;
+ .param .b64 param0;
+ st.param.b64 [param0+0], %rd25;
+ .param .b64 param1;
+ st.param.b64 [param1+0], %rd27;
+ .param .b32 param2;
+ st.param.b32 [param2+0], %r160;
+ .param .b64 param3;
+ st.param.b64 [param3+0], %rd29;
+ .param .b64 param4;
+ st.param.b64 [param4+0], %rd51;
+ call.uni
+ __assertfail,
+ (
+ param0,
+ param1,
+ param2,
+ param3,
+ param4
+ );
+ } // callseq 0
+$L__BB0_2:
+ .loc 1 0 55
+ ld.param.u64 %rd7, [triton__0d1d2d3d4d5de6de_param_4];
+ .loc 1 37 22
+ setp.lt.s64 %p38, %rd8, 0;
+ .loc 1 40 44
+ shl.b64 %rd34, %rd8, 8;
+ add.s64 %rd35, %rd34, 12865792;
+ selp.b64 %rd36, %rd35, %rd34, %p38;
+ cvt.u64.u32 %rd37, %r4;
+ .loc 1 40 40
+ or.b64 %rd38, %rd36, %rd37;
+ .loc 1 40 34
+ shl.b64 %rd39, %rd38, 2;
+ add.s64 %rd48, %rd5, %rd39;
+ .loc 1 40 52
+ mov.u32 %r32, 0x0;
+ mov.u32 %r33, 0x0;
+ mov.u32 %r34, 0x0;
+ mov.u32 %r35, 0x0;
+ @%p47 ld.global.L1::evict_last.v4.b32 { %r32, %r33, %r34, %r35 }, [ %rd48 + 0 ];
+ @!%p47 mov.u32 %r32, %r134;
+ @!%p47 mov.u32 %r33, %r134;
+ @!%p47 mov.u32 %r34, %r134;
+ @!%p47 mov.u32 %r35, %r134;
+ mov.b32 %f7, %r32;
+ mov.b32 %f8, %r33;
+ mov.b32 %f9, %r34;
+ mov.b32 %f10, %r35;
+ .loc 1 41 22
+ add.f32 %f11, %f1, %f7;
+ add.f32 %f12, %f2, %f8;
+ add.f32 %f13, %f3, %f9;
+ add.f32 %f14, %f4, %f10;
+$L__tmp1:
+ .loc 2 98 22
+ add.f32 %f15, %f11, 0f00000000;
+ add.f32 %f16, %f12, 0f00000000;
+ add.f32 %f17, %f13, 0f00000000;
+ add.f32 %f18, %f14, 0f00000000;
+ .loc 2 101 30
+ sub.f32 %f19, %f11, %f15;
+ sub.f32 %f20, %f12, %f16;
+ sub.f32 %f21, %f13, %f17;
+ sub.f32 %f22, %f14, %f18;
+ .loc 2 101 13
+ fma.rn.f32 %f23, %f11, %f19, 0f00000000;
+ fma.rn.f32 %f24, %f12, %f20, 0f00000000;
+ fma.rn.f32 %f25, %f13, %f21, 0f00000000;
+ fma.rn.f32 %f26, %f14, %f22, 0f00000000;
+$L__tmp2:
+ .loc 2 108 21
+ sub.f32 %f27, %f16, %f15;
+ mov.b32 %r41, 1065353216;
+ mov.b32 %r42, 1073741824;
+ .loc 2 110 60
+ div.full.f32 %r40, %r41, %r42;
+ mov.b32 %f28, %r40;
+ .loc 2 112 17
+ fma.rn.f32 %f29, %f28, %f27, %f15;
+ .loc 2 113 15
+ add.f32 %f30, %f23, %f24;
+ .loc 2 113 30
+ mul.f32 %f31, %f27, %f27;
+ .loc 2 113 22
+ fma.rn.f32 %f32, %f28, %f31, %f30;
+ .loc 2 108 21
+ sub.f32 %f33, %f17, %f29;
+ mov.b32 %r45, 1077936128;
+ .loc 2 110 60
+ div.full.f32 %r43, %r41, %r45;
+ mov.b32 %f34, %r43;
+ .loc 2 112 17
+ fma.rn.f32 %f35, %f34, %f33, %f29;
+ .loc 2 113 15
+ add.f32 %f36, %f25, %f32;
+ .loc 2 113 30
+ mul.f32 %f37, %f33, %f33;
+ .loc 2 113 38
+ fma.rn.f32 %f38, %f33, %f33, %f37;
+ .loc 2 113 22
+ fma.rn.f32 %f39, %f34, %f38, %f36;
+ .loc 2 108 21
+ sub.f32 %f40, %f18, %f35;
+ mov.b32 %r48, 1082130432;
+ .loc 2 110 60
+ div.full.f32 %r46, %r41, %r48;
+ mov.b32 %f41, %r46;
+ .loc 2 112 17
+ fma.rn.f32 %f42, %f41, %f40, %f35;
+ .loc 2 113 15
+ add.f32 %f43, %f26, %f39;
+ .loc 2 113 30
+ mul.f32 %f44, %f40, %f40;
+ .loc 2 113 38
+ mul.f32 %f45, %f44, 0f40400000;
+ .loc 2 113 22
+ fma.rn.f32 %f46, %f41, %f45, %f43;
+$L__tmp3:
+ .loc 2 120 46
+ mov.b32 %r101, %f42;
+ shfl.sync.bfly.b32 %r102, %r101, 16, 31, -1;
+ mov.b32 %f47, %r102;
+ mov.b32 %r103, %f46;
+ shfl.sync.bfly.b32 %r104, %r103, 16, 31, -1;
+ mov.b32 %f48, %r104;
+ shfl.sync.bfly.b32 %r50, %r48, 16, 31, -1;
+ mov.b32 %f49, %r50;
+$L__tmp4:
+ .loc 2 108 21
+ sub.f32 %f50, %f47, %f42;
+ .loc 2 109 28
+ add.f32 %f51, %f49, 0f40800000;
+ .loc 2 110 39
+ setp.eq.f32 %p39, %f51, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r51, %f51;
+ div.full.f32 %r49, %r50, %r51;
+ mov.b32 %f52, %r49;
+ .loc 2 110 49
+ selp.f32 %f53, 0f00000000, %f52, %p39;
+ .loc 2 112 17
+ fma.rn.f32 %f54, %f53, %f50, %f42;
+ .loc 2 113 15
+ add.f32 %f55, %f46, %f48;
+ .loc 2 113 30
+ mul.f32 %f56, %f50, %f50;
+ .loc 2 113 38
+ mul.f32 %f57, %f56, 0f40800000;
+ .loc 2 113 22
+ fma.rn.f32 %f58, %f53, %f57, %f55;
+$L__tmp5:
+ .loc 2 120 46
+ mov.b32 %r105, %f54;
+ shfl.sync.bfly.b32 %r106, %r105, 8, 31, -1;
+ mov.b32 %f59, %r106;
+ mov.b32 %r107, %f58;
+ shfl.sync.bfly.b32 %r108, %r107, 8, 31, -1;
+ mov.b32 %f60, %r108;
+ shfl.sync.bfly.b32 %r53, %r51, 8, 31, -1;
+ mov.b32 %f61, %r53;
+$L__tmp6:
+ .loc 2 108 21
+ sub.f32 %f62, %f59, %f54;
+ .loc 2 109 28
+ add.f32 %f63, %f51, %f61;
+ .loc 2 110 39
+ setp.eq.f32 %p40, %f63, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r54, %f63;
+ div.full.f32 %r52, %r53, %r54;
+ mov.b32 %f64, %r52;
+ .loc 2 110 49
+ selp.f32 %f65, 0f00000000, %f64, %p40;
+ .loc 2 112 17
+ fma.rn.f32 %f66, %f65, %f62, %f54;
+ .loc 2 113 15
+ add.f32 %f67, %f58, %f60;
+ .loc 2 113 30
+ mul.f32 %f68, %f62, %f62;
+ .loc 2 113 38
+ mul.f32 %f69, %f51, %f68;
+ .loc 2 113 22
+ fma.rn.f32 %f70, %f65, %f69, %f67;
+$L__tmp7:
+ .loc 2 120 46
+ mov.b32 %r109, %f66;
+ shfl.sync.bfly.b32 %r110, %r109, 4, 31, -1;
+ mov.b32 %f71, %r110;
+ mov.b32 %r111, %f70;
+ shfl.sync.bfly.b32 %r112, %r111, 4, 31, -1;
+ mov.b32 %f72, %r112;
+ shfl.sync.bfly.b32 %r56, %r54, 4, 31, -1;
+ mov.b32 %f73, %r56;
+$L__tmp8:
+ .loc 2 108 21
+ sub.f32 %f74, %f71, %f66;
+ .loc 2 109 28
+ add.f32 %f75, %f63, %f73;
+ .loc 2 110 39
+ setp.eq.f32 %p41, %f75, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r57, %f75;
+ div.full.f32 %r55, %r56, %r57;
+ mov.b32 %f76, %r55;
+ .loc 2 110 49
+ selp.f32 %f77, 0f00000000, %f76, %p41;
+ .loc 2 112 17
+ fma.rn.f32 %f78, %f77, %f74, %f66;
+ .loc 2 113 15
+ add.f32 %f79, %f70, %f72;
+ .loc 2 113 30
+ mul.f32 %f80, %f74, %f74;
+ .loc 2 113 38
+ mul.f32 %f81, %f63, %f80;
+ .loc 2 113 22
+ fma.rn.f32 %f82, %f77, %f81, %f79;
+$L__tmp9:
+ .loc 2 120 46
+ mov.b32 %r113, %f78;
+ shfl.sync.bfly.b32 %r114, %r113, 2, 31, -1;
+ mov.b32 %f83, %r114;
+ mov.b32 %r115, %f82;
+ shfl.sync.bfly.b32 %r116, %r115, 2, 31, -1;
+ mov.b32 %f84, %r116;
+ shfl.sync.bfly.b32 %r59, %r57, 2, 31, -1;
+ mov.b32 %f85, %r59;
+$L__tmp10:
+ .loc 2 108 21
+ sub.f32 %f86, %f83, %f78;
+ .loc 2 109 28
+ add.f32 %f87, %f75, %f85;
+ .loc 2 110 39
+ setp.eq.f32 %p42, %f87, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r60, %f87;
+ div.full.f32 %r58, %r59, %r60;
+ mov.b32 %f88, %r58;
+ .loc 2 110 49
+ selp.f32 %f89, 0f00000000, %f88, %p42;
+ .loc 2 112 17
+ fma.rn.f32 %f90, %f89, %f86, %f78;
+ .loc 2 113 15
+ add.f32 %f91, %f82, %f84;
+ .loc 2 113 30
+ mul.f32 %f92, %f86, %f86;
+ .loc 2 113 38
+ mul.f32 %f93, %f75, %f92;
+ .loc 2 113 22
+ fma.rn.f32 %f94, %f89, %f93, %f91;
+$L__tmp11:
+ .loc 2 120 46
+ mov.b32 %r117, %f90;
+ shfl.sync.bfly.b32 %r118, %r117, 1, 31, -1;
+ mov.b32 %f95, %r118;
+ mov.b32 %r119, %f94;
+ shfl.sync.bfly.b32 %r120, %r119, 1, 31, -1;
+ mov.b32 %f96, %r120;
+ shfl.sync.bfly.b32 %r62, %r60, 1, 31, -1;
+ mov.b32 %f97, %r62;
+$L__tmp12:
+ .loc 2 108 21
+ sub.f32 %f98, %f95, %f90;
+ .loc 2 109 28
+ add.f32 %f99, %f87, %f97;
+ .loc 2 110 39
+ setp.eq.f32 %p43, %f99, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r63, %f99;
+ div.full.f32 %r61, %r62, %r63;
+ mov.b32 %f100, %r61;
+ .loc 2 110 49
+ selp.f32 %f101, 0f00000000, %f100, %p43;
+ .loc 2 112 17
+ fma.rn.f32 %f102, %f98, %f101, %f90;
+ .loc 2 113 15
+ add.f32 %f103, %f94, %f96;
+ .loc 2 113 30
+ mul.f32 %f104, %f98, %f98;
+ .loc 2 113 38
+ mul.f32 %f105, %f87, %f104;
+ .loc 2 113 22
+ fma.rn.f32 %f106, %f101, %f105, %f103;
+$L__tmp13:
+ .loc 2 120 46
+ setp.eq.s32 %p18, %r2, 0;
+ shl.b32 %r121, %r3, 2;
+ mov.u32 %r122, global_smem;
+ add.s32 %r64, %r122, %r121;
+ mov.b32 %r65, %f102;
+ @%p18 st.shared.b32 [ %r64 + 0 ], %r65;
+ add.s32 %r123, %r122, 8;
+ add.s32 %r66, %r123, %r121;
+ mov.b32 %r67, %f106;
+ @%p18 st.shared.b32 [ %r66 + 0 ], %r67;
+ add.s32 %r124, %r122, 16;
+ add.s32 %r68, %r124, %r121;
+ @%p18 st.shared.b32 [ %r68 + 0 ], %r63;
+ bar.sync 0;
+ setp.lt.s32 %p21, %r1, 2;
+ add.s32 %r71, %r122, %r23;
+ @%p21 ld.shared.b32 %r70, [ %r71 + 0 ];
+ mov.b32 %f107, %r70;
+ add.s32 %r73, %r123, %r23;
+ @%p21 ld.shared.b32 %r72, [ %r73 + 0 ];
+ mov.b32 %f108, %r72;
+ add.s32 %r75, %r124, %r23;
+ @%p21 ld.shared.b32 %r74, [ %r75 + 0 ];
+ mov.b32 %f109, %r74;
+ shfl.sync.bfly.b32 %r126, %r70, 1, 31, -1;
+ mov.b32 %f110, %r126;
+ shfl.sync.bfly.b32 %r127, %r72, 1, 31, -1;
+ mov.b32 %f111, %r127;
+ shfl.sync.bfly.b32 %r77, %r74, 1, 31, -1;
+ mov.b32 %f112, %r77;
+$L__tmp14:
+ .loc 2 108 21
+ sub.f32 %f113, %f110, %f107;
+ .loc 2 109 28
+ add.f32 %f114, %f109, %f112;
+ .loc 2 110 39
+ setp.eq.f32 %p44, %f114, 0f00000000;
+ .loc 2 110 60
+ mov.b32 %r78, %f114;
+ div.full.f32 %r76, %r77, %r78;
+ mov.b32 %f115, %r76;
+ .loc 2 110 49
+ selp.f32 %f116, 0f00000000, %f115, %p44;
+ .loc 2 112 17
+ fma.rn.f32 %f117, %f113, %f116, %f107;
+ .loc 2 113 15
+ add.f32 %f118, %f108, %f111;
+ .loc 2 113 30
+ mul.f32 %f119, %f113, %f113;
+ .loc 2 113 38
+ mul.f32 %f120, %f109, %f119;
+ .loc 2 113 22
+ fma.rn.f32 %f121, %f120, %f116, %f118;
+$L__tmp15:
+ .loc 2 120 46
+ and.b32 %r128, %r1, 1;
+ setp.eq.b32 %p45, %r128, 1;
+ not.pred %p46, %p45;
+ and.pred %p24, %p21, %p46;
+ mov.b32 %r80, %f117;
+ @%p24 st.shared.b32 [ %r71 + 0 ], %r80;
+ mov.b32 %r82, %f121;
+ @%p24 st.shared.b32 [ %r73 + 0 ], %r82;
+ @%p24 st.shared.b32 [ %r75 + 0 ], %r78;
+ bar.sync 0;
+ ld.shared.f32 %f5, [global_smem];
+ ld.shared.f32 %f6, [global_smem+8];
+$L__tmp16:
+ .loc 1 59 51
+ mov.u32 %r85, 0x0;
+ mov.u32 %r86, 0x0;
+ mov.u32 %r87, 0x0;
+ mov.u32 %r88, 0x0;
+ @%p47 ld.global.L1::evict_last.v4.b32 { %r85, %r86, %r87, %r88 }, [ %rd32 + 0 ];
+ @!%p47 mov.u32 %r85, %r134;
+ @!%p47 mov.u32 %r86, %r134;
+ @!%p47 mov.u32 %r87, %r134;
+ @!%p47 mov.u32 %r88, %r134;
+ .loc 1 60 35
+ mul.wide.u32 %rd40, %r4, 4;
+ add.s64 %rd33, %rd6, %rd40;
+ .loc 1 60 40
+ mov.u32 %r93, 0x0;
+ mov.u32 %r94, 0x0;
+ mov.u32 %r95, 0x0;
+ mov.u32 %r96, 0x0;
+ @%p47 ld.global.L1::evict_last.v4.b32 { %r93, %r94, %r95, %r96 }, [ %rd33 + 0 ];
+ @!%p47 mov.u32 %r93, %r134;
+ @!%p47 mov.u32 %r94, %r134;
+ @!%p47 mov.u32 %r95, %r134;
+ @!%p47 mov.u32 %r96, %r134;
+ .loc 1 64 57
+ @%p12 bra $L__BB0_4;
+ mov.u64 %rd41, assertMessage_1;
+ cvta.global.u64 %rd42, %rd41;
+ mov.u64 %rd43, assertFile_1;
+ cvta.global.u64 %rd44, %rd43;
+ mov.u64 %rd45, assertFunc_1;
+ cvta.global.u64 %rd46, %rd45;
+ { // callseq 1, 0
+ .reg .b32 temp_param_reg;
+ .param .b64 param0;
+ st.param.b64 [param0+0], %rd42;
+ .param .b64 param1;
+ st.param.b64 [param1+0], %rd44;
+ .param .b32 param2;
+ st.param.b32 [param2+0], %r160;
+ .param .b64 param3;
+ st.param.b64 [param3+0], %rd46;
+ .param .b64 param4;
+ st.param.b64 [param4+0], %rd51;
+ call.uni
+ __assertfail,
+ (
+ param0,
+ param1,
+ param2,
+ param3,
+ param4
+ );
+ } // callseq 1
+$L__BB0_4:
+ .loc 1 65 54
+ mov.u32 %r130, 0x0;
+ mov.u32 %r131, 0x0;
+ mov.u32 %r132, 0x0;
+ mov.u32 %r133, 0x0;
+ @%p47 ld.global.L1::evict_first.v4.b32 { %r130, %r131, %r132, %r133 }, [ %rd48 + 0 ];
+ @!%p47 mov.u32 %r130, %r134;
+ @!%p47 mov.u32 %r131, %r134;
+ @!%p47 mov.u32 %r132, %r134;
+ @!%p47 mov.u32 %r133, %r134;
+ .loc 1 69 23
+ mov.b32 %r139, %f6;
+ mov.b32 %r140, 1132462080;
+ div.full.f32 %r138, %r139, %r140;
+ mov.b32 %f122, %r138;
+ .loc 1 71 24
+ add.f32 %f123, %f122, 0f3727C5AC;
+ .loc 1 72 30
+ rsqrt.approx.ftz.f32 %f124, %f123;
+ .loc 1 65 54
+ mov.b32 %f125, %r133;
+ .loc 1 59 51
+ mov.b32 %f126, %r88;
+ .loc 1 66 24
+ add.f32 %f127, %f126, %f125;
+ .loc 1 67 24
+ sub.f32 %f128, %f127, %f5;
+ .loc 1 65 54
+ mov.b32 %f129, %r132;
+ .loc 1 59 51
+ mov.b32 %f130, %r87;
+ .loc 1 66 24
+ add.f32 %f131, %f130, %f129;
+ .loc 1 67 24
+ sub.f32 %f132, %f131, %f5;
+ .loc 1 65 54
+ mov.b32 %f133, %r131;
+ .loc 1 59 51
+ mov.b32 %f134, %r86;
+ .loc 1 66 24
+ add.f32 %f135, %f134, %f133;
+ .loc 1 67 24
+ sub.f32 %f136, %f135, %f5;
+ .loc 1 65 54
+ mov.b32 %f137, %r130;
+ .loc 1 59 51
+ mov.b32 %f138, %r85;
+ .loc 1 66 24
+ add.f32 %f139, %f138, %f137;
+ .loc 1 67 24
+ sub.f32 %f140, %f139, %f5;
+ .loc 1 60 40
+ mov.b32 %f141, %r93;
+ mov.b32 %f142, %r94;
+ mov.b32 %f143, %r95;
+ mov.b32 %f144, %r96;
+ .loc 1 73 24
+ mul.f32 %f145, %f140, %f124;
+ mul.f32 %f146, %f136, %f124;
+ mul.f32 %f147, %f132, %f124;
+ mul.f32 %f148, %f128, %f124;
+ .loc 1 74 24
+ mul.f32 %f149, %f145, %f141;
+ mul.f32 %f150, %f146, %f142;
+ mul.f32 %f151, %f147, %f143;
+ mul.f32 %f152, %f148, %f144;
+ .loc 1 76 39
+ shl.b32 %r156, %r14, 8;
+ .loc 1 76 35
+ or.b32 %r157, %r156, %r4;
+ .loc 1 76 29
+ mul.wide.s32 %rd50, %r157, 2;
+ add.s64 %rd49, %rd7, %rd50;
+ .loc 1 76 52
+ mov.b32 %r150, %f149;
+ cvt.rn.bf16.f32 %rs1, %r150;
+ mov.b32 %r151, %f150;
+ cvt.rn.bf16.f32 %rs2, %r151;
+ mov.b32 %r152, %f151;
+ cvt.rn.bf16.f32 %rs3, %r152;
+ mov.b32 %r153, %f152;
+ cvt.rn.bf16.f32 %rs4, %r153;
+ mov.b32 %r158, {%rs1, %rs2};
+ mov.b32 %r159, {%rs3, %rs4};
+ @%p47 st.global.v2.b32 [ %rd49 + 0 ], { %r158, %r159 };
+ .loc 1 55 4
+ ret;
+$L__tmp17:
+$L__func_end0:
+
+}
+ // .globl __nv_rsqrtf
+.visible .func (.param .b32 func_retval0) __nv_rsqrtf(
+ .param .b32 __nv_rsqrtf_param_0
+)
+{
+ .reg .f32 %f<3>;
+$L__func_begin1:
+
+ ld.param.f32 %f1, [__nv_rsqrtf_param_0];
+ rsqrt.approx.ftz.f32 %f2, %f1;
+ st.param.f32 [func_retval0+0], %f2;
+ ret;
+$L__func_end1:
+
+}
+ .file 1 "/tmp/torchinductor_root/lh/clhe4a3stvufxafmq3kk5hodazz2efctffte646znjdnv3lqi5oa.py"
+ .file 2 "/usr/local/lib/python3.10/dist-packages/torch/_inductor/triton_helpers.py"
+ .section .debug_abbrev
+ {
+.b8 1
+.b8 17
+.b8 1
+.b8 37
+.b8 8
+.b8 19
+.b8 5
+.b8 3
+.b8 8
+.b8 16
+.b8 6
+.b8 27
+.b8 8
+.b8 180
+.b8 66
+.b8 12
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+.b8 0
+.b8 2
+.b8 46
+.b8 0
+.b8 135
+.b8 64
+.b8 8
+.b8 3
+.b8 8
+.b8 58
+.b8 11
+.b8 59
+.b8 11
+.b8 63
+.b8 12
+.b8 32
+.b8 11
+.b8 0
+.b8 0
+.b8 3
+.b8 46
+.b8 1
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 64
+.b8 10
+.b8 49
+.b8 19
+.b8 0
+.b8 0
+.b8 4
+.b8 29
+.b8 0
+.b8 49
+.b8 19
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 88
+.b8 11
+.b8 89
+.b8 11
+.b8 87
+.b8 11
+.b8 0
+.b8 0
+.b8 5
+.b8 29
+.b8 1
+.b8 49
+.b8 19
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 88
+.b8 11
+.b8 89
+.b8 11
+.b8 87
+.b8 11
+.b8 0
+.b8 0
+.b8 0
+ }
+ .section .debug_info
+ {
+.b32 298
+.b8 2
+.b8 0
+.b32 .debug_abbrev
+.b8 8
+.b8 1
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 0
+.b8 2
+.b8 0
+.b8 99
+.b8 108
+.b8 104
+.b8 101
+.b8 52
+.b8 97
+.b8 51
+.b8 115
+.b8 116
+.b8 118
+.b8 117
+.b8 102
+.b8 120
+.b8 97
+.b8 102
+.b8 109
+.b8 113
+.b8 51
+.b8 107
+.b8 107
+.b8 53
+.b8 104
+.b8 111
+.b8 100
+.b8 97
+.b8 122
+.b8 122
+.b8 50
+.b8 101
+.b8 102
+.b8 99
+.b8 116
+.b8 102
+.b8 102
+.b8 116
+.b8 101
+.b8 54
+.b8 52
+.b8 54
+.b8 122
+.b8 110
+.b8 106
+.b8 100
+.b8 110
+.b8 118
+.b8 51
+.b8 108
+.b8 113
+.b8 105
+.b8 53
+.b8 111
+.b8 97
+.b8 46
+.b8 112
+.b8 121
+.b8 0
+.b32 .debug_line
+.b8 47
+.b8 116
+.b8 109
+.b8 112
+.b8 47
+.b8 116
+.b8 111
+.b8 114
+.b8 99
+.b8 104
+.b8 105
+.b8 110
+.b8 100
+.b8 117
+.b8 99
+.b8 116
+.b8 111
+.b8 114
+.b8 95
+.b8 114
+.b8 111
+.b8 111
+.b8 116
+.b8 47
+.b8 108
+.b8 104
+.b8 0
+.b8 1
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 2
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 101
+.b8 54
+.b8 100
+.b8 101
+.b8 0
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 101
+.b8 54
+.b8 100
+.b8 101
+.b8 0
+.b8 1
+.b8 18
+.b8 1
+.b8 1
+.b8 3
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 1
+.b8 156
+.b32 125
+.b8 4
+.b32 125
+.b64 $L__tmp1
+.b64 $L__tmp2
+.b8 2
+.b8 44
+.b8 38
+.b8 5
+.b32 125
+.b64 $L__tmp2
+.b64 $L__tmp15
+.b8 2
+.b8 50
+.b8 41
+.b8 4
+.b32 125
+.b64 $L__tmp2
+.b64 $L__tmp15
+.b8 2
+.b8 120
+.b8 46
+.b8 0
+.b8 4
+.b32 125
+.b64 $L__tmp3
+.b64 $L__tmp16
+.b8 2
+.b8 50
+.b8 41
+.b8 0
+.b8 0
+ }
+ .section .debug_pubnames
+ {
+.b32 $L__pubNames_end0-$L__pubNames_start0
+$L__pubNames_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 302
+.b32 125
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 51
+.b8 100
+.b8 52
+.b8 100
+.b8 53
+.b8 100
+.b8 101
+.b8 54
+.b8 100
+.b8 101
+.b8 0
+.b32 0
+$L__pubNames_end0:
+ }
+ .section .debug_pubtypes
+ {
+.b32 $L__pubTypes_end0-$L__pubTypes_start0
+$L__pubTypes_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 302
+.b32 0
+$L__pubTypes_end0:
+ }
+ .section .debug_loc { }
diff --git a/wandb/run-20240927_074011-gzu8f7wl/files/config.yaml b/wandb/run-20240927_074011-gzu8f7wl/files/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6154fc1b71d0cd70e206d618e715900eed50f055
--- /dev/null
+++ b/wandb/run-20240927_074011-gzu8f7wl/files/config.yaml
@@ -0,0 +1,114 @@
+_wandb:
+ value:
+ cli_version: 0.18.1
+ m: []
+ python_version: 3.10.12
+ t:
+ "1":
+ - 1
+ - 55
+ "2":
+ - 1
+ - 55
+ "3":
+ - 2
+ - 13
+ - 16
+ - 23
+ - 55
+ - 61
+ "4": 3.10.12
+ "5": 0.18.1
+ "8":
+ - 5
+ "12": 0.18.1
+ "13": linux-x86_64
+always_save_checkpoint:
+ value: true
+attention_types:
+ value:
+ - default
+backend:
+ value: nccl
+batch_size:
+ value: 120
+beta1:
+ value: 0.9
+beta2:
+ value: 0.95
+bias:
+ value: false
+block_size:
+ value: 512
+checkpoint_path:
+ value: ""
+collect_activations:
+ value: false
+collect_attention_patterns:
+ value: false
+compile:
+ value: true
+dataset:
+ value: fineweb
+decay_lr:
+ value: true
+device:
+ value: cuda
+dropout:
+ value: 0
+dtype:
+ value: bfloat16
+embedding_types:
+ value:
+ - sinusoidal
+ - polynomial_legendre
+ - polynomial_chebyshev
+ - random_fourier
+ - wavelet
+eval_datasets:
+ value:
+ - wikitext-103-v1
+ - ptb
+ - lambada
+eval_interval:
+ value: 100
+eval_iters:
+ value: 100
+eval_only:
+ value: false
+grad_clip:
+ value: 1
+gradient_accumulation_steps:
+ value: 40
+init_from:
+ value: scratch
+learning_rate:
+ value: 0.0006
+log_interval:
+ value: 1
+lr_decay_iters:
+ value: 10000
+max_iters:
+ value: 10000
+min_lr:
+ value: 6e-05
+n_embd:
+ value: 256
+n_head:
+ value: 4
+n_layer:
+ value: 4
+out_dir:
+ value: out
+seed:
+ value: 1337
+wandb_log:
+ value: true
+wandb_project:
+ value: gpt2_positional_encodings_10B
+wandb_run_name:
+ value: experiment
+warmup_iters:
+ value: 100
+weight_decay:
+ value: 0.1