![\":octocat:\"](\"https://assets-cdn.github.com/images/icons/emoji/octocat.png\"){kind=icon}
',\n 'showdown': 'S'\n};\n\r\n/**\n * Created by Estevao on 31-05-2015.\n */\n\n/**\n * Showdown Converter class\n * @class\n * @param {object} [converterOptions]\n * @returns {Converter}\n */\nshowdown.Converter = function (converterOptions) {\n 'use strict';\n\n var\n /**\n * Options used by this converter\n * @private\n * @type {{}}\n */\n options = {},\n\n /**\n * Language extensions used by this converter\n * @private\n * @type {Array}\n */\n langExtensions = [],\n\n /**\n * Output modifiers extensions used by this converter\n * @private\n * @type {Array}\n */\n outputModifiers = [],\n\n /**\n * Event listeners\n * @private\n * @type {{}}\n */\n listeners = {},\n\n /**\n * The flavor set in this converter\n */\n setConvFlavor = setFlavor,\n\n /**\n * Metadata of the document\n * @type {{parsed: {}, raw: string, format: string}}\n */\n metadata = {\n parsed: {},\n raw: '',\n format: ''\n };\n\n _constructor();\n\n /**\n * Converter constructor\n * @private\n */\n function _constructor () {\n converterOptions = converterOptions || {};\n\n for (var gOpt in globalOptions) {\n if (globalOptions.hasOwnProperty(gOpt)) {\n options[gOpt] = globalOptions[gOpt];\n }\n }\n\n // Merge options\n if (typeof converterOptions === 'object') {\n for (var opt in converterOptions) {\n if (converterOptions.hasOwnProperty(opt)) {\n options[opt] = converterOptions[opt];\n }\n }\n } else {\n throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions +\n ' was passed instead.');\n }\n\n if (options.extensions) {\n showdown.helper.forEach(options.extensions, _parseExtension);\n }\n }\n\n /**\n * Parse extension\n * @param {*} ext\n * @param {string} [name='']\n * @private\n */\n function _parseExtension (ext, name) {\n\n name = name || null;\n // If it's a string, the extension was previously loaded\n if (showdown.helper.isString(ext)) {\n ext = showdown.helper.stdExtName(ext);\n name = ext;\n\n // LEGACY_SUPPORT CODE\n if (showdown.extensions[ext]) {\n console.warn('DEPRECATION WARNING: ' + ext + ' is an old extension that uses a deprecated loading method.' +\n 'Please inform the developer that the extension should be updated!');\n legacyExtensionLoading(showdown.extensions[ext], ext);\n return;\n // END LEGACY SUPPORT CODE\n\n } else if (!showdown.helper.isUndefined(extensions[ext])) {\n ext = extensions[ext];\n\n } else {\n throw Error('Extension \"' + ext + '\" could not be loaded. It was either not found or is not a valid extension.');\n }\n }\n\n if (typeof ext === 'function') {\n ext = ext();\n }\n\n if (!showdown.helper.isArray(ext)) {\n ext = [ext];\n }\n\n var validExt = validate(ext, name);\n if (!validExt.valid) {\n throw Error(validExt.error);\n }\n\n for (var i = 0; i < ext.length; ++i) {\n switch (ext[i].type) {\n\n case 'lang':\n langExtensions.push(ext[i]);\n break;\n\n case 'output':\n outputModifiers.push(ext[i]);\n break;\n }\n if (ext[i].hasOwnProperty('listeners')) {\n for (var ln in ext[i].listeners) {\n if (ext[i].listeners.hasOwnProperty(ln)) {\n listen(ln, ext[i].listeners[ln]);\n }\n }\n }\n }\n\n }\n\n /**\n * LEGACY_SUPPORT\n * @param {*} ext\n * @param {string} name\n */\n function legacyExtensionLoading (ext, name) {\n if (typeof ext === 'function') {\n ext = ext(new showdown.Converter());\n }\n if (!showdown.helper.isArray(ext)) {\n ext = [ext];\n }\n var valid = validate(ext, name);\n\n if (!valid.valid) {\n throw Error(valid.error);\n }\n\n for (var i = 0; i < ext.length; ++i) {\n switch (ext[i].type) {\n case 'lang':\n langExtensions.push(ext[i]);\n break;\n case 'output':\n outputModifiers.push(ext[i]);\n break;\n default:// should never reach here\n throw Error('Extension loader error: Type unrecognized!!!');\n }\n }\n }\n\n /**\n * Listen to an event\n * @param {string} name\n * @param {function} callback\n */\n function listen (name, callback) {\n if (!showdown.helper.isString(name)) {\n throw Error('Invalid argument in converter.listen() method: name must be a string, but ' + typeof name + ' given');\n }\n\n if (typeof callback !== 'function') {\n throw Error('Invalid argument in converter.listen() method: callback must be a function, but ' + typeof callback + ' given');\n }\n\n if (!listeners.hasOwnProperty(name)) {\n listeners[name] = [];\n }\n listeners[name].push(callback);\n }\n\n function rTrimInputText (text) {\n var rsp = text.match(/^\\s*/)[0].length,\n rgx = new RegExp('^\\\\s{0,' + rsp + '}', 'gm');\n return text.replace(rgx, '');\n }\n\n /**\n * Dispatch an event\n * @private\n * @param {string} evtName Event name\n * @param {string} text Text\n * @param {{}} options Converter Options\n * @param {{}} globals\n * @returns {string}\n */\n this._dispatch = function dispatch (evtName, text, options, globals) {\n if (listeners.hasOwnProperty(evtName)) {\n for (var ei = 0; ei < listeners[evtName].length; ++ei) {\n var nText = listeners[evtName][ei](evtName, text, this, options, globals);\n if (nText && typeof nText !== 'undefined') {\n text = nText;\n }\n }\n }\n return text;\n };\n\n /**\n * Listen to an event\n * @param {string} name\n * @param {function} callback\n * @returns {showdown.Converter}\n */\n this.listen = function (name, callback) {\n listen(name, callback);\n return this;\n };\n\n /**\n * Converts a markdown string into HTML\n * @param {string} text\n * @returns {*}\n */\n this.makeHtml = function (text) {\n //check if text is not falsy\n if (!text) {\n return text;\n }\n\n var globals = {\n gHtmlBlocks: [],\n gHtmlMdBlocks: [],\n gHtmlSpans: [],\n gUrls: {},\n gTitles: {},\n gDimensions: {},\n gListLevel: 0,\n hashLinkCounts: {},\n langExtensions: langExtensions,\n outputModifiers: outputModifiers,\n converter: this,\n ghCodeBlocks: [],\n metadata: {\n parsed: {},\n raw: '',\n format: ''\n }\n };\n\n // This lets us use ¨ trema as an escape char to avoid md5 hashes\n // The choice of character is arbitrary; anything that isn't\n // magic in Markdown will work.\n text = text.replace(/¨/g, '¨T');\n\n // Replace $ with ¨D\n // RegExp interprets $ as a special character\n // when it's in a replacement string\n text = text.replace(/\\$/g, '¨D');\n\n // Standardize line endings\n text = text.replace(/\\r\\n/g, '\\n'); // DOS to Unix\n text = text.replace(/\\r/g, '\\n'); // Mac to Unix\n\n // Stardardize line spaces\n text = text.replace(/\\u00A0/g, ' ');\n\n if (options.smartIndentationFix) {\n text = rTrimInputText(text);\n }\n\n // Make sure text begins and ends with a couple of newlines:\n text = '\\n\\n' + text + '\\n\\n';\n\n // detab\n text = showdown.subParser('detab')(text, options, globals);\n\n /**\n * Strip any lines consisting only of spaces and tabs.\n * This makes subsequent regexs easier to write, because we can\n * match consecutive blank lines with /\\n+/ instead of something\n * contorted like /[ \\t]*\\n+/\n */\n text = text.replace(/^[ \\t]+$/mg, '');\n\n //run languageExtensions\n showdown.helper.forEach(langExtensions, function (ext) {\n text = showdown.subParser('runExtension')(ext, text, options, globals);\n });\n\n // run the sub parsers\n text = showdown.subParser('metadata')(text, options, globals);\n text = showdown.subParser('hashPreCodeTags')(text, options, globals);\n text = showdown.subParser('githubCodeBlocks')(text, options, globals);\n text = showdown.subParser('hashHTMLBlocks')(text, options, globals);\n text = showdown.subParser('hashCodeTags')(text, options, globals);\n text = showdown.subParser('stripLinkDefinitions')(text, options, globals);\n text = showdown.subParser('blockGamut')(text, options, globals);\n text = showdown.subParser('unhashHTMLSpans')(text, options, globals);\n text = showdown.subParser('unescapeSpecialChars')(text, options, globals);\n\n // attacklab: Restore dollar signs\n text = text.replace(/¨D/g, '$$');\n\n // attacklab: Restore tremas\n text = text.replace(/¨T/g, '¨');\n\n // render a complete html document instead of a partial if the option is enabled\n text = showdown.subParser('completeHTMLDocument')(text, options, globals);\n\n // Run output modifiers\n showdown.helper.forEach(outputModifiers, function (ext) {\n text = showdown.subParser('runExtension')(ext, text, options, globals);\n });\n\n // update metadata\n metadata = globals.metadata;\n return text;\n };\n\n /**\n * Converts an HTML string into a markdown string\n * @param src\n * @param [HTMLParser] A WHATWG DOM and HTML parser, such as JSDOM. If none is supplied, window.document will be used.\n * @returns {string}\n */\n this.makeMarkdown = this.makeMd = function (src, HTMLParser) {\n\n // replace \\r\\n with \\n\n src = src.replace(/\\r\\n/g, '\\n');\n src = src.replace(/\\r/g, '\\n'); // old macs\n\n // due to an edge case, we need to find this: > <\n // to prevent removing of non silent white spaces\n // ex: this is sparta\n src = src.replace(/>[ \\t]+¨NBSP;<');\n\n if (!HTMLParser) {\n if (window && window.document) {\n HTMLParser = window.document;\n } else {\n throw new Error('HTMLParser is undefined. If in a webworker or nodejs environment, you need to provide a WHATWG DOM and HTML such as JSDOM');\n }\n }\n\n var doc = HTMLParser.createElement('div');\n doc.innerHTML = src;\n\n var globals = {\n preList: substitutePreCodeTags(doc)\n };\n\n // remove all newlines and collapse spaces\n clean(doc);\n\n // some stuff, like accidental reference links must now be escaped\n // TODO\n // doc.innerHTML = doc.innerHTML.replace(/\\[[\\S\\t ]]/);\n\n var nodes = doc.childNodes,\n mdDoc = '';\n\n for (var i = 0; i < nodes.length; i++) {\n mdDoc += showdown.subParser('makeMarkdown.node')(nodes[i], globals);\n }\n\n function clean (node) {\n for (var n = 0; n < node.childNodes.length; ++n) {\n var child = node.childNodes[n];\n if (child.nodeType === 3) {\n if (!/\\S/.test(child.nodeValue)) {\n node.removeChild(child);\n --n;\n } else {\n child.nodeValue = child.nodeValue.split('\\n').join(' ');\n child.nodeValue = child.nodeValue.replace(/(\\s)+/g, '$1');\n }\n } else if (child.nodeType === 1) {\n clean(child);\n }\n }\n }\n\n // find all pre tags and replace contents with placeholder\n // we need this so that we can remove all indentation from html\n // to ease up parsing\n function substitutePreCodeTags (doc) {\n\n var pres = doc.querySelectorAll('pre'),\n presPH = [];\n\n for (var i = 0; i < pres.length; ++i) {\n\n if (pres[i].childElementCount === 1 && pres[i].firstChild.tagName.toLowerCase() === 'code') {\n var content = pres[i].firstChild.innerHTML.trim(),\n language = pres[i].firstChild.getAttribute('data-language') || '';\n\n // if data-language attribute is not defined, then we look for class language-*\n if (language === '') {\n var classes = pres[i].firstChild.className.split(' ');\n for (var c = 0; c < classes.length; ++c) {\n var matches = classes[c].match(/^language-(.+)$/);\n if (matches !== null) {\n language = matches[1];\n break;\n }\n }\n }\n\n // unescape html entities in content\n content = showdown.helper.unescapeHTMLEntities(content);\n\n presPH.push(content);\n pres[i].outerHTML = 'tags around block-level tags.\n text = showdown.subParser('hashHTMLBlocks')(text, options, globals);\n text = showdown.subParser('paragraphs')(text, options, globals);\n\n text = globals.converter._dispatch('blockGamut.after', text, options, globals);\n\n return text;\n});\n\r\nshowdown.subParser('blockQuotes', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('blockQuotes.before', text, options, globals);\n\n // add a couple extra lines after the text and endtext mark\n text = text + '\\n\\n';\n\n var rgx = /(^ {0,3}>[ \\t]?.+\\n(.+\\n)*\\n*)+/gm;\n\n if (options.splitAdjacentBlockquotes) {\n rgx = /^ {0,3}>[\\s\\S]*?(?:\\n\\n)/gm;\n }\n\n text = text.replace(rgx, function (bq) {\n // attacklab: hack around Konqueror 3.5.4 bug:\n // \"----------bug\".replace(/^-/g,\"\") == \"bug\"\n bq = bq.replace(/^[ \\t]*>[ \\t]?/gm, ''); // trim one level of quoting\n\n // attacklab: clean up hack\n bq = bq.replace(/¨0/g, '');\n\n bq = bq.replace(/^[ \\t]+$/gm, ''); // trim whitespace-only lines\n bq = showdown.subParser('githubCodeBlocks')(bq, options, globals);\n bq = showdown.subParser('blockGamut')(bq, options, globals); // recurse\n\n bq = bq.replace(/(^|\\n)/g, '$1 ');\n // These leading spaces screw with
content, so we need to fix that:\n bq = bq.replace(/(\\s*[^\\r]+?<\\/pre>)/gm, function (wholeMatch, m1) {\n var pre = m1;\n // attacklab: hack around Konqueror 3.5.4 bug:\n pre = pre.replace(/^ /mg, '¨0');\n pre = pre.replace(/¨0/g, '');\n return pre;\n });\n\n return showdown.subParser('hashBlock')('\\n' + bq + '\\n
', options, globals);\n });\n\n text = globals.converter._dispatch('blockQuotes.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Process Markdown `` blocks.\n */\nshowdown.subParser('codeBlocks', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('codeBlocks.before', text, options, globals);\n\n // sentinel workarounds for lack of \\A and \\Z, safari\\khtml bug\n text += '¨0';\n\n var pattern = /(?:\\n\\n|^)((?:(?:[ ]{4}|\\t).*\\n+)+)(\\n*[ ]{0,3}[^ \\t\\n]|(?=¨0))/g;\n text = text.replace(pattern, function (wholeMatch, m1, m2) {\n var codeblock = m1,\n nextChar = m2,\n end = '\\n';\n\n codeblock = showdown.subParser('outdent')(codeblock, options, globals);\n codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);\n codeblock = showdown.subParser('detab')(codeblock, options, globals);\n codeblock = codeblock.replace(/^\\n+/g, ''); // trim leading newlines\n codeblock = codeblock.replace(/\\n+$/g, ''); // trim trailing newlines\n\n if (options.omitExtraWLInCodeBlocks) {\n end = '';\n }\n\n codeblock = '' + codeblock + end + '
';\n\n return showdown.subParser('hashBlock')(codeblock, options, globals) + nextChar;\n });\n\n // strip sentinel\n text = text.replace(/¨0/, '');\n\n text = globals.converter._dispatch('codeBlocks.after', text, options, globals);\n return text;\n});\n\r\n/**\n *\n * * Backtick quotes are used for Just type foo `bar` baz at the prompt.
\n *\n * There's no arbitrary limit to the number of backticks you\n * can use as delimters. If you need three consecutive backticks\n * in your code, use four for delimiters, etc.\n *\n * * You can use spaces to get literal backticks at the edges:\n *\n * ... type `` `bar` `` ...\n *\n * Turns to:\n *\n * ... type `bar` ...\n */\nshowdown.subParser('codeSpans', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('codeSpans.before', text, options, globals);\n\n if (typeof text === 'undefined') {\n text = '';\n }\n text = text.replace(/(^|[^\\\\])(`+)([^\\r]*?[^`])\\2(?!`)/gm,\n function (wholeMatch, m1, m2, m3) {\n var c = m3;\n c = c.replace(/^([ \\t]*)/g, '');\t// leading whitespace\n c = c.replace(/[ \\t]*$/g, '');\t// trailing whitespace\n c = showdown.subParser('encodeCode')(c, options, globals);\n c = m1 + '' + c + '';\n c = showdown.subParser('hashHTMLSpans')(c, options, globals);\n return c;\n }\n );\n\n text = globals.converter._dispatch('codeSpans.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Create a full HTML document from the processed markdown\n */\nshowdown.subParser('completeHTMLDocument', function (text, options, globals) {\n 'use strict';\n\n if (!options.completeHTMLDocument) {\n return text;\n }\n\n text = globals.converter._dispatch('completeHTMLDocument.before', text, options, globals);\n\n var doctype = 'html',\n doctypeParsed = '\\n',\n title = '',\n charset = '\\n',\n lang = '',\n metadata = '';\n\n if (typeof globals.metadata.parsed.doctype !== 'undefined') {\n doctypeParsed = '\\n';\n doctype = globals.metadata.parsed.doctype.toString().toLowerCase();\n if (doctype === 'html' || doctype === 'html5') {\n charset = '';\n }\n }\n\n for (var meta in globals.metadata.parsed) {\n if (globals.metadata.parsed.hasOwnProperty(meta)) {\n switch (meta.toLowerCase()) {\n case 'doctype':\n break;\n\n case 'title':\n title = '' + globals.metadata.parsed.title + ' \\n';\n break;\n\n case 'charset':\n if (doctype === 'html' || doctype === 'html5') {\n charset = '\\n';\n } else {\n charset = '\\n';\n }\n break;\n\n case 'language':\n case 'lang':\n lang = ' lang=\"' + globals.metadata.parsed[meta] + '\"';\n metadata += '\\n';\n break;\n\n default:\n metadata += '\\n';\n }\n }\n }\n\n text = doctypeParsed + '\\n\\n' + title + charset + metadata + '\\n\\n' + text.trim() + '\\n\\n';\n\n text = globals.converter._dispatch('completeHTMLDocument.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Convert all tabs to spaces\n */\nshowdown.subParser('detab', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('detab.before', text, options, globals);\n\n // expand first n-1 tabs\n text = text.replace(/\\t(?=\\t)/g, ' '); // g_tab_width\n\n // replace the nth with two sentinels\n text = text.replace(/\\t/g, '¨A¨B');\n\n // use the sentinel to anchor our regex so it doesn't explode\n text = text.replace(/¨B(.+?)¨A/g, function (wholeMatch, m1) {\n var leadingText = m1,\n numSpaces = 4 - leadingText.length % 4; // g_tab_width\n\n // there *must* be a better way to do this:\n for (var i = 0; i < numSpaces; i++) {\n leadingText += ' ';\n }\n\n return leadingText;\n });\n\n // clean up sentinels\n text = text.replace(/¨A/g, ' '); // g_tab_width\n text = text.replace(/¨B/g, '');\n\n text = globals.converter._dispatch('detab.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('ellipsis', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('ellipsis.before', text, options, globals);\n\n text = text.replace(/\\.\\.\\./g, '…');\n\n text = globals.converter._dispatch('ellipsis.after', text, options, globals);\n\n return text;\n});\n\r\n/**\n * Turn emoji codes into emojis\n *\n * List of supported emojis: https://github.com/showdownjs/showdown/wiki/Emojis\n */\nshowdown.subParser('emoji', function (text, options, globals) {\n 'use strict';\n\n if (!options.emoji) {\n return text;\n }\n\n text = globals.converter._dispatch('emoji.before', text, options, globals);\n\n var emojiRgx = /:([\\S]+?):/g;\n\n text = text.replace(emojiRgx, function (wm, emojiCode) {\n if (showdown.helper.emojis.hasOwnProperty(emojiCode)) {\n return showdown.helper.emojis[emojiCode];\n }\n return wm;\n });\n\n text = globals.converter._dispatch('emoji.after', text, options, globals);\n\n return text;\n});\n\r\n/**\n * Smart processing for ampersands and angle brackets that need to be encoded.\n */\nshowdown.subParser('encodeAmpsAndAngles', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('encodeAmpsAndAngles.before', text, options, globals);\n\n // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:\n // http://bumppo.net/projects/amputator/\n text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\\w+);)/g, '&');\n\n // Encode naked <'s\n text = text.replace(/<(?![a-z\\/?$!])/gi, '<');\n\n // Encode <\n text = text.replace(/\n text = text.replace(/>/g, '>');\n\n text = globals.converter._dispatch('encodeAmpsAndAngles.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Returns the string, with after processing the following backslash escape sequences.\n *\n * attacklab: The polite way to do this is with the new escapeCharacters() function:\n *\n * text = escapeCharacters(text,\"\\\\\",true);\n * text = escapeCharacters(text,\"`*_{}[]()>#+-.!\",true);\n *\n * ...but we're sidestepping its use of the (slow) RegExp constructor\n * as an optimization for Firefox. This function gets called a LOT.\n */\nshowdown.subParser('encodeBackslashEscapes', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('encodeBackslashEscapes.before', text, options, globals);\n\n text = text.replace(/\\\\(\\\\)/g, showdown.helper.escapeCharactersCallback);\n text = text.replace(/\\\\([`*_{}\\[\\]()>#+.!~=|-])/g, showdown.helper.escapeCharactersCallback);\n\n text = globals.converter._dispatch('encodeBackslashEscapes.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Encode/escape certain characters inside Markdown code runs.\n * The point is that in code, these characters are literals,\n * and lose their special Markdown meanings.\n */\nshowdown.subParser('encodeCode', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('encodeCode.before', text, options, globals);\n\n // Encode all ampersands; HTML entities are not\n // entities within a Markdown code span.\n text = text\n .replace(/&/g, '&')\n // Do the angle bracket song and dance:\n .replace(//g, '>')\n // Now, escape characters that are magic in Markdown:\n .replace(/([*_{}\\[\\]\\\\=~-])/g, showdown.helper.escapeCharactersCallback);\n\n text = globals.converter._dispatch('encodeCode.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Within tags -- meaning between < and > -- encode [\\ ` * _ ~ =] so they\n * don't conflict with their use in Markdown for code, italics and strong.\n */\nshowdown.subParser('escapeSpecialCharsWithinTagAttributes', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.before', text, options, globals);\n\n // Build a regex to find HTML tags.\n var tags = /<\\/?[a-z\\d_:-]+(?:[\\s]+[\\s\\S]+?)?>/gi,\n comments = /-]|-[^>])(?:[^-]|-[^-])*)--)>/gi;\n\n text = text.replace(tags, function (wholeMatch) {\n return wholeMatch\n .replace(/(.)<\\/?code>(?=.)/g, '$1`')\n .replace(/([\\\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);\n });\n\n text = text.replace(comments, function (wholeMatch) {\n return wholeMatch\n .replace(/([\\\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);\n });\n\n text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Handle github codeblocks prior to running HashHTML so that\n * HTML contained within the codeblock gets escaped properly\n * Example:\n * ```ruby\n * def hello_world(x)\n * puts \"Hello, #{x}\"\n * end\n * ```\n */\nshowdown.subParser('githubCodeBlocks', function (text, options, globals) {\n 'use strict';\n\n // early exit if option is not enabled\n if (!options.ghCodeBlocks) {\n return text;\n }\n\n text = globals.converter._dispatch('githubCodeBlocks.before', text, options, globals);\n\n text += '¨0';\n\n text = text.replace(/(?:^|\\n)(?: {0,3})(```+|~~~+)(?: *)([^\\s`~]*)\\n([\\s\\S]*?)\\n(?: {0,3})\\1/g, function (wholeMatch, delim, language, codeblock) {\n var end = (options.omitExtraWLInCodeBlocks) ? '' : '\\n';\n\n // First parse the github code block\n codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);\n codeblock = showdown.subParser('detab')(codeblock, options, globals);\n codeblock = codeblock.replace(/^\\n+/g, ''); // trim leading newlines\n codeblock = codeblock.replace(/\\n+$/g, ''); // trim trailing whitespace\n\n codeblock = '' + codeblock + end + '
';\n\n codeblock = showdown.subParser('hashBlock')(codeblock, options, globals);\n\n // Since GHCodeblocks can be false positives, we need to\n // store the primitive text and the parsed text in a global var,\n // and then return a token\n return '\\n\\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\\n\\n';\n });\n\n // attacklab: strip sentinel\n text = text.replace(/¨0/, '');\n\n return globals.converter._dispatch('githubCodeBlocks.after', text, options, globals);\n});\n\r\nshowdown.subParser('hashBlock', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('hashBlock.before', text, options, globals);\n text = text.replace(/(^\\n+|\\n+$)/g, '');\n text = '\\n\\n¨K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\\n\\n';\n text = globals.converter._dispatch('hashBlock.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Hash and escape elements that should not be parsed as markdown\n */\nshowdown.subParser('hashCodeTags', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('hashCodeTags.before', text, options, globals);\n\n var repFunc = function (wholeMatch, match, left, right) {\n var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;\n return '¨C' + (globals.gHtmlSpans.push(codeblock) - 1) + 'C';\n };\n\n // Hash naked \n text = showdown.helper.replaceRecursiveRegExp(text, repFunc, ']*>', ' ', 'gim');\n\n text = globals.converter._dispatch('hashCodeTags.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('hashElement', function (text, options, globals) {\n 'use strict';\n\n return function (wholeMatch, m1) {\n var blockText = m1;\n\n // Undo double lines\n blockText = blockText.replace(/\\n\\n/g, '\\n');\n blockText = blockText.replace(/^\\n/, '');\n\n // strip trailing blank lines\n blockText = blockText.replace(/\\n+$/g, '');\n\n // Replace the element text with a marker (\"¨KxK\" where x is its key)\n blockText = '\\n\\n¨K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\\n\\n';\n\n return blockText;\n };\n});\n\r\nshowdown.subParser('hashHTMLBlocks', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('hashHTMLBlocks.before', text, options, globals);\n\n var blockTags = [\n 'pre',\n 'div',\n 'h1',\n 'h2',\n 'h3',\n 'h4',\n 'h5',\n 'h6',\n 'blockquote',\n 'table',\n 'dl',\n 'ol',\n 'ul',\n 'script',\n 'noscript',\n 'form',\n 'fieldset',\n 'iframe',\n 'math',\n 'style',\n 'section',\n 'header',\n 'footer',\n 'nav',\n 'article',\n 'aside',\n 'address',\n 'audio',\n 'canvas',\n 'figure',\n 'hgroup',\n 'output',\n 'video',\n 'p'\n ],\n repFunc = function (wholeMatch, match, left, right) {\n var txt = wholeMatch;\n // check if this html element is marked as markdown\n // if so, it's contents should be parsed as markdown\n if (left.search(/\\bmarkdown\\b/) !== -1) {\n txt = left + globals.converter.makeHtml(match) + right;\n }\n return '\\n\\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\\n\\n';\n };\n\n if (options.backslashEscapesHTMLTags) {\n // encode backslash escaped HTML tags\n text = text.replace(/\\\\<(\\/?[^>]+?)>/g, function (wm, inside) {\n return '<' + inside + '>';\n });\n }\n\n // hash HTML Blocks\n for (var i = 0; i < blockTags.length; ++i) {\n\n var opTagPos,\n rgx1 = new RegExp('^ {0,3}(<' + blockTags[i] + '\\\\b[^>]*>)', 'im'),\n patLeft = '<' + blockTags[i] + '\\\\b[^>]*>',\n patRight = '';\n // 1. Look for the first position of the first opening HTML tag in the text\n while ((opTagPos = showdown.helper.regexIndexOf(text, rgx1)) !== -1) {\n\n // if the HTML tag is \\ escaped, we need to escape it and break\n\n\n //2. Split the text in that position\n var subTexts = showdown.helper.splitAtIndex(text, opTagPos),\n //3. Match recursively\n newSubText1 = showdown.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, 'im');\n\n // prevent an infinite loop\n if (newSubText1 === subTexts[1]) {\n break;\n }\n text = subTexts[0].concat(newSubText1);\n }\n }\n // HR SPECIAL CASE\n text = text.replace(/(\\n {0,3}(<(hr)\\b([^<>])*?\\/?>)[ \\t]*(?=\\n{2,}))/g,\n showdown.subParser('hashElement')(text, options, globals));\n\n // Special case for standalone HTML comments\n text = showdown.helper.replaceRecursiveRegExp(text, function (txt) {\n return '\\n\\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\\n\\n';\n }, '^ {0,3}', 'gm');\n\n // PHP and ASP-style processor instructions ( and <%...%>)\n text = text.replace(/(?:\\n\\n)( {0,3}(?:<([?%])[^\\r]*?\\2>)[ \\t]*(?=\\n{2,}))/g,\n showdown.subParser('hashElement')(text, options, globals));\n\n text = globals.converter._dispatch('hashHTMLBlocks.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Hash span elements that should not be parsed as markdown\n */\nshowdown.subParser('hashHTMLSpans', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('hashHTMLSpans.before', text, options, globals);\n\n function hashHTMLSpan (html) {\n return '¨C' + (globals.gHtmlSpans.push(html) - 1) + 'C';\n }\n\n // Hash Self Closing tags\n text = text.replace(/<[^>]+?\\/>/gi, function (wm) {\n return hashHTMLSpan(wm);\n });\n\n // Hash tags without properties\n text = text.replace(/<([^>]+?)>[\\s\\S]*?<\\/\\1>/g, function (wm) {\n return hashHTMLSpan(wm);\n });\n\n // Hash tags with properties\n text = text.replace(/<([^>]+?)\\s[^>]+?>[\\s\\S]*?<\\/\\1>/g, function (wm) {\n return hashHTMLSpan(wm);\n });\n\n // Hash self closing tags without />\n text = text.replace(/<[^>]+?>/gi, function (wm) {\n return hashHTMLSpan(wm);\n });\n\n /*showdown.helper.matchRecursiveRegExp(text, ']*>', ' ', 'gi');*/\n\n text = globals.converter._dispatch('hashHTMLSpans.after', text, options, globals);\n return text;\n});\n\n/**\n * Unhash HTML spans\n */\nshowdown.subParser('unhashHTMLSpans', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('unhashHTMLSpans.before', text, options, globals);\n\n for (var i = 0; i < globals.gHtmlSpans.length; ++i) {\n var repText = globals.gHtmlSpans[i],\n // limiter to prevent infinite loop (assume 10 as limit for recurse)\n limit = 0;\n\n while (/¨C(\\d+)C/.test(repText)) {\n var num = RegExp.$1;\n repText = repText.replace('¨C' + num + 'C', globals.gHtmlSpans[num]);\n if (limit === 10) {\n console.error('maximum nesting of 10 spans reached!!!');\n break;\n }\n ++limit;\n }\n text = text.replace('¨C' + i + 'C', repText);\n }\n\n text = globals.converter._dispatch('unhashHTMLSpans.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Hash and escape elements that should not be parsed as markdown\n */\nshowdown.subParser('hashPreCodeTags', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('hashPreCodeTags.before', text, options, globals);\n\n var repFunc = function (wholeMatch, match, left, right) {\n // encode html entities\n var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;\n return '\\n\\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\\n\\n';\n };\n\n // Hash \n text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^ {0,3}]*>\\\\s*]*>', '^ {0,3} \\\\s*
', 'gim');\n\n text = globals.converter._dispatch('hashPreCodeTags.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('headers', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('headers.before', text, options, globals);\n\n var headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),\n\n // Set text-style headers:\n //\tHeader 1\n //\t========\n //\n //\tHeader 2\n //\t--------\n //\n setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \\t]*\\n={2,}[ \\t]*\\n+/gm : /^(.+)[ \\t]*\\n=+[ \\t]*\\n+/gm,\n setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \\t]*\\n-{2,}[ \\t]*\\n+/gm : /^(.+)[ \\t]*\\n-+[ \\t]*\\n+/gm;\n\n text = text.replace(setextRegexH1, function (wholeMatch, m1) {\n\n var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m1) + '\"',\n hLevel = headerLevelStart,\n hashBlock = '' + spanGamut + ' ';\n return showdown.subParser('hashBlock')(hashBlock, options, globals);\n });\n\n text = text.replace(setextRegexH2, function (matchFound, m1) {\n var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m1) + '\"',\n hLevel = headerLevelStart + 1,\n hashBlock = '' + spanGamut + ' ';\n return showdown.subParser('hashBlock')(hashBlock, options, globals);\n });\n\n // atx-style headers:\n // # Header 1\n // ## Header 2\n // ## Header 2 with closing hashes ##\n // ...\n // ###### Header 6\n //\n var atxStyle = (options.requireSpaceBeforeHeadingText) ? /^(#{1,6})[ \\t]+(.+?)[ \\t]*#*\\n+/gm : /^(#{1,6})[ \\t]*(.+?)[ \\t]*#*\\n+/gm;\n\n text = text.replace(atxStyle, function (wholeMatch, m1, m2) {\n var hText = m2;\n if (options.customizedHeaderId) {\n hText = m2.replace(/\\s?\\{([^{]+?)}\\s*$/, '');\n }\n\n var span = showdown.subParser('spanGamut')(hText, options, globals),\n hID = (options.noHeaderId) ? '' : ' id=\"' + headerId(m2) + '\"',\n hLevel = headerLevelStart - 1 + m1.length,\n header = '' + span + ' ';\n\n return showdown.subParser('hashBlock')(header, options, globals);\n });\n\n function headerId (m) {\n var title,\n prefix;\n\n // It is separate from other options to allow combining prefix and customized\n if (options.customizedHeaderId) {\n var match = m.match(/\\{([^{]+?)}\\s*$/);\n if (match && match[1]) {\n m = match[1];\n }\n }\n\n title = m;\n\n // Prefix id to prevent causing inadvertent pre-existing style matches.\n if (showdown.helper.isString(options.prefixHeaderId)) {\n prefix = options.prefixHeaderId;\n } else if (options.prefixHeaderId === true) {\n prefix = 'section-';\n } else {\n prefix = '';\n }\n\n if (!options.rawPrefixHeaderId) {\n title = prefix + title;\n }\n\n if (options.ghCompatibleHeaderId) {\n title = title\n .replace(/ /g, '-')\n // replace previously escaped chars (&, ¨ and $)\n .replace(/&/g, '')\n .replace(/¨T/g, '')\n .replace(/¨D/g, '')\n // replace rest of the chars (&~$ are repeated as they might have been escaped)\n // borrowed from github's redcarpet (some they should produce similar results)\n .replace(/[&+$,\\/:;=?@\"#{}|^¨~\\[\\]`\\\\*)(%.!'<>]/g, '')\n .toLowerCase();\n } else if (options.rawHeaderId) {\n title = title\n .replace(/ /g, '-')\n // replace previously escaped chars (&, ¨ and $)\n .replace(/&/g, '&')\n .replace(/¨T/g, '¨')\n .replace(/¨D/g, '$')\n // replace \" and '\n .replace(/[\"']/g, '-')\n .toLowerCase();\n } else {\n title = title\n .replace(/[^\\w]/g, '')\n .toLowerCase();\n }\n\n if (options.rawPrefixHeaderId) {\n title = prefix + title;\n }\n\n if (globals.hashLinkCounts[title]) {\n title = title + '-' + (globals.hashLinkCounts[title]++);\n } else {\n globals.hashLinkCounts[title] = 1;\n }\n return title;\n }\n\n text = globals.converter._dispatch('headers.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Turn Markdown link shortcuts into XHTML tags.\n */\nshowdown.subParser('horizontalRule', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('horizontalRule.before', text, options, globals);\n\n var key = showdown.subParser('hashBlock')('
', options, globals);\n text = text.replace(/^ {0,2}( ?-){3,}[ \\t]*$/gm, key);\n text = text.replace(/^ {0,2}( ?\\*){3,}[ \\t]*$/gm, key);\n text = text.replace(/^ {0,2}( ?_){3,}[ \\t]*$/gm, key);\n\n text = globals.converter._dispatch('horizontalRule.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Turn Markdown image shortcuts into ![]()
tags.\n */\nshowdown.subParser('images', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('images.before', text, options, globals);\n\n var inlineRegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]??(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:([\"'])([^\"]*?)\\6)?[ \\t]?\\)/g,\n crazyRegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]?<([^>]*)>(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:(?:([\"'])([^\"]*?)\\6))?[ \\t]?\\)/g,\n base64RegExp = /!\\[([^\\]]*?)][ \\t]*()\\([ \\t]??(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*(?:([\"'])([^\"]*?)\\6)?[ \\t]?\\)/g,\n referenceRegExp = /!\\[([^\\]]*?)] ?(?:\\n *)?\\[([\\s\\S]*?)]()()()()()/g,\n refShortcutRegExp = /!\\[([^\\[\\]]+)]()()()()()/g;\n\n function writeImageTagBase64 (wholeMatch, altText, linkId, url, width, height, m5, title) {\n url = url.replace(/\\s/g, '');\n return writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title);\n }\n\n function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {\n\n var gUrls = globals.gUrls,\n gTitles = globals.gTitles,\n gDims = globals.gDimensions;\n\n linkId = linkId.toLowerCase();\n\n if (!title) {\n title = '';\n }\n // Special case for explicit empty url\n if (wholeMatch.search(/\\(? ?(['\"].*['\"])?\\)$/m) > -1) {\n url = '';\n\n } else if (url === '' || url === null) {\n if (linkId === '' || linkId === null) {\n // lower-case and turn embedded newlines into spaces\n linkId = altText.toLowerCase().replace(/ ?\\n/g, ' ');\n }\n url = '#' + linkId;\n\n if (!showdown.helper.isUndefined(gUrls[linkId])) {\n url = gUrls[linkId];\n if (!showdown.helper.isUndefined(gTitles[linkId])) {\n title = gTitles[linkId];\n }\n if (!showdown.helper.isUndefined(gDims[linkId])) {\n width = gDims[linkId].width;\n height = gDims[linkId].height;\n }\n } else {\n return wholeMatch;\n }\n }\n\n altText = altText\n .replace(/\"/g, '"')\n //altText = showdown.helper.escapeCharacters(altText, '*_', false);\n .replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);\n //url = showdown.helper.escapeCharacters(url, '*_', false);\n url = url.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);\n var result = '![\"'](\"' "title\n")
x \"optional title\")\n\n // base64 encoded images\n text = text.replace(base64RegExp, writeImageTagBase64);\n\n // cases with crazy urls like ./image/cat1).png\n text = text.replace(crazyRegExp, writeImageTag);\n\n // normal cases\n text = text.replace(inlineRegExp, writeImageTag);\n\n // handle reference-style shortcuts: ![img text]\n text = text.replace(refShortcutRegExp, writeImageTag);\n\n text = globals.converter._dispatch('images.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('italicsAndBold', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('italicsAndBold.before', text, options, globals);\n\n // it's faster to have 3 separate regexes for each case than have just one\n // because of backtracing, in some cases, it could lead to an exponential effect\n // called \"catastrophic backtrace\". Ominous!\n\n function parseInside (txt, left, right) {\n /*\n if (options.simplifiedAutoLink) {\n txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);\n }\n */\n return left + txt + right;\n }\n\n // Parse underscores\n if (options.literalMidWordUnderscores) {\n text = text.replace(/\\b___(\\S[\\s\\S]*?)___\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n text = text.replace(/\\b__(\\S[\\s\\S]*?)__\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n text = text.replace(/\\b_(\\S[\\s\\S]*?)_\\b/g, function (wm, txt) {\n return parseInside (txt, '', '');\n });\n } else {\n text = text.replace(/___(\\S[\\s\\S]*?)___/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/__(\\S[\\s\\S]*?)__/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/_([^\\s_][\\s\\S]*?)_/g, function (wm, m) {\n // !/^_[^_]/.test(m) - test if it doesn't start with __ (since it seems redundant, we removed it)\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n }\n\n // Now parse asterisks\n if (options.literalMidWordAsterisks) {\n text = text.replace(/([^*]|^)\\B\\*\\*\\*(\\S[\\s\\S]*?)\\*\\*\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n text = text.replace(/([^*]|^)\\B\\*\\*(\\S[\\s\\S]*?)\\*\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n text = text.replace(/([^*]|^)\\B\\*(\\S[\\s\\S]*?)\\*\\B(?!\\*)/g, function (wm, lead, txt) {\n return parseInside (txt, lead + '', '');\n });\n } else {\n text = text.replace(/\\*\\*\\*(\\S[\\s\\S]*?)\\*\\*\\*/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/\\*\\*(\\S[\\s\\S]*?)\\*\\*/g, function (wm, m) {\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n text = text.replace(/\\*([^\\s*][\\s\\S]*?)\\*/g, function (wm, m) {\n // !/^\\*[^*]/.test(m) - test if it doesn't start with ** (since it seems redundant, we removed it)\n return (/\\S$/.test(m)) ? parseInside (m, '', '') : wm;\n });\n }\n\n\n text = globals.converter._dispatch('italicsAndBold.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Form HTML ordered (numbered) and unordered (bulleted) lists.\n */\nshowdown.subParser('lists', function (text, options, globals) {\n 'use strict';\n\n /**\n * Process the contents of a single ordered or unordered list, splitting it\n * into individual list items.\n * @param {string} listStr\n * @param {boolean} trimTrailing\n * @returns {string}\n */\n function processListItems (listStr, trimTrailing) {\n // The $g_list_level global keeps track of when we're inside a list.\n // Each time we enter a list, we increment it; when we leave a list,\n // we decrement. If it's zero, we're not in a list anymore.\n //\n // We do this because when we're not inside a list, we want to treat\n // something like this:\n //\n // I recommend upgrading to version\n // 8. Oops, now this line is treated\n // as a sub-list.\n //\n // As a single paragraph, despite the fact that the second line starts\n // with a digit-period-space sequence.\n //\n // Whereas when we're inside a list (or sub-list), that line will be\n // treated as the start of a sub-list. What a kludge, huh? This is\n // an aspect of Markdown's syntax that's hard to parse perfectly\n // without resorting to mind-reading. Perhaps the solution is to\n // change the syntax rules such that sub-lists must start with a\n // starting cardinal number; e.g. \"1.\" or \"a.\".\n globals.gListLevel++;\n\n // trim trailing blank lines:\n listStr = listStr.replace(/\\n{2,}$/, '\\n');\n\n // attacklab: add sentinel to emulate \\z\n listStr += '¨0';\n\n var rgx = /(\\n)?(^ {0,3})([*+-]|\\d+[.])[ \\t]+((\\[(x|X| )?])?[ \\t]*[^\\r]+?(\\n{1,2}))(?=\\n*(¨0| {0,3}([*+-]|\\d+[.])[ \\t]+))/gm,\n isParagraphed = (/\\n[ \\t]*\\n(?!¨0)/.test(listStr));\n\n // Since version 1.5, nesting sublists requires 4 spaces (or 1 tab) indentation,\n // which is a syntax breaking change\n // activating this option reverts to old behavior\n if (options.disableForced4SpacesIndentedSublists) {\n rgx = /(\\n)?(^ {0,3})([*+-]|\\d+[.])[ \\t]+((\\[(x|X| )?])?[ \\t]*[^\\r]+?(\\n{1,2}))(?=\\n*(¨0|\\2([*+-]|\\d+[.])[ \\t]+))/gm;\n }\n\n listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {\n checked = (checked && checked.trim() !== '');\n\n var item = showdown.subParser('outdent')(m4, options, globals),\n bulletStyle = '';\n\n // Support for github tasklists\n if (taskbtn && options.tasklists) {\n bulletStyle = ' class=\"task-list-item\" style=\"list-style-type: none;\"';\n item = item.replace(/^[ \\t]*\\[(x|X| )?]/m, function () {\n var otp = 'a \n // instead of:\n // - - - a
\n // So, to prevent it, we will put a marker (¨A)in the beginning of the line\n // Kind of hackish/monkey patching, but seems more effective than overcomplicating the list parser\n item = item.replace(/^([-*+]|\\d\\.)[ \\t]+[\\S\\n ]*/g, function (wm2) {\n return '¨A' + wm2;\n });\n\n // m1 - Leading line or\n // Has a double return (multi paragraph) or\n // Has sublist\n if (m1 || (item.search(/\\n{2,}/) > -1)) {\n item = showdown.subParser('githubCodeBlocks')(item, options, globals);\n item = showdown.subParser('blockGamut')(item, options, globals);\n } else {\n // Recursion for sub-lists:\n item = showdown.subParser('lists')(item, options, globals);\n item = item.replace(/\\n$/, ''); // chomp(item)\n item = showdown.subParser('hashHTMLBlocks')(item, options, globals);\n\n // Colapse double linebreaks\n item = item.replace(/\\n\\n+/g, '\\n\\n');\n if (isParagraphed) {\n item = showdown.subParser('paragraphs')(item, options, globals);\n } else {\n item = showdown.subParser('spanGamut')(item, options, globals);\n }\n }\n\n // now we need to remove the marker (¨A)\n item = item.replace('¨A', '');\n // we can finally wrap the line in list item tags\n item = '' + item + '\\n';\n\n return item;\n });\n\n // attacklab: strip sentinel\n listStr = listStr.replace(/¨0/g, '');\n\n globals.gListLevel--;\n\n if (trimTrailing) {\n listStr = listStr.replace(/\\s+$/, '');\n }\n\n return listStr;\n }\n\n function styleStartNumber (list, listType) {\n // check if ol and starts by a number different than 1\n if (listType === 'ol') {\n var res = list.match(/^ *(\\d+)\\./);\n if (res && res[1] !== '1') {\n return ' start=\"' + res[1] + '\"';\n }\n }\n return '';\n }\n\n /**\n * Check and parse consecutive lists (better fix for issue #142)\n * @param {string} list\n * @param {string} listType\n * @param {boolean} trimTrailing\n * @returns {string}\n */\n function parseConsecutiveLists (list, listType, trimTrailing) {\n // check if we caught 2 or more consecutive lists by mistake\n // we use the counterRgx, meaning if listType is UL we look for OL and vice versa\n var olRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?\\d+\\.[ \\t]/gm : /^ {0,3}\\d+\\.[ \\t]/gm,\n ulRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?[*+-][ \\t]/gm : /^ {0,3}[*+-][ \\t]/gm,\n counterRxg = (listType === 'ul') ? olRgx : ulRgx,\n result = '';\n\n if (list.search(counterRxg) !== -1) {\n (function parseCL (txt) {\n var pos = txt.search(counterRxg),\n style = styleStartNumber(list, listType);\n if (pos !== -1) {\n // slice\n result += '\\n\\n<' + listType + style + '>\\n' + processListItems(txt.slice(0, pos), !!trimTrailing) + '\\n';\n\n // invert counterType and listType\n listType = (listType === 'ul') ? 'ol' : 'ul';\n counterRxg = (listType === 'ul') ? olRgx : ulRgx;\n\n //recurse\n parseCL(txt.slice(pos));\n } else {\n result += '\\n\\n<' + listType + style + '>\\n' + processListItems(txt, !!trimTrailing) + '\\n';\n }\n })(list);\n } else {\n var style = styleStartNumber(list, listType);\n result = '\\n\\n<' + listType + style + '>\\n' + processListItems(list, !!trimTrailing) + '\\n';\n }\n\n return result;\n }\n\n /** Start of list parsing **/\n text = globals.converter._dispatch('lists.before', text, options, globals);\n // add sentinel to hack around khtml/safari bug:\n // http://bugs.webkit.org/show_bug.cgi?id=11231\n text += '¨0';\n\n if (globals.gListLevel) {\n text = text.replace(/^(( {0,3}([*+-]|\\d+[.])[ \\t]+)[^\\r]+?(¨0|\\n{2,}(?=\\S)(?![ \\t]*(?:[*+-]|\\d+[.])[ \\t]+)))/gm,\n function (wholeMatch, list, m2) {\n var listType = (m2.search(/[*+-]/g) > -1) ? 'ul' : 'ol';\n return parseConsecutiveLists(list, listType, true);\n }\n );\n } else {\n text = text.replace(/(\\n\\n|^\\n?)(( {0,3}([*+-]|\\d+[.])[ \\t]+)[^\\r]+?(¨0|\\n{2,}(?=\\S)(?![ \\t]*(?:[*+-]|\\d+[.])[ \\t]+)))/gm,\n function (wholeMatch, m1, list, m3) {\n var listType = (m3.search(/[*+-]/g) > -1) ? 'ul' : 'ol';\n return parseConsecutiveLists(list, listType, false);\n }\n );\n }\n\n // strip sentinel\n text = text.replace(/¨0/, '');\n text = globals.converter._dispatch('lists.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Parse metadata at the top of the document\n */\nshowdown.subParser('metadata', function (text, options, globals) {\n 'use strict';\n\n if (!options.metadata) {\n return text;\n }\n\n text = globals.converter._dispatch('metadata.before', text, options, globals);\n\n function parseMetadataContents (content) {\n // raw is raw so it's not changed in any way\n globals.metadata.raw = content;\n\n // escape chars forbidden in html attributes\n // double quotes\n content = content\n // ampersand first\n .replace(/&/g, '&')\n // double quotes\n .replace(/\"/g, '"');\n\n content = content.replace(/\\n {4}/g, ' ');\n content.replace(/^([\\S ]+): +([\\s\\S]+?)$/gm, function (wm, key, value) {\n globals.metadata.parsed[key] = value;\n return '';\n });\n }\n\n text = text.replace(/^\\s*«««+(\\S*?)\\n([\\s\\S]+?)\\n»»»+\\n/, function (wholematch, format, content) {\n parseMetadataContents(content);\n return '¨M';\n });\n\n text = text.replace(/^\\s*---+(\\S*?)\\n([\\s\\S]+?)\\n---+\\n/, function (wholematch, format, content) {\n if (format) {\n globals.metadata.format = format;\n }\n parseMetadataContents(content);\n return '¨M';\n });\n\n text = text.replace(/¨M/g, '');\n\n text = globals.converter._dispatch('metadata.after', text, options, globals);\n return text;\n});\n\r\n/**\n * Remove one level of line-leading tabs or spaces\n */\nshowdown.subParser('outdent', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('outdent.before', text, options, globals);\n\n // attacklab: hack around Konqueror 3.5.4 bug:\n // \"----------bug\".replace(/^-/g,\"\") == \"bug\"\n text = text.replace(/^(\\t|[ ]{1,4})/gm, '¨0'); // attacklab: g_tab_width\n\n // attacklab: clean up hack\n text = text.replace(/¨0/g, '');\n\n text = globals.converter._dispatch('outdent.after', text, options, globals);\n return text;\n});\n\r\n/**\n *\n */\nshowdown.subParser('paragraphs', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('paragraphs.before', text, options, globals);\n // Strip leading and trailing lines:\n text = text.replace(/^\\n+/g, '');\n text = text.replace(/\\n+$/g, '');\n\n var grafs = text.split(/\\n{2,}/g),\n grafsOut = [],\n end = grafs.length; // Wrap tags\n\n for (var i = 0; i < end; i++) {\n var str = grafs[i];\n // if this is an HTML marker, copy it\n if (str.search(/¨(K|G)(\\d+)\\1/g) >= 0) {\n grafsOut.push(str);\n\n // test for presence of characters to prevent empty lines being parsed\n // as paragraphs (resulting in undesired extra empty paragraphs)\n } else if (str.search(/\\S/) >= 0) {\n str = showdown.subParser('spanGamut')(str, options, globals);\n str = str.replace(/^([ \\t]*)/g, '
');\n str += '
';\n grafsOut.push(str);\n }\n }\n\n /** Unhashify HTML blocks */\n end = grafsOut.length;\n for (i = 0; i < end; i++) {\n var blockText = '',\n grafsOutIt = grafsOut[i],\n codeFlag = false;\n // if this is a marker for an html block...\n // use RegExp.test instead of string.search because of QML bug\n while (/¨(K|G)(\\d+)\\1/.test(grafsOutIt)) {\n var delim = RegExp.$1,\n num = RegExp.$2;\n\n if (delim === 'K') {\n blockText = globals.gHtmlBlocks[num];\n } else {\n // we need to check if ghBlock is a false positive\n if (codeFlag) {\n // use encoded version of all text\n blockText = showdown.subParser('encodeCode')(globals.ghCodeBlocks[num].text, options, globals);\n } else {\n blockText = globals.ghCodeBlocks[num].codeblock;\n }\n }\n blockText = blockText.replace(/\\$/g, '$$$$'); // Escape any dollar signs\n\n grafsOutIt = grafsOutIt.replace(/(\\n\\n)?¨(K|G)\\d+\\2(\\n\\n)?/, blockText);\n // Check if grafsOutIt is a pre->code\n if (/^]*>\\s*]*>/.test(grafsOutIt)) {\n codeFlag = true;\n }\n }\n grafsOut[i] = grafsOutIt;\n }\n text = grafsOut.join('\\n');\n // Strip leading and trailing lines:\n text = text.replace(/^\\n+/g, '');\n text = text.replace(/\\n+$/g, '');\n return globals.converter._dispatch('paragraphs.after', text, options, globals);\n});\n\r\n/**\n * Run extension\n */\nshowdown.subParser('runExtension', function (ext, text, options, globals) {\n 'use strict';\n\n if (ext.filter) {\n text = ext.filter(text, globals.converter, options);\n\n } else if (ext.regex) {\n // TODO remove this when old extension loading mechanism is deprecated\n var re = ext.regex;\n if (!(re instanceof RegExp)) {\n re = new RegExp(re, 'g');\n }\n text = text.replace(re, ext.replace);\n }\n\n return text;\n});\n\r\n/**\n * These are all the transformations that occur *within* block-level\n * tags like paragraphs, headers, and list items.\n */\nshowdown.subParser('spanGamut', function (text, options, globals) {\n 'use strict';\n\n text = globals.converter._dispatch('spanGamut.before', text, options, globals);\n text = showdown.subParser('codeSpans')(text, options, globals);\n text = showdown.subParser('escapeSpecialCharsWithinTagAttributes')(text, options, globals);\n text = showdown.subParser('encodeBackslashEscapes')(text, options, globals);\n\n // Process anchor and image tags. Images must come first,\n // because ![foo][f] looks like an anchor.\n text = showdown.subParser('images')(text, options, globals);\n text = showdown.subParser('anchors')(text, options, globals);\n\n // Make links out of things like `).\n text = showdown.subParser('autoLinks')(text, options, globals);\n text = showdown.subParser('simplifiedAutoLinks')(text, options, globals);\n text = showdown.subParser('emoji')(text, options, globals);\n text = showdown.subParser('underline')(text, options, globals);\n text = showdown.subParser('italicsAndBold')(text, options, globals);\n text = showdown.subParser('strikethrough')(text, options, globals);\n text = showdown.subParser('ellipsis')(text, options, globals);\n\n // we need to hash HTML tags inside spans\n text = showdown.subParser('hashHTMLSpans')(text, options, globals);\n\n // now we encode amps and angles\n text = showdown.subParser('encodeAmpsAndAngles')(text, options, globals);\n\n // Do hard breaks\n if (options.simpleLineBreaks) {\n // GFM style hard breaks\n // only add line breaks if the text does not contain a block (special case for lists)\n if (!/\\n\\n¨K/.test(text)) {\n text = text.replace(/\\n+/g, '
\\n');\n }\n } else {\n // Vanilla hard breaks\n text = text.replace(/ +\\n/g, '
\\n');\n }\n\n text = globals.converter._dispatch('spanGamut.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('strikethrough', function (text, options, globals) {\n 'use strict';\n\n function parseInside (txt) {\n if (options.simplifiedAutoLink) {\n txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);\n }\n return '' + txt + '';\n }\n\n if (options.strikethrough) {\n text = globals.converter._dispatch('strikethrough.before', text, options, globals);\n text = text.replace(/(?:~){2}([\\s\\S]+?)(?:~){2}/g, function (wm, txt) { return parseInside(txt); });\n text = globals.converter._dispatch('strikethrough.after', text, options, globals);\n }\n\n return text;\n});\n\r\n/**\n * Strips link definitions from text, stores the URLs and titles in\n * hash references.\n * Link defs are in the form: ^[id]: url \"optional title\"\n */\nshowdown.subParser('stripLinkDefinitions', function (text, options, globals) {\n 'use strict';\n\n var regex = /^ {0,3}\\[(.+)]:[ \\t]*\\n?[ \\t]*\\s]+)>?(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*\\n?[ \\t]*(?:(\\n*)[\"|'(](.+?)[\"|')][ \\t]*)?(?:\\n+|(?=¨0))/gm,\n base64Regex = /^ {0,3}\\[(.+)]:[ \\t]*\\n?[ \\t]*?(?: =([*\\d]+[A-Za-z%]{0,4})x([*\\d]+[A-Za-z%]{0,4}))?[ \\t]*\\n?[ \\t]*(?:(\\n*)[\"|'(](.+?)[\"|')][ \\t]*)?(?:\\n\\n|(?=¨0)|(?=\\n\\[))/gm;\n\n // attacklab: sentinel workarounds for lack of \\A and \\Z, safari\\khtml bug\n text += '¨0';\n\n var replaceFunc = function (wholeMatch, linkId, url, width, height, blankLines, title) {\n linkId = linkId.toLowerCase();\n if (url.match(/^data:.+?\\/.+?;base64,/)) {\n // remove newlines\n globals.gUrls[linkId] = url.replace(/\\s/g, '');\n } else {\n globals.gUrls[linkId] = showdown.subParser('encodeAmpsAndAngles')(url, options, globals); // Link IDs are case-insensitive\n }\n\n if (blankLines) {\n // Oops, found blank lines, so it's not a title.\n // Put back the parenthetical statement we stole.\n return blankLines + title;\n\n } else {\n if (title) {\n globals.gTitles[linkId] = title.replace(/\"|'/g, '"');\n }\n if (options.parseImgDimensions && width && height) {\n globals.gDimensions[linkId] = {\n width: width,\n height: height\n };\n }\n }\n // Completely remove the definition from the text\n return '';\n };\n\n // first we try to find base64 link references\n text = text.replace(base64Regex, replaceFunc);\n\n text = text.replace(regex, replaceFunc);\n\n // attacklab: strip sentinel\n text = text.replace(/¨0/, '');\n\n return text;\n});\n\r\nshowdown.subParser('tables', function (text, options, globals) {\n 'use strict';\n\n if (!options.tables) {\n return text;\n }\n\n var tableRgx = /^ {0,3}\\|?.+\\|.+\\n {0,3}\\|?[ \\t]*:?[ \\t]*(?:[-=]){2,}[ \\t]*:?[ \\t]*\\|[ \\t]*:?[ \\t]*(?:[-=]){2,}[\\s\\S]+?(?:\\n\\n|¨0)/gm,\n //singeColTblRgx = /^ {0,3}\\|.+\\|\\n {0,3}\\|[ \\t]*:?[ \\t]*(?:[-=]){2,}[ \\t]*:?[ \\t]*\\|[ \\t]*\\n(?: {0,3}\\|.+\\|\\n)+(?:\\n\\n|¨0)/gm;\n singeColTblRgx = /^ {0,3}\\|.+\\|[ \\t]*\\n {0,3}\\|[ \\t]*:?[ \\t]*(?:[-=]){2,}[ \\t]*:?[ \\t]*\\|[ \\t]*\\n( {0,3}\\|.+\\|[ \\t]*\\n)*(?:\\n|¨0)/gm;\n\n function parseStyles (sLine) {\n if (/^:[ \\t]*--*$/.test(sLine)) {\n return ' style=\"text-align:left;\"';\n } else if (/^--*[ \\t]*:[ \\t]*$/.test(sLine)) {\n return ' style=\"text-align:right;\"';\n } else if (/^:[ \\t]*--*[ \\t]*:$/.test(sLine)) {\n return ' style=\"text-align:center;\"';\n } else {\n return '';\n }\n }\n\n function parseHeaders (header, style) {\n var id = '';\n header = header.trim();\n // support both tablesHeaderId and tableHeaderId due to error in documentation so we don't break backwards compatibility\n if (options.tablesHeaderId || options.tableHeaderId) {\n id = ' id=\"' + header.replace(/ /g, '_').toLowerCase() + '\"';\n }\n header = showdown.subParser('spanGamut')(header, options, globals);\n\n return '' + header + '\\n';\n }\n\n function parseCells (cell, style) {\n var subText = showdown.subParser('spanGamut')(cell, options, globals);\n return '' + subText + '\\n';\n }\n\n function buildTable (headers, cells) {\n var tb = '\\n\\n\\n',\n tblLgn = headers.length;\n\n for (var i = 0; i < tblLgn; ++i) {\n tb += headers[i];\n }\n tb += ' \\n\\n\\n';\n\n for (i = 0; i < cells.length; ++i) {\n tb += '\\n';\n for (var ii = 0; ii < tblLgn; ++ii) {\n tb += cells[i][ii];\n }\n tb += ' \\n';\n }\n tb += '\\n
\\n';\n return tb;\n }\n\n function parseTable (rawTable) {\n var i, tableLines = rawTable.split('\\n');\n\n for (i = 0; i < tableLines.length; ++i) {\n // strip wrong first and last column if wrapped tables are used\n if (/^ {0,3}\\|/.test(tableLines[i])) {\n tableLines[i] = tableLines[i].replace(/^ {0,3}\\|/, '');\n }\n if (/\\|[ \\t]*$/.test(tableLines[i])) {\n tableLines[i] = tableLines[i].replace(/\\|[ \\t]*$/, '');\n }\n // parse code spans first, but we only support one line code spans\n tableLines[i] = showdown.subParser('codeSpans')(tableLines[i], options, globals);\n }\n\n var rawHeaders = tableLines[0].split('|').map(function (s) { return s.trim();}),\n rawStyles = tableLines[1].split('|').map(function (s) { return s.trim();}),\n rawCells = [],\n headers = [],\n styles = [],\n cells = [];\n\n tableLines.shift();\n tableLines.shift();\n\n for (i = 0; i < tableLines.length; ++i) {\n if (tableLines[i].trim() === '') {\n continue;\n }\n rawCells.push(\n tableLines[i]\n .split('|')\n .map(function (s) {\n return s.trim();\n })\n );\n }\n\n if (rawHeaders.length < rawStyles.length) {\n return rawTable;\n }\n\n for (i = 0; i < rawStyles.length; ++i) {\n styles.push(parseStyles(rawStyles[i]));\n }\n\n for (i = 0; i < rawHeaders.length; ++i) {\n if (showdown.helper.isUndefined(styles[i])) {\n styles[i] = '';\n }\n headers.push(parseHeaders(rawHeaders[i], styles[i]));\n }\n\n for (i = 0; i < rawCells.length; ++i) {\n var row = [];\n for (var ii = 0; ii < headers.length; ++ii) {\n if (showdown.helper.isUndefined(rawCells[i][ii])) {\n\n }\n row.push(parseCells(rawCells[i][ii], styles[ii]));\n }\n cells.push(row);\n }\n\n return buildTable(headers, cells);\n }\n\n text = globals.converter._dispatch('tables.before', text, options, globals);\n\n // find escaped pipe characters\n text = text.replace(/\\\\(\\|)/g, showdown.helper.escapeCharactersCallback);\n\n // parse multi column tables\n text = text.replace(tableRgx, parseTable);\n\n // parse one column tables\n text = text.replace(singeColTblRgx, parseTable);\n\n text = globals.converter._dispatch('tables.after', text, options, globals);\n\n return text;\n});\n\r\nshowdown.subParser('underline', function (text, options, globals) {\n 'use strict';\n\n if (!options.underline) {\n return text;\n }\n\n text = globals.converter._dispatch('underline.before', text, options, globals);\n\n if (options.literalMidWordUnderscores) {\n text = text.replace(/\\b___(\\S[\\s\\S]*?)___\\b/g, function (wm, txt) {\n return '' + txt + '';\n });\n text = text.replace(/\\b__(\\S[\\s\\S]*?)__\\b/g, function (wm, txt) {\n return '' + txt + '';\n });\n } else {\n text = text.replace(/___(\\S[\\s\\S]*?)___/g, function (wm, m) {\n return (/\\S$/.test(m)) ? '' + m + '' : wm;\n });\n text = text.replace(/__(\\S[\\s\\S]*?)__/g, function (wm, m) {\n return (/\\S$/.test(m)) ? '' + m + '' : wm;\n });\n }\n\n // escape remaining underscores to prevent them being parsed by italic and bold\n text = text.replace(/(_)/g, showdown.helper.escapeCharactersCallback);\n\n text = globals.converter._dispatch('underline.after', text, options, globals);\n\n return text;\n});\n\r\n/**\n * Swap back in all the special characters we've hidden.\n */\nshowdown.subParser('unescapeSpecialChars', function (text, options, globals) {\n 'use strict';\n text = globals.converter._dispatch('unescapeSpecialChars.before', text, options, globals);\n\n text = text.replace(/¨E(\\d+)E/g, function (wholeMatch, m1) {\n var charCodeToReplace = parseInt(m1);\n return String.fromCharCode(charCodeToReplace);\n });\n\n text = globals.converter._dispatch('unescapeSpecialChars.after', text, options, globals);\n return text;\n});\n\r\nshowdown.subParser('makeMarkdown.blockquote', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes()) {\n var children = node.childNodes,\n childrenLength = children.length;\n\n for (var i = 0; i < childrenLength; ++i) {\n var innerTxt = showdown.subParser('makeMarkdown.node')(children[i], globals);\n\n if (innerTxt === '') {\n continue;\n }\n txt += innerTxt;\n }\n }\n // cleanup\n txt = txt.trim();\n txt = '> ' + txt.split('\\n').join('\\n> ');\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.codeBlock', function (node, globals) {\n 'use strict';\n\n var lang = node.getAttribute('language'),\n num = node.getAttribute('precodenum');\n return '```' + lang + '\\n' + globals.preList[num] + '\\n```';\n});\n\r\nshowdown.subParser('makeMarkdown.codeSpan', function (node) {\n 'use strict';\n\n return '`' + node.innerHTML + '`';\n});\n\r\nshowdown.subParser('makeMarkdown.emphasis', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes()) {\n txt += '*';\n var children = node.childNodes,\n childrenLength = children.length;\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n txt += '*';\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.header', function (node, globals, headerLevel) {\n 'use strict';\n\n var headerMark = new Array(headerLevel + 1).join('#'),\n txt = '';\n\n if (node.hasChildNodes()) {\n txt = headerMark + ' ';\n var children = node.childNodes,\n childrenLength = children.length;\n\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.hr', function () {\n 'use strict';\n\n return '---';\n});\n\r\nshowdown.subParser('makeMarkdown.image', function (node) {\n 'use strict';\n\n var txt = '';\n if (node.hasAttribute('src')) {\n txt += ' + '>';\n if (node.hasAttribute('width') && node.hasAttribute('height')) {\n txt += ' =' + node.getAttribute('width') + 'x' + node.getAttribute('height');\n }\n\n if (node.hasAttribute('title')) {\n txt += ' \"' + node.getAttribute('title') + '\"';\n }\n txt += ')';\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.links', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes() && node.hasAttribute('href')) {\n var children = node.childNodes,\n childrenLength = children.length;\n txt = '[';\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n txt += '](';\n txt += '<' + node.getAttribute('href') + '>';\n if (node.hasAttribute('title')) {\n txt += ' \"' + node.getAttribute('title') + '\"';\n }\n txt += ')';\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.list', function (node, globals, type) {\n 'use strict';\n\n var txt = '';\n if (!node.hasChildNodes()) {\n return '';\n }\n var listItems = node.childNodes,\n listItemsLenght = listItems.length,\n listNum = node.getAttribute('start') || 1;\n\n for (var i = 0; i < listItemsLenght; ++i) {\n if (typeof listItems[i].tagName === 'undefined' || listItems[i].tagName.toLowerCase() !== 'li') {\n continue;\n }\n\n // define the bullet to use in list\n var bullet = '';\n if (type === 'ol') {\n bullet = listNum.toString() + '. ';\n } else {\n bullet = '- ';\n }\n\n // parse list item\n txt += bullet + showdown.subParser('makeMarkdown.listItem')(listItems[i], globals);\n ++listNum;\n }\n\n // add comment at the end to prevent consecutive lists to be parsed as one\n txt += '\\n\\n';\n return txt.trim();\n});\n\r\nshowdown.subParser('makeMarkdown.listItem', function (node, globals) {\n 'use strict';\n\n var listItemTxt = '';\n\n var children = node.childNodes,\n childrenLenght = children.length;\n\n for (var i = 0; i < childrenLenght; ++i) {\n listItemTxt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n // if it's only one liner, we need to add a newline at the end\n if (!/\\n$/.test(listItemTxt)) {\n listItemTxt += '\\n';\n } else {\n // it's multiparagraph, so we need to indent\n listItemTxt = listItemTxt\n .split('\\n')\n .join('\\n ')\n .replace(/^ {4}$/gm, '')\n .replace(/\\n\\n+/g, '\\n\\n');\n }\n\n return listItemTxt;\n});\n\r\n\n\nshowdown.subParser('makeMarkdown.node', function (node, globals, spansOnly) {\n 'use strict';\n\n spansOnly = spansOnly || false;\n\n var txt = '';\n\n // edge case of text without wrapper paragraph\n if (node.nodeType === 3) {\n return showdown.subParser('makeMarkdown.txt')(node, globals);\n }\n\n // HTML comment\n if (node.nodeType === 8) {\n return '\\n\\n';\n }\n\n // process only node elements\n if (node.nodeType !== 1) {\n return '';\n }\n\n var tagName = node.tagName.toLowerCase();\n\n switch (tagName) {\n\n //\n // BLOCKS\n //\n case 'h1':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 1) + '\\n\\n'; }\n break;\n case 'h2':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 2) + '\\n\\n'; }\n break;\n case 'h3':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 3) + '\\n\\n'; }\n break;\n case 'h4':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 4) + '\\n\\n'; }\n break;\n case 'h5':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 5) + '\\n\\n'; }\n break;\n case 'h6':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 6) + '\\n\\n'; }\n break;\n\n case 'p':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.paragraph')(node, globals) + '\\n\\n'; }\n break;\n\n case 'blockquote':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.blockquote')(node, globals) + '\\n\\n'; }\n break;\n\n case 'hr':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.hr')(node, globals) + '\\n\\n'; }\n break;\n\n case 'ol':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ol') + '\\n\\n'; }\n break;\n\n case 'ul':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ul') + '\\n\\n'; }\n break;\n\n case 'precode':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.codeBlock')(node, globals) + '\\n\\n'; }\n break;\n\n case 'pre':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.pre')(node, globals) + '\\n\\n'; }\n break;\n\n case 'table':\n if (!spansOnly) { txt = showdown.subParser('makeMarkdown.table')(node, globals) + '\\n\\n'; }\n break;\n\n //\n // SPANS\n //\n case 'code':\n txt = showdown.subParser('makeMarkdown.codeSpan')(node, globals);\n break;\n\n case 'em':\n case 'i':\n txt = showdown.subParser('makeMarkdown.emphasis')(node, globals);\n break;\n\n case 'strong':\n case 'b':\n txt = showdown.subParser('makeMarkdown.strong')(node, globals);\n break;\n\n case 'del':\n txt = showdown.subParser('makeMarkdown.strikethrough')(node, globals);\n break;\n\n case 'a':\n txt = showdown.subParser('makeMarkdown.links')(node, globals);\n break;\n\n case 'img':\n txt = showdown.subParser('makeMarkdown.image')(node, globals);\n break;\n\n default:\n txt = node.outerHTML + '\\n\\n';\n }\n\n // common normalization\n // TODO eventually\n\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.paragraph', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes()) {\n var children = node.childNodes,\n childrenLength = children.length;\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n }\n\n // some text normalization\n txt = txt.trim();\n\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.pre', function (node, globals) {\n 'use strict';\n\n var num = node.getAttribute('prenum');\n return '' + globals.preList[num] + '
';\n});\n\r\nshowdown.subParser('makeMarkdown.strikethrough', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes()) {\n txt += '~~';\n var children = node.childNodes,\n childrenLength = children.length;\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n txt += '~~';\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.strong', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (node.hasChildNodes()) {\n txt += '**';\n var children = node.childNodes,\n childrenLength = children.length;\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals);\n }\n txt += '**';\n }\n return txt;\n});\n\r\nshowdown.subParser('makeMarkdown.table', function (node, globals) {\n 'use strict';\n\n var txt = '',\n tableArray = [[], []],\n headings = node.querySelectorAll('thead>tr>th'),\n rows = node.querySelectorAll('tbody>tr'),\n i, ii;\n for (i = 0; i < headings.length; ++i) {\n var headContent = showdown.subParser('makeMarkdown.tableCell')(headings[i], globals),\n allign = '---';\n\n if (headings[i].hasAttribute('style')) {\n var style = headings[i].getAttribute('style').toLowerCase().replace(/\\s/g, '');\n switch (style) {\n case 'text-align:left;':\n allign = ':---';\n break;\n case 'text-align:right;':\n allign = '---:';\n break;\n case 'text-align:center;':\n allign = ':---:';\n break;\n }\n }\n tableArray[0][i] = headContent.trim();\n tableArray[1][i] = allign;\n }\n\n for (i = 0; i < rows.length; ++i) {\n var r = tableArray.push([]) - 1,\n cols = rows[i].getElementsByTagName('td');\n\n for (ii = 0; ii < headings.length; ++ii) {\n var cellContent = ' ';\n if (typeof cols[ii] !== 'undefined') {\n cellContent = showdown.subParser('makeMarkdown.tableCell')(cols[ii], globals);\n }\n tableArray[r].push(cellContent);\n }\n }\n\n var cellSpacesCount = 3;\n for (i = 0; i < tableArray.length; ++i) {\n for (ii = 0; ii < tableArray[i].length; ++ii) {\n var strLen = tableArray[i][ii].length;\n if (strLen > cellSpacesCount) {\n cellSpacesCount = strLen;\n }\n }\n }\n\n for (i = 0; i < tableArray.length; ++i) {\n for (ii = 0; ii < tableArray[i].length; ++ii) {\n if (i === 1) {\n if (tableArray[i][ii].slice(-1) === ':') {\n tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii].slice(-1), cellSpacesCount - 1, '-') + ':';\n } else {\n tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount, '-');\n }\n } else {\n tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount);\n }\n }\n txt += '| ' + tableArray[i].join(' | ') + ' |\\n';\n }\n\n return txt.trim();\n});\n\r\nshowdown.subParser('makeMarkdown.tableCell', function (node, globals) {\n 'use strict';\n\n var txt = '';\n if (!node.hasChildNodes()) {\n return '';\n }\n var children = node.childNodes,\n childrenLength = children.length;\n\n for (var i = 0; i < childrenLength; ++i) {\n txt += showdown.subParser('makeMarkdown.node')(children[i], globals, true);\n }\n return txt.trim();\n});\n\r\nshowdown.subParser('makeMarkdown.txt', function (node) {\n 'use strict';\n\n var txt = node.nodeValue;\n\n // multiple spaces are collapsed\n txt = txt.replace(/ +/g, ' ');\n\n // replace the custom ¨NBSP; with a space\n txt = txt.replace(/¨NBSP;/g, ' ');\n\n // \", <, > and & should replace escaped html entities\n txt = showdown.helper.unescapeHTMLEntities(txt);\n\n // escape markdown magic characters\n // emphasis, strong and strikethrough - can appear everywhere\n // we also escape pipe (|) because of tables\n // and escape ` because of code blocks and spans\n txt = txt.replace(/([*_~|`])/g, '\\\\$1');\n\n // escape > because of blockquotes\n txt = txt.replace(/^(\\s*)>/g, '\\\\$1>');\n\n // hash character, only troublesome at the beginning of a line because of headers\n txt = txt.replace(/^#/gm, '\\\\#');\n\n // horizontal rules\n txt = txt.replace(/^(\\s*)([-=]{3,})(\\s*)$/, '$1\\\\$2$3');\n\n // dot, because of ordered lists, only troublesome at the beginning of a line when preceded by an integer\n txt = txt.replace(/^( {0,3}\\d+)\\./gm, '$1\\\\.');\n\n // +, * and -, at the beginning of a line becomes a list, so we need to escape them also (asterisk was already escaped)\n txt = txt.replace(/^( {0,3})([+-])/gm, '$1\\\\$2');\n\n // images and links, ] followed by ( is problematic, so we escape it\n txt = txt.replace(/]([\\s]*)\\(/g, '\\\\]$1\\\\(');\n\n // reference URIs must also be escaped\n txt = txt.replace(/^ {0,3}\\[([\\S \\t]*?)]:/gm, '\\\\[$1]:');\n\n return txt;\n});\n\r\nvar root = this;\n\n// AMD Loader\nif (typeof define === 'function' && define.amd) {\n define(function () {\n 'use strict';\n return showdown;\n });\n\n// CommonJS/nodeJS Loader\n} else if (typeof module !== 'undefined' && module.exports) {\n module.exports = showdown;\n\n// Regular Browser loader\n} else {\n root.showdown = showdown;\n}\n}).call(this);\r\n\n//# sourceMappingURL=showdown.js.map\r\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/showdown/dist/showdown.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"thesis\":\"thesis__3uAQ4\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./components/thesis.css\n// module id = J9SO\n// module chunks = 0","import { Component, cloneElement, h } from 'preact';\n\nvar EMPTY$1 = {};\n\nfunction assign(obj, props) {\n\t// eslint-disable-next-line guard-for-in\n\tfor (var i in props) {\n\t\tobj[i] = props[i];\n\t}\n\treturn obj;\n}\n\nfunction exec(url, route, opts) {\n\tvar reg = /(?:\\?([^#]*))?(#.*)?$/,\n\t\tc = url.match(reg),\n\t\tmatches = {},\n\t\tret;\n\tif (c && c[1]) {\n\t\tvar p = c[1].split('&');\n\t\tfor (var i=0; i b.rank) ? -1 :\n\t\t(a.index - b.index)\n\t);\n}\n\n// filter out VNodes without attributes (which are unrankeable), and add `index`/`rank` properties to be used in sorting.\nfunction prepareVNodeForRanking(vnode, index) {\n\tvnode.index = index;\n\tvnode.rank = rankChild(vnode);\n\treturn vnode.attributes;\n}\n\nfunction segmentize(url) {\n\treturn url.replace(/(^\\/+|\\/+$)/g, '').split('/');\n}\n\nfunction rankSegment(segment) {\n\treturn segment.charAt(0)==':' ? (1 + '*+?'.indexOf(segment.charAt(segment.length-1))) || 4 : 5;\n}\n\nfunction rank(path) {\n\treturn segmentize(path).map(rankSegment).join('');\n}\n\nfunction rankChild(vnode) {\n\treturn vnode.attributes.default ? 0 : rank(vnode.attributes.path);\n}\n\nvar customHistory = null;\n\nvar ROUTERS = [];\n\nvar subscribers = [];\n\nvar EMPTY = {};\n\nfunction isPreactElement(node) {\n\treturn node.__preactattr_!=null || typeof Symbol!=='undefined' && node[Symbol.for('preactattr')]!=null;\n}\n\nfunction setUrl(url, type) {\n\tif ( type === void 0 ) type='push';\n\n\tif (customHistory && customHistory[type]) {\n\t\tcustomHistory[type](url);\n\t}\n\telse if (typeof history!=='undefined' && history[type+'State']) {\n\t\thistory[type+'State'](null, null, url);\n\t}\n}\n\n\nfunction getCurrentUrl() {\n\tvar url;\n\tif (customHistory && customHistory.location) {\n\t\turl = customHistory.location;\n\t}\n\telse if (customHistory && customHistory.getCurrentLocation) {\n\t\turl = customHistory.getCurrentLocation();\n\t}\n\telse {\n\t\turl = typeof location!=='undefined' ? location : EMPTY;\n\t}\n\treturn (\"\" + (url.pathname || '') + (url.search || ''));\n}\n\n\n\nfunction route(url, replace) {\n\tif ( replace === void 0 ) replace=false;\n\n\tif (typeof url!=='string' && url.url) {\n\t\treplace = url.replace;\n\t\turl = url.url;\n\t}\n\n\t// only push URL into history if we can handle it\n\tif (canRoute(url)) {\n\t\tsetUrl(url, replace ? 'replace' : 'push');\n\t}\n\n\treturn routeTo(url);\n}\n\n\n/** Check if the given URL can be handled by any router instances. */\nfunction canRoute(url) {\n\tfor (var i=ROUTERS.length; i--; ) {\n\t\tif (ROUTERS[i].canRoute(url)) { return true; }\n\t}\n\treturn false;\n}\n\n\n/** Tell all router instances to handle the given URL. */\nfunction routeTo(url) {\n\tvar didRoute = false;\n\tfor (var i=0; i 0;\n\t};\n\n\t/** Re-render children with a new URL to match against. */\n\tRouter.prototype.routeTo = function routeTo (url) {\n\t\tthis._didRoute = false;\n\t\tthis.setState({ url: url });\n\n\t\t// if we're in the middle of an update, don't synchronously re-route.\n\t\tif (this.updating) { return this.canRoute(url); }\n\n\t\tthis.forceUpdate();\n\t\treturn this._didRoute;\n\t};\n\n\tRouter.prototype.componentWillMount = function componentWillMount () {\n\t\tROUTERS.push(this);\n\t\tthis.updating = true;\n\t};\n\n\tRouter.prototype.componentDidMount = function componentDidMount () {\n\t\tvar this$1 = this;\n\n\t\tif (customHistory) {\n\t\t\tthis.unlisten = customHistory.listen(function (location) {\n\t\t\t\tthis$1.routeTo((\"\" + (location.pathname || '') + (location.search || '')));\n\t\t\t});\n\t\t}\n\t\tthis.updating = false;\n\t};\n\n\tRouter.prototype.componentWillUnmount = function componentWillUnmount () {\n\t\tif (typeof this.unlisten==='function') { this.unlisten(); }\n\t\tROUTERS.splice(ROUTERS.indexOf(this), 1);\n\t};\n\n\tRouter.prototype.componentWillUpdate = function componentWillUpdate () {\n\t\tthis.updating = true;\n\t};\n\n\tRouter.prototype.componentDidUpdate = function componentDidUpdate () {\n\t\tthis.updating = false;\n\t};\n\n\tRouter.prototype.getMatchingChildren = function getMatchingChildren (children, url, invoke) {\n\t\treturn children\n\t\t\t.filter(prepareVNodeForRanking)\n\t\t\t.sort(pathRankSort)\n\t\t\t.map( function (vnode) {\n\t\t\t\tvar matches = exec(url, vnode.attributes.path, vnode.attributes);\n\t\t\t\tif (matches) {\n\t\t\t\t\tif (invoke !== false) {\n\t\t\t\t\t\tvar newProps = { url: url, matches: matches };\n\t\t\t\t\t\tassign(newProps, matches);\n\t\t\t\t\t\tdelete newProps.ref;\n\t\t\t\t\t\tdelete newProps.key;\n\t\t\t\t\t\treturn cloneElement(vnode, newProps);\n\t\t\t\t\t}\n\t\t\t\t\treturn vnode;\n\t\t\t\t}\n\t\t\t}).filter(Boolean);\n\t};\n\n\tRouter.prototype.render = function render (ref, ref$1) {\n\t\tvar children = ref.children;\n\t\tvar onChange = ref.onChange;\n\t\tvar url = ref$1.url;\n\n\t\tvar active = this.getMatchingChildren(children, url, true);\n\n\t\tvar current = active[0] || null;\n\t\tthis._didRoute = !!current;\n\n\t\tvar previous = this.previousUrl;\n\t\tif (url!==previous) {\n\t\t\tthis.previousUrl = url;\n\t\t\tif (typeof onChange==='function') {\n\t\t\t\tonChange({\n\t\t\t\t\trouter: this,\n\t\t\t\t\turl: url,\n\t\t\t\t\tprevious: previous,\n\t\t\t\t\tactive: active,\n\t\t\t\t\tcurrent: current\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn current;\n\t};\n\n\treturn Router;\n}(Component));\n\nvar Link = function (props) { return (\n\th('a', assign({ onClick: handleLinkClick }, props))\n); };\n\nvar Route = function (props) { return h(props.component, props); };\n\nRouter.subscribers = subscribers;\nRouter.getCurrentUrl = getCurrentUrl;\nRouter.route = route;\nRouter.Router = Router;\nRouter.Route = Route;\nRouter.Link = Link;\n\nexport { subscribers, getCurrentUrl, route, Router, Route, Link };export default Router;\n//# sourceMappingURL=preact-router.es.js.map\n\n\n\n// WEBPACK FOOTER //\n// ../node_modules/preact-router/dist/preact-router.es.js","import style from \"./panel.css\";\nimport { Component } from 'preact';\n\nexport default class Panel extends Component {\n\tgetStyle() {\n\t\treturn style.panel;\n\t};\n\n\trender() {\n\t\tlet title = null;\n\t\tif(this.props.title !== undefined) {\n\t\t\ttitle = ({this.props.title}
);\n\t\t}\n\n\t\treturn (\n\t\t\t\n\t\t\t\t{title}\n\t\t\t\t{this.props.children}\n\t\t\t\n\t\t);\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/panel.js","import style from \"./split.css\";\nimport { Component } from 'preact';\n\nexport default class Split extends Component {\n\trender() {\n\t let title = null;\n\t if(this.props.title !== undefined) {\n title = ({this.props.title}
)\n }\n\n let children;\n if(Array.isArray(this.props.children)) {\n children = this.props.children.map(element => {\n return ({element});\n });\n }\n else {\n children = {this.props.children};\n }\n\t\treturn (\n\t \n {title}\n {children}\n \n );\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/split.js","import style from \"./todo.css\";\r\nimport { Component } from 'preact';\r\n\r\nexport default class Todo extends Component {\r\n\trender() {\r\n\t\treturn {this.props.children};\r\n\t}\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/todo.js","import style from './home.css'\r\nimport { Component } from 'preact';\r\nimport Panel from '../components/panel';\r\nimport Split from '../components/split';\r\nimport Todo from '../components/todo';\r\n\r\nexport default class Home extends Component {\r\n render() {\r\n return (\r\n \r\n Indice
\r\n \r\n Statistica ed elementi di probabilità}>\r\n \r\n Appunti scritti mentre studiavo per l'esame di Statistica ed elementi di probabilità del corso triennale di Informatica all'Unimore del Prof. Luca La Rocca.\r\n
\r\n \r\n Cleaver}>\r\n \r\n Progetto in Java sviluppato per l'esame di Programmazione ad Oggetti del corso triennale di Informatica all'Unimore, tenuto dai Prof. Giacomo Cabri e Nicola Capodieci.\r\n
\r\n \r\n Fisica}>\r\n \r\n Appunti delle lezioni di Fisica del corso triennale di Informatica all'Unimore, tenute dalla Prof.ssa Rossella Brunetti nel primo semestre dell'Anno Accademico 2019/2020.\r\n
\r\n \r\n Sistemi Operativi}>\r\n \r\n Soluzioni agli Arzigogoli proposti dal Prof. Mauro Andreolini durante le lezioni di Sistemi Operativi del corso triennale di Informatica all'Unimore tenutesi nel primo semestre dell'Anno Accademico 2019/2020.\r\n
\r\n \r\n Algoritmi e Strutture Dati}>\r\n \r\n Appunti delle lezioni di Algoritmi e Strutture Dati del corso triennale di Informatica all'Unimore, tenute dalla Prof.ssa Manuela Montangero nel secondo semestre dell'Anno Accademico 2018/2019.\r\n
\r\n \r\n Videolezioni di Geometria}>\r\n \r\n Ottime videolezioni di Geometria con licenza CC BY-NC-SA 4.0 che ho trovato sul portale Dolly 2018 dell'Unimore.\r\n
\r\n \r\n Come installare MinGW}>\r\n \r\n Un breve tutorial con immagini su come installare e configurare MinGW per compilare programmi C e C++ su Windows.\r\n
\r\n \r\n \r\n \r\n @unimoreinfo}>\r\n \r\n Il gruppo Telegram del corso di Informatica dell'Unimore!\r\n
\r\n \r\n Calendario Lezioni}>\r\n \r\n Calendario Google quasi sempre aggiornato delle lezioni e degli esami del secondo anno dell'Unimore durante l'Anno Accademico 2019/2020.\r\n
\r\n \r\n Erre2}>\r\n \r\n Portale contenente appunti e riassunti mantenuto da Lorenzo Balugani.\r\n
\r\n \r\n vezzalinistefano/Appunti-Algoritmi}>\r\n \r\n Appunti di Algoritmi e Strutture Dati mantenuti da Vezzalini Stefano.\r\n
\r\n \r\n \r\n \r\n )\r\n }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./pages/home.js","import style from './latex.css';\nimport { Component } from 'preact';\n\nexport default class Latex extends Component {\n\trender() {\n\t\tlet equation = `{\\\\color{White} ${this.props.children} }`;\n\t\treturn (\n\t\t\t
);\n\t}\n}\n\n\n// WEBPACK FOOTER //\n// ./components/latex.js","import style from \"./plus.css\";\r\nimport { Component } from 'preact';\r\n\r\nexport default class Plus extends Component {\r\n\trender() {\r\n\t\treturn {this.props.children};\r\n\t}\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/plus.js","import style from \"./minus.css\";\r\nimport { Component } from 'preact';\r\n\r\nexport default class Minus extends Component {\r\n\trender() {\r\n\t\treturn {this.props.children};\r\n\t}\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/minus.js","import style from './fisica.css';\nimport { Component } from 'preact';\nimport Latex from '../components/latex';\nimport Panel from '../components/panel';\nimport Split from '../components/split';\nimport Plus from '../components/plus';\nimport Minus from '../components/minus';\nimport Todo from '../components/todo';\n\nconst r = String.raw;\n\nexport default class Fisica extends Component {\n\trender() {\n return (\n \n Fisica
\n \n \n \n Usa le regole base della trigonometria:\n
\n \n {r`\\vec{v} = \\vec{v}_x + \\vec{v}_y`} \n
\n \n {r`\\left | \\vec{v}_x \\right | = \\left | \\vec{v} \\right | \\sin \\alpha`} \n
\n \n {r`\\left | \\vec{v}_y \\right | = \\left | \\vec{v} \\right | \\cos \\alpha`} \n
\n \n \n \n Scomponi in componenti, poi sommali:\n
\n \n {r`\\vec{v} + \\vec{w} = (\\vec{v}_x + \\vec{w}_x) + (\\vec{v}_y + \\vec{w}_y)`} \n
\n \n Produce il vettore risultante dall'applicazione della regola del parallelogramma.\n
\n \n \n \n Alla fine è sempre una somma:\n
\n \n {r`\\vec{v} - \\vec{w} = (\\vec{v}_x - \\vec{w}_x) + (\\vec{v}_y - \\vec{w}_y)`} \n
\n \n Produce il vettore che parte da w e arriva a v .\n
\n \n \n \n Si chiama scalare perchè il risultato è uno scalare, non un vettore.\n
\n \n {r`\\vec{v} \\cdot \\vec{w} = \\left | \\vec{v} \\right | \\left | \\vec{w} \\right | \\cos \\alpha`} \n
\n \n Produce il modulo della proiezione di {r`\\vec{a}`} su {r`\\vec{b}`} .\n
\n \n \n \n Si chiama vettoriale perchè il risultato è un altro vettore.\n
\n \n {r`\\vec{c} = \\vec{a} \\times \\vec{b}`} {r`\\left | \\vec{c} \\right | = \\left | \\vec{a} \\right | \\cdot \\left | \\vec{b} \\right | \\cdot \\sin(\\alpha)`} - Regola della mano destra
\n
\n \n Non è commutativo!\n
\n \n \n \n \n \n Se un corpo puntiforme ha forza risultante nulla, allora la sua velocità non cambia.\n
\n \n {r`\\Sigma \\vec{F} = 0 \\Longleftrightarrow \\Delta v = 0`} \n
\n \n \n \n La forza risultante di un corpo è direttamente proporzionale alla sua accelerazione, e la costante di proporzionalità è la massa.\n
\n \n {r`\\Sigma \\vec{F} = m \\vec{a}`} \n
\n \n \n \n Due corpi esercitano forze uguali e opposte uno sull'altro. \n
\n \n {r`\\vec{F}_{21} = -\\vec{F}_{12}`} \n
\n \n \n \n \n \n Due corpi puntiformi si attirano uno verso l'altro con forza:\n
\n \n {r`\\left | \\vec{F} \\right | = G \\frac{m_1 m_2}{s^2}`} \n
\n \n G è la costante di gravitazione universale e vale:\n
\n \n {r`G = 6.67 \\cdot 10^{-11} \\frac{N m^2}{{kg}^2}`} \n
\n \n \n \n Se nel sistema di riferimento consideriamo la Terra ferma, allora un corpo è attratto verso la Terra con forza peso uguale a:\n
\n \n {r`\\left | \\vec{F} \\right | = g m`} \n
\n \n g è la costante di gravità della Terra, e vale:\n
\n \n {r`g = 9.81 \\frac{m}{s^2}`} \n
\n \n \n \n Per pianeti diversi dalla Terra vale la stessa regola:\n
\n \n {r`\\left | \\vec{F} \\right | = g m`} \n
\n \n L'unica differenza è che cambia la costante di gravità:\n
\n \n {r`g_{luna} = 1.62 \\frac{m}{s^2}`} \n
\n \n {r`g_{marte} = 3.71 \\frac{m}{s^2}`} \n
\n \n \n \n \n \n Si oppone alle forze applicate alla superficie di contatto.\n
\n \n Un libro appoggiato su un tavolo ha la forza di gravità che lo attira verso il terreno e la forza normale che lo trattiene dal cadere. \n
\n \n \n \n Impedisce a un corpo di muoversi se non viene spinto da una forza che supera una certa soglia:\n
\n \n {r`\\left | \\vec{F} \\right | \\leq \\mu_{s} \\left | \\vec{F}_{normale} \\right |`} \n
\n \n \n \n Rallenta i corpi che si stanno muovendo finchè essi non si fermano:\n
\n \n {r`\\left | \\vec{F} \\right | \\leq \\mu_{d} \\left | \\vec{F}_{normale} \\right |`} \n
\n \n \n \n E' forza trasmessa tra due estremi di una fune.\n
\n \n Può essere redirezionata per mezzo di carrucole.\n
\n \n \n \n Una molla cerca sempre di tornare alla sua posizione indeformata con forza:\n
\n \n {r`F = -k x`} \n
\n \n (E' negativa perchè la forza è opposta a quella applicata per deformarla.)\n
\n \n \n \n \n \n È un vettore che indica la posizione di un corpo rispetto a un'origine.\n
\n \n {r`\\Delta \\vec{s} = \\vec{s}(fine) - \\vec{s}(inizio)`} \n
\n \n \n \n È un vettore che misura la variazione di posizione nel tempo.\n
\n \n {r`\\vec{v} = \\frac{\\Delta \\vec{s}}{\\Delta t}`} \n
\n \n Se si considera un intervallo di tempo infinitesimale si dice velocità istantanea:\n
\n \n {r`\\vec{v} = \\lim_{\\Delta t \\to 0} \\frac{\\Delta \\vec{s}}{\\Delta t} = \\frac{d \\vec{s}}{dt}`} \n
\n \n \n \n È un vettore che misura la variazione di velocità nel tempo.\n
\n \n {r`\\vec{a} = \\frac{\\Delta \\vec{v}}{\\Delta t}`} \n
\n \n Se si considera un intervallo di tempo infinitesimale si dice accelerazione istantanea:\n
\n \n {r`\\vec{a} = \\lim_{\\Delta v \\to 0} \\frac{\\Delta \\vec{v}}{\\Delta t} = \\frac{d \\vec{v}}{d t} = \\frac{d^2 \\vec{s}}{d t^2}`} \n
\n \n Quantità di moto (momento lineare)}>\n \n La quantità di moto è una proprietà vettoriale dei corpi:\n
\n \n {r`\\vec{p} = m \\vec{v}`} \n
\n \n Se la forza risultante è nulla, la quantità di moto non cambia.\n
\n \n {r`\\Sigma \\vec{F} = 0 \\Longleftrightarrow \\Delta \\vec{p} = 0`} \n
\n \n \n \n \n \n La legge oraria è:\n
\n \n {r`s(t) = v \\cdot \\Delta t + s(0)`} \n
\n \n \n \n È costante:\n
\n \n {r`v(t) = k`} \n
\n \n \n \n La velocità non varia:\n
\n \n {r`a(t) = 0`} \n
\n \n \n \n Si applica la prima legge di Newton:\n
\n \n f(t) = 0 \n
\n \n \n \n \n \n La legge oraria è:\n
\n \n {r`s(t) = \\frac{1}{2} a \\cdot (\\Delta t)^2 + v(0) \\cdot (\\Delta t) + s(0)`} \n
\n \n \n \n È una retta:\n
\n \n {r`v(t) = a \\Delta t + v(0)`} \n
\n \n \n \n È costante:\n
\n \n {r`a(t) = k`} \n
\n \n \n \n Si applica la prima legge di Newton:\n
\n \n f(t) = m a \n
\n \n \n \n \n \n E' la distanza dal centro massima che raggiunge il corpo.\n
\n \n (L'ampiezza di una sinusoide.)\n
\n \n \n \n Indica quanto in fretta cambia la posizione del corpo. \n
\n \n Dipende dal periodo:\n
\n \n {r`\\omega = \\frac{2 \\pi}{T}`} \n
\n \n \n \n E' una sinusoide:\n
\n \n {r`s(t) = A \\sin (\\omega \\cdot t + \\phi)`} \n
\n \n \n \n E' la sinusoide dello spostamento, sfasata di {r`\\frac{\\pi}{2}`} :\n
\n \n {r`v(t) = A \\sin (\\omega \\cdot t + \\phi + \\frac{\\pi}{2})`} \n
\n \n \n \n E' la sinusoide della velocità, sfasata di {r`\\pi`} :\n
\n \n {r`a(t) = A \\sin (\\omega \\cdot t + \\phi + \\pi)`} \n
\n \n \n \n Si applica la prima legge di Newton:\n
\n \n f(t) = m a \n
\n \n \n \n \n \n Il moto parabolico è dato sommando un moto rettilineo uniforme sull'asse orizzontale e un moto rettilineo uniformemente accelerato sull'asse verticale.\n
\n \n \n \n Il moto parabolico è dato sommando due moti armonici semplici: uno sull'asse X, e l'altro, sfasato di {r`\\frac{\\pi}{2}`} , sull'asse Y.\n
\n \n \n \n \n \n Velocità angolare\n
\n \n Quanto cambia la fase nel tempo.\n
\n \n {r`\\omega = \\frac{2 \\pi}{T}`} \n
\n \n \n \n E' l'angolo percorso dal corpo rispetto alla posizione iniziale.\n
\n \n Si indica con {r`\\phi`} , e generalmente si usa in radianti.\n
\n \n \n \n Si applicano le formule per la circonferenza:\n
\n \n {r`v = \\frac{\\Delta s}{t} = \\frac{2 \\pi \\cdot r}{T} = \\omega r`} \n
\n \n \n \n Il corpo ha sempre un accelerazione verso il centro che gli impedisce di abbandonare il moto: \n
\n \n {r`a = \\frac{v^2}{r} = r \\cdot \\omega^2 = v \\cdot \\omega`} \n
\n \n \n \n È verso il centro e si calcola con:\n
\n \n {r`F = m \\cdot a`} \n
\n \n \n \n \n \n E' compiuto da una forza che sposta un corpo.\n
\n \n {r`W = \\vec{F} \\cdot \\vec{s} = F \\cdot \\Delta s \\cdot cos(\\alpha )`} \n
\n \n (Se la forza non è parallela allo spostamento, il prodotto scalare ci fa considerare solo la componente parallela.)\n
\n \n \n \n Un corpo ha energia cinetica in ogni momento uguale a:\n
\n \n {r`E_c = \\frac{1}{2} m v^2`} \n
\n \n Se una forza effettua lavoro su un corpo, cambia la sua energia cinetica pari al lavoro effettuato:\n
\n \n {r`\\Delta E_c = W`} \n
\n \n \n \n Un corpo ha energia potenziale in ogni momento pari a: \n
\n \n {r`E_{p_g} = m \\cdot g \\cdot h`} \n
\n \n (Con h uguale a un altezza scelta come punto di riferimento.)\n
\n \n \n \n Una molla ha sempre energia potenziale elastica pari a:\n
\n \n {r`E_{p_e} = \\frac{1}{2} k x^2`} \n
\n \n \n \n Sono conservative le forze per le quali il lavoro compiuto non dipende dal percorso seguito per andare dalla partenza all'arrivo.\n
\n \n Ad esempio, è conservativa la forza di gravità, ma non è conservativa la forza di attrito.\n
\n \n Se in un sistema ci sono solo forze conservative, allora l'energia meccanica totale si conserva:\n
\n \n {r`E = E_k + E_p`} \n
\n \n \n \n È la velocità di trasferimento di energia:\n
\n \n {r`P = \\frac{\\Delta E}{\\Delta t}`} \n
\n \n \n \n \n \n È una proprietà dei corpi che può essere positiva o negativa .\n
\n \n Si conserva: in un sistema chiuso la carica totale è costante.\n
\n \n Esiste un'unità elementare: {r`C_{elettrone} = 1.602 \\cdot 10^{-19}`} .\n
\n \n Cariche opp oste si attraggono; cariche uguali si respingono.\n
\n \n \n \n Più ioni ha un corpo, meglio la carica si muove attraverso di esso.\n
\n \n I corpi in cui la carica si muove bene sono conduttori, mentre quelli in cui si muove difficilmente sono isolanti.\n
\n \n Il corpo umano è un buon conduttore.\n
\n \n \n \n \n \n E' possibile polarizzare un corpo per accumulare la carica di un segno in una certa zona.\n
\n \n \n \n \n \n Se un corpo conduttore è in contatto con la Terra, le cariche su di esso saranno equilibrate e il corpo diventerà elettricamente neutro (con stesso numero di cariche positive e negative all'interno).\n
\n \n \n \n \n \n Strofinando tra loro due corpi isolanti, essi si polarizzeranno per strofinio.\n
\n \n \n \n Toccando un conduttore con un corpo carico, il conduttore potrà polarizzarsi per contatto.\n
\n \n \n \n Se un corpo conduttore ha cariche \"esterne\" di un certo segno vicino, esso avrà tutte le cariche del segno opposto in equilibrio vicino alle cariche esterne, e tutte le cariche dello stesso segno più lontano possibile da esse.\n
\n \n Mettendo a terra il conduttore, nuove cariche del segno opposto saranno attratte all'interno del corpo per equilibrare le cariche che si sono allontanate.\n
\n \n Staccando il conduttore da terra e rimuovendo le cariche esterne, esso si ritroverà caricato del segno opposto rispetto alle cariche esterne.\n
\n \n \n \n \n \n Due corpi carichi si attraggono tra loro con forza: \n
\n \n {r`\\left | \\vec{F}_{elettrica} \\right | = \\frac{-k \\cdot q_1 \\cdot q_2}{s^2}`} \n
\n \n {r`k`} è la costante di Coulomb, e vale {r`k = 8.99 \\cdot 10^9 \\frac{N \\cdot m^2}{C^2}`} .\n
\n \n \n \n La costante {r`k`} è in realtà dipendente da un altra costante, {r`\\epsilon_0`} , la permeabilità del vuoto.\n
\n \n {r`k = \\frac{1}{4 \\pi \\cdot \\epsilon_0}`} \n
\n \n {r`\\left | \\vec{F}_{elettrica} \\right | = \\frac{q_1 \\cdot q_2}{4 \\pi \\cdot \\epsilon_0 \\cdot s^2}`} \n
\n \n \n \n Misura che forza viene applicata in ogni punto su una carica unitaria:\n
\n \n {r`\\vec{E} = \\frac{\\vec{F}_{elettrica}}{q} = \\frac{-k \\cdot q}{s^2}`} \n
\n \n \n \n È la differenza tra \"quanto\" campo elettrico entra e quanto campo elettrico esce da una certa area.\n
\n \n In qualsiasi superficie chiusa, il flusso elettrico è uguale alla componente perpendicolare del campo elettrico moltiplicato per l'area.\n
\n \n {r`\\Phi_E = \\vec{E} \\cdot \\vec{A}`} \n
\n \n Se il campo elettrico è uniforme, se ne può calcolare facilmente il valore:\n
\n \n {r`\\Phi_E = \\vec{E} \\cdot \\vec{A} = E_\\perp \\cdot A \\cdot \\cos(\\alpha)`} \n
\n \n Circa. E' una specie di integrale... \n
\n \n \n \n Il flusso elettrico è direttamente proporzionale alla carica presente all'interno della superficie.\n
\n \n {r`\\Phi_E = 4 \\pi \\cdot k \\cdot q = \\frac{q}{\\epsilon_0}`} \n
\n \n Ovvero, i campi elettrostatici sono generati dalle cariche elettriche.\n
\n \n \n \n \n \n Un corpo carico vicino ad altre cariche possiede un'energia potenziale elettrica {r`U_e`} .\n
\n \n \n \n Potenziale elettrico (tensione)}>\n \n È il valore dell'energia potenziale elettrica per una carica unitaria.\n
\n \n {r`V = \\frac{U_e}{q}`} \n
\n \n La sua unità di misura è il Volt ({r`V`} ).\n
\n \n In una batteria è detto forza elettromotrice, e corrisponde al lavoro compiuto da una batteria ideale per spostare una carica unitaria tra i due poli.\n
\n \n Corrente elettrica (intensità)}>\n \n Quanta carica passa attraverso un'area (perpendicolare al flusso) nel tempo.\n
\n \n {r`I = \\frac{\\Delta q}{\\Delta t}`} \n
\n \n Fintanto che c'è differenza di potenziale, ci sarà anche intensità non nulla.\n
\n \n La sua unità di misura è l'Ampere ({r`A`} ).\n
\n \n Corrente continua (DC)}>\n \n Quando in un circuito la direzione della corrente è costante.\n
\n \n Corrente alternata (AC)}>\n \n Quando in un circuito la direzione della corrente si alterna periodicamente.\n
\n \n \n \n Possiamo calcolare la potenza di un circuito:\n
\n \n {r`P = \\frac{\\Delta U_e}{\\Delta t} = I \\cdot \\Delta V = I^2 \\cdot R = \\frac{(\\Delta V)^2}{R}`} \n
\n \n \n \n \n \n Riduce l'intensità di corrente, e converte parte del potenziale in calore.\n
\n \n Il potenziale utilizzato è pari a:\n
\n \n {r`V = R \\cdot I`} \n
\n \n Dove {r`R`} è una costante detta resistenza con unità di misura Ohm ({r`\\Omega`} ).\n
\n \n La resistenza di un conduttore vale:\n
\n \n {r`R = \\rho \\frac{L_{unghezza}}{A_{rea}}`} \n
\n \n {r`\\rho`} è la resistività del materiale, e varia in base alla temperatura:\n
\n \n {r`\\rho = \\rho_0 (1 + \\alpha(T - T_0))`} \n
\n \n \n \n Immagazzina potenziale elettrico, permettendo di riutilizzarla in seguito.\n
\n \n Per farlo, cattura cariche positive e negative sulle sue due armature; perchè questo avvenga, deve essere compiuto lavoro.\n
\n \n Ha una capacità caratteristica, che in un condensatore a facce piane parallele è:\n
\n \n {r`C = \\frac{q_{massima}}{\\Delta V}`} \n
\n \n Condensatori di capacità maggiore immagazzinano più potenziale con meno carica.\n
\n \n La capacità aumenta se viene messo qualcosa tra le armature:\n
\n \n {r`C_{nuova} = \\kappa \\cdot \\frac{\\epsilon_0 \\cdot A}{s}`} \n
\n \n Dove {r`\\kappa`} è la costante dielettrica relativa del materiale inserito, {r`A`} l'area di una armatura e {r`s`} la distanza tra le due armature.\n
\n \n Se il campo elettrico creatosi tra le due armature supera la rigidità dielettrica del condensatore, la carica immagazzinata viene persa e ha luogo un breakdown.\n
\n \n La sua unità di misura è il Farad ({r`Fa`} )\n
\n \n \n \n Misura la corrente elettrica se messo in serie.\n
\n \n (Funzionamento: ha una resistenza interna bassisima in modo da non influire significativamente sulla corrente.)\n
\n \n \n \n Misura la differenza di potenziale se messo in parallelo.\n
\n \n (Funzionamento: ha una resistenza altissima in modo da non influire significativamente sulla tensione.)\n
\n \n \n \n \n \n Per nodo si intende un qualsiasi punto del circuito.\n
\n \n Da un nodo entra ed esce la stessa corrente.\n
\n \n \n \n Per maglia si intende un qualsiasi percorso chiuso all'interno del circuito.\n
\n \n In una maglia chiusa, la somma delle differenze di potenziale è 0.\n
\n \n \n \n \n \n Più parti di circuito sono in serie se sono consecutive e senza biforcazioni.\n
\n \n Parti di circuito in serie sono attraversate dalla stessa corrente.\n
\n \n \n \n Più parti di circuito sono in parallelo tra loro se hanno lo stesso punto di partenza e lo stesso punto di arrivo. \n
\n \n Parti di circuito in parallelo hanno la stessa differenza di potenziale.\n
\n \n \n \n \n \n Nei circuiti in serie, tutte le resistenze possono essere sostituite con una equivalente dalla resistenza della somma di tutte le quelle sostituite:\n
\n \n {r`R_{serie} = \\sum_{i=1}^{n} R_i`} \n
\n \n \n \n Nei circuiti in parallelo, tutte le resistenze possono essere sostituite con una equivalente dalla resistenza di:\n
\n \n {r`R_{parallelo} = \\frac{1}{\\sum_{i=1}^{n} \\frac{1}{R_i}}`} \n
\n \n \n \n \n \n Nei circuiti in serie, tutti i condensatori possono essere sostituiti con uno equivalente dalla capacità di:\n
\n \n {r`C_{serie} = \\frac{1}{\\sum_{i=1}^{n} \\frac{1}{C_i}}`} \n
\n \n \n \n Nei circuiti in parallelo, tutte i condensatori possono essere sostituite con uno equivalente dalla capacità della somma di tutti quelli sostituiti:\n
\n \n {r`C_{parallelo} = \\sum_{i=1}^{n} C_n`} \n
\n \n \n \n \n \n E' una costante fisica fondamentale che rappresenta quanto un materiale si magnetizza facilmente.\n
\n \n {r`\\mu_0 = 4 \\pi \\cdot 10^{-7} \\frac{H}{m}`} ({r`\\frac{N}{A^2}`} )\n
\n \n \n \n Come un campo elettrico, ma per i magneti.\n
\n \n Il suo simbolo è {r`B`} , e la sua unità di misura è il Tesla (T ).\n
\n \n \n \n È \"quanto\" campo magnetico attraversa un percorso chiuso.\n
\n \n Per qualsiasi percorso chiuso, il flusso magnetico è uguale alla somma di tutti i \"sottoflussi\" magnetici calcolati sui suoi lati.\n
\n \n {r`\\Phi_{B_{i}} = \\vec{B} \\cdot \\vec{L}_n = B \\cdot L_i \\cdot \\sin(\\alpha) = B_\\parallel \\cdot L_i`} \n
\n \n {r`\\Phi_{B} = \\sum_{i=0}^{n_{lati}} \\Phi_{Bn}`} \n
\n \n La sua unità di misura è il Weber ({r`Wb = T \\cdot m^2`} ).\n
\n \n \n \n Il flusso magnetico attraverso qualsiasi superficie chiusa è sempre nullo.\n
\n \n Ovvero, non esistono monopoli magnetici.\n
\n \n \n \n L'intensità di corrente che attraversa un percorso chiuso è direttamente proporzionale al flusso magnetico dello stesso percorso.\n
\n \n {r`\\Phi_B = \\mu_0 \\cdot I`} \n
\n \n \n \n Forza magnetica su carica puntiforme (Forza di Lorentz)}>\n \n I campi magnetici applicano una forza sulle cariche vicine:\n
\n \n {r`\\vec{F}_{B} = q \\cdot (\\vec{v} \\times \\vec{B})`} \n
\n \n Dove {r`\\vec{B}`} è l'intensità del campo magnetico e {r`\\vec{v}`} la velocità della carica considerata.\n
\n \n Si ha una forza massima se la velocità è perpendicolare al campo magnetico.\n
\n \n In un campo magnetico uniforme, una velocità perpendicolare al campo porta alla creazione di un moto circolare uniforme.\n
\n \n \n \n I campi magnetici influenzano ovviamente anche le cariche presenti in un conduttore:\n
\n \n {r`\\vec{F}_{magnetica} = I \\cdot (\\vec{L} \\times \\vec{B})`} [1]\n
\n \n Dove {r`I`} è la corrente elettrica, {r`\\vec{L}`} è un vettore che punta nella direzione di scorrimento della corrente e ha come modulo la lunghezza del conduttore.\n
\n \n \n \n \n \n Una spira in cui passa corrente produce un campo magnetico perpendicolare al piano creato dalla spira.\n
\n \n \n \n Un solenoide sono tante spire avvolte in modo da formare una specie di cilindro.\n
\n \n All'interno del solenoide si crea un campo (quasi) uniforme:\n
\n \n {r`\\left | \\vec{B} \\right | = \\mu_0 \\cdot I \\cdot \\frac{A_{vvolgimenti}}{L_{unghezzafilo}}`} \n
\n \n \n \n Caso particolare della Legge di Ampère.\n
\n \n Il modulo del campo magnetico B prodotto da un filo in cui passa una corrente continua I alla distanza s è:\n
\n \n {r`\\left | \\vec{B} \\right | = \\frac{\\mu \\cdot I}{2 \\pi r}`} \n
\n \n Il campo magnetico così creato gira attorno al filo in senso antiorario.\n
\n \n Due fili attraversati dalla stessa corrente si attraggono, due fili attraversati da corr enti opp oste si respingono.\n
\n \n \n \n \n \n Un conduttore perpendicolare ad un campo magnetico può ottenere una differenza di potenziale se messo in movimento in un direzione perpendicolare alla direzione del conduttore e del campo. \n
\n \n La differenza di potenziale si crea a causa della forza magnetica, che fa spostare tutti gli elettroni verso un capo del conduttore. \n
\n \n Essa vale:\n
\n \n {r`\\Delta V_{indotta} = v \\cdot B \\cdot L`} \n
\n \n Dove v è la velocità del conduttore, B è l'intensità del campo magnetico ed L è la lunghezza del conduttore.\n
\n \n \n \n In un campo magnetico {r`B`} uniforme e perpendicolare al piano di una spira di area {r`A`} , il flusso magnetico si può determinare con la Legge di Faraday-Neumann-Lenz:\n
\n \n {r`\\Phi_B = \\vec{B} \\cdot \\vec{A} = B \\cdot A \\cdot \\cos(\\alpha)`} \n
\n \n \n \n \n \n Dice che la forza elettromotrice media indotta in un percorso dipende dalla variazione nel tempo del flusso magnetico nello stesso percorso.\n
\n \n {r`\\Delta V_{indotta} = - \\frac{\\Delta \\Phi_B}{\\Delta t}`} \n
\n \n Il meno è dovuto alla Legge di Lenz, che specifica qualitativamente il verso della forza elettromotrice indotta.\n
\n \n \n \n In un solenoide, la forza elettromotrice indotta è uguale a:\n
\n \n {r`\\Delta V_{indotta} = - \\frac{N \\cdot \\Delta \\Phi_{B_{spira}}}{\\Delta t} = - \\frac{N \\cdot B \\cdot A \\cdot cos(\\alpha)}{\\Delta t}`} \n
\n \n Dove {r`N`} è il numero delle spire del solenoide.\n
\n \n \n \n Correnti o campi elettrici variabili creano un campo magnetico.\n
\n \n \n \n \n \n Nel vuoto, il campo elettrico {r`E`} e il campo magnetico {r`B`} sono perpendicolari tra loro e la direzione di propagazione, e sono entrambe funzioni del tempo.\n
\n \n Si dice quindi che sono onde elettromagnetiche.\n
\n \n Esse sono legate dalla relazione:\n
\n \n {r`E = c \\cdot B`} \n
\n \n Dove {r`c`} è la velocità delle onde (luce) nel vuoto, e a sua volta è uguale a:\n
\n \n {r`c = \\frac{1}{\\sqrt{\\epsilon_0 \\cdot \\mu_0}} = 3.00 \\cdot 10^8 \\frac{m}{s}`} \n
\n \n \n \n {r`A(t) = A_{max} \\cdot \\sin \\left ( \\frac{2 \\pi}{\\lambda} - \\omega t + \\phi \\right )`} \n
\n \n Dove {r`A_{max}`} è l'ampiezza massima che può avere l'onda, {r`\\frac{2 \\pi}{\\lambda} = \\left | \\vec{k} \\right |`} è il vettore d'onda, {r`\\omega`} la frequenza angolare e {r`\\phi`} la fase.\n
\n \n \n \n \n \n I solidi, se portati ad alta temperatura, emettono luce con uno spettro continuo.\n
\n \n I gas, invece, ad alta temperatura emettono luce solo con particolari lunghezze d'onda. \n
\n \n In un gas di idrogeno, le lunghezze d'onda emesse sono ricavabili con:\n
\n \n {r`\\frac{1}{\\lambda} = R \\left ( \\frac{1}{4} - \\frac{1}{n^2} \\right )`} \n
\n \n Con {r`R = 1.097 \\cdot 10^7 \\frac{1}{m}`} , detta costante di Rydberg, e {r`n`} un numero intero.\n
\n \n \n \n Una grandezza si dice quantizzata (o discreta) se può assumere solo determinati valori. \n
\n \n Una grandezza si dice continua se può assumere qualsiasi valore e quindi se non è quantizzata.\n
\n \n Energia, momento angolare e raggio sono quantizzati.\n
\n \n Nota costante quantica è {r`h`} , la costante di Planck, ovvero il valore minimo possibile per la carica (talvolta espressa come {r`\\hbar = \\left ( \\frac{h}{2 \\pi} \\right )`} .\n
\n \n \n \n \n \n L'energia degli elettroni è quantizzata.\n
\n \n Inoltre, per essi è valido che:\n
\n \n {r`m \\cdot v_n \\cdot 2 \\pi \\cdot r = n \\cdot h`} \n
\n \n Ancora, il raggio delle orbite è uguale a:\n
\n \n {r`r_n = n^2 \\cdot a_0 = n^2 \\cdot \\frac{\\hbar}{m_{elettrone} \\cdot k \\cdot e^2} `} \n
\n \n Con {r`a_0 = \\left ( \\frac{h}{2 \\pi} \\right )^2 \\cdot \\frac{1}{m_{elettrone} \\cdot k \\cdot e^2} = 5.29 \\cdot 10^{-11} m`} .\n
\n \n Infine, in ogni stato, l'energia è pari a:\n
\n \n {r`E_n = \\frac{1}{n^2} \\cdot E_1 = - \\frac{1}{n^2} \\cdot \\frac{a_0^2}{2 \\cdot m \\cdot \\hbar^4} = - \\frac{1}{n^2} \\cdot \\frac{m_{elettrone} \\cdot k^2 \\cdot e^4}{2 \\cdot \\hbar^2}`} \n
\n \n Due elettroni non possono occupare lo stesso stato.\n
\n \n Questo modello funziona solo per atomi con numero atomico basso. Atomi con molti elettroni hanno comportamenti diversi, descritti dal modello di\n
\n \n \n \n \n \n Nei solidi, le lunghezze d'onda sono talmente tanto vicine da poter essere considerate una banda.\n
\n \n Possono però comunque avere dei gap dovuti agli intervalli di energia non ammessi.\n
\n \n \n \n \n \n Refactor this \n
\n \n Se la banda di emissione con energia più alta di un corpo è assente o è separata da un gap dell'ordine di grandezza maggiore di {r`10^1 eV`} , allora il corpo è un isolante.\n
\n \n Se invece la banda di emissione si sovrappone a un altra, allora il corpo è un conduttore.\n
\n \n Se il gap è invece dell'ordine di grandezza di {r`1 eV`} , allora il corpo è un semiconduttore.\n
\n \n \n \n Legami in cui mancano elettroni .\n
\n \n Elettroni di altri legami possono spostarsi per colmare le lacune , creandone altre, e spostandole in direzione opposta a quella della corrente.\n
\n \n \n \n Se si inserisce in un cristallo semiconduttore si inserisce un atomo con numero atomico diverso, si otterrà:\n
\n \n - Con numero atomico maggiore, un semiconduttore di
tipo N con elettroni in eccesso liberi di scorrere. \n - Con numero atomico minore, un semiconduttore di
tipo P con lacune in eccesso libere di catturare elettroni da altri legami. \n
\n \n Maggiore impurezza porta a maggiore conduttività.\n
\n \n \n \n Aumentando la temperatura di un semiconduttore si aumenta la conduttività, perchè eccita le particelle e favorisce il movimento di elettroni e lacune .\n
\n \n \n Ottica (non l'abbiamo fatta)}>\n \n \n I corpi possono assorbire o riflettere le onde elettromagnetiche che li colpiscono.\n
\n \n \n \n Un corpo nero è un corpo che assorbe tutte le onde elettromagnetiche che riceve senza rifletterne nessuna.\n
\n \n Le onde assorbite vengono poi riemesse sotto forma di un onda di {r`\\lambda`} variabile in base alla temperatura.\n
\n \n {r`\\lambda_{max} \\cdot T`} è costante.\n
\n \n \n \n L'energia assorbita e emessa dai corpi neri è quantizzata.\n
\n \n \n \n Un onda magnetica con un quanto di energia è detta fotone:\n
\n \n {r`E_{fotone} = h \\cdot f`} \n
\n \n \n \n A volte, i fotoni che colpiscono un metallo possono estrarvi degli elettroni e creare una differenza di potenziale.\n
\n \n Perchè avvenga, la frequenza deve essere maggiore di una certa soglia.\n
\n \n Il numero di elettroni estratti dipende dall'intensità dell'onda, mentre l'energia cinetica degli elettroni dipende dalla frequenza.\n
\n \n Non c'è nessun ritardo tra l'assorbimento del fotone e l'estrazione di elettroni.\n
\n \n \n \n )\n\t}\n}\n\n\n// WEBPACK FOOTER //\n// ./pages/fisica.js","import style from \"./markdown.css\";\nimport { Component } from 'preact';\nimport showdown from \"showdown\";\n\nexport default class Markdown extends Component {\n\trender() {\n let converter = new showdown.Converter();\n converter.setFlavor(\"github\");\n let html = converter.makeHtml(`${this.props.children}`);\n // noinspection CheckTagEmptyBody\n return ;\n\t}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/markdown.js","import style from './vldigeometria.css';\r\nimport { Component } from 'preact';\r\nimport Markdown from '../components/markdown';\r\nimport Panel from '../components/panel';\r\n\r\nconst r = String.raw;\r\n\r\nexport default class VlDiGeometria extends Component {\r\n\trender() {\r\n\t\t//Imported from unimore-info-wiki\r\n\t\treturn (\r\n\t\t\t\r\n Videolezioni di Geometria
\r\n \r\n {r`\r\nTutte le videolezioni sono state pubblicate sotto licenza [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) dalla Prof.ssa Beatrice Ruini nell'anno accademico 2018/2019 sul [portale Dolly 2018](https://dolly.fim.unimore.it/2018/course/view.php?id=14#section-0) (Moodle).\r\n\r\nPer comodità, ho estratto l'url sorgente del video dall'embed presente nella rispettiva pagina.\r\n\r\n1. [Definizione di Spazio Vettoriale](https://www.youtube.com/watch?v=7eHEzf4403c) (1:17:29)\r\n2. [Sottospazi vettoriali I](https://www.youtube.com/watch?v=FPqrULk5HBU) (37:15)\r\n3. [Sottospazi vettoriali II](https://www.youtube.com/watch?v=ubDWUw9hk0k) (43:26)\r\n4. [Sottospazi vettoriali III](https://www.youtube.com/watch?v=381n4NPb6Oc) (40:29)\r\n5. [Lineare dipendenza e indipendenza](https://www.youtube.com/watch?v=9YVQ5olYrh0) (56:12)\r\n6. [Basi di uno spazio vettoriale I](https://www.youtube.com/watch?v=mEF_lcTzEoE) (25:52)\r\n7. [Basi di uno spazio vettoriale II](https://www.youtube.com/watch?v=k1r9JfXY53k) (48:24)\r\n8. [Teorema di Grassmann](https://www.youtube.com/watch?v=3sqB-MMyCWM) (32:36)\r\n9. [Basi e Matrici](https://www.youtube.com/watch?v=Rd6AB_jE7YI) (27:06)\r\n10. [Definizione di Applicazioni Lineari](https://www.youtube.com/watch?v=rmd7ffZeVYk) (16:23)\r\n11. [Proprietà delle Applicazioni Lineari](https://www.youtube.com/watch?v=MH7ztQGkqmw) (31:58)\r\n12. [Definizione di determinante](https://www.youtube.com/watch?v=EwubcLwBdzk) (36:43)\r\n13. [Proprietà e metodo di triangolazione](https://www.youtube.com/watch?v=SFusGarV6HI) (22:36)\r\n14. [Teorema di Laplace](https://www.youtube.com/watch?v=BqZDWnKl2nQ) (29:03)\r\n15. [4 applicazioni del Teorema di Laplace](https://www.youtube.com/watch?v=2tr3y725GY0) (47:53)\r\n16. [Spazi vettoriali euclidei reali - Parte 1](https://www.youtube.com/watch?v=W7Z1hm-jwMM) (28:46)\r\n17. [Spazi vettoriali euclidei reali - Parte 2](https://www.youtube.com/watch?v=zjmKE9TMGm8) (27:17)\r\n18. [Autovalori e autovettori](https://www.youtube.com/watch?v=XlrlcnvcTtQ) (33:00)\r\n19. [Polinomio caratteristico](https://www.youtube.com/watch?v=61icRbgWTdI) (31:31)\r\n20. [Teorema diagonalizzabilità](https://www.youtube.com/watch?v=wm5V6en9OFo) (18:49)\r\n21. [Spazi affini](https://player.vimeo.com/video/291457587) (20:46)\r\n22. [Sottospazi affini](https://player.vimeo.com/video/291458991) (21:32)\r\n23. [Parallelismo e Riferimenti Affini](https://player.vimeo.com/video/291510181) (16:57)\r\n24. [Rappresentazione di Sottospazi Affini](https://player.vimeo.com/video/291510296) (31:17)\r\n25. [Spazi Euclidei](https://player.vimeo.com/video/291510612) (35:57)\r\n26. [Teoria dei ranghi](https://player.vimeo.com/video/291510964) (9:44)\r\n27. [Teoria dei ranghi 2](https://player.vimeo.com/video/291510862) (14:44)\r\n\r\nNell'anno accademico 2018/2019 non sono stati trattati gli argomenti nei video 21, 22 e 23.\r\n `} \r\n \r\n\t\t\t\r\n\t\t);\r\n\t}\r\n}\r\n\r\n\n\n\n// WEBPACK FOOTER //\n// ./pages/vldigeometria.js","import style from './mingwinstall.css';\r\nimport { Component } from 'preact';\r\nimport Panel from '../components/panel';\r\n\r\nexport default class MingwInstall extends Component {\r\n\trender() {\r\n\t\t//Imported from unimore-info-wiki\r\n\t\treturn (\r\n\t\t\t\r\n Come installare MinGW
\r\n \r\n\t\t\t\t\t Scaricate l'installer ufficiale,\r\n\t\t\t\t\t\ted eseguitelo.
![\"\"/](\"https://i.imgur.com/mDZSqjV.png\")
\r\n\t\t\t\t\t Dovrebbe comparire questa schermata. Cliccate su Install, poi scegliete una cartella di installazione\r\n\t\t\t\t\t\t(ricordatevela!) e poi Continue. Lasciate stare le altre opzioni, dovrebbero essere tutte spuntate,\r\n\t\t\t\t\t\ttranne For all users, che dovrebbe essere disattivato.
![\"\"/](\"https://i.imgur.com/brdw8Xy.png\")
\r\n\t\t\t\t\t Aspettate che finisca il download. Pochi secondi dopo, dovrebbe finire e dovrebbe apparire un tasto\r\n\t\t\t\t\t\tContinue. Premetelo.
![\"\"/](\"https://i.imgur.com/aPTwrxz.png\")
\r\n\t\t\t\t\t Dovrebbe apparirvi questa finestra. L'installer di MinGW è una specie di gestore pacchetti (tipo apt su\r\n\t\t\t\t\t\tUbuntu); potete scegliere quali pacchetti installare, e quindi quali funzionalità.
![\"\"/](\"https://i.imgur.com/5QLSkFN.png\")
\r\n\t\t\t\t\t Nel nostro caso, dovrebbero servirci mingw32-base-bin (per il C e alcune librerie C++) e\r\n\t\t\t\t\t\tmingw32-gcc-g++-bin (per il C++). Cliccate, quindi, sui due quadratini corrispondenti, e premete\r\n\t\t\t\t\t\tMark for Installation. Dovrebbe comparire una freccia gialla sul quadratino.
![\"\"/](\"https://i.imgur.com/zP74nks.png\")
\r\n\t\t\t\t\t Ora, è il momento di installare i pacchetti. Aprite il menù Installation, poi premete\r\n\t\t\t\t\t\tApply Changes, e di nuovo Apply.
![\"\"/](\"https://i.imgur.com/jp4uz5B.png\")
\r\n\t\t\t\t\t Lasciate che scarichi, ci vorrà un po'. Guardatevi un video nel frattempo, fatevi una partitina a qualcosa, tornate\r\n\t\t\t\t\t\tdopo circa 10 minuti.
![\"\"/](\"https://i.imgur.com/Lq9IepY.png\")
\r\n\t\t\t\t\t Una volta installato, dobbiamo aggiungere g++ ai programmi eseguibili da Prompt dei Comandi: premete il\r\n\t\t\t\t\t\ttasto Windows, e scrivete PATH. Windows dovrebbe trovarvi automaticamente quell'opzione.
\r\n\t\t\t\t\t![\"\"/](\"https://i.imgur.com/dy3b5Ub.png\")
\r\n\t\t\t\t\t Dentro la finestra di Proprietà del Sistema, premete Variabili d'ambiente.
![\"\"/](\"https://i.imgur.com/FjYpT1n.png\")
\r\n\t\t\t\t\t Trovate la variabile d'ambiente globale Path, e fateci doppio click per modificarla.
![\"\"/](\"https://i.imgur.com/klZQ9So.png\")
\r\n\t\t\t\t\t Ora dovreste vedere l'elenco di tutte le cartelle contenenti programmi eseguibili da terminale: dobbiamo aggiungere\r\n\t\t\t\t\t\tquella di MinGW! Premete Sfoglia.
![\"\"/](\"https://i.imgur.com/F6lBCqS.png\")
\r\n\t\t\t\t\t Trovate la cartella in cui avete installato MinGW (vi avevo detto di ricordarvela!); entrateci, poi selezionate la\r\n\t\t\t\t\t\tsottocartella bin e premete OK su tutte le finestre che avete aperto fino ad ora,\r\n\t\t\t\t\t\tchiudendole.
\r\n\t\t\t\t\t Complimenti! Avete installato MinGW e potete compilare programmi C e C++ da Windows! Avete a disposizione\r\n\t\t\t\t\t\tgcc e g++ sul Prompt dei Comandi, e potete finalmente creare dei file .exe!
\r\n\t\t\t\t \r\n\t\t\t\r\n\t\t);\r\n\t}\r\n}\r\n\r\n\n\n\n// WEBPACK FOOTER //\n// ./pages/mingwinstall.js","import style from './copyright.css';\r\nimport { Component } from 'preact';\r\n\r\nexport default class Copyright extends Component {\r\n\trender() {\r\n\t\treturn © 2019 - Stefano Pigozzi - CC BY-SA 4.0 - Codice sorgente;\r\n\t}\r\n}\n\n\n// WEBPACK FOOTER //\n// ./components/copyright.js","import style from \"./theorem.css\";\r\nimport Panel from \"./panel.js\";\r\n\r\nexport default class Theorem extends Panel {\r\n getStyle() {\r\n return super.getStyle() + \" \" + style.theorem;\r\n }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/theorem.js","import style from \"./hypothesis.css\";\r\nimport {Component} from \"preact\";\r\n\r\nexport default class Hypothesis extends Component {\r\n render() {\r\n return (\r\n \r\n \r\n Ipotesi\r\n
\r\n {this.props.children}\r\n \r\n )\r\n }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/hypothesis.js","import style from \"./thesis.css\";\r\nimport {Component} from \"preact\";\r\n\r\nexport default class Thesis extends Component {\r\n render() {\r\n return (\r\n \r\n \r\n Tesi\r\n
\r\n {this.props.children}\r\n \r\n )\r\n }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/thesis.js","import style from \"./proof.css\";\r\nimport {Component} from \"preact\";\r\n\r\nexport default class Proof extends Component {\r\n render() {\r\n return (\r\n \r\n \r\n Dimostrazione\r\n
\r\n {this.props.children}\r\n \r\n )\r\n }\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./components/proof.js","import style from \"./example.css\";\nimport {Component} from \"preact\";\n\nexport default class Example extends Component {\n render() {\n return (\n \n {this.props.children}\n
\n )\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./components/example.js","import style from './statistica.css';\nimport { Component } from 'preact';\nimport Latex from '../components/latex';\nimport Panel from '../components/panel';\nimport Split from '../components/split';\nimport Todo from '../components/todo';\nimport Theorem from \"../components/theorem\";\nimport Hypothesis from \"../components/hypothesis\";\nimport Thesis from \"../components/thesis\";\nimport Proof from \"../components/proof\";\nimport Example from \"../components/example\";\nimport Plus from \"../components/plus\";\nimport Minus from \"../components/minus\";\n\nconst r = String.raw;\n\nexport default class Statistica extends Component {\n\trender() {\n\t /*\n \n \n \n Gruppo intero di oggetti di cui si cercano informazioni.\n
\n \n \n \n Popolazione finita di oggetti concreti che possono essere campionati ciascuno solo una volta.\n
\n \n \n \n Popolazione di valori ottenuti da prove sperimentali indipendenti ripetute più volte.\n
\n \n \n \n \n \n Sottoinsieme della popolazione che contiene gli oggetti che si sono osservati.\n
\n \n Simple random sample}>\n \n Campione di una data dimensione in cui qualsiasi selezione di n elementi ha la stessa probabilità di costituire il campione.\n
\n \n Sample of convenience}>\n \n Campione ottenuto in un modo casuale non ben definito.\n
\n \n Sample with replacement}>\n \n Campione ottenuto sostituendo nella popolazione gli elementi estratti con dei nuovi elementi.\n
\n \n Dire che un campione è ottenuto with replacement è equivalente a dire che la popolazione che si sta campionando è infinita, e quindi che tutti gli elementi sono indipendenti.\n
\n \n \n \n Campione ottenuto da una popolazione in cui certi elementi hanno più probabilità di essere stati selezionati di altri.\n
\n \n Stratified random sample}>\n \n Campione ottenuto da un sottoinsieme della popolazione detto strato.\n
\n \n Cluster sample}>\n \n Campione ottenuto selezionando più cluster di elementi alla volta.\n
\n \n \n \n Sampling variation}>\n \n Differenza di informazioni presente tra due campioni diversi della stessa popolazione.\n
\n \n \n \n Gli elementi in un campione sono indipendenti se gli elementi estratti in precedenza non influsicono significativamente sulle probabilità di estrazione dell'elemento successivo.\n
\n \n \n \n \n \n Esperimento in cui c'è una sola popolazione da cui vengono estratti campioni.\n
\n \n Serve per verificare delle condizioni.\n
\n \n \n \n Esperimento in cui sono presenti più popolazioni (aventi caratteristiche differenti una dall'altra dette fattori) da cui vengono estratti campioni.\n
\n \n Serve per capire quali fattori influenzano il risultato dell'esperimento.\n
\n \n \n \n Numerico o quantitativo}>\n Il dato descrive un valore numerico relativo all'elemento, come ad esempio una quantità fisica.\n \n Categorico o qualitativo}>\n Il dato indica una categoria a cui appartiene l'elemento, come ad esempio il suo colore.\n \n \n\t */\n return (\n \n Statistica ed Elementi di Probabilità
\n \n \n \n {r`P(E) = \\frac{casi\\ favorevoli}{casi\\ possibili}`} \n
\n \n \n \n {r`P(E) = \\frac{successi}{prove\\ totali}`} \n
\n \n \n \n Il prezzo che un individuo coerente riterrebbe equo per ricevere 1 nel caso l'evento si verificasse e 0 nel caso l'evento non si verificasse.\n
\n \n \n \n \n \n \"omegone\"\n
\n \n L'insieme di tutti gli esiti possibili di un esperimento.\n
\n \n {r`\\Omega = \\left \\{ 1, 2, 3, 4, 5, 6 \\right \\}`} \n
\n \n \n \n \"omeghino\"\n
\n \n Un elemento dello spazio campionario.\n
\n \n {r`\\omega = 1`} \n
\n \n \n \n \"e\"\n
\n \n Un sottoinsieme dello spazio campionario.\n
\n \n {r`E = \\left \\{ 1, 2 \\right \\}`} \n
\n \n Lo spazio campionario stesso è un evento certo.\n
\n \n \n \n \"not e\"\n
\n \n Il complementare di un sottoinsieme.\n
\n \n {r`\\bar{E} = \\left \\{ 3, 4, 5, 6 \\right \\}`} \n
\n \n \n \n \"e intersecato effe\"\n
\n \n L'intersezione di più sottoinsiemi.\n
\n \n {r`E \\cap F = \\left \\{ 1 \\right \\}`} \n
\n \n \n \n \"e unito a effe\"\n
\n \n L'unione di più sottoinsiemi.\n
\n \n {r`E \\cup F = \\left \\{ 1, 2, 3, 4 \\right \\}`} \n
\n \n \n \n \"e meno effe\"\n
\n \n {r`E \\setminus F = E \\cap \\bar{F}`} \n
\n \n \n \n \"e contenuto in effe\"\n
\n \n L'inclusione del primo insieme in un altro.\n
\n \n {r`E \\subseteq F`} \n
\n \n Se si verifica E , allora si verifica anche F .\n
\n \n \n \n \"e è impossibile\"\n
\n \n Un sottoinsieme vuoto.\n
\n \n {r`E = \\emptyset`} \n
\n \n \n \n \"e ed effe si escludono mutualmente\"\n
\n \n La disgiunzione di due insiemi.\n
\n \n {r`E \\cap F = \\emptyset`} \n
\n \n \n \n \n \n \"famiglia effe\"\n
\n \n I sottoinsiemi dello spazio campionario formano una famiglia di sottoinsiemi detta famiglia degli eventi.\n
\n \n {r`\\mathcal{F}`} \n
\n \n Qualsiasi sottoinsieme appartenente a {r`\\mathcal{F}`} è considerato un evento.\n
\n \n {r`\\sigma`} -algebra}>\n \n \"sigma algebra\"\n
\n \n Se la famiglia degli eventi soddisfa questi tre requisiti, allora viene detta {r`\\sigma`} -algebra:\n
\n \n - \n Lo spazio campionario è un evento:
{r`\\Omega \\in \\mathcal{F}`} \n \n - \n Se un sottoinsieme è un evento, allora anche il suo complementare lo è:
{r`E \\in \\mathcal{F} \\implies \\bar{E} \\in \\mathcal{F}`} \n \n - \n Se due sottoinsiemi sono eventi, allora lo sono anche la loro unione e intersezione:
{r`(E, F) \\in \\mathcal{F} \\implies (E \\cup F, E \\cap F) \\in \\mathcal{F}`} \n \n
\n \n Un esempio: {r`E \\in \\mathcal{F} \\implies \\mathcal{F} = \\{ \\emptyset, E, \\bar{E}, \\Omega \\}`} \n
\n \n \n \n \n \"la partizione e composta da e uno, e due, e tre...\"\n
\n \n Un insieme di esiti e eventi:\n
\n \n - Finito.
\n - In cui tutti gli eventi hanno probabilità diversa da 0.
\n - In cui tutti gli eventi sono mutualmente esclusivi.
\n - In cui l'unione di tutti i suoi elementi copre lo spazio campionario.
\n
\n \n La partizione {r`E_i`} è composta dagli eventi {r`E_1`} , {r`E_2`} , {r`E_3`} , fino a {r`E_n`} .\n
\n \n Se lo spazio campionario fosse una torta, una sua partizione sarebbe l'insieme delle fette di uno dei modi in cui si potrebbe tagliare.\n \n \n \n \n \n \n La probabilità di un evento è un numero tra 0 e 1.\n
\n \n {r`\\forall E \\in \\mathcal{F}, 0 \\leq P(E) \\leq 1`} \n
\n \n \n \n La probabilità dello spazio campionario è sempre 1.\n
\n \n {r`P(\\Omega) = 1`} \n
\n \n \n \n La probabilità dell'unione di eventi indipendenti è uguale alla somma delle loro probabilità.\n
\n \n {r`P \\left ( \\bigcup_i E_i \\right ) = \\sum_i P ( E_i )`} \n
\n \n \n \n \n \n La probabilità di un evento negato è uguale a 1 meno la probabilità dell'evento non negato.\n
\n \n {r`P(\\bar{E}) = 1 - P({E})`} \n
\n \n \n \n La probabilità di un evento incluso in un altro è sempre minore o uguale alla probabilità dell'evento in cui è incluso.\n
\n \n {r`F \\subseteq E \\implies P(F) \\leq P(E)`} \n
\n \n \n \n La probabilità di un evento unito a un altro è uguale alla somma delle probabilità dei due eventi meno la probabilità della loro intersezione.\n
\n \n {r`P(E \\cup F) = P(E) + P(F) - P(E \\cap F)`} \n
\n \n Sommando le probabilità dei due eventi, l'intersezione viene contata due volte, e va quindi rimossa!\n \n \n \n \n \n \n Spazi campionari in cui ci sono un numero finito di esiti e ogni esito ha la stessa probabilità di verificarsi.\n
\n \n {r`P(E) = \\frac{len(E)}{len(\\Omega)}`} \n
\n \n \n \n Gli spazi campionari possono avere un numero infinito di esiti: sono equiprobabili geometrici se nessun esito è privilegiato rispetto agli altri.\n
\n \n \n \n \n \n Estraggo un numero, da un sacchetto con n numeri, mi segno che numero ho estratto e lo tengo fuori dal sacchetto. Ripeto per k volte.\n
\n \n Tengo conto dell'ordine in cui ho estratto i numeri.\n
\n \n {r`\\boldsymbol{D}_{n, k} = \\frac{n!}{(n - k)!}`} \n
\n \n \n \n Estraggo un numero, da un sacchetto con n numeri, mi segno che numero ho estratto e lo rimetto nel sacchetto. Ripeto per k volte.\n
\n \n Tengo conto dell'ordine in cui ho estratto i numeri.\n
\n \n {r`\\boldsymbol{D}^{r}_{n, k} = n^k`} \n
\n \n \n \n Estraggo un numero, da un sacchetto con n numeri, mi segno che numero ho estratto e lo tengo fuori dal sacchetto. Ripeto per k volte.\n
\n \n Non mi interessa l'ordine in cui ho estratto i numeri.\n
\n \n {r`\\boldsymbol{C}_{n, k} = \\binom{n}{k} = \\frac{n!}{(k)! \\cdot (n - k)!}`} \n
\n \n \n \n Estraggo un numero, da un sacchetto con n numeri, mi segno che numero ho estratto e lo rimetto nel sacchetto. Ripeto per k volte.\n
\n \n Non mi interessa l'ordine in cui ho estratto i numeri.\n
\n \n {r`\\boldsymbol{C}^{r}_{n, k} = \\binom{n + k - 1}{k} = \\frac{(n + k - 1)!}{(k)! \\cdot (n - 1)!}`} \n
\n \n \n \n Estraggo n numeri e guardo in quanti ordini diversi li posso mettere.\n
\n \n {r`\\boldsymbol{P}_n = n!`} \n
\n \n \n \n \n \n \"E dato F\"\n
\n \n La probabilità che si verifichi E sapendo che si è già verificato F .\n
\n \n {r`P(E|F) = \\frac{P(E \\cap F)}{P(F)}`} \n
\n \n Ricorda vagamente le pipe di bash, però al contrario...\n \n \n \n \n Se due eventi sono mutualmente esclusivi, entrambe le loro probabilità condizionate saranno uguali a 0.\n
\n \n {r`E \\cap F = \\emptyset \\Longleftrightarrow P(E|F) = P(F|E) = 0`} \n
\n \n \n \n \n \n Si può sfruttare la formula inversa della probabilità condizionata per calcolare catene di intersezioni:\n
\n \n {r`P(E_1 \\cap \\times \\cap E_n) = P(E_1) \\times P(E_2 | E_1) \\times \\dots \\times P(E_n | E_1 \\cap E_2 \\cap \\dots \\cap E_{n-1})`} \n
\n \n \n \n \n \n La probabilità che si verifichi un evento è pari alla somma delle probabilità dell'evento stesso dati tutti gli eventi di una partizione.\n
\n \n {r`P(F) = \\sum_{i} P(F|E_i) \\cdot P(E_i)`} \n
\n \n \n \n La legge delle alternative funziona anche quando ad essere partizionato è un evento:\n
\n \n {r`P(F|G) = \\sum_i P(F|E_i \\cap G) \\cdot P(E_i | G)`} \n
\n \n \n \n Tramite la formula di Bayes possiamo risalire alla probabilità di un evento condizionato a un altro partendo dalla probabilità di quest'ultimo condizionato al primo:\n
\n \n {r`P(E_h | F) = \\frac{P(F | E_h) \\cdot P(E_h)}{P(F)}`} \n
\n \n In pratica, invertiamo gli eventi.\n \n \n \n \n \n \n \"eventi indipendenti a due a due\"\n
\n \n Se due eventi sono indipendenti, sapere che uno dei due si è verificato non influisce sulle probabilità che si sia verificato l'altro.\n
\n \n {r`P(E \\cap F) = P(E) \\cdot P(F) \\Longleftrightarrow P(E|F) = P(E) \\Longleftrightarrow P(F|E) = P(F)`} \n
\n \n \n \n \"eventi indipendenti a tre a tre, a quattro a quattro, a cinque a cinque...\"\n
\n \n Si può verificare l'indipendenza di più eventi alla volta:\n
\n \n {r`P(E \\cap F \\cap G) = P(E) \\cdot P(F) \\cdot P(G)`} \n
\n \n Eventi indipendenti a due a due non sono per forza indipendenti a tre a tre, e viceversa.\n
\n \n \n \n Un insieme di n eventi è una famiglia di eventi indipendenti se, preso un qualsiasi numero di eventi da essa, essi risulteranno indipendenti.\n
\n \n Tutti gli eventi provenienti da essa saranno indipendenti sia a due a due, sia a tre a tre, sia a quattro a quattro, e così via!\n \n \n \n \n \n \n Una funzione che fa corrispondere un numero reale a ogni possibile esito dello spazio campionario. {r`X(\\omega) : \\Omega \\to \\mathbb{R}`} .\n
\n \n Insieme di ripartizione}>\n \n Ad ogni variabile aleatoria sono associati gli eventi {r`A_t = \\{ \\omega | X(\\omega) \\leq t \\}`} , che contengono tutti gli esiti a cui la variabile aleatoria associa un valore minore o uguale a t .\n
\n \n Per definizione, tutte le variabili aleatorie devono rispettare questa condizione:\n
\n \n {r`\\forall t \\in \\mathbb{R}, A_t \\in \\mathcal{F}`} \n
\n \n All'aumentare di t, l'insieme conterrà sempre più elementi.\n \n \n \n \n \"supporto di X\"\n
\n \n Il codominio della variabile aleatoria è il suo supporto.\n
\n \n Per indicare che un valore x_0 appartiene al supporto di X , si usa la notazione X \\mapsto x_0 .\n
\n \n \n \n \n \n La funzione probabilità {r`p_X : X \\to [0, 1]`} di una variabile aleatoria discreta X è la funzione che associa ad ogni esito la sua probabilità:\n
\n \n {r`p_X (x) = \\begin{cases}\n P([X = x]) \\quad se\\ X \\mapsto x \\\\\n 0 \\qquad \\qquad \\quad se\\ X \\not\\mapsto x\n \\end{cases}`} \n
\n \n \n \n La funzione densità {r`f_X : X \\to [0, 1]`} di una variabile aleatoria continua X è l'equivalente continuo della funzione probabilità:\n
\n \n {r`P([a < X \\leq b]) = \\int_a^b f_X (x) dx`} \n
\n \n A differenza della funzione probabilità, è possibile che la funzione densità non esista per una certa variabile aleatoria.\n
\n \n Rappresenta \"quanta\" probabilità c'è in un'unità di x!\n \n \n \n \n \n \n Ogni variabile aleatoria ha una funzione di ripartizione {r`F_X : \\mathbb{R} \\to [0, 1]`} associata, che rappresenta la probabilità che la variabile aleatoria assuma un valore minore o uguale a t :\n
\n \n Si può dire che essa rappresenti la probabilità dell'evento {r`A_t`} :\n
\n \n {r`F_X (t) = P(A_t) = \\begin{cases}\n \\sum_{i = 0}^{t} p_X (x_i) \\quad nel\\ discreto\\\\\n \\\\\n \\int_{-\\infty}^t f_X (x) dx \\quad nel\\ continuo\n \\end{cases}`} \n
\n \n \n \n - È sempre monotona crescente (non strettamente).
\n - Vale 0 a
-\\infty e 1 a +\\infty .
\n - È continua da destra:
{r`\\forall x_0 \\in \\mathbb{R}, F_X (x_0) = \\lim_{t \\to x^+_0} F_X (t)`} \n
\n \n \n \n Possiamo usare la funzione di ripartizione per calcolare la probabilità di un certo valore reale:\n
\n \n {r`P([X = x_0]) = \\lim_{t \\to x^+_0} F_X (t) - \\lim_{t \\to x^-_0} F_X (t)`} \n
\n \n \n \n \n \n Nel discreto basta abbinare un nuovo valore a ogni valore della variabile originale.\n
\n \n \n \n Nel continuo applichiamo la formula dell'integrazione per sostituzione:\n
\n \n {r`f_Y (y) = \\int_{g(a)}^{g(b)} f_X ( g^{-1} (x) ) g^{-2} (x)`} \n
\n \n \n \n Trasformare variabili aleatorie è molto utile nell'informatica per creare distribuzioni partendo da una funzione random() che restituisce numeri da 0 a 1 con una distribuzione lineare.\n
\n \n \n \n \n \n Ogni variabile aleatoria che ha una funzione di ripartizione e un supporto finito ha anche una media (o valore medio o atteso):\n
\n \n {r`E(X) = \\int_0^{+infty} (1 - F_X (t)) dt - \\int_{-\\infty}^{0} F_X (t) dt`} \n
\n \n Nel discreto, si può calcolare con:\n
\n \n {r`E(X) = \\sum_i P(X = x_i) \\cdot x_i`} \n
\n \n Nel continuo, si può calcolare con:\n
\n \n {r`E(X) = \\int_{-\\infty}^{+\\infty} f_X (x) \\cdot x \\cdot dx`} \n
\n \n \n \n \n \n Valore per cui la funzione probabilità o funzione densità è massima.\n
\n \n \n \n Il quantile {r`x_{\\alpha}`} di ordine {r`0 \\leq \\alpha \\leq 1`} della variabile aleatoria X è il più piccolo numero tale che:\n
\n \n \n {r`P([X < x_{\\alpha}]) \\leq \\alpha \\leq P([X \\leq x_{\\alpha}])`}\n \n
\n \n\n
\n \n Il quantile di ordine 0.5 {r`x_{0.5}`} è detto mediana.\n
\n \n I quantili di ordine 0.25 {r`x_{0.25}`} e 0.75 {r`x_{0.75}`} sono detti quartili.\n
\n \n I quantili di ordine {r`\\frac{n}{100}`} sono detti n -esima percentile.\n
\n \n \n \n È un valore che indica quanto la variabile aleatoria si discosta generalmente dalla media:\n
\n \n {r`Var(X) = E( (X - E(X) )^2 ) = E ( X^2 ) - (E(X))^2`} \n
\n \n \n \n \n \n Data una variabile aleatoria non-negativa:\n
\n \n {r`\\forall k > 0, P([X \\geq k]) \\leq \\frac{E(X)}{k}`} \n
\n \n Divide in due parti ({r`P(X < k)`} e {r`P(X \\geq k)`} ) la funzione X, la cui media risulterà uguale a:\n
\n \n {r`E(X) = \\overline{k} \\cdot P(X < k) + k \\cdot P(X \\geq k)`} \n
\n \n \n \n \"disuguaglianza di cebicev\"\n
\n \n Se la variabile aleatoria X ha media e varianza, allora la probabilità che essa abbia un valore a più di {r`\\epsilon`} di distanza dal valore medio è minore o uguale a {r`\\frac{Var(X)}{\\epsilon^2}`} .\n
\n \n {r`\\forall \\epsilon > 0, P([ \\left| X - E(X) \\right| \\geq \\epsilon]) \\leq \\frac{Var(X)}{\\epsilon^2}`} \n
\n \n E anche:\n
\n \n {r`\\forall \\epsilon > 0, P([ \\left| X - E(X) \\right| < \\epsilon]) \\geq 1 - \\frac{Var(X)}{\\epsilon^2}`} \n
\n \n Serve per semplificare i calcoli quando la funzione di ripartizione è difficile da calcolare!\n \n \n \n \n \n \n Il momento k -esimo di una variabile aleatoria è:\n
\n \n \n {r`\\mu_k = E ( X^k ) = \\begin{cases}\n \\sum_i x_i^k p_X (x_i) \\qquad nel\\ discreto\\\\\n \\\\\n \\int_{-\\infty}^{+\\infty} x^k f_X (x) dx \\qquad nel\\ continuo\n \\end{cases}`}\n \n
\n \n La media di una variabile aleatoria è anche il suo primo momento.\n \n \n \n \n La funzione generatrice dei momenti è:\n
\n \n {r`m_X (t) = E( e^{t \\cdot X} )`} \n
\n \n Se due variabile aleatorie hanno la stessa funzione generatrice dei momenti, allora esse hanno la stessa distribuzione.\n
\n \n E' la trasformata di Laplace della variabile aleatoria di X.\n
\n \n \n \n La funzione caratteristica è:\n
\n \n {r`H_X (t) = E ( e^{i \\cdot t \\cdot X} )`} \n
\n \n Se due variabile aleatorie hanno la stessa funzione caratteristica, allora esse hanno la stessa distribuzione.\n
\n \n E' la trasformata di Fourier della variabile aleatoria di X.\n
\n \n \n \n \n \n Per dire che una variabile ha una certa distribuzione, si usa la notazione:\n
\n \n {r`X \\sim Distribuzione()`} \n
\n \n \n \n Una prova con solo due possibili esiti: successo e insuccesso .\n
\n \n \n \n Una sequenza di prove di Bernoulli per le quali le probabilità di successo e fallimento rimangono invariate.\n
\n \n \n \n \n \n Una variabile aleatoria che rappresenta una prova di Bernoulli:\n
\n \n - vale
1 in caso di successo . \n - vale
0 in caso di insuccesso . \n
\n \n Il suo simbolo è {r`Ber(p)`} \n
\n \n \n \n La distribuzione bernoulliana ha come densità:\n
\n \n {r`f_X (k) : \\{0, 1\\} = \\begin{cases}\n p \\quad se\\ k = 1\\\\\n q \\quad se\\ k = 0\\\\\n 0 \\quad altrimenti\n \\end{cases} = p^x \\cdot q^{1 - k}`} \n
\n \n \n \n \n \n Una variabile aleatoria che conta il numero di successi di n prove di uno schema di Bernoulli.\n
\n \n Il suo simbolo è {r`Bin(n, p)`} .\n
\n \n \n \n La binomiale ha come densità:\n
\n \n {r`f_X (k) : \\{0..n\\} = \\binom{n}{k} \\cdot p^k \\cdot q^{n - k}`} \n
\n \n \n \n La funzione generatrice dei momenti della binomiale è:\n
\n \n {r`m_X (t) = (q + p \\cdot e^t) ^ n`} \n
\n \n La media di una binomiale è:\n
\n \n {r`E(X) = n \\cdot p`} \n
\n \n La varianza di una binomiale è:\n
\n \n {r`Var(X) = n \\cdot p \\cdot q`} \n
\n \n \n \n \n \n Una variabile aleatoria che conta il numero di prove in uno schema di Bernoulli fino alla comparsa del primo successo.\n
\n \n Il suo simbolo è Geo(p) .\n
\n \n \n \n La geometrica ha come densità:\n
\n \n {r`f_X (k) : \\mathbb{N} = q^{k - 1} p`} \n
\n \n \n \n La funzione generatrice dei momenti della geometrica è:\n
\n \n {r`m_X (t) = \\frac{p \\cdot e^t}{1 - q \\cdot e^t}`} \n
\n \n La media della geometrica è:\n
\n \n {r`E(X) = \\frac{1}{p}`} \n
\n \n La varianza della geometrica è:\n
\n \n {r`Var(X) = \\frac{q}{p^2}`} \n
\n \n \n \n La geometrica non tiene conto degli eventi avvenuti in passato: ha la proprietà dell'assenza di memoria:\n
\n \n {r`P([X = i + j | X > i ]) = P([X = j])`} \n
\n \n Ovvero, riscalando opportunamente l'asse Y posso prendere come 0 qualsiasi punto dell'asse X.\n \n \n \n \n \n \n Una variabile aleatoria che conta il numero di prove in uno schema di Bernoulli necessarie perchè si verifichi l'n -esimo successo.\n
\n \n Il suo simbolo è {r`\\overline{Bin}(n, p)`} .\n
\n \n \n \n La binomiale negativa ha come densità:\n
\n \n {r`f_X (k) : \\{ n .. +\\infty \\} \\in \\mathbb{N} = \\binom{k - 1}{n - 1} \\cdot p^n \\cdot q^{k - n} `} \n
\n \n \n \n
\n La funzione generatrice dei momenti della binomiale negativa è:\n
\n \n {r`m_X (t) : \\{ t < ln(\\frac{1}{q}) \\} = \\left( \\frac{p \\cdot e^t}{1 - q \\cdot e^t} \\right) ^n`} \n
\n \n La media della binomiale negativa è:\n
\n \n {r`E(X) = \\frac{n}{p}`} \n
\n \n La varianza della binomiale negativa è:\n
\n \n {r`Var(X) = \\frac{n \\cdot q}{p^2}`} \n
\n \n \n \n \n \n \n Una variabile aleatoria che conta il numero k di insuccessi consecutivi in uno schema di Bernoulli:\n
\n \n Il suo simbolo rimane {r`Geo(p)`} .\n
\n \n \n \n La geometrica traslata ha come densità:\n
\n \n {r`f_X (k) : \\mathbb{N} = p \\cdot q^k `} \n
\n \n \n \n La funzione generatrice dei momenti della geometrica traslata è:\n
\n \n {r`m_X (t) : \\left\\{ t < ln \\left( \\frac{1}{q} \\right) \\right\\} = \\frac{p}{1 - q \\cdot e^t}`} \n
\n \n La media della geometrica traslata è:\n
\n \n {r`E(X) = \\frac{q}{p}`} \n
\n \n La varianza della geometrica è:\n
\n \n {r`Var(X) = \\frac{q}{p^2}`} \n
\n \n \n \n La geometrica traslata non tiene conto degli eventi avvenuti in passato: ha la proprietà dell'assenza di memoria:\n
\n \n {r`P([X = i + j | X > i ]) = P([X = j])`} \n
\n \n Ovvero, riscalando opportunamente l'asse Y posso prendere come 0 qualsiasi punto dell'asse X.\n \n \n \n \n \n \n Una variabile aleatoria che conta il numero di insuccessi in uno schema di Bernoulli prima che si verifichi l'n -esimo successo.\n
\n \n Il suo simbolo rimane {r`\\overline{Bin}(n, p)`} .\n
\n \n \n \n La binomiale negativa traslata ha come densità:\n
\n \n {r`f_X (k) : \\mathbb{N} = \\binom{k + n - 1}{n - 1} \\cdot p^n \\cdot q^k `} \n
\n \n \n \n
\n La funzione generatrice dei momenti della binomiale negativa traslata è:\n
\n \n {r`m_X (t) : \\left\\{ t < ln \\left( \\frac{1}{q} \\right) \\right\\} = \\left( \\frac{p \\cdot e^t}{1 - q \\cdot e^t} \\right) ^n`} \n
\n \n La media della binomiale negativa traslata è:\n
\n \n {r`E(X) = \\frac{n \\cdot q}{p}`} \n
\n \n La varianza della binomiale negativa traslata è:\n
\n \n {r`Var(X) = \\frac{n \\cdot q}{p^2}`} \n
\n \n \n \n \n \n \n Una variabile aleatoria che, sapendo il numero di successi K e di insuccessi N-K , conta quanti successi si otterrebbero se se ne estraessero n in blocco.\n
\n \n Il suo simbolo è Ipe(N, K, n) .\n
\n \n \n \n La ipergeometrica ha come densità:\n
\n \n {r`f_X (k) : \\{0..n\\} \\in \\mathbb{N} = \\frac{\\binom{K}{k} \\cdot \\binom{N - K}{n - k}}{\\binom{N}{n}}`} \n
\n \n \n \n
\n La funzione generatrice dei momenti della ipergeometrica è trascurabile.\n
\n \n La media della ipergeometrica è:\n
\n \n {r`E(X) = n \\cdot \\frac{K}{N}`} \n
\n \n La varianza della ipergeometrica è:\n
\n \n {r`Var(X) = n \\cdot \\frac{K}{N} \\cdot \\frac{N - K}{N} \\cdot \\frac{N - n}{N - 1}`} \n
\n \n \n \n \n \n \n Una variabile aleatoria che soddisfa tutte le seguenti caratteristiche:\n
\n \n - Binomiale:
{r`X \\sim Bin(n, p)`} \n - Il numero di prove tende a infinito:
{r`n \\to +\\infty`} \n - La probabilità di successo tende a 0:
{r`p \\to 0`} \n - La media è finita:
{r`E(X) = n \\cdot p \\to \\mu \\neq 0`} \n
\n \n Il suo simbolo è {r`Poi(\\mu)`} \n
\n \n \n \n La poissoniana ha come densità:\n
\n \n {r`f_X (k) : \\mathbb{N} = \\frac{e^{-\\mu} \\cdot \\mu^k}{k!}`} \n
\n \n \n \n
\n La funzione generatrice dei momenti della poissoniana è:\n
\n \n {r`m_X (t) = e^{\\mu \\cdot (e^t - 1)}`} \n
\n \n La media della poissoniana è:\n
\n \n {r`E(X) = \\mu`} \n
\n \n La varianza della poissoniana è:\n
\n \n {r`Var(X) = \\mu`} \n
\n \n Gli altri momenti della poissoniana sono:\n
\n \n {r`E(X^2) = \\mu^2 + \\mu`}
\n \n \n \n \n \n \n Una successione di arrivi avvenuti in un certo arco temporale che:\n
\n \n - non sono sovrapposti.
\n - hanno intensità
{r`\\lambda`} costante. \n - avvengono indipendentemente gli uni dagli altri.
\n
\n \n \n \n Una variabile aleatoria N_t che conta il numero di arrivi di uno schema di Poisson di intensità {r`\\lambda`} in un intervallo di tempo di durata t .\n
\n \n E' una distribuzione poissoniana con {r`\\mu = t \\cdot \\lambda`} : {r`Poi(t \\cdot \\lambda)`} \n
\n \n E' paragonabile a una bernoulliana: ogni successo corrisponde a un arrivo, mentre il tempo è il numero di prove effettuate (ma nel continuo).\n \n \n \n \n \n \n Una variabile aleatoria che conta il tempo diwidehattesa prima del primo arrivo di un processo di Poisson di intensità {r`\\lambda`} .\n
\n \n Il suo simbolo è {r`Esp(\\lambda)`} .\n
\n \n \n \n L'esponenziale ha come densità:\n
\n \n {r`f_X (x) = \\begin{cases}\n 0 \\qquad \\qquad x < 0\\\\\n \\lambda \\cdot e^{-\\lambda \\cdot x} \\quad x > 0\n \\end{cases}`} \n
\n \n L'esponenziale ha come funzione di ripartizione:\n
\n \n {r`F_X (t) = \\begin{cases}\n 0 \\qquad \\qquad t < 0\\\\\n 1 - e^{-\\lambda \\cdot t} \\quad t \\geq 0\n \\end{cases}`} \n
\n \n \n \n La funzione generatrice dei momenti dell'esponenziale è:\n
\n \n {r`m_X (t) : \\{ t | t < \\lambda \\} \\in \\mathbb{R} = \\frac{\\lambda}{\\lambda - t}`} \n
\n \n La media dell'esponenziale è:\n
\n \n {r`E(X) = \\frac{1}{\\lambda}`} \n
\n \n La varianza dell'esponenziale è:\n
\n \n {r`Var(X) = \\frac{1}{\\lambda^2}`} \n
\n \n \n \n L'esponenziale non tiene conto degli eventi avvenuti in passato: ha la proprietà dell'assenza di memoria:\n
\n \n {r`P([X > s + t | X > s]) = P([X > t])`} \n
\n \n Ovvero, riscalando opportunamente l'asse Y posso prendere come 0 qualsiasi punto dell'asse X.\n \n \n \n \n \n \n Una variabile aleatoria che conta il tempo diwidehattesa prima dell'n -esimo arrivo di un processo di Poisson di intensità {r`\\lambda`} .\n
\n \n Il suo simbolo è {r`\\Gamma(n, \\lambda)`} .\n
\n \n \n \n La legge gamma ha come densità:\n
\n \n {r`f_X (x) = \\begin{cases}\n 0 \\qquad \\qquad \\qquad \\qquad \\qquad x < 0\\\\\n \\frac{1}{(n-1)!} \\cdot \\lambda^n \\cdot x^{n-1} \\cdot e^{-\\lambda \\cdot x} \\quad k > 0\n \\end{cases}`} \n
\n \n \n \n
\n La funzione generatrice dei momenti della legge gamma è:\n
\n \n {r`m_X (t) : ( t < \\lambda ) \\in \\mathbb{R} = \\left( \\frac{\\lambda}{\\lambda - t} \\right) ^\\alpha`} \n
\n \n La media della legge gamma è:\n
\n \n {r`E(X) = \\frac{\\alpha}{\\lambda}`} \n
\n \n La varianza della legge gamma è:\n
\n \n {r`Var(X) = \\frac{\\alpha}{\\lambda^2}`} \n
\n \n \n \n \n \n \n Una variabile aleatoria che può assumere qualsiasi valore in un intervallo {r`[a, b]`} in modo equiprobabile.\n
\n \n Il suo simbolo è {r`Uni(a, b)`} \n
\n \n Su di essa vale la seguente proprietà:\n
\n \n {r`P(X \\in (c, d)) = \\frac{d - c}{b - a}`} \n
\n \n \n \n La distribuzione uniforme ha come densità:\n
\n \n {r`f_X (x) = \\begin{cases}\n \\frac{1}{b - a} \\qquad a \\leq x \\leq b\\\\\n 0 \\qquad \\quad altrimenti \n \\end{cases}`} \n
\n \n La distribuzione uniforme ha come funzione di ripartizione:\n
\n \n {r`f_X (x) = \\begin{cases}\n 0 \\qquad \\quad x < a \n \\frac{1}{b - a} \\qquad a \\leq x \\leq b\\\\\n 1 \\qquad \\quad x > b\n \\end{cases}`} \n
\n \n \n \n
\n La funzione generatrice dei momenti della distribuzione uniforme è:\n
\n \n {r`m_X (t) = \\frac{e^{b \\cdot t} - e^{a \\cdot t}}{(b - a) \\cdot t}`} \n
\n \n La media della distribuzione uniforme è:\n
\n \n {r`E(X) = \\frac{a + b}{2}`} \n
\n \n La varianza della distribuzione uniforme è:\n
\n \n {r`Var(X) = \\frac{(b - a)^2}{12}`} \n
\n \n \n \n \n \n \n Una variabile aleatoria con una specifica distribuzione.\n
\n \n Il suo simbolo è {r`Nor(\\mu, \\sigma^2)`} .\n
\n \n \\mu e \\sigma^2 sono rispettivamente la media e la varianza della distribuzione!\n \n \n \n \n La distribuzione normale ha come densità:\n
\n \n {r`f_X (x) = \\frac{e^{-\\frac{(x - \\mu)^2}{2 \\sigma^2}}}{\\sqrt{2 \\pi \\cdot \\sigma^2}}`} \n
\n \n \n \n
\n La funzione generatrice dei momenti della distribuzione normale è:\n
\n \n {r`m_X (t) = e^{\\mu \\cdot t + \\frac{\\sigma^2 \\cdot t^2}{2}}`} \n
\n \n La media della distribuzione normale è:\n
\n \n {r`E(X) = \\mu`} \n
\n \n La varianza della distribuzione normale è:\n
\n \n {r`Var(X) = \\sigma^2`} \n
\n \n \n \n \n \n \n Qualsiasi normale può essere trasformata in qualsiasi altra normale:\n
\n \n {r`X \\sim Nor(m, v^2) \\implies \\alpha X + \\beta \\sim Nor(\\alpha m + \\beta, (\\alpha v)^2)`} \n
\n \n \n \n La distribuzione normale standard Z è:\n
\n \n Z \\sim Nor(0, 1) \n
\n \n La sua funzione di ripartizione è detta {r`\\phi(z)`} e vale:\n
\n \n {r`F_Z(z) = \\phi(z) = \\frac{1}{\\sqrt{2 \\pi}} \\int_{-\\infty}^{z} e^{-\\frac{x^2}{2}} dx`} \n
\n \n \n \n Da un quantile {r`z_\\alpha`} della normale standard è possibile risalire allo stesso quantile di qualsiasi altra normale:\n
\n \n {r`x_\\alpha = \\mu + z_\\alpha \\cdot \\sqrt{\\sigma^2}`} \n
\n \n \n \n \n \n La distribuzione normale ha una particolare relazione con la distribuzione Gamma:\n
\n \n {r`Z^2 \\sim \\chi^2 (v = 1)`} \n
\n \n \n \n \"chi-quadro a un grado di libertà\"\n
\n \n Esiste una distribuzione Gamma particolare:\n
\n \n {r`\\Gamma \\left( \\frac{1}{2}, \\frac{1}{2} \\right) = \\chi^2 (v = 1)`} \n
\n \n Più chi-quadro possono essere sommate per aumentare i loro gradi di libertà:\n
\n \n {r`\\chi^2 (n) + \\chi^2 (m) = \\chi^2 (n + m)`} \n
\n \n \n \n Un'altra funzione particolare è la funzione T di Student:\n
\n \n {r`T(v) = \\frac{Nor(0, 1)}{\\sqrt{\\frac{\\chi^2(v)}{v}}}`} \n
\n \n \n \n \n \n La binomiale è come una ipergeometrica ma con ripetizioni, quindi per valori molto grandi di N rispetto a n , si può dire che:\n
\n \n {r`Ipe(N, K, n) \\approx Bin(n, \\frac{K}{N})`} \n
\n \n \n \n La binomiale non è altro che una poissoniana a tempo discreto, quindi, se n è grande e n \\cdot p è nell'ordine di grandezza delle unità, allora:\n
\n \n {r`Bin(n, p) \\approx Poi(n \\cdot p)`} \n
\n \n \n \n Per il Teorema di De Moivre-Laplace, se una binomiale ha una n grande e p non vicina a 0 o 1, si può approssimare con:\n
\n \n {r`Bin(n, p) \\approx Nor(n \\cdot p, n \\cdot p \\cdot q)`} \n
\n \n \n \n Passando da una variabile discreta X a una continua Y , per ogni valore discreto k la probabilità viene \"spalmata\" su tutto l'intervallo {r`(k - \\frac{1}{2}, k + \\frac{1}{2})`} :\n
\n \n {r`P(X < k) \\simeq P(Y \\leq k - \\frac{1}{2})`} {r`P(X \\leq k) \\simeq P(Y \\leq k + \\frac{1}{2})`} {r`P(X \\geq k) \\simeq P(Y \\geq k - \\frac{1}{2})`} {r`P(X > k) \\simeq P(Y \\geq k + \\frac{1}{2})`}
\n \n \n \n \n \n Un vettore composto da variabili aleatorie.\n
\n \n Il suo simbolo generalmente è {r`\\boldsymbol{X}`} oppure {r`X, Y`} .\n
\n \n \n \n I vettori aleatori hanno più funzioni di ripartizione che si differenziano in base al numero di parametri.\n
\n \n Se il numero di parametri coincide con la dimensione del vettore aleatorio, allora la funzione sarà una funzione di ripartizione congiunta:\n
\n \n {r`F_{X, Y} (x, y) = P(X \\leq x, Y \\leq y)`} \n
\n \n Se il numero di parametri è minore della dimensione del vettore aleatorio, allora la funzione sarà una funzione di ripartizione marginale:\n
\n \n {r`F_X (x) = P(X \\leq x) = \\lim_{y \\to +\\infty} F_{X, Y} (x, y)`} \n
\n \n \n \n I vettori aleatori discreti hanno più densità che si differenziano in base al numero di parametri.\n
\n \n Se il numero di parametri coincide con la dimensione del vettore aleatorio, allora la funzione sarà una densità congiunta:\n
\n \n {r`p_{X, Y} (x, y) = P(X = x, Y = y)`} \n
\n \n Se il numero di parametri è minore della dimensione del vettore aleatorio, allora la funzione sarà una densità marginale:\n
\n \n {r`p_X (x) = \\sum_j p_{X, Y} (x_i, y_j)`} \n
\n \n \n \n \n \n Più variabili aleatorie sono indipendenti se, per qualsiasi scelta di intervalli A_i :\n
\n \n {r`P(X_1 \\in A_1, \\dots, X_n \\in A_n) = P(X_1 \\in A_1) \\times \\dots \\times P(X_n \\in A_n)`} \n
\n \n \n \n E' possibile calcolare la media di qualsiasi funzione g(X, Y) avente elementi del vettore come variabili:\n
\n \n {r`E(g(X, Y)) = \\sum_{i, j} g(x_i, y_i) \\cdot p_{X, Y} (x_i, y_i)`} \n
\n \n Solitamente si calcola la media di x \\cdot y .\n \n \n Le medie di più variabili aleatorie si possono sommare:\n
\n \n {r`E(X + Y) = E(X) + E(Y)`} \n
\n \n \n \n \n \n Un operatore che misura la correlazione di due variabili aleatorie.\n
\n \n Si calcola con il valore atteso dei prodotti delle distanze dalla media:\n
\n \n {r`Cov(X, Y) = E((X - E(X) \\cdot (Y - E(Y)) = E(XY) - E(X) \\cdot E(Y)`} \n
\n \n Ha diverse proprietà:\n
\n \n - Il suo valore nullo è 0:
{r`Cov(X, \\alpha) = 0`} \n - E' commutativa:
{r`Cov(X, Y) = Cov(Y, X)`} \n - E' semplificabile:
{r`Cov(X, X) = Var(X)`} \n - E' lineare:
{r`Cov(\\alpha X, \\beta Y) = \\alpha \\cdot \\beta \\cdot Cov(X, Y)`} \n - E' distributiva:
{r`Cov(X + Y, V + W) = Cov(X, Y) + Cov(X, W) + Cov(Y, V) + Cov(Y, W)`} \n
\n \n \n \n Due variabili sono variabili incorrelate se:\n
\n \n {r`Cov(X, Y) = 0`} \n
\n \n Variabili indipendenti sono sempre incorrelate.\n
\n \n \n \n Una matrice {r`\\boldsymbol{C_X}`} che contiene la covarianza tra tutte le variabili di un vettore aleatorio {r`\\boldsymbol{X}`} :\n
\n \n {r`\n \\boldsymbol{C_X} = \n \\begin{bmatrix}\n Var(X_1) & Cov(X_1, X_2) & Cov(X_1, X_3)\\\\\n Cov(X_2, X_1) & Var(X_2) & Cov(X_2, X_3)\\\\\n Cov(X_3, X_1) & Cov(X_3, X_2) & Var(X_3)\n \\end{bmatrix}\n `} \n
\n \n E' sempre simmetrica e semidefinita positiva (tutti gli autovalori sono \\geq 0 .\n
\n \n \n \n Un valore che misura come due variabili aleatorie sono correlate:\n
\n \n {r`\\rho_{X, Y} = \\frac{Cov(X, Y)}{\\sqrt{Var(X)} \\cdot \\sqrt{Var(Y)}}`} \n
\n \n E' sempre compreso tra -1 e 1:\n
\n \n {r`-1 \\leq \\rho_{X, Y} \\leq 1`} \n
\n \n Vale esattamente -1 o 1 solo se esiste un legame lineare tra le due variaibli:\n
\n \n {r`Y = a X + b \\Longleftrightarrow | \\rho_{X, Y} | = 1`} \n
\n \n \n \n La varianza di due variabili aleatorie sommate è:\n
\n \n {r`Var(X + Y) = Var(X) + Var(Y) + 2 \\cdot Cov(X, Y)`} \n
\n \n Si dimostra applicando le proprietà della covarianza!\n \n \n Se più variabili aleatorie X_i sono indipendenti ({r`Cov(X, Y) = 0`} ), allora:\n
\n \n {r`Var \\left( \\sum_i X_i \\right) = \\sum_i Var(X_i)`} \n
\n \n \n \n \n \n Una n-pla di variabili aleatorie con la stessa distribuzione della variabile aleatoria X (\"popolazione\") ma indipendenti tra loro.\n
\n \n Le variabili aleatorie sono come un lazy-load in programmazione; quando ci sarà bisogno del loro valore numerico, esse si realizzeranno nel loro valore.\n \n \n \n \n Il valore dato dalla media aritmetica degli n elementi del campione elevati alla potenza k :\n
\n \n {r`M^{(k)}_n = \\frac{1}{n} \\cdot \\sum_{i = 1}^n X_i^k `} \n
\n \n Il momento campionario di primo ordine è la media campionaria {r`\\overline{X}_n`} .\n
\n \n \n \n La media aritmetica dello scarto quadratico medio degli elementi del campione.\n
\n \n Se è noto il valore medio {r`m = E(X)`} di X:\n
\n \n {r`S_0^2 = \\frac{1}{n} \\cdot \\sum_{i = 1}^n (X_i - m)^2 = M_n^(2) - 2 \\cdot m \\cdot \\overline{X}_n + m^2`} \n
\n \n Altrimenti:\n
\n \n {r`S_n^2 = \\frac{1}{n - 1} \\cdot \\sum_{i = 1}^n (X_i - \\overline{X}_n)^2 = \\frac{1}{n - 1} \\cdot ( n \\cdot M_2^{(2)} - n \\cdot \\overline{X}_n^2)`} \n
\n \n \n \n \n \n Se calcoliamo la media della media campionaria, risulterà vero che:\n
\n \n {r`E(\\overline{X}_n) = E(X)`} \n
\n \n Quindi, è possibile usare i campioni per trovare la media di una variabile aleatoria!\n \n \n \n \n Se calcoliamo la varianza della media campionaria, risulterà vero che:\n
\n \n {r`Var(\\overline{X}_n) = \\frac{Var(X)}{n}`} \n
\n \n Quindi, possiamo stimare l'errore della media calcolata tramite campioni!\n \n \n \n \n Se calcoliamo la media della varianza campionaria, risulterà vero che:\n
\n \n {r`E(S_0^2) = E(S_n^2) = Var(X)`} \n
\n \n Quindi, possiamo stimare l'errore della media calcolata tramite campioni!\n \n \n \n \n \n \n Se la popolazione X ha una distribuzione normale ({r`X \\sim Nor(\\mu, \\sigma^2)`} )...\n
\n \n \n \n ...allora sappiamo anche la distribuzione della media campionaria!\n
\n \n {r`\\overline{X}_n \\sim Nor \\left( \\mu, \\frac{\\sigma^2}{n} \\right)`} \n
\n \n \n \n ...e anche della varianza campionaria!\n
\n \n {r`S_0^2 \\sim \\frac{\\sigma^2}{n} \\cdot \\chi^2 (n)`} \n
\n \n {r`S_n^2 \\sim \\frac{\\sigma^2}{n - 1} \\cdot \\chi^2 (n-1)`} \n
\n \n \n \n ...e che media campionaria e varianza campionaria sono indipendenti tra loro!\n
\n \n \n \n \n \n Se la successione di variabili aleatorie X_n all'infinito ha la stessa funzione di ripartizione della popolazione X , allora essa converge in distribuzione.\n
\n \n {`\\\\lim_{n \\\\to +\\\\infty} F_{X_n} (x) = F_X (x) \\\\implies X_n \\\\xrightarrow{d} X`} \n
\n \n \n \n Se la successione di variabili aleatorie X_n all'infinito ha la stessa probabilità della popolazione X , allora essa converge in probabilità.\n
\n \n {`\\\\forall \\\\epsilon > 0, \\\\lim_{n \\\\to +\\\\infty} P( | X_n - X | < \\\\epsilon) = 1 \\\\implies X_n \\\\xrightarrow{p} X`} \n
\n \n \n \n Se la successione di variabili aleatorie X_n all'infinito ha la stessa probabilità a della popolazione X , allora essa converge quasi certamente.\n
\n \n {`\\\\forall \\\\epsilon > 0, P \\left( \\\\lim_{n \\\\to +\\\\infty} | X_n - X | < \\\\epsilon) \\right) = 1 \\\\implies X_n \\\\xrightarrow{qc} X`} \n
\n \n \n \n Se la successione di variabili aleatorie X_n all'infinito ha la media del quadrato della distanza tra la successione e la popolazione X uguale a 0, allora essa converge in media quadratica.\n
\n \n {`\\\\lim_{n \\\\to +\\\\infty} E( | X_n - X |^2 = 0 \\\\implies X_n \\\\xrightarrow{mq} X`} \n
\n \n \n \n {`\n \\\\begin{matrix}\n X_n \\\\xrightarrow{mq} X\\\\\\\\\n X_n \\\\xrightarrow{qc} X\n \\\\end{matrix} \\\\implies X_n \\\\xrightarrow{p} X \\\\implies X_n \\\\xrightarrow{d} X`\n } \n
\n \n In più:\n
\n \n {`X_n \\\\xrightarrow{p} x \\\\Longleftrightarrow X_n \\\\xrightarrow{d} x`} \n
\n \n \n \n \n \n La successione delle medie campionarie {r`\\overline{X}_n`} converge in probabilità alla media della popolazione {r`E(X)`} , se essa esiste.\n
\n \n {`\\\\overline{X}_n \\\\xrightarrow{p} X`} \n
\n \n Ovvero:\n
\n \n {r`\\forall \\epsilon > 0, \\lim_{n \\to +\\infty} P( | \\overline{X}_n - E(X) | < \\epsilon) = 1`} \n
\n \n {r`P( | \\overline{X}_n - E(X) | < \\epsilon) \\to 1`} \n
\n \n \n \n La successione delle medie campionarie {r`\\overline{X}_n`} converge quasi certamente alla media della popolazione {r`E(X)`} , se essa esiste.\n
\n \n {`\\\\overline{X}_n \\\\xrightarrow{qc} X`} \n
\n \n Ovvero:\n
\n \n {r`\\forall \\epsilon > 0, P \\left( \\lim_{n \\to +\\infty} | \\overline{X}_n - E(X) | < \\epsilon \\right) = 1`} \n
\n \n Dimostra che l'interpretazione frequentista della probabilità è valida!\n \n \n \n \n \n \n La successione delle medie campionarie {r`\\overline{X}_n`} converge in distribuzione a {r`Nor(0, 1) = \\Phi()`} .\n
\n \n {r`\\overline{X}_n \\approx Nor \\left(E(X), \\frac{Var(X)}{n} \\right)`} \n
\n \n Ovvero:\n
\n \n {r`\\forall x \\in \\mathbb{R}, \\lim_{n \\to +\\infty} P \\left( \\frac{\\overline{X}_n - E(X)}{\\sqrt{\\frac{Var(X)}{n}}} \\leq x \\right) = \\Phi(x)`} \n
\n \n \n \n \n \n E' una somma di bernoulliane, e quindi si approssima a una normale:\n
\n \n {r`Bin(n, p) \\approx Nor(n \\cdot p, n \\cdot p \\cdot q)`} \n
\n \n \n \n E' una somma di geometriche, e quindi si approssima a una normale:\n
\n \n {r`\\overline{Bin} (n, p) \\approx Nor \\left( \\frac{n}{p}, \\frac{n \\cdot (1 - p)}{p^2} \\right)`} \n
\n \n \n \n E' una somma di altre poissoniane, e quindi si approssima a una normale:\n
\n \n {r`Poi(\\lambda) \\approx Nor(\\lambda, \\lambda)`} \n
\n \n \n \n E' una somma di esponenziali, e quindi si approssima a una normale:\n
\n \n {r`\\Gamma (\\alpha, \\lambda) \\approx Nor \\left( \\frac{\\alpha}{\\lambda}, \\frac{\\alpha}{\\lambda^2} \\right)`} \n
\n \n \n \n Se n è grande, allora:\n
\n \n {r`Y = \\sum_{i=1}^{n} X_i`} \n
\n \n \n \n \n \n Per indicare parametri sconosciuti di una legge si usa \\theta .\n
\n \n \n \n Una variabile aleatoria funzione di un campione:\n
\n \n {r`T(\\boldsymbol{X})`} \n
\n \n Ad esempio, sono statistiche media e varianza campionaria, così come il campione stesso {r`T(\\boldsymbol{X}) = \\boldsymbol{X}`} .\n \n \n \n \n \n \n Una statistica T_n ottenuta da n osservazioni, che stimi i parametri di una legge e sia indipendente da essi.\n
\n \n \n \n Uno stimatore è corretto se il suo valore atteso coincide con quello dei parametri che stima:\n
\n \n {r`E(T_n) = \\theta`} \n
\n \n \n \n Uno stimatore è asintoticamente corretto se, per infinite osservazioni, il suo valore atteso coincide con quello dei parametri che stima:\n
\n \n {r`\\lim_{n \\to +\\infty} E(T_n) = \\theta`} \n
\n \n \n \n Uno stimatore è consistente in media quadratica se:\n
\n \n {r`\\lim_{n \\to +\\infty} E((T_n - \\theta)^2) = 0`} \n
\n \n \n \n Uno stimatore è consistente in probabilità se:\n
\n \n {r`\\forall \\epsilon > 0, \\lim_{n \\to +\\infty} P( |T_n - \\theta| < \\epsilon) = 1`} \n
\n \n \n \n Uno stimatore è asintoticamente normale se:\n
\n \n {r`\\lim_{n \\to +\\infty} \\frac{T_n - E(T_n)}{\\sqrt{Var(T_n)}} \\sim Nor(0, 1)`} \n
\n \n \n \n \n \n Si può usare il metodo dei momenti per ottenere uno stimatore di una popolazione X .\n
\n \n Lo stimatore di {r`\\theta`} così ottenuto sarà indicato aggiungendo un cappellino e una M a \\theta : {r`\\widehat{\\theta}_M`} \n
\n \n Visto che:\n
\n \n {r`\\theta = g(E(X))`} {r`\\widehat{E(X)} = \\overline{X}_n`}
\n \n Allora:\n
\n \n {r`\\widehat{\\theta}_M = g( \\overline{X}_n )`} \n
\n \n Se {r`\\theta`} non è esprimibile in termini di {r`E(X)`} , si possono usare i momenti successivi {r`M_n^2`} , {r`M_n^3`} , {r`M_n^3`} ...\n
\n \n \n \n \n \n Si può usare il metodo della massima verosomiglianza per ottenere uno stimatore di una popolazione X .\n
\n \n Lo stimatore di {r`\\theta`} così ottenuto sarà indicato aggiungendo un cappellino e una L a \\theta : {r`\\widehat{\\theta}_L`} \n
\n \n Consiste nel trovare il massimo assoluto {r`\\widehat{\\theta}_L`} della la funzione di verosomiglianza {r`L`} :\n
\n \n {r`L(x_1, ..., x_n; \\theta) = \\prod_{i=1}^n f_X(x_i; \\theta)`} \n
\n \n Gli stimatori di massima verosomiglianza sono asintoticamente corretti, consistenti in probabilità e asintoticamente normali.\n
\n \n \n \n Gli stimatori di massima verosomiglianza godono delle seguenti proprietà:\n
\n \n - Sono asintoticamente corretti.
\n - Sono consistenti in probabilità.
\n - Sono asintoticamente normali.
\n - Sono invarianti:
{r`\\widehat{g(\\theta)}_L = g(\\widehat{\\theta}_L)`} \n
\n \n \n \n \n \n Per il metodo dei momenti oppure per il metodo della massima verosomiglianza:\n
\n \n {r`\\widehat{p}_M = \\widehat{p}_L = \\overline{X}_n`} \n
\n \n \n \n Per il metodo dei momenti oppure per il metodo della massima verosomiglianza:\n
\n \n {r`\\widehat{\\mu}_M = \\widehat{\\mu}_L = \\overline{X}_n`} \n
\n \n \n \n Per il metodo dei momenti oppure per il metodo della massima verosomiglianza:\n
\n \n {r`\\widehat{\\lambda}_M = \\widehat{\\lambda}_L = \\frac{1}{\\overline{X}_n}`} \n
\n \n \n \n Per il metodo della massima verosomiglianza:\n
\n \n {r`\\widehat{\\mu}_L = \\overline{X}_n`}
\n {r`\\widehat{\\sigma^2}_L = \\frac{\\sum (X_i - \\overline{X}_n)^2 }{n}`}
\n \n \n \n \n \n \"intervallo di confidenza al 95%\"\n
\n \n L'intervallo di valori di \\theta all'interno del quale siamo \"più o meno sicuri\" si trovi il valore effettivo:\n
\n \n L'intervallo di confidenza a N della stima {r`\\widehat{W}`} è l'intervallo ]a, b[ tale che:\n
\n \n {r`P( a < W < b ) = N`} \n
\n \n Può anche essere unilatero nel caso limiti la stima in una sola direzione, positiva o negativa.\n
\n \n \n \n \n \n Se conosciamo la varianza di una normale, allora possiamo ricavare velocemente gli intervalli di confidenza all'\\alpha % con queste formule:\n
\n \n - Intervalli bilateri:
{r`\\mu \\in \\left[ \\overline{x}_n - z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\sigma^2}{n}}, \\overline{x}_n + z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\sigma^2}{n}} \\right]`} \n - Intervallo unilatero da sinistra:
{r`\\mu \\in \\left( -\\infty, \\overline{x}_n + z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\sigma^2}{n}} \\right]`} \n - Intervallo unilatero da destra:
{r`\\mu \\in \\left[ \\overline{x}_n - z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\sigma^2}{n}}, +\\infty \\right)`} \n
\n \n \n \n Se non conosciamo la varianza di una normale, allora possiamo ricavare velocemente gli intervalli di confidenza all'\\alpha % con queste formule:\n
\n \n - Intervalli bilateri:
{r`\\mu \\in \\left[ \\overline{x}_n - t_{1 - \\frac{\\alpha}{2}; n-1} \\cdot \\sqrt{\\frac{s_n^2}{n}}, \\overline{x}_n + t_{1 - \\frac{\\alpha}{2}; n-1} \\cdot \\sqrt{\\frac{s_n^2}{n}} \\right]`} \n - Intervallo unilatero da sinistra:
{r`\\mu \\in \\left( -\\infty, \\overline{x}_n + t_{1 - \\frac{\\alpha}{2}; n-1} \\cdot \\sqrt{\\frac{s_n^2}{n}} \\right]`} \n - Intervallo unilatero da destra:
{r`\\mu \\in \\left[ \\overline{x}_n - t_{1 - \\frac{\\alpha}{2}; n-1} \\cdot \\sqrt{\\frac{s_n^2}{n}}, +\\infty \\right)`} \n
\n \n {r`t_{\\alpha, v}`} è un quantile della distribuzione di Student di parametro v .\n
\n \n \n \n \n \n L'intervallo di confidenza per la proprorzione di una bernoulliana qualsiasi si ottiene da questa formula:\n
\n \n {r`p \\in \\left[ \\overline{p} - z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\overline{p} \\cdot (1 - \\overline{p})}{n+4}}, \\overline{p} + z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{\\overline{p} \\cdot (1 - \\overline{p})}{n+4}} \\right]`} \n
\n \n \n \n \n \n L'intervallo di confidenza per la media di una qualsiasi popolazione si ottiene da questa formula:\n
\n \n {r`m \\in \\left[ \\overline{x}_n - z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{s^2_n}{n}}, \\overline{x}_n + z_{1 - \\frac{\\alpha}{2}} \\cdot \\sqrt{\\frac{s^2_n}{n}} \\right]`} \n
\n \n \n \n )\n\t}\n}\n\n\n// WEBPACK FOOTER //\n// ./pages/statistica.js","import './index.css';\nimport './manifest.json';\nimport { Component } from 'preact';\nimport Router from 'preact-router';\nimport Home from './pages/home';\nimport Fisica from './pages/fisica';\nimport VlDiGeometria from './pages/vldigeometria';\nimport MingwInstall from './pages/mingwinstall';\nimport Copyright from './components/copyright';\nimport Statistica from './pages/statistica';\n\n// noinspection JSUnusedGlobalSymbols\nexport default class App extends Component {\n\trender() {\n\t\treturn (\n\t\t\t\n\t\t\t\tAppuntiweb di Steffo
\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t \n\t\t\t\t