Datasets:

Infi-MM
/

InfiMM-WebMath-40B

Dataset card Data Studio Files Files and versions Community

Split (1)

train · ~22.8M rows (showing the first 514k)

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

URL stringlengths 15 1.68k	text_list listlengths 1 199	image_list listlengths 1 199	metadata stringlengths 1.19k 3.08k
https://www.dynamictutorialsandservices.org/2019/05/gauhati-university-question-papers_1.html	[ "## Monday, May 20, 2019", null, "2015\nFINANCIAL MANAGEMENT\nFull Marks: 80\nTime: 3 hours\n(The figures in the margin indicate full marks for the questions)\n1. Answer the following as directed: 1x10=10\na) In respect of raising finance from new issue market, companies are prohibited from issuing shares at a discount except in the case of issue of sweat equity shares. (State true or false)\nb) Key financial functions of a firm include the following except:\n1) Investment decision.\n3) Dividend decision.\n4) Financial decision.\nc) Use of debt capital to gain is known as:\n1) Financial leverage.\n2) Operating leverage.\n3) Financial operating leverage.\n4) Position and operating ratio.\nd) When fluctuations in sales are accompanied by disproportionate fluctuations in operating profit, it result, in:\n1) Operating leverage.\n2) Financial operating leverage.\n3) Fixed capital turnover.\n4) Capital operating turnover.\ne) In a capital budgeting decision, where a number of alternatives are competing for selection in terms of profitability, opportunity to accept and whether it is more desirable than an alternative opportunity, it is necessary:\n1) To make decision whether to accept or reject a given investment proposal.\n2) To rank them in order of profitability.\n3) To rank them in order of sensitive index.\n4) Both (1) and (3).\nf) Which is the correct description of the situation of a firm after conversion of debentures into equity?\n1) Increase in debt equity ratio and increase in the risk factor.\n2) Increase in debt equity ratio and decrease in the risk factor.\n3) Decrease debt equity ratio and increase in the risk factor.\n4) Decrease in debt equity ratio and decrease in the risk factor.\ng) The capital employed as working capital constantly, changes its form to drive the ‘business wheel’, it is known as the:\n1) Gross working capital.\n2) Circulating capital.\n3) Operating working capital.\n4) Fluctuating working capital.\nh) Current assets are twice the current liabilities. If the working capital is Rs. 20,000, current assets would be:\n1) Rs. 10,000.\n2) Rs. 40,000.\n3) Rs. 80,000.\n4) Rs. 20,000.\ni) Tandon Committee and Chore Committee recommendations related to\n1) Bank finance for working capital requirements.\n2) Guidelines from ministry of corporate affairs on working capital finance.\n3) SEBI guidelines for long term capital finance.\n4) RBI direction on SLR and CRR.\nj) The Profitability Index (PI) or Benefit Cost Ratio is the relation between the present value of future net cash flows and the initial cash outlay. (State true or false)\na) State the meaning of net working capital.\nb) State the sources of finance.\nc) State the meaning of financial leverage.\nd) State the meaning of pay-back period.\ne) State the use of credit policy in determining working capital level.\n3. Answer the following within 150-200 words each: 5x4=20\n(a) Define net present value. How is it computed in a capital budgeting decision?\nOr\nDiscuss the use of Internal Rate of Return (IRR).\n(b) Discuss the procedure for calculation of cost preference share capital.\nOr\nExamine the difference between financial leverage and operating leverage.\n(c) State the use of EBIT-EPS analysis in financial decisions.\nOr\nWhat is a wealth or value maximization objective or goal of an entity?\n(d) What is cost of capital? How is it ascertained?\n(a) Elaborate the determinants of capital structure of a corporate entity and the benefits of a balanced capital structure.\nOr\nWhat is over-capitalization? Discuss the consequences of over capitalization.\n(b) Explain the residual theory of dividend.\nOr\nExplain the measurement and interpretation of operating leverage with examples.\n(c) From the following details, estimate the working capital requirement of Sarbogh Manufacturing Company which is working at 60% capacity: 10\nProduction at 100% capacity: 24,000 unit p.a.\nSelling price: Rs. 100 per unit\nRaw material: Rs. 30 per unit\nLabour: Rs. 20 per unit.\nOverheads Rs. 14,000 per month including Rs. 2,000 as depreciation per month.\nProcessing time: One month\nInventory holding: One month\nRaw material: One month\nFinished goods: Two months\n\n-000-" ]	[ null, "https://3.bp.blogspot.com/-mqdbvGZUL9o/XOKuoBE1fvI/AAAAAAAAELw/7wxM8lUMEGEY6SsFsw2YXDGnz_MrrX4XQCLcBGAs/s1600/pco.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8455937,"math_prob":0.9097752,"size":4290,"snap":"2020-34-2020-40","text_gpt3_token_len":978,"char_repetition_ratio":0.13485767,"word_repetition_ratio":0.047895502,"special_character_ratio":0.23636363,"punctuation_ratio":0.136419,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9630543,"pos_list":[0,1,2],"im_url_duplicate_count":[null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-10-01T23:22:09Z\",\"WARC-Record-ID\":\"<urn:uuid:ebf688fb-e4b5-4f74-86cd-bcb369b9cd8b>\",\"Content-Length\":\"219015\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:e09bd545-1a53-4e90-9d00-2183adf728b6>\",\"WARC-Concurrent-To\":\"<urn:uuid:8e08f2aa-9862-4ff5-9334-8dd6d3123218>\",\"WARC-IP-Address\":\"172.217.2.115\",\"WARC-Target-URI\":\"https://www.dynamictutorialsandservices.org/2019/05/gauhati-university-question-papers_1.html\",\"WARC-Payload-Digest\":\"sha1:X4YPHWJGWVO6X7QAJXZ62ZNJZLZ2RIHC\",\"WARC-Block-Digest\":\"sha1:3Z6BFP5RIGLHM3UUW22UJXNRH5J7LDSW\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-40/CC-MAIN-2020-40_segments_1600402132335.99_warc_CC-MAIN-20201001210429-20201002000429-00722.warc.gz\"}"}
https://www.codecademy.com/courses/learn-data-structures-and-algorithms-with-python/lessons/recursion-python/exercises/recursion-python-big-o	[ "Learn\n\nExcellent job writing your first recursive function. Our next task may seem familiar so there won’t be as much guidance.\n\nWe’d like a function `factorial` that, given a positive integer as input, returns the product of every integer from 1 up to the input. If the input is less than 2, return 1.\n\nFor example:\n\n``````factorial(4)\n# 4 * 3 * 2 * 1\n# 24``````\n\nSince this function is similar to the previous problem, we’ll add an additional wrinkle. You’ll need to evaluate the big O runtime of the function.\n\nNote that if this is the first time you’re seeing Big O notation, this might be a bit confusing. You can learn much more about this topic in the Asymptotic Notation section of the Computer Science path. That being said, it is also fine to just continue working through this course and learn more about Big O later!\n\nWith an iterative function, we would consider how the number of iterations grows in relation to the size of the input.\n\nFor example you may ask yourself, are we looping once more for each new element in the list?\n\nThat’s linear or `O(N)`.\n\nAre we looping an additional number of elements in the list for each new element in the list?\n\nThat’s quadratic or `O(N^2)`.\n\nWith recursive functions, the thought process is similar but we’re replacing loop iterations with recursive function calls.\n\nIn other words, are we recursing once more for each new element in the list?\n\nThat’s linear or `O(N)`.\n\nLet’s analyze our previous function, `sum_to_one()`.\n\n``````sum_to_one(4)\n# recursive call to sum_to_one(3)\n# recursive call to sum_to_one(2)\n# recursive call to sum_to_one(1)\n\n# Let's increase the input...\n\nsum_to_one(5)\n# recursive call to sum_to_one(4)\n# recursive call to sum_to_one(3)\n# recursive call to sum_to_one(2)\n# recursive call to sum_to_one(1)``````\n\nWhat do you think? We added one to the input, how many more recursive calls were necessary?\n\nTalk through a few more inputs and then start coding when you’re ready to move on.\n\n### Instructions\n\n1.\n\nDefine the `factorial` function with one parameter: `n`.\n\nSet up a base case.\n\nThink about the input(s) that wouldn’t need a recursive call for your function.\n\nReturn the appropriate value.\n\n2.\n\nNow let’s consider the recursive step for `factorial()`.\n\nIf we’re in the recursive step that means `factorial()` has been invoked with an integer of at least 2.\n\nWe need to return the current input value multiplied by the return value of the recursive call.\n\nStructure the recursive call so it invokes `factorial()` with an argument one less than the current input.\n\n3.\n\nNice work, test out your function by printing the result of calling `factorial()` with 12 as an input.\n\nNow, change the input to a really large number, think big, and run the code.\n\nIf you chose an input large enough, you should see a `RecursionError`." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8364673,"math_prob":0.94335157,"size":2713,"snap":"2021-31-2021-39","text_gpt3_token_len":625,"char_repetition_ratio":0.17054264,"word_repetition_ratio":0.10191083,"special_character_ratio":0.23516403,"punctuation_ratio":0.10037175,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9939511,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-09-16T21:28:59Z\",\"WARC-Record-ID\":\"<urn:uuid:8d3dcaef-85db-40b3-9d65-ba3428d3f876>\",\"Content-Length\":\"126770\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:da4caac7-085f-4c77-847d-637d7fe7c121>\",\"WARC-Concurrent-To\":\"<urn:uuid:1bd963f1-41f4-4f32-951d-f358adc83084>\",\"WARC-IP-Address\":\"104.18.199.63\",\"WARC-Target-URI\":\"https://www.codecademy.com/courses/learn-data-structures-and-algorithms-with-python/lessons/recursion-python/exercises/recursion-python-big-o\",\"WARC-Payload-Digest\":\"sha1:TMJFR4IAK2ZWGMLUQQMYMFCGLFFZJEFP\",\"WARC-Block-Digest\":\"sha1:NWGDJHVW22RLIAXFRVMW3VLACJQ5M4VF\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-39/CC-MAIN-2021-39_segments_1631780053759.24_warc_CC-MAIN-20210916204111-20210916234111-00220.warc.gz\"}"}
https://ipv6.snipplr.com/view/90681/a-pathfinding-example	[ "# Posted By\n\nnulldev on 02/18/15\n\n# Statistics\n\nViewed 245 times\nFavorited by 0 user(s)\n\n# A* Pathfinding Example\n\n/ Published in: Java", null, "", null, "An A* pathfinding algorithm in Java, taken from: http://software-talk.org/blog/2012/01/a-star-java/\n\nCopy this code and paste it in your HTML\n`/** * The main A Star Algorithm in Java. * * finds an allowed path from start to goal coordinates on this map. * <p> * This method uses the A Star algorithm. The hCosts value is calculated in * the given Node implementation. * <p> * This method will return a LinkedList containing the start node at the * beginning followed by the calculated shortest allowed path ending * with the end node. * <p> * If no allowed path exists, an empty list will be returned. * <p> * <p> * x/y must be bigger or equal to 0 and smaller or equal to width/hight. * * @param oldX x where the path starts * @param oldY y where the path starts * @param newX x where the path ends * @param newY y where the path ends * @return the path as calculated by the A Star algorithm */ public final List<T> findPath(int oldX, int oldY, int newX, int newY) { openList = new LinkedList<T>(); closedList = new LinkedList<T>(); openList.add(nodes[oldX][oldY]); // add starting node to open list done = false; T current; while (!done) { current = lowestFInOpen(); // get node with lowest fCosts from openList closedList.add(current); // add current node to closed list openList.remove(current); // delete current node from open list if ((current.getxPosition() == newX) && (current.getyPosition() == newY)) { // found goal return calcPath(nodes[oldX][oldY], current); } // for all adjacent nodes: List<T> adjacentNodes = getAdjacent(current); for (int i = 0; i < adjacentNodes.size(); i++) { T currentAdj = adjacentNodes.get(i); if (!openList.contains(currentAdj)) { // node is not in openList currentAdj.setPrevious(current); // set current node as previous for this node currentAdj.sethCosts(nodes[newX][newY]); // set h costs of this node (estimated costs to goal) currentAdj.setgCosts(current); // set g costs of this node (costs from start to this node) openList.add(currentAdj); // add node to openList } else { // node is in openList if (currentAdj.getgCosts() > currentAdj.calculategCosts(current)) { // costs from current node are cheaper than previous costs currentAdj.setPrevious(current); // set current node as previous for this node currentAdj.setgCosts(current); // set g costs of this node (costs from start to this node) } } } if (openList.isEmpty()) { // no path exists return new LinkedList<T>(); // return empty list } } return null; // unreachable }`", null, "Subscribe to comments" ]	[ null, "https://ipv6.snipplr.com/img/icon_sav.png", null, "https://ipv6.snipplr.com/img/loader.gif", null, "https://ipv6.snipplr.com/images/rss.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.6487825,"math_prob":0.7539979,"size":2772,"snap":"2020-34-2020-40","text_gpt3_token_len":740,"char_repetition_ratio":0.15498555,"word_repetition_ratio":0.12997903,"special_character_ratio":0.30555555,"punctuation_ratio":0.13163482,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.991543,"pos_list":[0,1,2,3,4,5,6],"im_url_duplicate_count":[null,null,null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-09-29T18:08:03Z\",\"WARC-Record-ID\":\"<urn:uuid:18d566b7-c740-493b-b46c-ab47a6b5f711>\",\"Content-Length\":\"35220\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:86e75fb0-869f-430b-8452-1701cee33712>\",\"WARC-Concurrent-To\":\"<urn:uuid:b33151b9-e19a-4db0-9b5a-2c86efdd3699>\",\"WARC-IP-Address\":\"104.25.39.44\",\"WARC-Target-URI\":\"https://ipv6.snipplr.com/view/90681/a-pathfinding-example\",\"WARC-Payload-Digest\":\"sha1:DBGE5Q5HU34UESKXKYJFEWP2CGC7WZJP\",\"WARC-Block-Digest\":\"sha1:LUWHJ2EPC3A6AOXNXHEHQNM6SX5MDRRE\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-40/CC-MAIN-2020-40_segments_1600400202418.22_warc_CC-MAIN-20200929154729-20200929184729-00275.warc.gz\"}"}
https://studylib.net/doc/13211059/a-find-the-3rd-degree-taylor-polynomial-t--x--that-approx...	[ "# a)Find the 3rd degree Taylor polynomial T (x) that approximates the", null, "```a)Find the 3rd degree Taylor polynomial T3 (x) that approximates the\nfunction f (x) = x−2 about the point a = 1.\nb) Us the Taylor inequality to estimate the accuracy of the approximation\nf (x) ∼ T3 (x) when .8 ≤ x ≤ 1.1.\nc) Write the Taylor Sereis expansion of f (x) = x−2 at a = 1. Write the result\nusing summation notation.\nd) For what values does the series found in part c) converge?\n1)\na) Solve for y in terms of x: ln(y 2 − 1) − ln(y − 1) = ln(sin x)).\nb) Evaluate the expression cos(arcsin( √x22 +4 )).\nc) For what values of x does the expression in b) make sense?\n2)\na) Simplify i27 .\n√\n√\nb) Write the complex number 8 2 − 8 2i in polar form.\nc) express e3+iπ/6 in the form a + bi.\nd) Compute the three cube roots of −1.\n3)\n4)\nCalculate the following integrals. Show your work.\nZ\nZ\nZ\nZ\nxe3x dx\n1\ndx\n(1 − x2 )3/2\n1\ndx\nx2 − 1\nZ 1/2\n0\nZ\nln(2x)dx\n√\n1\ndx\n1 − x2\nsin3 (2x) cos2 (2x)dx\n√\nZ\nx+4\ndx\nx2 + 5x − 6\nZ 1\n4\ne x\n√ dx\nx\na) Find the formula for the n-th term of the sequence −2/5, 4/25,\n−8/125, 16/625,...\ncos(nπ)\nb) Compute n→∞\nlim\nif the limit exists.\n2n + 1\n3 ln n\nc) Compute n→∞\nlim\nif the limit exists.\nln(n2 )\n5)\n1\nDetermine whether the series is absolutely convergent, conditionally convergent or divergent. If it is a gemoetric series find the limit. Justify your\n2n\n∞\n∞ n2 + 5n + 1\nX\nX\nn2\n(−1) n\n5\n5 − 2n2\nn=1\nn=1\n∞ 2n + 1\n∞\nX\nX\neπ π −n en\nn\n3\nn=1\nn=1\n6)\n(−1)n−1\n√\nn+1\nn=1\n3n3 + 2n2 + 3n4\n5\n2\nn=1 3n + 3n − 3n\n∞\nX\n∞\nX\na) Sketch the curve of the parametric equation x = t2 − 2t, y = t + 1,\n−1 ≤ t ≤ 3 and indicate with arrows the direction.\nb) Find points on the curve where the tangent is horizontal or vertical.\nc) Find the tangent to the curve at point (0, 3).\nd) Calculate the length of the curve.\n7)\nSketch the region that lies inside the curve r = 1 − cos θ and outside the\ncurve r = 3/2. Find the area.\n8)\n9)\nt).\nIf\ndy\n= 2yt and y(0) = 50, find y as a function of t (assume y > 0 for all\ndt\nLet f (x) = 2x + 12 cos(2x) for 0 ≤ x ≤ 4π.\na) Determine whether f is invertible.\nb) Give domain and range for f and f −1 .\ndf −1\nc) Calculate\n(x) 1 . (Note that f (π) =\nx= 2 +2π\ndx\n10)\n11)\nCalculate ii .\n2\n1\n2\n+ 2π.)\n```" ]	[ null, "https://s2.studylib.net/store/data/013211059_1-0ce8ff2a0aeb1c4dd7ec581ab001ac77-768x994.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.64041895,"math_prob":0.9997377,"size":2137,"snap":"2022-27-2022-33","text_gpt3_token_len":842,"char_repetition_ratio":0.108298175,"word_repetition_ratio":0.012048192,"special_character_ratio":0.413664,"punctuation_ratio":0.09021113,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9998497,"pos_list":[0,1,2],"im_url_duplicate_count":[null,2,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-08-12T05:13:04Z\",\"WARC-Record-ID\":\"<urn:uuid:cfe3e4be-95e1-4883-9e3a-c2d14ce34a12>\",\"Content-Length\":\"41773\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:284235a8-83f0-420c-b0ba-fe71d0ffc519>\",\"WARC-Concurrent-To\":\"<urn:uuid:3707b751-33c0-4b56-a96f-73fe6af24331>\",\"WARC-IP-Address\":\"104.21.72.58\",\"WARC-Target-URI\":\"https://studylib.net/doc/13211059/a-find-the-3rd-degree-taylor-polynomial-t--x--that-approx...\",\"WARC-Payload-Digest\":\"sha1:HG7JYBCIZ6IIJSHJNDKT4DENNRXGWPGL\",\"WARC-Block-Digest\":\"sha1:TDK6HE7RNFMQKVLY36SOGUTSOZVXNV2O\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-33/CC-MAIN-2022-33_segments_1659882571584.72_warc_CC-MAIN-20220812045352-20220812075352-00214.warc.gz\"}"}
https://codegolf.stackexchange.com/questions/74789/vandermonde-determinant	[ "# Vandermonde Determinant\n\nGiven a vector of $$\\n\\$$ values $$\\(x_1,x_2,x_3,\\ldots,x_n)\\$$ return the determinant of the corresponding Vandermonde matrix\n\n$$\\V(x_1, x_2, \\ldots, x_n) = \\begin{bmatrix}1 & x_1 & x_1^2 & x_1^3 & \\ldots &x_1^{n-1} \\\\1 & x_2 & x_2^2 & x_2^3 & \\ldots &x_2^{n-1} \\\\ \\vdots & & & \\vdots & & \\vdots \\\\ 1 & x_n & x_n^2 & x_n^3 & \\ldots & x_n^{n-1}\\end{bmatrix}\\$$.\n\nThis determinant can be written as:\n\n$$\\\\det V(x_1, x_2, \\ldots x_n) = \\prod_\\limits{1 \\leqslant i < j \\leqslant n} (x_j - x_i)\\$$\n\n### Details\n\nYour program/function has to accept a list of floating point numbers in any convenient format that allows for a variable length, and output the specified determinant.\n\nYou can assume that the input as well as the output is within the range of the values your language supports. If you language does not support floating point numbers, you may assume integers.\n\n### Some test cases\n\nNote that whenever there are two equal entries, the determinant will be 0 as there are two equal rows in the corresponding Vandermonde matrix. Thanks to @randomra for pointing out this missing testcase.\n\n[1,2,2,3] 0\n[-13513] 1\n[1,2] 1\n[2,1] -1\n[1,2,3] 2\n[3,2,1] -2\n[1,2,3,4] 12\n[1,2,3,4,5] 288\n[1,2,4] 6\n[1,2,4,8] 1008\n[1,2,4,8,16] 20321280\n[0, .1, .2,...,1] 6.6586e-028\n[1, .5, .25, .125] 0.00384521\n[.25, .5, 1, 2, 4] 19.3798828\n\n• Can we assume the input is at least of length 2? Mar 4, 2016 at 21:00\n• @Pietu1998 No, see the first test case. Mar 4, 2016 at 21:02\n• Important test case: [1,2,2,3] => 0: two equal elements in the array, to test if the code checks self-difference (xi-xi) just by comparing to 0. Mar 5, 2016 at 11:10\n• @randomra Thank you, I totally forgot to include one of those. Whenever two entries are equal, the determinant will be 0 as there are two times the same row. Mar 7, 2016 at 20:39\n• @flawr The expected output was clear from your specs. I suggested the test case so answers not prepared for equal numbers could find their mistakes more easily. Mar 7, 2016 at 21:19\n\n# Jelly, 5 bytes\n\nœc2IP\n\n\nœc2 gets all combinations without replacement of length 2. I computes the difference list of each of those pairs, yielding a list like [, , , ..., ]. We take the Product.\n\nTry it here!\n\nIn modern Jelly, Œc works as a short form of œc2, so ŒcIP is a 4-byte solution.\n\n# Mathematica, 30 bytes\n\n1##&@@(#2-#&@@@#~Subsets~{2})&\n\n\nThis is an anonymous function.\n\nExpanded by Mathematica, it is equivalent to (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &. 1##& is an equivalent for Times (thanks tips page), which is applied to each distinct pair of elements from the input list, generated by Subsets[list, {2}]. Note that Subsets does not check for uniqueness of elements.\n\n# Ruby, 49 47 bytes\n\n->x{eval(x.combination(2).map{\|a,b\|b-a}?)\|\|1}\n\n\nThis is a lambda function that accepts a real valued, one-dimensional array and returns a float or an integer depending on the type of the input. To call it, assign it to a variable then do f.call(input).\n\nWe get all combinations of size 2 using .combination(2) and get the differences for each pair using .map {\|a, b\| b - a}. We join the resulting array into a string separated by , then eval this, which returns the product. If the input has length 1, this will be nil, which is falsey in Ruby, so we can just \|\|1 at the end to return 1 in this situation. Note that this still works when the product is 0 because for whatever reason 0 is truthy in Ruby.\n\nVerify all test cases online\n\nSaved 2 bytes thanks to Doorknob!\n\n## J, 13 bytes\n\n-/ .@(^/i.)#\n\n\nThis is a monadic function that takes in an array and returns a number. Use it like this:\n\n f =: -/ .@(^/i.)#\nf 1 2 4\n6\n\n\n## Explanation\n\nI explicitly construct the Vandermonde matrix associated with the input array, and then compute its determinant.\n\n-/ .@(^/i.)# Denote input by y\n# Length of y, say n\ni. Range from 0 to n - 1\n^/ Direct product of y with the above range using ^ (power)\nThis gives the Vandermonde matrix\n1 y0 y0^2 ... y0^(n-1)\n1 y1 y1^2 ... y1^(n-1)\n...\n1 y(n-1) y(n-1)^2 ... y(n-1)^(n-1)\n-/ .* Evaluate the determinant of this matrix\n\n• I thought whitespace was non-crucial in J... Mar 5, 2016 at 18:02\n• @CᴏɴᴏʀO'Bʀɪᴇɴ The determinant is a special case that requires a separating space, since . is also a modifier character. Same for : on its own. Mar 5, 2016 at 18:29\n• Oh! That's cool. Mar 5, 2016 at 18:30\n• @CᴏɴᴏʀO'Bʀɪᴇɴ Actually, I think that is exactly what makes J uncool. J stands for Jot, i.e. a dot or little ring (APL's ∘), as in jotting with J... The incredibly overloaded . and : (which again is visually the same as two stacked .s) makes J hard to read (for me). How much more so when whitespace next to the dots determine meaning! J's . must be the most overloaded symbol in all of computing history: I count 53 distinct meanings of . and 43 (61 if you count all of _9: to 9:) distinct meanings of :. Yukk. ;-)\nMar 7, 2016 at 13:28\n• @Nᴮᶻ it may help to think of the . as its own token; thus, it could, without a white space, be mistaken for another operator. If J is not for you, however, that's understandable. Mar 7, 2016 at 17:50\n\n# MATL, 9\n\n!G-qZRQpp\n\n\nTry it online!\n\nThis computes a matrix of all differences and then keeps only the part below the main diagonal, making the other entries 1 so they won't affect the product. The lower triangular function makes the unwanted elements 0, not 1. So we subtract 1, take the lower triangular part, and add 1 back. Then we can take the product of all entries.\n\nt % take input. Transpose\nG % push input again\n- % subtract with broadccast: matrix of all pairwise differences\nq % subtract 1\nZR % make zero all values on the diagonal and above\np % product of all columns\np % product of all those products\n\n• It's unfortunate but 2Xn!dp only seems to work with single values when the value is greater than or equal to 2... I had written it myself trying to beat Jelly :P Mar 4, 2016 at 21:42\n• @FryAmTheEggman Awww. You are right. Thanks for the heads-up! Mar 4, 2016 at 21:48\n• Yeah, I figured that was the problem. I'd consider trying something like adding a wrapper when you get Xn to do a check like if size(arg) == [1,1] ... or something. I'm too lazy to look trough the source, but (hopefully) it shouldn't be that difficult. Mar 4, 2016 at 21:52\n• @FryAmTheEggman In fact I'm not sure that's the problem (that's why I quickly edited my comment). If the first input is a number then the second input should be 1 or 0 and then it makes no difference if the first input is interpreted as array or as a number. The real problem is, second input can't exceed the array size. \"How many ways are there to choose 2 elements out of 1 element\". In this case the array/number difference matters: if first input is an array return [](empty array), if it's a number return 0. I guess I'll return [], because then p forces the other interpretation Mar 4, 2016 at 22:01\n• @FryAmTheEggman I think I'll split the function in two versions. Thanks again! Mar 4, 2016 at 22:44\n\n## Pyth, 151312 11 bytes\n\nF+1-M.c_Q2\n\n Q take input (in format [1,2,3,...])\n_ reverse the array: later we will be subtracting, and we want to\nsubtract earlier elements from later elements\n.c 2 combinations of length 2: this gets the correct pairs\n-M map a - a over each subarray\n+1 prepend a 1 to the array: this does not change the following\nresult, but prevents an error on empty array\nF fold over multiply (multiply all numbers in array)\n\n\nThanks to @FryAmTheEggman and @Pietu1998 for a byte each!\n\n• F on an empty array should really be 1. Mar 6, 2016 at 16:28\n\n# Mathematica, 32 bytes\n\nDet@Table[#^j,{j,0,Length@#-1}]&\n\n\nI was surprised not to find a builtin for Vandermonde stuff. Probably because it's so easy to do it oneself.\n\nThis one explicitly constructs the transpose of a VM and takes its determinant (which is of course the same as the original's). This method turned out to be significantly shorter than using any formula I know of.\n\n• Does not work if the list contains a zero element (giving 0^0 for j=0). Oct 7, 2020 at 12:24\n• \"I was surprised not to find a builtin for Vandermonde stuff.\" There is, but is somewhat hidden (and undocumented). Moreover, it does not make it shorter ;) : Det@LinearAlgebraPrivateVandermondeMatrix. Oct 11, 2020 at 12:33\n\nf(h:t)=f tproduct[x-h\|x<-t]\nf _=1\n\n\nA recursive solution. When a new element h is prepended to the front, the expression is multiplied by the product of x-h for each element x of the list. Thanks to Zgarb for 1 byte.\n\n# APL (Dyalog Extended), 19 bytes\n\n{×/-∊(⍳≢⍵)↓¨↓∘.-⍨⍵}\n\n\nDfn producing the pairs, then taking the product.\n\n↓∘.-⍨⍵ all pairs (with repeats)\n\n(⍳≢⍵) range from 1 to the length of the input\n\n↓¨ drop 1 2 3 4... elements to avoid repeats\n\n-∊ flatten and negate\n\n×/ take the product\n\nTry it online!\n\n• ↓∘.-⍨⍵ -> ⍵-⊂⍵ and train: ×/∘∊⍳∘≢↓¨⊂-⊢\n– ngn\nOct 6, 2020 at 21:48\n• That's pretty clever, should I update my post? Oct 7, 2020 at 9:07\n• thanks. sure, update and explain it if you want. i have no intention of posting separately.\n– ngn\nOct 7, 2020 at 13:52\n\n# Husk, 12 9 8 bytes\n\nΠṁhṠzM-ḣ\n\n\nTry it online!\n\n(Apparently the only one of the three which was correct)\n\n-3 bytes by calculating difference instead of pairs.\n\n-1 from Jo King\n\n## Explanation\n\nΠṁhṠzM-ḣ\nṠz zip the input with\nḣ prefixes\nM- subtract the input from each\nṁh remove first element of each, join\nΠ product\n\n• @Shaggy the longest one was the correct one :P Oct 6, 2020 at 16:02\n• 8 bytes through using prefixes instead\n– Jo King\nOct 7, 2020 at 4:35\n\n# Matlab, 26 bytes\n\n(noncompeting)\n\nStraightforward use of builtins. Note that (once again) Matlab's vander creates Vandermonde matrices but with the order of the rows flipped.\n\n@(v)det(fliplr(vander(v)))\n\n• Why noncompeting? Mar 4, 2016 at 20:35\n• Because I'm the one who made this challenge, I just wanted to provide this so people can try their own examples. Mar 4, 2016 at 20:36\n• Isn't Det(flipped rows) = (-1)^n Det(original)? Mar 4, 2016 at 21:22\n• I'm not quite sure, as the determinant switches sign whenever you switch two columns or rows. Mar 4, 2016 at 22:24\n• @hYPotenuser - Replace n with n+1. All you're doing is multiplying by a matrix P which is all zeros except for the diagonal going from the bottom left to top right (so you want det(P vander(v))= det(P) det(vander(v))). By expansion along the first column or whatever, you'll see det(P) = (-1)^(n+1). Apr 24, 2018 at 2:39\n\n# Perl, 38 41 bytes\n\nInclude +1 for -p\n\nGive the numbers on a line on STDIN. So e.g. run as\n\nperl -p vandermonde.pl <<< \"1 2 4 8\"\n\n\nUse an evil regex to get the double loop:\n\nvandermonde.pl:\n\n$n=1;/(^\| ).* (??{$n=$'-$&;A})/;_=n\n\n\n# Pari/GP, 35 bytes\n\na->matdet(matrix(#a,,i,j,a[i]^j--))\n\n\nTry it online!\n\n## Rust, 86 bytes\n\n\|a:Vec<f32>\|(0..a.len()).flat_map(\|x\|(x+1..a.len()).map(move\|y\|y-x)).fold(1,\|a,b\|ab);\n\n\nRust, verbose as usual...\n\nExplanation will come later (it's pretty straightforward, though).\n\n f x=product[x!!j-x!!i\|j<-[1..length x-1],i<-[0..j-1]]\n\n\nUsage example: f [1,2,4,8,16] -> 20321280.\n\nGo through the indices j and i in a nested loop and make a list of the differences of the elements at position j and i. Make the product of all elements in the list.\n\nOther variants that turned out to be slightly longer:\n\nf x=product[last l-i\|l<-scanl1(++)$pure<$>x,i<-init l], 54 bytes\n\nimport Data.List;f i=product[y-x\|[x,y]<-subsequences i], 55 bytes\n\n## CJam, 16 bytes\n\n1l~{)1$f-@+:\\}h In response to A Simmons' post, despite CJam's lack of a combinations operator, yes it is possible to do better :) -1 byte thanks to @MartinBüttner. 1 Push 1 to kick off product l~ Read and evaluate input V { }h Do-while loop until V is empty ) Pop last element of V 1$ Copy the prefix\nf- Element-wise subtract each from the popped element\n@+ Add the current product to the resulting array\n:* Take product to produce new product\n\\ Swap, putting V back on top\n\n\n## JavaScript (ES6), 61 bytes\n\na=>a.reduce((p,x,i)=>a.slice(0,i).reduce((p,y)=>p(x-y),p),1)\n\n\nI tried an array comprehension (Firefox 30-57) and it was 5 bytes longer:\n\na=>[for(i of a.keys(p=1))for(j of Array(i).keys())p=a[i]-a[j]]&&p\n\n\nThe boring nested loop is probably shorter though.\n\n# 05AB1E, 6 bytes\n\nη-€¨˜P\n\n\nTry it online!\n\nCommented:\n\nη # prefixes of the input\n- # subtract those from the input\n€ # for each sublist:\n¨ # remove the last element (i=j)\n˜ # flatten the list\nP # take the product\n\n\nThere are a few alternatives at the same length, such as ηõš-˜P.\n\n# Desmos, 10+39=49 bytes\n\nn=a.length\n\\prod_{i=1}^n\\prod_{j=i+1}^n(a[j]-a[i])\n\n\nView it in Desmos\n\nThere's not a lot to be golfed here other than \"caching\" a.length in an array, but I would like to point out that Desmos can handle the ... notation in arrays!\n\n# Japt v1.4.5, 8 bytes\n\nà2 ®rnÃ×\n\n\nTry it (includes all test cases)\n\nà2 ®raÃ× :Implicit input of array\nà2 :Combinations of length 2 (using v1.4.5 avoids a bug here in later versions)\n® :Map\nr : Reduce by\nn : Inverse subtraction\nÃ :End map\n× :Reduce by multiplication\n\n• [-13513] returns -13513. Oct 6, 2020 at 14:16\n• I cobbled this together based on other solutions, @Razetime, 'cause I don't \"speak\" mathematical notation; other than the fact that the a should be an n, though (which wouldn't affect this test case), I can't figure out what the fix should be. The insomnia probably isn't helping. (I really wish people would stop relying on it as the sole means of defining their spec). Oct 6, 2020 at 15:40\n• can relate very much to that. Oct 6, 2020 at 15:41\n• Figured it out: Japt v1.4.6 introduced a bug whereby attempting to get the combinations of length n of an array with length less than n returns the original array instead of the empty array so I was able to \"fix\" it by downgrading to v1.4.5. Thanks, @Razetime Oct 6, 2020 at 15:55\n• Nice work done! +1 Oct 6, 2020 at 15:57\n\n# Python 3, 91 bytes (does NOT work yet)\n\nlambda x:eval(\"\".join([str(b-a) for a,b in combinations(x,2)]))or 1\nfrom itertools import\n\n\nTry it online!\n\nFixing currently.\n\n• you don't ned the brackets and you dont need the space between ) and for Jan 1 at 14:54\n\n# Factor + math.matrices math.matrices.laplace, 45 bytes\n\n[ dup length vandermonde-matrix determinant ]\n\n\nAttempt This Online!\n\n1q~La\\{1$f++}/{,2=},{~-}%~]La-:* I'm sure someone can golf this better in CJam... The main issue is that I can't see a good way of getting the subsets so that uses up most of my bytes. This generates the power set (using an idea by Martin Büttner) and then selects the length-2 elements. # R, 41 bytes function(v)det(outer(v,1:sum(v\|1)-1,\"^\")) Try it online! I was surprised not to see an R answer here! # Perl 5-pa, 36 bytes $\\=1;map$\\=$q-$_,@F while$q=pop@F}{\n\n\nTry it online!\n\n# Arn, 27 bytes\n\nùW®š¡'‡ùHÓáâ§○iò;êñ⁺bì&B\"\\$7\n\n\nTry it!\n\n# Explained\n\nUnpacked: {v{v-:{}\\.{}\\[_ _{.{}->--((:s)#\n\n ... \\ % Fold with multiplication after mapping\n{ % Begin block\n* ... \\\nv{ % Block with key of v\nv % Variable with identifier v\n- % Minus\n_ % Variable intialized to STDIN; implied\n} % End block\n_ % Implied\n}\n[ % Begin sequence\n_ % Entry equal to STDIN\n_{ % Block with key of _ (needed otherwise the first _ will be grabbed)\n_ % Last entry; implied\n}\n-> % Of length\n-- % Reduced by one\n( % Begin expression\n(\n_ % Implied\n:s % Split on spaces\n) % End expression\n# % Length\n) % Implied\n] % End of sequence; implied\n\n\nHad to fix a few major bugs I only found because of this challenge! Also made me consider adding a few quality of life features (including an upgrade to precedence and # automatically casting to a vector).\n\nSpeaking of bugs, I am 100% certain this works on the downloadable version, and it should be working on the online version very soon." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.61354244,"math_prob":0.92563796,"size":1434,"snap":"2023-40-2023-50","text_gpt3_token_len":569,"char_repetition_ratio":0.10769231,"word_repetition_ratio":0.0,"special_character_ratio":0.4344491,"punctuation_ratio":0.21203439,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9831603,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-12-06T12:13:29Z\",\"WARC-Record-ID\":\"<urn:uuid:6df97efb-702e-497a-a32f-851bbe201965>\",\"Content-Length\":\"472384\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:56fba450-4862-46d0-9ab0-5e04a7c82617>\",\"WARC-Concurrent-To\":\"<urn:uuid:c65bca29-031d-45cb-9198-fe14b1b89c02>\",\"WARC-IP-Address\":\"172.64.144.30\",\"WARC-Target-URI\":\"https://codegolf.stackexchange.com/questions/74789/vandermonde-determinant\",\"WARC-Payload-Digest\":\"sha1:RMHOHBIS3XCYYALSE7LRTGBFSUTXWGSY\",\"WARC-Block-Digest\":\"sha1:IN7YR6BVA2DAAS3SMTFGUW52UKJYXNYB\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-50/CC-MAIN-2023-50_segments_1700679100593.71_warc_CC-MAIN-20231206095331-20231206125331-00645.warc.gz\"}"}
https://cavale.enseeiht.fr/redmine/projects/lustrec-tests/repository/lustrec-tests/revisions/c3af303290bdd0d060ff28352063282fd6a4def9/annotate/tests/cocospec/StopwatchSpec.lus	[ "### Profile\n\n1 2 3 fd5381b7 Bourbouh ```------------------------- ``` ```-- Auxiliary operators -- ``` ```------------------------- ``` ```node Even (N: int) returns (B: bool) ; ``` ```let ``` ``` B = (N mod 2 = 0) ; ``` ```tel ``` ```node ToInt (X: bool) returns (N: int) ; ``` ```let ``` ``` N = if X then 1 else 0 ; ``` ```tel ``` ```node Count (X: bool) returns (N: int) ; ``` ```let ``` ``` N = ToInt(X) -> ToInt(X) + pre N ; ``` ```tel ``` ```node Sofar ( X : bool ) returns ( Y : bool ) ; ``` ```let ``` ``` Y = X -> (X and (pre Y)) ; ``` ```tel ``` ```node Since ( X, Y : bool ) returns ( Z : bool ) ; ``` ```let ``` ``` Z = X or (Y and (false -> pre Z)) ; ``` ```tel ``` ```node SinceIncl ( X, Y : bool ) returns ( Z : bool ) ; ``` ```let ``` ``` Z = Y and (X or (false -> pre Z)) ; ``` ```tel ``` ```node Increased (N: int) returns (B: bool) ; ``` ```let ``` ``` B = true -> N > pre N ; ``` ```tel ``` ```node Stable (N: int) returns (B: bool) ; ``` ```let ``` ``` B = true -> N = pre N ; ``` ```tel ``` ```------------------------------- ``` ```-- Stopwatch high-level spec -- ``` ```------------------------------- ``` 6c964a9b ploc c3af3032 Bourbouh fd5381b7 Bourbouh ```contract stopwatchSpec ( toggle, reset : bool ) returns ( time : int ) ; ``` ```let ``` ``` -- the watch is activated initially if the toggle button is pressed ``` ``` -- afterwards, it is activated iff ``` ``` -- it was activated before and the toggle button is unpressed or ``` ``` -- it was not activated before and the toggle button is pressed ``` ``` var on: bool = toggle -> (pre on and not toggle) ``` ``` or (not pre on and toggle) ; ``` ``` ``` ``` -- we can assume that the two buttons are never pressed together ``` ``` assume not (toggle and reset) ; ``` ``` ``` ``` -- the elapsed time starts at 1 or 0 depending ``` ``` -- on whether the watch is activated or not ``` ``` guarantee (on => time = 1) -> true ; ``` ``` guarantee (not on => time = 0) -> true ; ``` ``` -- the elapsed time is always non-negative ``` ``` guarantee time >= 0 ; ``` ``` ``` ``` -- if there is no reset now and there was an even number of counts since the last reset ``` ``` -- then the current elapsed time is the same as the previous one ``` ``` guarantee not reset and Since(reset, Even(Count(toggle))) ``` ``` => Stable(time) ; ``` ``` -- if there is no reset now and there was an odd number of counts since the last reset ``` ``` -- then the current elapsed time is greater than previous one ``` ``` guarantee not reset and Since(reset, not Even(Count(toggle))) ``` ``` => Increased(time) ; ``` ```-- guarantee true -> not Even(Count(toggle)) and Count(reset) = 0 => time > pre time ; ``` ``` ``` ``` -- the watch is in resetting mode if the reset button is pressed ``` ``` -- while in that mode, the elapsed time is 0 ``` ``` mode resetting ( ``` ``` require reset ; ``` ``` ensure time = 0 ; ``` ``` ) ; ``` ``` -- the watch is in running mode if is activated and ``` ``` -- the reset button is unpressed. ``` ``` -- while in that mode, the elapsed time increases by 1 ``` ``` mode running ( ``` ``` require on ; ``` ``` require not reset ; ``` ``` ensure true -> time = pre time + 1 ; ``` ``` ) ; ``` ``` -- the watch is in stopped mode if is not activated and ``` ``` -- the reset button is unpressed ``` ``` -- while in that mode, the elapsed time remains the same ``` ``` mode stopped ( ``` ``` require not reset ; ``` ``` require not on ; ``` ``` ensure true -> time = pre time ; ``` ``` ) ; ``` ```tel ``` c3af3032 Bourbouh fd5381b7 Bourbouh ```------------------------------ ``` ```-- Stopwatch low-level spec -- ``` ```------------------------------ ``` ```node stopwatch ( toggle, reset : bool ) returns ( count : int ); ``` ```(@contract import stopwatchSpec(toggle, reset ) returns (count) ; ) ``` ``` var running : bool; ``` ```let ``` ``` running = (false -> pre running) <> toggle ; ``` ``` count = ``` ``` if reset then 0 ``` ``` else if running then 1 -> pre count + 1 ``` ``` else 0 -> pre count ; ``` ```tel ```" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.5353984,"math_prob":0.9471627,"size":4488,"snap":"2022-05-2022-21","text_gpt3_token_len":1651,"char_repetition_ratio":0.24487065,"word_repetition_ratio":0.1650655,"special_character_ratio":0.54567736,"punctuation_ratio":0.10623229,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9972028,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-05-20T09:54:16Z\",\"WARC-Record-ID\":\"<urn:uuid:7e654287-51e2-4bb3-97a2-cf016f4cd490>\",\"Content-Length\":\"55931\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:37fc90c8-3156-4be2-a7fe-17ecde5e755b>\",\"WARC-Concurrent-To\":\"<urn:uuid:52388389-d462-46b4-a133-96b0cff188bb>\",\"WARC-IP-Address\":\"147.127.176.50\",\"WARC-Target-URI\":\"https://cavale.enseeiht.fr/redmine/projects/lustrec-tests/repository/lustrec-tests/revisions/c3af303290bdd0d060ff28352063282fd6a4def9/annotate/tests/cocospec/StopwatchSpec.lus\",\"WARC-Payload-Digest\":\"sha1:IB3AFVD56KKEVMZBKFINZW7XPMXZ5W5I\",\"WARC-Block-Digest\":\"sha1:VXSLMUQ2X7PRJLM5RB7Z66KTI3T7TEF6\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-21/CC-MAIN-2022-21_segments_1652662531779.10_warc_CC-MAIN-20220520093441-20220520123441-00394.warc.gz\"}"}
https://pro.arcgis.com/es/pro-app/2.9/arcpy/spatial-analyst/fuzzylinear-class.htm	[ "# FuzzyLinear\n\nDisponible con una licencia de Spatial Analyst.\n\n## Resumen\n\nDefines a fuzzy membership function through a linear transformation between the user-specified minimum value, a membership of 0, to the user-defined maximum value, which is assigned a membership of 1.\n\n## Debate\n\nThe tool that uses the FuzzyLinear object: Fuzzy Membership.\n\nThe Linear function is useful when the smaller values linearly increase in membership to the larger values for a positive slope and opposite for a negative slope.\n\nThe Linear function does not work with negative numbers.\n\n## Sintaxis\n\n` FuzzyLinear (minimum, maximum)`\n Parámetro Explicación Tipo de datos minimum The value that will have a membership of 0. If the minimum value is less than the maximum, the linear function will have a positive slope. If the minimum value is greater than the maximum, the linear function will have a negative slope.(El valor predeterminado es Minimum of the input) Double maximum The value that will have a membership of 1. If the maximum value is greater than the minimum, the linear function will have a positive slope. If the maximum value is less than the minimum, the linear function will have a negative slope.(El valor predeterminado es Maximum of the input) Double\n\n Propiedad Explicación Tipo de datos minimum(Lectura y escritura) The value that will have a membership of 0. If the minimum value is less than the maximum, the linear function will have a positive slope. If the minimum value is greater than the maximum, the slope will have a negative slope. Double maximum(Lectura y escritura) The value that will have a membership of 1. If the maximum value is greater than the minimum, the linear function will have a positive slope. If the maximum value is less than the minimum, the slope will have a negative slope. Double\n\n## Muestra de código\n\nFuzzyLinear example 1 (Python window)\n\nDemonstrates how to create a FuzzyLinear class and use it in the FuzzyMembership tool within the Python window.\n\n``````import arcpy\nfrom arcpy.sa import \nfrom arcpy import env\nenv.workspace = \"c:/sapyexamples/data\"\noutFzyMember = FuzzyMembership(\"as_std\", FuzzyLinear(12, 16))\noutFzyMember.save(\"c:/sapyexamples/fzyline\")``````\nFuzzyLinear example 2 (stand-alone script)\n\nPerforms a FuzzyMembership using the FuzzyLinear class.\n\n``````# Name: FuzzyLinear_Ex_02.py\n# Description: Scales input raster data into values ranging from zero to one\n# indicating the strength of a membership in a set.\n# Requirements: Spatial Analyst Extension\n\n# Import system modules\nimport arcpy\nfrom arcpy import env\nfrom arcpy.sa import \n\n# Set environment settings\nenv.workspace = \"C:/sapyexamples/data\"\n\n# Set local variables\ninRaster = \"as_std\"\n\n# Create the FuzzyLinear algorithm object\nmin = 19\nmax = 22\nmyFuzzyAlgorithm = FuzzyLinear(min, max)\n\n# Execute FuzzyMembership\noutFuzzyMember = FuzzyMembership(inRaster, myFuzzyAlgorithm)\n\n# Save the output\noutFuzzyMember.save(\"c:/sapyexamples/fzyline2\")``````" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.67620593,"math_prob":0.94295603,"size":2846,"snap":"2023-40-2023-50","text_gpt3_token_len":674,"char_repetition_ratio":0.17874736,"word_repetition_ratio":0.38228437,"special_character_ratio":0.20379479,"punctuation_ratio":0.10472279,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9933352,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-10-04T23:46:31Z\",\"WARC-Record-ID\":\"<urn:uuid:5893435f-d2af-4d51-97f4-ab641a72d134>\",\"Content-Length\":\"21933\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:eec245f5-ca69-4cc9-8111-25306e356597>\",\"WARC-Concurrent-To\":\"<urn:uuid:bf6b758f-768f-49bf-9d8c-c9b78c8b25dd>\",\"WARC-IP-Address\":\"198.102.60.60\",\"WARC-Target-URI\":\"https://pro.arcgis.com/es/pro-app/2.9/arcpy/spatial-analyst/fuzzylinear-class.htm\",\"WARC-Payload-Digest\":\"sha1:D65F4NOCCK3KXNU5K6RBOY7CL2JJHOUX\",\"WARC-Block-Digest\":\"sha1:BVHEFNNNSCCCH7E3PXJGLFTBDLTCTH27\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-40/CC-MAIN-2023-40_segments_1695233511424.48_warc_CC-MAIN-20231004220037-20231005010037-00446.warc.gz\"}"}
https://py4u.org/questions/452104/	[ "# Is it worth using Python's re.compile?\n\n## Question:\n\nIs there any benefit in using compile for regular expressions in Python?\n\n``````h = re.compile('hello')\nh.match('hello world')\n``````\n\nvs\n\n``````re.match('hello', 'hello world')\n``````\n\nRegular Expressions are compiled before being used when using the second version. If you are going to executing it many times it is definatly better to compile it first. If not compiling every time you match for one off’s is fine.\n\nMy understanding is that those two examples are effectively equivalent. The only difference is that in the first, you can reuse the compiled regular expression elsewhere without causing it to be compiled again.\n\nHere’s a reference for you: http://diveintopython3.ep.io/refactoring.html\n\nCalling the compiled pattern object’s search function with the string ‘M’ accomplishes the same thing as calling re.search with both the regular expression and the string ‘M’. Only much, much faster. (In fact, the re.search function simply compiles the regular expression and calls the resulting pattern object’s search method for you.)\n\nFWIW:\n\n``````\\$ python -m timeit -s \"import re\" \"re.match('hello', 'hello world')\"\n100000 loops, best of 3: 3.82 usec per loop\n\n\\$ python -m timeit -s \"import re; h=re.compile('hello')\" \"h.match('hello world')\"\n1000000 loops, best of 3: 1.26 usec per loop\n``````\n\nso, if you’re going to be using the same regex a lot, it may be worth it to do `re.compile` (especially for more complex regexes).\n\nThe standard arguments against premature optimization apply, but I don’t think you really lose much clarity/straightforwardness by using `re.compile` if you suspect that your regexps may become a performance bottleneck.\n\nUpdate:\n\nUnder Python 3.6 (I suspect the above timings were done using Python 2.x) and 2018 hardware (MacBook Pro), I now get the following timings:\n\n``````% python -m timeit -s \"import re\" \"re.match('hello', 'hello world')\"\n1000000 loops, best of 3: 0.661 usec per loop\n\n% python -m timeit -s \"import re; h=re.compile('hello')\" \"h.match('hello world')\"\n1000000 loops, best of 3: 0.285 usec per loop\n\n% python -m timeit -s \"import re\" \"h=re.compile('hello'); h.match('hello world')\"\n1000000 loops, best of 3: 0.65 usec per loop\n\n% python --version\nPython 3.6.5 :: Anaconda, Inc.\n``````\n\nI also added a case (notice the quotation mark differences between the last two runs) that shows that `re.match(x, ...)` is literally [roughly] equivalent to `re.compile(x).match(...)`, i.e. no behind-the-scenes caching of the compiled representation seems to happen.\n\nI’ve had a lot of experience running a compiled regex 1000s of times versus compiling on-the-fly, and have not noticed any perceivable difference. Obviously, this is anecdotal, and certainly not a great argument against compiling, but I’ve found the difference to be negligible.\n\nEDIT:\nAfter a quick glance at the actual Python 2.5 library code, I see that Python internally compiles AND CACHES regexes whenever you use them anyway (including calls to `re.match()`), so you’re really only changing WHEN the regex gets compiled, and shouldn’t be saving much time at all – only the time it takes to check the cache (a key lookup on an internal `dict` type).\n\nFrom module re.py (comments are mine):\n\n``````def match(pattern, string, flags=0):\nreturn _compile(pattern, flags).match(string)\n\ndef _compile(key):\n\n# Does cache check at top of function\ncachekey = (type(key),) + key\np = _cache.get(cachekey)\nif p is not None: return p\n\n# ...\n# Does actual compilation on cache miss\n# ...\n\n# Caches compiled regex\nif len(_cache) >= _MAXCACHE:\n_cache.clear()\n_cache[cachekey] = p\nreturn p\n``````\n\nI still often pre-compile regular expressions, but only to bind them to a nice, reusable name, not for any expected performance gain.\n\nThis is a good question. You often see people use re.compile without reason. It lessens readability. But sure there are lots of times when pre-compiling the expression is called for. Like when you use it repeated times in a loop or some such.\n\nIt’s like everything about programming (everything in life actually). Apply common sense.\n\nFor me, the biggest benefit to `re.compile` is being able to separate definition of the regex from its use.\n\nEven a simple expression such as `0\|[1-9][0-9]` (integer in base 10 without leading zeros) can be complex enough that you’d rather not have to retype it, check if you made any typos, and later have to recheck if there are typos when you start debugging. Plus, it’s nicer to use a variable name such as num or num_b10 than `0\|[1-9][0-9]`.\n\nIt’s certainly possible to store strings and pass them to re.match; however, that’s less readable:\n\n``````num = \"...\"\n# then, much later:\nm = re.match(num, input)\n``````\n\nVersus compiling:\n\n``````num = re.compile(\"...\")\n# then, much later:\nm = num.match(input)\n``````\n\nThough it is fairly close, the last line of the second feels more natural and simpler when used repeatedly.\n\nInterestingly, compiling does prove more efficient for me (Python 2.5.2 on Win XP):\n\n``````import re\nimport time\n\nrgx = re.compile('(w+)s+[0-9_]?s+w')\nstr = \"average 2 never\"\na = 0\n\nt = time.time()\n\nfor i in xrange(1000000):\nif re.match('(w+)s+[0-9_]?s+w', str):\n#~ if rgx.match(str):\na += 1\n\nprint time.time() - t\n``````\n\nRunning the above code once as is, and once with the two `if` lines commented the other way around, the compiled regex is twice as fast\n\nIn general, I find it is easier to use flags (at least easier to remember how), like `re.I` when compiling patterns than to use flags inline.\n\n``````>>> foo_pat = re.compile('foo',re.I)\n>>> foo_pat.findall('some string FoO bar')\n['FoO']\n``````\n\nvs\n\n``````>>> re.findall('(?i)foo','some string FoO bar')\n['FoO']\n``````\n\nor anything else for that matter —\n\n``````\"\"\" Re.py: Re.match = re.match + cache\nefficiency: re.py does this already (but what's _MAXCACHE ?)\nreadability, inline / separate: matter of taste\n\"\"\"\n\nimport re\n\ncache = {}\n_re_type = type( re.compile( \"\" ))\n\ndef match( pattern, str, opt ):\n\"\"\" Re.match = re.match + cache re.compile( pattern )\n\"\"\"\nif type(pattern) == _re_type:\ncpat = pattern\nelif pattern in cache:\ncpat = cache[pattern]\nelse:\ncpat = cache[pattern] = re.compile( pattern, opt )\nreturn cpat.match( str )\n\n# def search ...\n``````\n\nA wibni, wouldn’t it be nice if: cachehint( size= ), cacheinfo() -> size, hits, nclear …\n\nI ran this test before stumbling upon the discussion here. However, having run it I thought I’d at least post my results.\n\nI stole and bastardized the example in Jeff Friedl’s “Mastering Regular Expressions”. This is on a macbook running OSX 10.6 (2Ghz intel core 2 duo, 4GB ram). Python version is 2.6.1.\n\nRun 1 – using re.compile\n\n``````import re\nimport time\nimport fpformat\nRegex1 = re.compile('^(a\|b\|c\|d\|e\|f\|g)+\\$')\nRegex2 = re.compile('^[a-g]+\\$')\nTimesToDo = 1000\nTestString = \"\"\nfor i in range(1000):\nTestString += \"abababdedfg\"\nStartTime = time.time()\nfor i in range(TimesToDo):\nRegex1.search(TestString)\nSeconds = time.time() - StartTime\nprint \"Alternation takes \" + fpformat.fix(Seconds,3) + \" seconds\"\n\nStartTime = time.time()\nfor i in range(TimesToDo):\nRegex2.search(TestString)\nSeconds = time.time() - StartTime\nprint \"Character Class takes \" + fpformat.fix(Seconds,3) + \" seconds\"\n\nAlternation takes 2.299 seconds\nCharacter Class takes 0.107 seconds\n``````\n\nRun 2 – Not using re.compile\n\n``````import re\nimport time\nimport fpformat\n\nTimesToDo = 1000\nTestString = \"\"\nfor i in range(1000):\nTestString += \"abababdedfg\"\nStartTime = time.time()\nfor i in range(TimesToDo):\nre.search('^(a\|b\|c\|d\|e\|f\|g)+\\$',TestString)\nSeconds = time.time() - StartTime\nprint \"Alternation takes \" + fpformat.fix(Seconds,3) + \" seconds\"\n\nStartTime = time.time()\nfor i in range(TimesToDo):\nre.search('^[a-g]+\\$',TestString)\nSeconds = time.time() - StartTime\nprint \"Character Class takes \" + fpformat.fix(Seconds,3) + \" seconds\"\n\nAlternation takes 2.508 seconds\nCharacter Class takes 0.109 seconds\n``````\n\nI just tried this myself. For the simple case of parsing a number out of a string and summing it, using a compiled regular expression object is about twice as fast as using the `re` methods.\n\nAs others have pointed out, the `re` methods (including `re.compile`) look up the regular expression string in a cache of previously compiled expressions. Therefore, in the normal case, the extra cost of using the `re` methods is simply the cost of the cache lookup.\n\nHowever, examination of the code, shows the cache is limited to 100 expressions. This begs the question, how painful is it to overflow the cache? The code contains an internal interface to the regular expression compiler, `re.sre_compile.compile`. If we call it, we bypass the cache. It turns out to be about two orders of magnitude slower for a basic regular expression, such as `r'w+s+([0-9_]+)s+w'`.\n\nHere’s my test:\n\n``````#!/usr/bin/env python\nimport re\nimport time\n\ndef timed(func):\ndef wrapper(args):\nt = time.time()\nresult = func(args)\nt = time.time() - t\nprint '%s took %.3f seconds.' % (func.func_name, t)\nreturn result\nreturn wrapper\n\nregularExpression = r'w+s+([0-9_]+)s+w'\ntestString = \"average 2 never\"\n\n@timed\ndef noncompiled():\na = 0\nfor x in xrange(1000000):\nm = re.match(regularExpression, testString)\na += int(m.group(1))\nreturn a\n\n@timed\ndef compiled():\na = 0\nrgx = re.compile(regularExpression)\nfor x in xrange(1000000):\nm = rgx.match(testString)\na += int(m.group(1))\nreturn a\n\n@timed\ndef reallyCompiled():\na = 0\nrgx = re.sre_compile.compile(regularExpression)\nfor x in xrange(1000000):\nm = rgx.match(testString)\na += int(m.group(1))\nreturn a\n\n@timed\ndef compiledInLoop():\na = 0\nfor x in xrange(1000000):\nrgx = re.compile(regularExpression)\nm = rgx.match(testString)\na += int(m.group(1))\nreturn a\n\n@timed\ndef reallyCompiledInLoop():\na = 0\nfor x in xrange(10000):\nrgx = re.sre_compile.compile(regularExpression)\nm = rgx.match(testString)\na += int(m.group(1))\nreturn a\n\nr1 = noncompiled()\nr2 = compiled()\nr3 = reallyCompiled()\nr4 = compiledInLoop()\nr5 = reallyCompiledInLoop()\nprint \"r1 = \", r1\nprint \"r2 = \", r2\nprint \"r3 = \", r3\nprint \"r4 = \", r4\nprint \"r5 = \", r5\n</pre>\nAnd here is the output on my machine:\n<pre>\n\\$ regexTest.py\nnoncompiled took 4.555 seconds.\ncompiled took 2.323 seconds.\nreallyCompiled took 2.325 seconds.\ncompiledInLoop took 4.620 seconds.\nreallyCompiledInLoop took 4.074 seconds.\nr1 = 2000000\nr2 = 2000000\nr3 = 2000000\nr4 = 2000000\nr5 = 20000\n``````\n\nThe ‘reallyCompiled’ methods use the internal interface, which bypasses the cache. Note the one that compiles on each loop iteration is only iterated 10,000 times, not one million.\n\ni’d like to motivate that pre-compiling is both conceptually and ‘literately’ (as in ‘literate programming’) advantageous. have a look at this code snippet:\n\n``````from re import compile as _Re\n\nclass TYPO:\n\ndef text_has_foobar( self, text ):\nreturn self._text_has_foobar_re_search( text ) is not None\n_text_has_foobar_re_search = _Re( r\"\"\"(?i)foobar\"\"\" ).search\n\nTYPO = TYPO()\n``````\n\n``````from TYPO import TYPO\nprint( TYPO.text_has_foobar( 'FOObar ) )\n``````\n\nthis is about as simple in terms of functionality as it can get. because this is example is so short, i conflated the way to get `_text_has_foobar_re_search` all in one line. the disadvantage of this code is that it occupies a little memory for whatever the lifetime of the `TYPO` library object is; the advantage is that when doing a foobar search, you’ll get away with two function calls and two class dictionary lookups. how many regexes are cached by `re` and the overhead of that cache are irrelevant here.\n\ncompare this with the more usual style, below:\n\n``````import re\n\nclass Typo:\n\ndef text_has_foobar( self, text ):\nreturn re.compile( r\"\"\"(?i)foobar\"\"\" ).search( text ) is not None\n``````\n\nIn the application:\n\n``````typo = Typo()\nprint( typo.text_has_foobar( 'FOObar ) )\n``````\n\nI readily admit that my style is highly unusual for python, maybe even debatable. however, in the example that more closely matches how python is mostly used, in order to do a single match, we must instantiate an object, do three instance dictionary lookups, and perform three function calls; additionally, we might get into `re` caching troubles when using more than 100 regexes. also, the regular expression gets hidden inside the method body, which most of the time is not such a good idea.\n\nbe it said that every subset of measures—targeted, aliased import statements; aliased methods where applicable; reduction of function calls and object dictionary lookups—can help reduce computational and conceptual complexity.\n\nHere’s a simple test case:\n\n``````~\\$ for x in 1 10 100 1000 10000 100000 1000000; do python -m timeit -n \\$x -s 'import re' 're.match(\"[0-9]{3}-[0-9]{3}-[0-9]{4}\", \"123-123-1234\")'; done\n1 loops, best of 3: 3.1 usec per loop\n10 loops, best of 3: 2.41 usec per loop\n100 loops, best of 3: 2.24 usec per loop\n1000 loops, best of 3: 2.21 usec per loop\n10000 loops, best of 3: 2.23 usec per loop\n100000 loops, best of 3: 2.24 usec per loop\n1000000 loops, best of 3: 2.31 usec per loop\n``````\n\nwith re.compile:\n\n``````~\\$ for x in 1 10 100 1000 10000 100000 1000000; do python -m timeit -n \\$x -s 'import re' 'r = re.compile(\"[0-9]{3}-[0-9]{3}-[0-9]{4}\")' 'r.match(\"123-123-1234\")'; done\n1 loops, best of 3: 1.91 usec per loop\n10 loops, best of 3: 0.691 usec per loop\n100 loops, best of 3: 0.701 usec per loop\n1000 loops, best of 3: 0.684 usec per loop\n10000 loops, best of 3: 0.682 usec per loop\n100000 loops, best of 3: 0.694 usec per loop\n1000000 loops, best of 3: 0.702 usec per loop\n``````\n\nSo, it would seem to compiling is faster with this simple case, even if you only match once.\n\nUsing the given examples:\n\n``````h = re.compile('hello')\nh.match('hello world')\n``````\n\nThe match method in the example above is not the same as the one used below:\n\n``````re.match('hello', 'hello world')\n``````\n\nre.compile() returns a regular expression object, which means `h` is a regex object.\n\nThe regex object has its own match method with the optional pos and endpos parameters:\n\npos\n\nThe optional second parameter pos gives an index in the string where\nthe search is to start; it defaults to 0. This is not completely\nequivalent to slicing the string; the `'^'` pattern character matches at\nthe real beginning of the string and at positions just after a\nnewline, but not necessarily at the index where the search is to\nstart.\n\nendpos\n\nThe optional parameter endpos limits how far the string will be\nsearched; it will be as if the string is endpos characters long, so\nonly the characters from pos to `endpos - 1` will be searched for a\nmatch. If endpos is less than pos, no match will be found; otherwise,\nif rx is a compiled regular expression object, ```rx.search(string, 0, 50)``` is equivalent to `rx.search(string[:50], 0)`.\n\nThe regex object’s search, findall, and finditer methods also support these parameters.\n\n`re.match(pattern, string, flags=0)` does not support them as you can see,\nnor does its search, findall, and finditer counterparts.\n\nA match object has attributes that complement these parameters:\n\nmatch.pos\n\nThe value of pos which was passed to the search() or match() method of\na regex object. This is the index into the string at which the RE\nengine started looking for a match.\n\nmatch.endpos\n\nThe value of endpos which was passed to the search() or match() method\nof a regex object. This is the index into the string beyond which the\nRE engine will not go.\n\nA regex object has two unique, possibly useful, attributes:\n\nregex.groups\n\nThe number of capturing groups in the pattern.\n\nregex.groupindex\n\nA dictionary mapping any symbolic group names defined by (?P) to\ngroup numbers. The dictionary is empty if no symbolic groups were used\nin the pattern.\n\nAnd finally, a match object has this attribute:\n\nmatch.re\n\nThe regular expression object whose match() or search() method\nproduced this match instance.\n\nPerformance difference aside, using re.compile and using the compiled regular expression object to do match (whatever regular expression related operations) makes the semantics clearer to Python run-time.\n\nI had some painful experience of debugging some simple code:\n\n``````compare = lambda s, p: re.match(p, s)\n``````\n\nand later I’d use compare in\n\n``````[x for x in data if compare(patternPhrases, x[columnIndex])]\n``````\n\nwhere `patternPhrases` is supposed to be a variable containing regular expression string, `x[columnIndex]` is a variable containing string.\n\nI had trouble that `patternPhrases` did not match some expected string!\n\nBut if I used the re.compile form:\n\n``````compare = lambda s, p: p.match(s)\n``````\n\nthen in\n\n``````[x for x in data if compare(patternPhrases, x[columnIndex])]\n``````\n\nPython would have complained that “string does not have attribute of match”, as by positional argument mapping in `compare`, `x[columnIndex]` is used as regular expression!, when I actually meant\n\n``````compare = lambda p, s: p.match(s)\n``````\n\nIn my case, using re.compile is more explicit of the purpose of regular expression, when it’s value is hidden to naked eyes, thus I could get more help from Python run-time checking.\n\nSo the moral of my lesson is that when the regular expression is not just literal string, then I should use re.compile to let Python to help me to assert my assumption.\n\nI agree with Honest Abe that the `match(...)` in the given examples are different. They are not a one-to-one comparisons and thus, outcomes are vary. To simplify my reply, I use A, B, C, D for those functions in question. Oh yes, we are dealing with 4 functions in `re.py` instead of 3.\n\nRunning this piece of code:\n\n``````h = re.compile('hello') # (A)\nh.match('hello world') # (B)\n``````\n\nis same as running this code:\n\n``````re.match('hello', 'hello world') # (C)\n``````\n\nBecause, when looked into the source `re.py`, (A + B) means:\n\n``````h = re._compile('hello') # (D)\nh.match('hello world')\n``````\n\nand (C) is actually:\n\n``````re._compile('hello').match('hello world')\n``````\n\nSo, (C) is not the same as (B). In fact, (C) calls (B) after calling (D) which is also called by (A). In other words, `(C) = (A) + (B)`. Therefore, comparing (A + B) inside a loop has the same result as (C) inside a loop.\n\nGeorge’s `regexTest.py` proved this for us.\n\n``````noncompiled took 4.555 seconds. # (C) in a loop\ncompiledInLoop took 4.620 seconds. # (A + B) in a loop\ncompiled took 2.323 seconds. # (A) once + (B) in a loop\n``````\n\nEveryone’s interest is, how to get the result of 2.323 seconds. In order to make sure `compile(...)` only gets called once, we need to store the compiled regex object in memory. If we are using a class, we could store the object and reuse when every time our function gets called.\n\n``````class Foo:\nregex = re.compile('hello')\ndef my_function(text)\nreturn regex.match(text)\n``````\n\nIf we are not using class (which is my request today), then I have no comment. I’m still learning to use a global variable in Python, and I know a global variable is a bad thing.\n\nOne more point, I believe that using `(A) + (B)` approach has an upper hand. Here are some facts as I observed (please correct me if I’m wrong):\n\n1. Calls A once, it will do one search in the `_cache` followed by one `sre_compile.compile()` to create a regex object. Calls A twice, it will do two searches and one compile (because the regex object is cached).\n\n2. If the `_cache` gets flushed in between, then the regex object is released from memory and Python needs to compile again. (someone suggests that Python won’t recompile.)\n\n3. If we keep the regex object by using (A), the regex object will still get into _cache and get flushed somehow. But our code keeps a reference on it and the regex object will not be released from memory. Those, Python need not to compile again.\n\n4. The 2 seconds difference in George’s test compiled loop vs compiled is mainly the time required to build the key and search the _cache. It doesn’t mean the compile time of regex.\n\n5. George’s reallycompile test show what happens if it really re-do the compile every time: it will be 100x slower (he reduced the loop from 1,000,000 to 10,000).\n\nHere are the only cases that (A + B) is better than (C):\n\n1. If we can cache a reference of the regex object inside a class.\n2. If we need to calls (B) repeatedly (inside a loop or multiple times), we must cache the reference to the regex object outside the loop.\n\nCase that (C) is good enough:\n\n1. We cannot cache a reference.\n2. We only use it once in a while.\n3. In overall, we don’t have too many regex (assume the compiled one never get flushed)\n\nJust a recap, here are the A B C:\n\n``````h = re.compile('hello') # (A)\nh.match('hello world') # (B)\nre.match('hello', 'hello world') # (C)\n``````\n\nThere is one addition perk of using re.compile(), in the form of adding comments to my regex patterns using re.VERBOSE\n\n``````pattern = '''\nhello[ ]world # Some info on my pattern logic. [ ] to recognize space\n'''\n\nre.search(pattern, 'hello world', re.VERBOSE)\n``````\n\nAlthough this does not affect the speed of running your code, I like to do it this way as it is part of my commenting habit. I throughly dislike spending time trying to remember the logic that went behind my code 2 months down the line when I want to make modifications.\n\nThis answer might be arriving late but is an interesting find. Using compile can really save you time if you are planning on using the regex multiple times (this is also mentioned in the docs). Below you can see that using a compiled regex is the fastest when the match method is directly called on it. passing a compiled regex to re.match makes it even slower and passing re.match with the patter string is somewhere in the middle.\n\n``````>>> ipr = r'D+((([0-2][0-5]?[0-5]?).){3}([0-2][0-5]?[0-5]?))D+'\n>>> average(timeit.repeat(\"re.match(ipr, 'abcd100.10.255.255 ')\", globals={'ipr': ipr, 're': re}))\n1.5077415757028423\n>>> ipr = re.compile(ipr)\n>>> average(timeit.repeat(\"re.match(ipr, 'abcd100.10.255.255 ')\", globals={'ipr': ipr, 're': re}))\n1.8324008992184038\n>>> average(timeit.repeat(\"ipr.match('abcd100.10.255.255 ')\", globals={'ipr': ipr, 're': re}))\n0.9187896518778871\n``````\n\nI’ve had a lot of experience running a compiled regex 1000s\nof times versus compiling on-the-fly, and have not noticed\nany perceivable difference\n\nThe votes on the accepted answer leads to the assumption that what @Triptych says is true for all cases. This is not necessarily true. One big difference is when you have to decide whether to accept a regex string or a compiled regex object as a parameter to a function:\n\n``````>>> timeit.timeit(setup=\"\"\"\n... import re\n... f=lambda x, y: x.match(y) # accepts compiled regex as parameter\n... h=re.compile('hello')\n... \"\"\", stmt=\"f(h, 'hello world')\")\n0.32881879806518555\n>>> timeit.timeit(setup=\"\"\"\n... import re\n... f=lambda x, y: re.compile(x).match(y) # compiles when called\n... \"\"\", stmt=\"f('hello', 'hello world')\")\n0.809190034866333\n``````\n\nIt is always better to compile your regexs in case you need to reuse them.\n\nNote the example in the timeit above simulates creation of a compiled regex object once at import time versus “on-the-fly” when required for a match.\n\nMostly, there is little difference whether you use re.compile or not. Internally, all of the functions are implemented in terms of a compile step:\n\n``````def match(pattern, string, flags=0):\nreturn _compile(pattern, flags).match(string)\n\ndef fullmatch(pattern, string, flags=0):\nreturn _compile(pattern, flags).fullmatch(string)\n\ndef search(pattern, string, flags=0):\nreturn _compile(pattern, flags).search(string)\n\ndef sub(pattern, repl, string, count=0, flags=0):\nreturn _compile(pattern, flags).sub(repl, string, count)\n\ndef subn(pattern, repl, string, count=0, flags=0):\nreturn _compile(pattern, flags).subn(repl, string, count)\n\ndef split(pattern, string, maxsplit=0, flags=0):\nreturn _compile(pattern, flags).split(string, maxsplit)\n\ndef findall(pattern, string, flags=0):\nreturn _compile(pattern, flags).findall(string)\n\ndef finditer(pattern, string, flags=0):\nreturn _compile(pattern, flags).finditer(string)\n``````\n\nIn addition, re.compile() bypasses the extra indirection and caching logic:\n\n``````_cache = {}\n\n_pattern_type = type(sre_compile.compile(\"\", 0))\n\n_MAXCACHE = 512\ndef _compile(pattern, flags):\n# internal: compile pattern\ntry:\np, loc = _cache[type(pattern), pattern, flags]\nif loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):\nreturn p\nexcept KeyError:\npass\nif isinstance(pattern, _pattern_type):\nif flags:\nraise ValueError(\n\"cannot process flags argument with a compiled pattern\")\nreturn pattern\nif not sre_compile.isstring(pattern):\nraise TypeError(\"first argument must be string or compiled pattern\")\np = sre_compile.compile(pattern, flags)\nif not (flags & DEBUG):\nif len(_cache) >= _MAXCACHE:\n_cache.clear()\nif p.flags & LOCALE:\nif not _locale:\nreturn p\nloc = _locale.setlocale(_locale.LC_CTYPE)\nelse:\nloc = None\n_cache[type(pattern), pattern, flags] = p, loc\nreturn p\n``````\n\nIn addition to the small speed benefit from using re.compile, people also like the readability that comes from naming potentially complex pattern specifications and separating them from the business logic where there are applied:\n\n``````#### Patterns ############################################################\nnumber_pattern = re.compile(r'd+(.d)?') # Integer or decimal number\nassign_pattern = re.compile(r':=') # Assignment operator\nidentifier_pattern = re.compile(r'[A-Za-z]+') # Identifiers\nwhitespace_pattern = re.compile(r'[t ]+') # Spaces and tabs\n\n#### Applications ########################################################\n\n``````\n\nNote, one other respondent incorrectly believed that pyc files stored compiled patterns directly; however, in reality they are rebuilt each time when the PYC is loaded:\n\n``````>>> from dis import dis\n>>> with open('tmp.pyc', 'rb') as f:\n\n6 IMPORT_NAME 0 (re)\n9 STORE_NAME 0 (re)\n\n21 CALL_FUNCTION 1\n24 STORE_NAME 2 (lc_vowels)\n30 RETURN_VALUE\n``````\n\nThe above disassembly comes from the PYC file for a `tmp.py` containing:\n\n``````import re\nlc_vowels = re.compile(r'[aeiou]{2,5}')\n``````\n\nI really respect all the above answers. From my opinion\nYes! For sure it is worth to use re.compile instead of compiling the regex, again and again, every time.\n\nUsing re.compile makes your code more dynamic, as you can call the already compiled regex, instead of compiling again and aagain. This thing benefits you in cases:\n\n1. Processor Efforts\n2. Time Complexity.\n3. Makes regex Universal.(can be used in findall, search, match)\n4. And makes your program looks cool.\n\nExample :\n\n`````` example_string = \"The room number of her room is 26A7B.\"\nfind_alpha_numeric_string = re.compile(r\"bw+b\")\n``````\n\n# Using in Findall\n\n`````` find_alpha_numeric_string.findall(example_string)\n``````\n\n# Using in search\n\n`````` find_alpha_numeric_string.search(example_string)\n``````\n\nSimilarly you can use it for: Match and Substitute\n\nBesides the performance.\n\nUsing `compile` helps me to distinguish the concepts of\n1. module(re),\n2. regex object\n3. match object\nWhen I started learning regex\n\n``````#regex object\nregex_object = re.compile(r'[a-zA-Z]+')\n#match object\nmatch_object = regex_object.search('1.Hello')\n#matching content\nmatch_object.group()\noutput:\nOut: 'Hello'\nV.S.\nre.search(r'[a-zA-Z]+','1.Hello').group()\nOut: 'Hello'\n``````\n\nAs a complement, I made an exhaustive cheatsheet of module `re` for your reference.\n\n``````regex = {\n'brackets':{'single_character': ['[]', '.', {'negate':'^'}],\n'capturing_group' : ['()','(?:)', '(?!)' '\|', '\\', 'backreferences and named group'],\n'repetition' : ['{}', '?', '+?', '??', 'greedy v.s. lazy ?']},\n'lookbehind' : ['(?<=...)','(?<!...)'],\n'caputuring' : ['(?P<name>...)', '(?P=name)', '(?:)'],},\n'escapes':{'anchor' : ['^', 'b', '\\$'],\n'non_printable' : ['n', 't', 'r', 'f', 'v'],\n'shorthand' : ['d', 'w', 's']},\n'methods': {['search', 'match', 'findall', 'finditer'],\n['split', 'sub']},\n'match_object': ['group','groups', 'groupdict','start', 'end', 'span',]\n}\n``````\n\nAccording to the Python documentation:\n\nThe sequence\n\n``````prog = re.compile(pattern)\nresult = prog.match(string)\n``````\n\nis equivalent to\n\n``````result = re.match(pattern, string)\n``````\n\nbut using `re.compile()` and saving the resulting regular expression object for reuse is more efficient when the expression will be used several times in a single program.\n\nSo my conclusion is, if you are going to match the same pattern for many different texts, you better precompile it.\n\nAs an alternative answer, as I see that it hasn’t been mentioned before, I’ll go ahead and quote the Python 3 docs:\n\nShould you use these module-level functions, or should you get the pattern and call its methods yourself? If you’re accessing a regex within a loop, pre-compiling it will save a few function calls. Outside of loops, there’s not much difference thanks to the internal cache.\n\nTo me, the main gain is that I only need to remember, and read, one form of the complicated regex API syntax – the `<compiled_pattern>.method(xxx)` form rather than that and the `re.func(<pattern>, xxx)` form.\n\nThe `re.compile(<pattern>)` is a bit of extra boilerplate, true.\n\nBut where regex are concerned, that extra compile step is unlikely to be a big cause of cognitive load. And in fact, on complicated patterns, you might even gain clarity from separating the declaration from whatever regex method you then invoke on it.\n\nI tend to first tune complicated patterns in a website like Regex101, or even in a separate minimal test script, then bring them into my code, so separating the declaration from its use fits my workflow as well.\n\nHere is an example where using `re.compile` is over 50 times faster, as requested.\n\nThe point is just the same as what I made in the comment above, namely, using `re.compile` can be a significant advantage when your usage is such as to not benefit much from the compilation cache. This happens at least in one particular case (that I ran into in practice), namely when all of the following are true:\n\n• You have a lot of regex patterns (more than `re._MAXCACHE`, whose default is currently 512), and\n• you use these regexes a lot of times, and\n• you consecutive usages of the same pattern are separated by more than `re._MAXCACHE` other regexes in between, so that each one gets flushed from the cache between consecutive usages.\n``````import re\nimport time\n\ndef setup(N=1000):\n# Patterns 'a.a', 'a.b', ..., 'z.z'\npatterns = [chr(i) + '.' + chr(j)\nfor i in range(ord('a'), ord('z') + 1)\nfor j in range(ord('a'), ord('z') + 1)]\n# If this assertion below fails, just add more (distinct) patterns.\n# assert(re._MAXCACHE < len(patterns))\n# N strings. Increase N for larger effect.\nstrings = ['abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz'] * N\nreturn (patterns, strings)\n\ndef without_compile():\nprint('Without re.compile:')\npatterns, strings = setup()\nprint('searching')\ncount = 0\nfor s in strings:\nfor pat in patterns:\ncount += bool(re.search(pat, s))\nreturn count\n\ndef without_compile_cache_friendly():\nprint('Without re.compile, cache-friendly order:')\npatterns, strings = setup()\nprint('searching')\ncount = 0\nfor pat in patterns:\nfor s in strings:\ncount += bool(re.search(pat, s))\nreturn count\n\ndef with_compile():\nprint('With re.compile:')\npatterns, strings = setup()\nprint('compiling')\ncompiled = [re.compile(pattern) for pattern in patterns]\nprint('searching')\ncount = 0\nfor s in strings:\nfor regex in compiled:\ncount += bool(regex.search(s))\nreturn count\n\nstart = time.time()\nprint(with_compile())\nd1 = time.time() - start\nprint(f'-- That took {d1:.2f} seconds.n')\n\nstart = time.time()\nprint(without_compile_cache_friendly())\nd2 = time.time() - start\nprint(f'-- That took {d2:.2f} seconds.n')\n\nstart = time.time()\nprint(without_compile())\nd3 = time.time() - start\nprint(f'-- That took {d3:.2f} seconds.n')\n\nprint(f'Ratio: {d3/d1:.2f}')\n``````\n\nExample output I get on my laptop (Python 3.7.7):\n\n``````With re.compile:\ncompiling\nsearching\n676000\n-- That took 0.33 seconds.\n\nWithout re.compile, cache-friendly order:\nsearching\n676000\n-- That took 0.67 seconds.\n\nWithout re.compile:\nsearching\n676000\n-- That took 23.54 seconds.\n\nRatio: 70.89\n``````\n\nI didn’t bother with `timeit` as the difference is so stark, but I get qualitatively similar numbers each time. Note that even without `re.compile`, using the same regex multiple times and moving on to the next one wasn’t so bad (only about 2 times as slow as with `re.compile`), but in the other order (looping through many regexes), it is significantly worse, as expected. Also, increasing the cache size works too: simply setting `re._MAXCACHE = len(patterns)` in `setup()` above (of course I don’t recommend doing such things in production as names with underscores are conventionally “private”) drops the ~23 seconds back down to ~0.7 seconds, which also matches our understanding.\n\nAlthough the two approaches are comparable in terms of speed, you should know that there still is some negligible time difference which might be of your concern if you’re dealing with millions of iterations.\n\nThe following speed test:\n\n``````import re\nimport time\n\nSIZE = 100_000_000\n\nstart = time.time()\nfoo = re.compile('foo')\n[foo.search('bar') for _ in range(SIZE)]\nprint('compiled: ', time.time() - start)\n\nstart = time.time()\n[re.search('foo', 'bar') for _ in range(SIZE)]\nprint('uncompiled:', time.time() - start)\n``````\n\ngives these results:\n\n``````compiled: 14.647532224655151\nuncompiled: 61.483458042144775\n``````\n\nThe compiled approach is on my PC (with Python 3.7.0) consistently about 4 times faster.\n\nAs explained in the documentation:\n\nIf you’re accessing a regex within a loop, pre-compiling it will save a few function calls. Outside of loops, there’s not much difference thanks to the internal cache.\n\nCategories: questions Tags: ,\nAnswers are sorted by their score. The answer accepted by the question owner as the best is marked with\nat the top-right corner." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.75397533,"math_prob":0.8196119,"size":66464,"snap":"2023-14-2023-23","text_gpt3_token_len":17297,"char_repetition_ratio":0.15046644,"word_repetition_ratio":0.9909436,"special_character_ratio":0.2864859,"punctuation_ratio":0.17209508,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.96588594,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-06-04T06:39:38Z\",\"WARC-Record-ID\":\"<urn:uuid:598e8c48-c3c9-408c-99e4-b79ad4e98d1d>\",\"Content-Length\":\"63625\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:d1d354af-58c2-4c66-bfbc-b3222baffa3f>\",\"WARC-Concurrent-To\":\"<urn:uuid:67a94312-4b6c-4ae0-9eee-09a5b1f43846>\",\"WARC-IP-Address\":\"104.21.83.140\",\"WARC-Target-URI\":\"https://py4u.org/questions/452104/\",\"WARC-Payload-Digest\":\"sha1:VDM4NZPSQQYXJC5M4EFRCXW7HABUKT65\",\"WARC-Block-Digest\":\"sha1:EPVXI3FCLUADXRQ3GH5STEOYVUXJM2EB\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-23/CC-MAIN-2023-23_segments_1685224649518.12_warc_CC-MAIN-20230604061300-20230604091300-00490.warc.gz\"}"}
https://www.felixcloutier.com/x86/jcc	[ "# Jcc — Jump if Condition Is Met\n\nOpcode Instruction Op/En 64-Bit Mode Compat/Leg Mode Description\n77 cb JA rel8 D Valid Valid Jump short if above (CF=0 and ZF=0).\n73 cb JAE rel8 D Valid Valid Jump short if above or equal (CF=0).\n72 cb JB rel8 D Valid Valid Jump short if below (CF=1).\n76 cb JBE rel8 D Valid Valid Jump short if below or equal (CF=1 or ZF=1).\n72 cb JC rel8 D Valid Valid Jump short if carry (CF=1).\nE3 cb JCXZ rel8 D N.E. Valid Jump short if CX register is 0.\nE3 cb JECXZ rel8 D Valid Valid Jump short if ECX register is 0.\nE3 cb JRCXZ rel8 D Valid N.E. Jump short if RCX register is 0.\n74 cb JE rel8 D Valid Valid Jump short if equal (ZF=1).\n7F cb JG rel8 D Valid Valid Jump short if greater (ZF=0 and SF=OF).\n7D cb JGE rel8 D Valid Valid Jump short if greater or equal (SF=OF).\n7C cb JL rel8 D Valid Valid Jump short if less (SF≠ OF).\n7E cb JLE rel8 D Valid Valid Jump short if less or equal (ZF=1 or SF≠ OF).\n76 cb JNA rel8 D Valid Valid Jump short if not above (CF=1 or ZF=1).\n72 cb JNAE rel8 D Valid Valid Jump short if not above or equal (CF=1).\n73 cb JNB rel8 D Valid Valid Jump short if not below (CF=0).\n77 cb JNBE rel8 D Valid Valid Jump short if not below or equal (CF=0 and ZF=0).\n73 cb JNC rel8 D Valid Valid Jump short if not carry (CF=0).\n75 cb JNE rel8 D Valid Valid Jump short if not equal (ZF=0).\n7E cb JNG rel8 D Valid Valid Jump short if not greater (ZF=1 or SF≠ OF).\n7C cb JNGE rel8 D Valid Valid Jump short if not greater or equal (SF≠ OF).\n7D cb JNL rel8 D Valid Valid Jump short if not less (SF=OF).\n7F cb JNLE rel8 D Valid Valid Jump short if not less or equal (ZF=0 and SF=OF).\n71 cb JNO rel8 D Valid Valid Jump short if not overflow (OF=0).\n7B cb JNP rel8 D Valid Valid Jump short if not parity (PF=0).\n79 cb JNS rel8 D Valid Valid Jump short if not sign (SF=0).\n75 cb JNZ rel8 D Valid Valid Jump short if not zero (ZF=0).\n70 cb JO rel8 D Valid Valid Jump short if overflow (OF=1).\n7A cb JP rel8 D Valid Valid Jump short if parity (PF=1).\n7A cb JPE rel8 D Valid Valid Jump short if parity even (PF=1).\n7B cb JPO rel8 D Valid Valid Jump short if parity odd (PF=0).\n78 cb JS rel8 D Valid Valid Jump short if sign (SF=1).\n74 cb JZ rel8 D Valid Valid Jump short if zero (ZF = 1).\n0F 87 cw JA rel16 D N.S. Valid Jump near if above (CF=0 and ZF=0). Not supported in 64-bit mode.\n0F 87 cd JA rel32 D Valid Valid Jump near if above (CF=0 and ZF=0).\n0F 83 cw JAE rel16 D N.S. Valid Jump near if above or equal (CF=0). Not supported in 64-bit mode.\n0F 83 cd JAE rel32 D Valid Valid Jump near if above or equal (CF=0).\n0F 82 cw JB rel16 D N.S. Valid Jump near if below (CF=1). Not supported in 64-bit mode.\n0F 82 cd JB rel32 D Valid Valid Jump near if below (CF=1).\n0F 86 cw JBE rel16 D N.S. Valid Jump near if below or equal (CF=1 or ZF=1). Not supported in 64-bit mode.\n0F 86 cd JBE rel32 D Valid Valid Jump near if below or equal (CF=1 or ZF=1).\n0F 82 cw JC rel16 D N.S. Valid Jump near if carry (CF=1). Not supported in 64-bit mode.\n0F 82 cd JC rel32 D Valid Valid Jump near if carry (CF=1).\n0F 84 cw JE rel16 D N.S. Valid Jump near if equal (ZF=1). Not supported in 64-bit mode.\n0F 84 cd JE rel32 D Valid Valid Jump near if equal (ZF=1).\n0F 84 cw JZ rel16 D N.S. Valid Jump near if 0 (ZF=1). Not supported in 64-bit mode.\n0F 84 cd JZ rel32 D Valid Valid Jump near if 0 (ZF=1).\n0F 8F cw JG rel16 D N.S. Valid Jump near if greater (ZF=0 and SF=OF). Not supported in 64-bit mode.\n0F 8F cd JG rel32 D Valid Valid Jump near if greater (ZF=0 and SF=OF).\n0F 8D cw JGE rel16 D N.S. Valid Jump near if greater or equal (SF=OF). Not supported in 64-bit mode.\n0F 8D cd JGE rel32 D Valid Valid Jump near if greater or equal (SF=OF).\n0F 8C cw JL rel16 D N.S. Valid Jump near if less (SF≠ OF). Not supported in 64-bit mode.\n0F 8C cd JL rel32 D Valid Valid Jump near if less (SF≠ OF).\n0F 8E cw JLE rel16 D N.S. Valid Jump near if less or equal (ZF=1 or SF≠ OF). Not supported in 64-bit mode.\n0F 8E cd JLE rel32 D Valid Valid Jump near if less or equal (ZF=1 or SF≠ OF).\n0F 86 cw JNA rel16 D N.S. Valid Jump near if not above (CF=1 or ZF=1). Not supported in 64-bit mode.\n0F 86 cd JNA rel32 D Valid Valid Jump near if not above (CF=1 or ZF=1).\n0F 82 cw JNAE rel16 D N.S. Valid Jump near if not above or equal (CF=1). Not supported in 64-bit mode.\n0F 82 cd JNAE rel32 D Valid Valid Jump near if not above or equal (CF=1).\n0F 83 cw JNB rel16 D N.S. Valid Jump near if not below (CF=0). Not supported in 64-bit mode.\n0F 83 cd JNB rel32 D Valid Valid Jump near if not below (CF=0).\n0F 87 cw JNBE rel16 D N.S. Valid Jump near if not below or equal (CF=0 and ZF=0). Not supported in 64-bit mode.\n0F 87 cd JNBE rel32 D Valid Valid Jump near if not below or equal (CF=0 and ZF=0).\n0F 83 cw JNC rel16 D N.S. Valid Jump near if not carry (CF=0). Not supported in 64-bit mode.\n0F 83 cd JNC rel32 D Valid Valid Jump near if not carry (CF=0).\n0F 85 cw JNE rel16 D N.S. Valid Jump near if not equal (ZF=0). Not supported in 64-bit mode.\n0F 85 cd JNE rel32 D Valid Valid Jump near if not equal (ZF=0).\n0F 8E cw JNG rel16 D N.S. Valid Jump near if not greater (ZF=1 or SF≠ OF). Not supported in 64-bit mode.\n0F 8E cd JNG rel32 D Valid Valid Jump near if not greater (ZF=1 or SF≠ OF).\n0F 8C cw JNGE rel16 D N.S. Valid Jump near if not greater or equal (SF≠ OF). Not supported in 64-bit mode.\n0F 8C cd JNGE rel32 D Valid Valid Jump near if not greater or equal (SF≠ OF).\n0F 8D cw JNL rel16 D N.S. Valid Jump near if not less (SF=OF). Not supported in 64-bit mode.\n0F 8D cd JNL rel32 D Valid Valid Jump near if not less (SF=OF).\n0F 8F cw JNLE rel16 D N.S. Valid Jump near if not less or equal (ZF=0 and SF=OF). Not supported in 64-bit mode.\n0F 8F cd JNLE rel32 D Valid Valid Jump near if not less or equal (ZF=0 and SF=OF).\n0F 81 cw JNO rel16 D N.S. Valid Jump near if not overflow (OF=0). Not supported in 64-bit mode.\n0F 81 cd JNO rel32 D Valid Valid Jump near if not overflow (OF=0).\n0F 8B cw JNP rel16 D N.S. Valid Jump near if not parity (PF=0). Not supported in 64-bit mode.\n0F 8B cd JNP rel32 D Valid Valid Jump near if not parity (PF=0).\n0F 89 cw JNS rel16 D N.S. Valid Jump near if not sign (SF=0). Not supported in 64-bit mode.\n0F 89 cd JNS rel32 D Valid Valid Jump near if not sign (SF=0).\n0F 85 cw JNZ rel16 D N.S. Valid Jump near if not zero (ZF=0). Not supported in 64-bit mode.\n0F 85 cd JNZ rel32 D Valid Valid Jump near if not zero (ZF=0).\n0F 80 cw JO rel16 D N.S. Valid Jump near if overflow (OF=1). Not supported in 64-bit mode.\n0F 80 cd JO rel32 D Valid Valid Jump near if overflow (OF=1).\n0F 8A cw JP rel16 D N.S. Valid Jump near if parity (PF=1). Not supported in 64-bit mode.\n0F 8A cd JP rel32 D Valid Valid Jump near if parity (PF=1).\n0F 8A cw JPE rel16 D N.S. Valid Jump near if parity even (PF=1). Not supported in 64-bit mode.\n0F 8A cd JPE rel32 D Valid Valid Jump near if parity even (PF=1).\n0F 8B cw JPO rel16 D N.S. Valid Jump near if parity odd (PF=0). Not supported in 64-bit mode.\n0F 8B cd JPO rel32 D Valid Valid Jump near if parity odd (PF=0).\n0F 88 cw JS rel16 D N.S. Valid Jump near if sign (SF=1). Not supported in 64-bit mode.\n0F 88 cd JS rel32 D Valid Valid Jump near if sign (SF=1).\n0F 84 cw JZ rel16 D N.S. Valid Jump near if 0 (ZF=1). Not supported in 64-bit mode.\n0F 84 cd JZ rel32 D Valid Valid Jump near if 0 (ZF=1).\n\n## Instruction Operand Encoding ¶\n\n Op/En Operand 1 Operand 2 Operand 3 Operand 4 D Offset NA NA NA\n\n## Description ¶\n\nChecks the state of one or more of the status flags in the EFLAGS register (CF, OF, PF, SF, and ZF) and, if the flags are in the specified state (condition), performs a jump to the target instruction specified by the destination operand. A condition code (cc) is associated with each instruction to indicate the condition being tested for. If the condition is not satisfied, the jump is not performed and execution continues with the instruction following the Jcc instruction.\n\nThe target instruction is specified with a relative offset (a signed offset relative to the current value of the instruction pointer in the EIP register). A relative offset (rel8, rel16, or rel32) is generally specified as a label in assembly code, but at the machine code level, it is encoded as a signed, 8-bit or 32-bit immediate value, which is added to the instruction pointer. Instruction coding is most efficient for offsets of –128 to +127. If the operand-size attribute is 16, the upper two bytes of the EIP register are cleared, resulting in a maximum instruction pointer size of 16 bits.\n\nThe conditions for each Jcc mnemonic are given in the “Description” column of the table on the preceding page. The terms “less” and “greater” are used for comparisons of signed integers and the terms “above” and “below” are used for unsigned integers.\n\nBecause a particular state of the status flags can sometimes be interpreted in two ways, two mnemonics are defined for some opcodes. For example, the JA (jump if above) instruction and the JNBE (jump if not below or equal) instruction are alternate mnemonics for the opcode 77H.\n\nThe Jcc instruction does not support far jumps (jumps to other code segments). When the target for the conditional jump is in a different segment, use the opposite condition from the condition being tested for the Jcc instruction, and then access the target with an unconditional far jump (JMP instruction) to the other segment. For example, the following conditional far jump is illegal:\n\nJZ FARLABEL;\n\nTo accomplish this far jump, use the following two instructions:\n\nJNZ BEYOND;\n\nJMP FARLABEL;\n\nBEYOND:\n\nThe JRCXZ, JECXZ and JCXZ instructions differ from other Jcc instructions because they do not check status flags. Instead, they check RCX, ECX or CX for 0. The register checked is determined by the address-size attribute. These instructions are useful when used at the beginning of a loop that terminates with a conditional loop instruction (such as LOOPNE). They can be used to prevent an instruction sequence from entering a loop when RCX, ECX or CX is 0. This would cause the loop to execute 264, 232 or 64K times (not zero times).\n\nAll conditional jumps are converted to code fetches of one or two cache lines, regardless of jump address or cache-ability.\n\nIn 64-bit mode, operand size is fixed at 64 bits. JMP Short is RIP = RIP + 8-bit offset sign extended to 64 bits. JMP Near is RIP = RIP + 32-bit offset sign extended to 64 bits.\n\n## Operation ¶\n\n```IF condition\nTHEN\ntempEIP ← EIP + SignExtend(DEST);\nIF OperandSize = 16\nTHEN tempEIP ← tempEIP AND 0000FFFFH;\nFI;\nIF tempEIP is not within code segment limit\nTHEN #GP(0);\nELSE EIP ← tempEIP\nFI;\nFI;\n```\n\nNone\n\n## Protected Mode Exceptions ¶\n\n #GP(0) If the offset being jumped to is beyond the limits of the CS segment. #UD If the LOCK prefix is used.\n\n #GP If the offset being jumped to is beyond the limits of the CS segment or is outside of the effective address space from 0 to FFFFH. This condition can occur if a 32-bit address size override prefix is used. #UD If the LOCK prefix is used.\n\n## Virtual-8086 Mode Exceptions ¶\n\nSame exceptions as in real address mode.\n\n## Compatibility Mode Exceptions ¶\n\nSame exceptions as in protected mode.\n\n## 64-Bit Mode Exceptions ¶\n\n #GP(0) If the memory address is in a non-canonical form. #UD If the LOCK prefix is used." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.64563453,"math_prob":0.9070917,"size":11559,"snap":"2021-04-2021-17","text_gpt3_token_len":3952,"char_repetition_ratio":0.28420597,"word_repetition_ratio":0.34880516,"special_character_ratio":0.34795398,"punctuation_ratio":0.10080183,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.975078,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-01-21T04:09:16Z\",\"WARC-Record-ID\":\"<urn:uuid:26c772c6-e17b-4ab0-b6b8-3aef887dae02>\",\"Content-Length\":\"22124\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:00b0e004-4910-49e3-bfba-287ee8759a80>\",\"WARC-Concurrent-To\":\"<urn:uuid:f76f1bb6-3d03-4e3c-8421-dbdd4caecb38>\",\"WARC-IP-Address\":\"104.248.60.43\",\"WARC-Target-URI\":\"https://www.felixcloutier.com/x86/jcc\",\"WARC-Payload-Digest\":\"sha1:MTRLYL4SV2WJHUKHIB2K4P2JMEDXDKXH\",\"WARC-Block-Digest\":\"sha1:MZEQLPAOQCFKBJSKVONAVGTMFW7R6K7H\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-04/CC-MAIN-2021-04_segments_1610703522242.73_warc_CC-MAIN-20210121035242-20210121065242-00795.warc.gz\"}"}
https://coolcodea.wordpress.com/2015/12/11/252-snake/	[ "This is the old snake game, as shown below. posted his version on the Codea forum, but got stuck on making the snake longer when it ate food. So, Joao, this is for you.\n\nIf you are fairly new to Codea, this may help you understand things like tables a little better.\n\n### How the Snake game works\n\nYou use a joystick (up/down/left/right) to steer a snake (green squares) around the screen, trying to touch the food (red square). Each time you touch the food, your length increases by 1, and new food appears. If you go off the edge of the screen, you lose.\n\nThis used to be a popular game on old “feature” phones, you know, those really old ones with about 10 pixels on the screen, because this game didn’t use many pixels. In fact, the snake was made up of 1 pixel squares.\n\nIf you did that with your iPad, you wouldn’t see the snake, it would be so tiny, so we have to make it bigger. We’ll pretend the iPad screen is made up of little squares, each 20 pixels wide. The snake and food will also be squares which are 20 pixels wide.\n\nNow, when you touch the joystick controls, the head of the snake needs to turn left, right, up or down, and the rest of the snake will follow.", null, "So suppose the snake is 4 squares long, and is going from right to left. Then we turn down.\n\nThe picture shows how the first square goes down and is followed by the other squares. But the other squares don’t all start going down immediately – they follow exactly the same path as the first square, so the last square (number 4 in the picture) goes left 3 squares before it starts going down.\n\nHow do we do this? How do we get the squares to remember the path that the first square took?\n\nThe answer is amazingly easy, and it’s probably why this game was made originally, because it is so simple.\n\nOur program will have a list of the positions for the squares of the snake. So suppose the list for the picture above looks like this, before we turn down the screen:\n\n(200,100), (220,100), (240,100), (260,100)\n\nYou can see the x values of the squares are 20 pixels apart, so they are in a row next to each other (as you see above).\n\nNow we turn down. The list for the second picture above will look like this. The first square has gone down 20 pixels and the other squares have moved left\n\n(200,80), (200,100), (220,100), (240,100)\n\nand the list for the third picture will look like this (the second square has now started going down)\n\n(200,60), (200,80), (200,100), (220,100)\n\nCan you see the pattern?\n\nThe first item in each list is the new position of the head of the snake.\n\nTo get the positions of the rest of the snake, you take the list for the previous move, and move them all one to the left, because the second square is moving to where the first square was, the third square moves to where the second square was, and so on.\n\nSo if you have a four-square snake with a list of positions (a,b,c,d), and the snake moves to e, then the list of positions will become (e,a,b,c). This means you add the new position at the front of the list, and delete the last item on the list.\n\nThis does exactly what we need.\n\nAnd it gets better, because there is an easy solution for our next problem. How do we add a square to the tail of the snake if it eats some food? Should it go above, below, left or right of the end of the snake? The obvious answer is that it should go where the tail of the snake has just been, ie the empty square where it was one move ago. And this is incredibly easy to do.\n\nWhen we are adding a new position to our list, we look at whether we ate food, and if we did, we don’t delete the last item on the list (but if we didn’t eat food, we do delete it). This effectively adds a new item on the end, exactly where the tail of the snake was one move ago. Perfect.\n\nIf we moved the snake by one square (20 pixels) every frame, it would get across the whole screen in about a second, which is way too fast. We need to slow it down.\n\nWe can do this by using a counter that increases by 1 at each frame. Then, every (say) 10th frame, we move the snake.\n\nAdjusting every 10th frame means the picture only changes 6 times a second, and it will look jumpy. I’ll fix this below, but first, let’s program it like this.\n\nHere is my setup function\n\n```function setup()\nspeed=20 --a bigger number makes it slower and easier\nsize=20 --size of each squares (pixels)\n--start our snake in the middle of the screen\n-- // is integer division, ie WIDTH/2//size=math.floor(WIDTH/2)\n--we do this because the snake must be exactly on a square\nstart=vec2(WIDTH/2//size,HEIGHT/2//size)size\nS={start} --table holding snake squares\n--JOYSTICK SETUP CODE GOES HERE (we'll look at this later)\n--set the direction we are moving (nothing at first)\ncounter=0\nend\n```\n\nAnd here is my draw function. When you start out programming, you will probably have most of your code in the draw function, and it starts getting very messy. It’s a good idea to put the code into separate functions, making it easier to debug.\n\n```function draw()\nbackground(150, 192, 209, 255)\nDrawSnake()\nDrawFood()\nDrawJoyStick()\nend\n```\n\nHere is the DrawSnake code – this is the important function. See the numbered notes underneath\n\n```function DrawSnake()\n--update snake position\ncounter=counter+1\nif counter%speed==0 then --\nlocal p=S+directionsize --\nif p.x<0 or p.x>WIDTH or p.y<0 or p.y>HEIGHT then --\n--LOSE GAME - NOT PROGRAMMED\nend\ntable.insert(S,1,p) --\n--eat food\nif S:dist(food)<0.1 then --\n--UPDATE SCORE -- NOT PROGRAMMED\nAddFood() --create new food somewhere else\nelse\ntable.remove(S,#S) --\nend\nend\n\npushStyle() --\nfill(75, 140, 72, 255)\nfor i=1,#S do --\nrect(S[i].x,S[i].y,size)\nend\npopStyle()\nend```\n\n counter%speed = remainder of counter/speed. It will be 0 if counter is an exact multiple of speed, so if speed=10, then this will give an answer of 0 when counter =10, 20, 30,…. So this is an easy way of doing something every 10 frames.\n\n I haven’t shown you this yet, but touching the joystick gives you a direction vector, Left is (-1,0), right is (1,0), up is (0,1) and down is (0,-1). We multiply this by the size of our squares, and add it to the position of the first item in our snake list.\n\n if we go off the edge off the screen, we lose. I didn’t program what happens if you lose.\n\n if we are still on the screen, we insert our new position p into the first place in our snake table.\n\n if we are very close to the position of the food (the dist function calculates distance in pixels between two points), then we ate the food. I didn’t program the score, but I add new food somewhere else.\n\n I delete the last item in the snake table, but only if we didn’t eat food (as explained above).\n\n whenever I change colours, I put pushStyle() first, and popStyle() when I’ve finished. This makes Codea save the previous settings and put them back afterwards.\n\n now I draw the squares of the snake using a for loop (#S is the number of items in the table S)\n\nBelow is my function for adding food. I’ve included it to show how I can make sure it is not too close to the player, and it is not too close to the joystick controls. As with the snake, the food position needs to be a multiple of the square size (ie 20), so I start by calculating how many squares there are in the width and height, choosing one at random, and doing my checks. If it’s too close to the snake or the joystick, I do it again, and break (ie exit) if everything is OK.\n\n```function AddFood()\nwhile true do --keep looping until we get a position we want\n--positions must be a multiple of the size, so\n--first figure out how many we can fit into the screen\nlocal w,h=WIDTH//size,HEIGHT//size\n--choose one that isn't on the edge\nfood=vec2(math.random(2,w-1),math.random(2,h-1))size\n--make sure it is further than 50 pixels from our snake head\n--and also that it is not inside our joystick\nif food:dist(S)>50 and food:dist(joyCentre)>joyLength then\nbreak\nend\nend\nend\n```\n\nFinally, the joystick code. This code goes in setup. What is all this? I set up a table with 4 items, one for each of the paddle arms. Each of these 4 items is a table, made up of the centre position of that joystick arm, its length and width, and the direction to go in, if that arm is touched.\n\n```joyCentre=vec2(WIDTH-140,140) --centre of joystick paddle\njoyWidth,joyLength=40,80 --length and width of paddle arms\njoyArms={\n{joyCentre-vec2(joyLength,joyWidth)/2,joyLength,joyWidth,vec2(-1,0)},\n{joyCentre+vec2(joyLength,joyWidth)/2,joyLength,joyWidth,vec2(1,0)},\n{joyCentre-vec2(joyWidth,joyLength)/2,joyWidth,joyLength,vec2(0,-1)},\n{joyCentre+vec2(joyWidth,joyLength)/2,joyWidth,joyLength,vec2(0,1)}\n}\n```\n\nThe reason I do this here, is that it makes the touch code much simpler.\n\n```function touched(t)\nif t.state==ENDED then --if we have finished touching\nfor i=1,4 do --check if we touched each arm\nlocal j=joyArms[i] --just to make the next line shorter\n--check if we touched inside this arm\nif math.abs(t.x-j.x)<j and\nmath.abs(t.y-j.y)<j then\ndirection=j\nbreak\nend\nend\nend\nend\n```\n\nDrawing the joystick is also simple. I’m lazy, and I draw the 4 arms as two thick lines instead of 4 rectangles.\n\n```function DrawJoyStick()\npushStyle()\nstroke(86, 133, 199, 255)\nstrokeWidth(joyWidth)\nline(joyCentre.x-joyLength,joyCentre.y,\njoyCentre.x+joyLength,joyCentre.y)\nline(joyCentre.x,joyCentre.y-joyLength,\njoyCentre.x,joyCentre.y+joyLength)\npopStyle()\nend\n```\n\n### What about the jumpy updating?\n\nSo far, our program looks like this. Can we make it less jumpy?\n\nInstead of just jumping from one square to the next, we can interpolate, so the movement is smooth. We will still only eat food or change direction every S frames, where S is the speed we have chosen, but we will move the squares in between.\n\nThis is easy to do. Imagine we have a 4-square snake with positions (a,b,c,d), and it is going to move to e (it doesn’t matter whether this is in the same direction or not).\n\nIn the program above, we would wait for S frames (where S is the speed), and then change the list to (e,a,b,c).\n\nWhat we will do now, is to add e to the front of the list, and delete the last item. Then when we draw, we use the counter to interpolate. So if the speed is 10 (ie it takes 10 frames to move one square, or 20 pixels), the position of the first snake square will be as follows for the next 3 frames\n\n```frame 1 = e1/10 + a9/10\nframe 2 = e2/10 + a8/10\nframe 3 = e3/10 + a7/10\n....\nframe 10 = e10/10 + a0/10\n```\n\nSo we calculate each square’s position by interpolating between its previous position and its next position. It means one small change to our initial table, so instead of S={start}, we have S={start,start}, so we have two positions to interpolate between, even if they are the same at the beginning.\n\nThis is the code for drawing the snake\n\n```local f=(counter%speed)/speed --fraction\nfor i=1,#S-1 do\nlocal x,y=S[i].xf+S[i+1].x(1-f),S[i].yf+S[i+1].y*(1-f)\nrect(x,y,size)\nend\n```\n\nNote how my loop stops one before the end of the table S. That’s because I included an extra item in it at the beginning for interpolation. The first snake square interpolates between the first and second item, the second square interpolates between the second and third list items, and the last snake square interpolates between the second to last and last list items.\n\nAnd when you do all this, you get the result shown in the video at the top of this post.\n\nHere is the final code. I’m not sure the joystick code is working perfectly, but I mainly did this post to show how to program snake, so I’m not going to go back and look at it.\n\nI hope you enjoy it, and maybe try changing it." ]	[ null, "https://coolcodea.files.wordpress.com/2015/12/snake1.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.88130516,"math_prob":0.9642367,"size":11716,"snap":"2022-40-2023-06","text_gpt3_token_len":3069,"char_repetition_ratio":0.13806352,"word_repetition_ratio":0.016990291,"special_character_ratio":0.27133834,"punctuation_ratio":0.1292619,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.98270607,"pos_list":[0,1,2],"im_url_duplicate_count":[null,3,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-02-05T07:14:56Z\",\"WARC-Record-ID\":\"<urn:uuid:39709403-5a2f-40c6-ab93-f7e27a74cdbf>\",\"Content-Length\":\"107276\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:4763ed26-9daf-45a2-85b7-5d19c5130d53>\",\"WARC-Concurrent-To\":\"<urn:uuid:1c050d8d-884f-4551-8b15-c0876d851cf9>\",\"WARC-IP-Address\":\"192.0.78.12\",\"WARC-Target-URI\":\"https://coolcodea.wordpress.com/2015/12/11/252-snake/\",\"WARC-Payload-Digest\":\"sha1:GUSKXWB6HMMO2NNBUQNSMRV6SNDCLLOK\",\"WARC-Block-Digest\":\"sha1:LCCJLPB2K5EYUN3GVYGAAL4QHHJS7JB3\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-06/CC-MAIN-2023-06_segments_1674764500250.51_warc_CC-MAIN-20230205063441-20230205093441-00805.warc.gz\"}"}
https://number.academy/4378	[ "# Number 4378\n\nNumber 4,378 spell 🔊, write in words: four thousand, three hundred and seventy-eight . Ordinal number 4378th is said 🔊 and write: four thousand, three hundred and seventy-eighth. The meaning of number 4378 in Maths: Is Prime? Factorization and prime factors tree. The square root and cube root of 4378. What is 4378 in computer science, numerology, codes and images, writing and naming in other languages. Other interesting facts related to 4378.\n\n## What is 4,378 in other units\n\nThe decimal (Arabic) number 4378 converted to a Roman number is (IV)CCCLXXVIII. Roman and decimal number conversions.\n The number 4378 converted to a Mayan number is", null, "Decimal and Mayan number conversions.\n\n#### Weight conversion\n\n4378 kilograms (kg) = 9651.7 pounds (lbs)\n4378 pounds (lbs) = 1985.8 kilograms (kg)\n\n#### Length conversion\n\n4378 kilometers (km) equals to 2721 miles (mi).\n4378 miles (mi) equals to 7046 kilometers (km).\n4378 meters (m) equals to 14364 feet (ft).\n4378 feet (ft) equals 1335 meters (m).\n4378 centimeters (cm) equals to 1723.6 inches (in).\n4378 inches (in) equals to 11120.1 centimeters (cm).\n\n#### Temperature conversion\n\n4378° Fahrenheit (°F) equals to 2414.4° Celsius (°C)\n4378° Celsius (°C) equals to 7912.4° Fahrenheit (°F)\n\n#### Power conversion\n\n4378 Horsepower (hp) equals to 3219.58 kilowatts (kW)\n4378 kilowatts (kW) equals to 5953.23 horsepower (hp)\n\n#### Time conversion\n\n(hours, minutes, seconds, days, weeks)\n4378 seconds equals to 1 hour, 12 minutes, 58 seconds\n4378 minutes equals to 3 days, 58 minutes\n\n### Codes and images of the number 4378\n\nNumber 4378 morse code: ....- ...-- --... ---..\nSign language for number 4378:", null, "", null, "", null, "", null, "Number 4378 in braille:", null, "Images of the number\nImage (1) of the numberImage (2) of the number", null, "", null, "More images, other sizes, codes and colors ...\n\n#### Number 4378 infographic", null, "### Gregorian, Hebrew, Islamic, Persian and Buddhist year (calendar)\n\nGregorian year 4378 is Buddhist year 4921.\nBuddhist year 4378 is Gregorian year 3835 .\nGregorian year 4378 is Islamic year 3871 or 3872.\nIslamic year 4378 is Gregorian year 4869 or 4870.\nGregorian year 4378 is Persian year 3756 or 3757.\nPersian year 4378 is Gregorian 4999 or 5000.\nGregorian year 4378 is Hebrew year 8138 or 8139.\nHebrew year 4378 is Gregorian year 618.\nThe Buddhist calendar is used in Sri Lanka, Cambodia, Laos, Thailand, and Burma. The Persian calendar is official in Iran and Afghanistan.\n\n## Share in social networks", null, "## Mathematics of no. 4378\n\n### Multiplications\n\n#### Multiplication table of 4378\n\n4378 multiplied by two equals 8756 (4378 x 2 = 8756).\n4378 multiplied by three equals 13134 (4378 x 3 = 13134).\n4378 multiplied by four equals 17512 (4378 x 4 = 17512).\n4378 multiplied by five equals 21890 (4378 x 5 = 21890).\n4378 multiplied by six equals 26268 (4378 x 6 = 26268).\n4378 multiplied by seven equals 30646 (4378 x 7 = 30646).\n4378 multiplied by eight equals 35024 (4378 x 8 = 35024).\n4378 multiplied by nine equals 39402 (4378 x 9 = 39402).\nshow multiplications by 6, 7, 8, 9 ...\n\n### Fractions: decimal fraction and common fraction\n\n#### Fraction table of 4378\n\nHalf of 4378 is 2189 (4378 / 2 = 2189).\nOne third of 4378 is 1459,3333 (4378 / 3 = 1459,3333 = 1459 1/3).\nOne quarter of 4378 is 1094,5 (4378 / 4 = 1094,5 = 1094 1/2).\nOne fifth of 4378 is 875,6 (4378 / 5 = 875,6 = 875 3/5).\nOne sixth of 4378 is 729,6667 (4378 / 6 = 729,6667 = 729 2/3).\nOne seventh of 4378 is 625,4286 (4378 / 7 = 625,4286 = 625 3/7).\nOne eighth of 4378 is 547,25 (4378 / 8 = 547,25 = 547 1/4).\nOne ninth of 4378 is 486,4444 (4378 / 9 = 486,4444 = 486 4/9).\nshow fractions by 6, 7, 8, 9 ...\n\n### Calculator\n\n 4378\n\n#### Is Prime?\n\nThe number 4378 is not a prime number. The closest prime numbers are 4373, 4391.\n4378th prime number in order is 41887.\n\n#### Factorization and factors (dividers)\n\nThe prime factors of 4378 are 2 * 11 * 199\nThe factors of 4378 are 1 , 2 , 11 , 22 , 199 , 398 , 2189 , 4378\nTotal factors 8.\nSum of factors 7200 (2822).\n\n#### Powers\n\nThe second power of 43782 is 19.166.884.\nThe third power of 43783 is 83.912.618.152.\n\n#### Roots\n\nThe square root √4378 is 66,166457.\nThe cube root of 34378 is 16,359069.\n\n#### Logarithms\n\nThe natural logarithm of No. ln 4378 = loge 4378 = 8,384347.\nThe logarithm to base 10 of No. log10 4378 = 3,641276.\nThe Napierian logarithm of No. log1/e 4378 = -8,384347.\n\n### Trigonometric functions\n\nThe cosine of 4378 is 0,189485.\nThe sine of 4378 is -0,981884.\nThe tangent of 4378 is -5,181865.\n\n### Properties of the number 4378\n\nMore math properties ...\n\n## Number 4378 in Computer Science\n\nCode typeCode value\nPIN 4378 It's recommendable to use 4378 as a password or PIN.\n4378 Number of bytes4.3KB\nUnix timeUnix time 4378 is equal to Thursday Jan. 1, 1970, 1:12:58 a.m. GMT\nIPv4, IPv6Number 4378 internet address in dotted format v4 0.0.17.26, v6 ::111a\n4378 Decimal = 1000100011010 Binary\n4378 Decimal = 20000011 Ternary\n4378 Decimal = 10432 Octal\n4378 Decimal = 111A Hexadecimal (0x111a hex)\n4378 BASE64NDM3OA==\n4378 MD550a074e6a8da4662ae0a29edde722179\n4378 SHA1403c6155cdc33e7cb519cd17c7d0a7c82317a1b5\n4378 SHA22464b453bd82a8f1c5df906492e980fa96d9edfbc687a808a2f765e213\n4378 SHA256e6785e32be8b07b04790aaf5585c202f6c0528e70004ce35b46650bd9f644ce3\n4378 SHA38473b31cdbe34ee59a29e38b846fff93bc104586e63680c287efd9fe03465b5ae886a11a5671182d60c82782d9f0104932\nMore SHA codes related to the number 4378 ...\n\nIf you know something interesting about the 4378 number that you did not find on this page, do not hesitate to write us here.\n\n## Numerology 4378\n\n### The meaning of the number 8 (eight), numerology 8\n\nCharacter frequency 8: 1\n\nThe number eight (8) is the sign of organization, perseverance and control of energy to produce material and spiritual achievements. It represents the power of realization, abundance in the spiritual and material world. Sometimes it denotes a tendency to sacrifice but also to be unscrupulous.\nMore about the meaning of the number 8 (eight), numerology 8 ...\n\n### The meaning of the number 7 (seven), numerology 7\n\nCharacter frequency 7: 1\n\nThe number 7 (seven) is the sign of the intellect, thought, psychic analysis, idealism and wisdom. This number first needs to gain self-confidence and to open his/her life and heart to experience trust and openness in the world. And then you can develop or balance the aspects of reflection, meditation, seeking knowledge and knowing.\nMore about the meaning of the number 7 (seven), numerology 7 ...\n\n### The meaning of the number 4 (four), numerology 4\n\nCharacter frequency 4: 1\n\nThe number four (4) came to establish stability and to follow the process in the world. It needs to apply a clear purpose to develop internal stability. It evokes a sense of duty and discipline. Number 4 personality speaks of solid construction. It teaches us to evolve in the tangible and material world, to develop reason and logic and our capacity for effort, accomplishment and work.\nMore about the meaning of the number 4 (four), numerology 4 ...\n\n### The meaning of the number 3 (three), numerology 3\n\nCharacter frequency 3: 1\n\nThe number three (3) came to share genuine expression and sensitivity with the world. People associated with this number need to connect with their deepest emotions. The number 3 is characterized by its pragmatism, it is utilitarian, sagacious, dynamic, creative, it has objectives and it fulfills them. He/she is also self-expressive in many ways and with good communication skills.\nMore about the meaning of the number 3 (three), numerology 3 ...\n\n## Interesting facts about the number 4378\n\n### Asteroids\n\n• (4378) Voigt is asteroid number 4378. It was discovered by W. Landgraf from La Silla Observatory on 5/14/1988.\n\n### Distances between cities\n\n• There is a 4,378 miles (7,045 km) direct distance between Abobo (Ivory Coast) and Nizhniy Novgorod (Russia).\n• There is a 2,721 miles (4,378 km) direct distance between Accra (Ghana) and Fortaleza (Brazil).\n• There is a 2,721 miles (4,378 km) direct distance between Antalya (Turkey) and Novosibirsk (Russia).\n• There is a 2,721 miles (4,378 km) direct distance between Baku (Azerbaijan) and Madurai (India).\n• More distances between cities ...\n• There is a 4,378 miles (7,045 km) direct distance between Bogor (Indonesia) and Shiraz (Iran).\n• There is a 4,378 miles (7,045 km) direct distance between Curitiba (Brazil) and Niamey (Niger).\n• There is a 4,378 miles (7,045 km) direct distance between Da Nang (Viet Nam) and Mogadishu (Somalia).\n• There is a 4,378 miles (7,045 km) direct distance between Dakar (Senegal) and Maputo (Mozambique).\n• There is a 4,378 miles (7,045 km) direct distance between Fès (Morocco) and Jacksonville (USA).\n• There is a 2,721 miles (4,378 km) direct distance between Gujrānwāla (Pakistan) and Minsk (Belarus).\n• There is a 2,721 miles (4,378 km) direct distance between Hefei (China) and Semarang (Indonesia).\n• There is a 2,721 miles (4,378 km) direct distance between Chennai (India) and Mecca (Saudi Arabia).\n• There is a 4,378 miles (7,045 km) direct distance between Kaduna (Nigeria) and Sūrat (India).\n• There is a 2,721 miles (4,378 km) direct distance between Karaj (Iran) and Nairobi (Kenya).\n• There is a 2,721 miles (4,378 km) direct distance between Luoyang (China) and Mysore (India).\n• There is a 2,721 miles (4,378 km) direct distance between Madrid (Spain) and Medina (Saudi Arabia).\n\n### Mathematics\n\n• 4378 is the number of partitions of 38 that do not contain 1 as a part.\n\n## Number 4,378 in other languages\n\nHow to say or write the number four thousand, three hundred and seventy-eight in Spanish, German, French and other languages. The character used as the thousands separator.\n Spanish: 🔊 (número 4.378) cuatro mil trescientos setenta y ocho German: 🔊 (Anzahl 4.378) viertausenddreihundertachtundsiebzig French: 🔊 (nombre 4 378) quatre mille trois cent soixante-dix-huit Portuguese: 🔊 (número 4 378) quatro mil, trezentos e setenta e oito Chinese: 🔊 (数 4 378) 四千三百七十八 Arabian: 🔊 (عدد 4,378) أربعة آلاف و ثلاثمائةثمانية و سبعون Czech: 🔊 (číslo 4 378) čtyři tisíce třista sedmdesát osm Korean: 🔊 (번호 4,378) 사천삼백칠십팔 Danish: 🔊 (nummer 4 378) firetusinde og trehundrede og otteoghalvfjerds Hebrew: (מספר 4,378) ארבע אלף שלש מאות שבעים ושמנה Dutch: 🔊 (nummer 4 378) vierduizenddriehonderdachtenzeventig Japanese: 🔊 (数 4,378) 四千三百七十八 Indonesian: 🔊 (jumlah 4.378) empat ribu tiga ratus tujuh puluh delapan Italian: 🔊 (numero 4 378) quattromilatrecentosettantotto Norwegian: 🔊 (nummer 4 378) fire tusen, tre hundre og sytti-åtte Polish: 🔊 (liczba 4 378) cztery tysiące trzysta siedemdziesiąt osiem Russian: 🔊 (номер 4 378) четыре тысячи триста семьдесят восемь Turkish: 🔊 (numara 4,378) dörtbinüçyüzyetmişsekiz Thai: 🔊 (จำนวน 4 378) สี่พันสามร้อยเจ็ดสิบแปด Ukrainian: 🔊 (номер 4 378) чотири тисячi триста сiмдесят вiсiм Vietnamese: 🔊 (con số 4.378) bốn nghìn ba trăm bảy mươi tám Other languages ...\n\n## News to email\n\nPrivacy Policy.\n\n## Comment\n\nIf you know something interesting about the number 4378 or any natural number (positive integer) please write us here or on facebook." ]	[ null, "https://numero.wiki/s/numeros-mayas/numero-maya-4378.png", null, "https://numero.wiki/s/senas/lenguaje-de-senas-numero-4.png", null, "https://numero.wiki/s/senas/lenguaje-de-senas-numero-3.png", null, "https://numero.wiki/s/senas/lenguaje-de-senas-numero-7.png", null, "https://numero.wiki/s/senas/lenguaje-de-senas-numero-8.png", null, "https://number.academy/img/braille-4378.svg", null, "https://numero.wiki/img/a-4378.jpg", null, "https://numero.wiki/img/b-4378.jpg", null, "https://number.academy/i/infographics/8/number-4378-infographic.png", null, "https://numero.wiki/s/share-desktop.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.63790655,"math_prob":0.93135804,"size":9289,"snap":"2022-27-2022-33","text_gpt3_token_len":3331,"char_repetition_ratio":0.15939687,"word_repetition_ratio":0.087649405,"special_character_ratio":0.38647863,"punctuation_ratio":0.15619789,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.97027653,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],"im_url_duplicate_count":[null,1,null,null,null,null,null,null,null,null,null,1,null,1,null,1,null,1,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-07-01T07:04:22Z\",\"WARC-Record-ID\":\"<urn:uuid:b7c7ad17-126e-4a3d-bb5e-b12b9fd4002e>\",\"Content-Length\":\"45477\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:a87ed8c6-5d86-482c-8653-dcfb043dedd9>\",\"WARC-Concurrent-To\":\"<urn:uuid:f85a62f2-2359-4dcb-b2c6-522650eb02d9>\",\"WARC-IP-Address\":\"162.0.227.212\",\"WARC-Target-URI\":\"https://number.academy/4378\",\"WARC-Payload-Digest\":\"sha1:H2UV6ZDWYVNEKZEYAGBUZRRIB2EJNOI5\",\"WARC-Block-Digest\":\"sha1:TGGJ5EKBRQQGRGRPU3YIVTYNA5LCBVR5\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-27/CC-MAIN-2022-27_segments_1656103922377.50_warc_CC-MAIN-20220701064920-20220701094920-00312.warc.gz\"}"}
https://mathematica.stackexchange.com/questions/92269/distributing-function-arguments-with-function-compositions-how-to-compute-f	[ "# Distributing function arguments with function compositions. How to compute $(f + g^2)(x) = f(x) + g(x)^2$?\n\nSuppose I have two functions f and g. To compute $f + g$ evaluated at a point $x$, I know that one can use Through to compute, Through[(f+g)[x]] to get f[x] + g[x].\n\nQuestion: Suppose I want to compute $f + g^2$, evaluated at point $x$. Thus if it is evaluated at point x, the correct answer would be f[x] + Power[g[x],2]. I want also an analogous result for the \"minus\" case, as in $f - g^2$.\n\nCertainly, writing Power[g,2] instead of g in the above will not work since Mathematica will compute Through[( f + Power[g,2] )[x] ] as f[x] + Power[g,2][x].\n\nI'd also tried to use Composition along with pure functions. So I consider Through[ (f + (Power[#,2]&)@* g)[x] ] but this results in only the first function being correctly distributed, and so the result is, f[x] (-(#1^2 &@g))[x], which is still incorrect.\n\nEdit (on the issue of \"minus\"): The above code for the case of \"plus\" (i.e. $(f+g)(x) = f(x) + g(x)$) will indeed work. That is, when one uses Through[ (f + (Power[#,2]&)@ g)[x] ], it will indeed result in f[x] + g[x]^2 as expected.\n\nHowever, an issue arises when we consider \"minus\" (i.e. $(f-g)(x) = f(x) - g(x)$) will not generate the intuitive result; that is, writing Through[ (f - (Power[#, 2] &)@g ) [x] ] will generate the result f[x] + (-(#1^2 &@g))[x], which is (at least, mathematically) unexpected. However, by \"tucking in\" the minus sign, as Through[ (f + (-Power[#, 2] &)@g ) [x] ], we get back the desired result f[x] - g[x]^2.\n\n• Through[(f + Composition[Power[#, 2] &, g])[x]] worked for me. I have the feeling that you're not matching parentheses correctly, but since I don't have a version that has the Composition short notation, I can't quite verify that. Aug 24 '15 at 22:47\n• @march Thanks. Actually writing out Composition explicitly also works for me too. I don't quite see the matching parentheses issue in my original code but I'm perfectly happy just typing out the full word! Aug 24 '15 at 22:50\n• I just checked on MMA Online, and it seems like Through[ (f + (Power[#,2]&)@ g)[x] ] works, too, so I'm not sure what's going on. I like the question, though; it just seems that you have a syntax error in your notebook that didn't carry over to your question, maybe? Aug 24 '15 at 22:51\n• @march Ah... I think I see the issue. In the actual application I had in mind, I'd used \"minus\" (i.e. $f - g^2$) instead of writing \"plus\" (i.e. $f + g^2$) as in the toy example I gave. If I (with \"plus\") write Through[ (f + ( Power[#, 2] &)@g ) [x] ] , then yes, I do get the desired result of f[x] + g[x]^2. But I switch to \"minus\", and write Through[ (f - ( ( Power[#, 2] &)@g ) ) [x] ] Aug 24 '15 at 22:53\n• f[x] + (-(#1^2 &@g))[x] is the result if I used \"minus\" Aug 24 '15 at 22:54\n\nIt is sometimes beneficial to first work with functions (in mathematical sense) as symbols and apply to them some pointwise operations. Then, just at the end, convert resulting expression to pure function (in Mathematica sense) and pass some arguments.\n\nThis task can be automated using something like following purify function:\n\nClearAll[purify]\nDefault[purify, 2] =\nsym : Except[HoldPattern@Symbol[___], _Symbol] /;\nNot@MemberQ[Attributes[sym], Constant];\nDefault[purify, 3] = {-1};\npurify[\nexpr_, Shortest[patt_., 1], Shortest[levelspec_., 2],\nopts:OptionsPattern[Replace]\n] :=\nEvaluate@Replace[Unevaluated[expr], func:patt :> func[##], levelspec, opts]&\n\n\nFor the problems from question:\n\npurify[f + g^2][x]\n( f[x] + g[x]^2 )\n\npurify[f - g][x]\n( f[x] - g[x] )\n\n\nMore complicated example:\n\ntestExpr = (f + g) (f - 2 g + 5 h^2) // Expand\npurify[%][x, y]\n( f^2 - f g - 2 g^2 + 5 f h^2 + 5 g h^2 )\n( f[x, y]^2 - f[x, y] g[x, y] - 2 g[x, y]^2 + 5 f[x, y] h[x, y]^2 + 5 g[x, y] h[x, y]^2 )\n\n\nConsider only specific symbols as \"functions\":\n\npurify[testExpr, f \| h][x, y]\n( -2 g^2 - g f[x, y] + f[x, y]^2 + 5 g h[x, y]^2 + 5 f[x, y] h[x, y]^2 )\n\n\nDefault behavior for user functions mixed with built-ins:\n\npurify[π + f + Sin][x]\n( π + f[x] + Sin[x] )\n\n\nConsider more complicated expressions as functions:\n\npurify[f + g[a], f \| _g, All][x]\n( f[x] + g[a][x] )\n\n\npurify[f + g[π + f][a], f, Heads -> True][x]\n( f[x] + g[π + f[x]][a] )\n\n\nHeld expressions:\n\npurify[Hold[f + f]][x]\n( Hold[f[x] + f[x]] )\n\n\n## Code Explanation\n\nPer request of @Wjx, here's small explanation of posted code.\n\npurify function replaces, in given expression, sub-expressions (let's call them func), matching given pattern, with func[##], where ## represents arbitrary sequence of arguments. This replacement is evaluated inside a Function, since Function has HoldAll attribute we need to use Evaluate for replacement to be evaluated.\n\npurified = purify[x + f, f]\n( x + f[##1] & )\n\n\nCalling this function, with any arguments, results in given expression with arguments passed to selected sub-expressions.\n\npurified[x, y, z]\n( x + f[x, y, z] )\n\n\nSince purify replaces sub-expressions, its functionality seemed, to me, closest to Replace built-in function, on which purify is based, so I decided it should use similar interface.\n\nAs first argument purify and Replace accept arbitrary expression in which replacements are performed.\n\nAs second argument Replace accepts rules, but in purify right hand side of replacement is fixed, so instead of replacement rules purify accepts only a pattern (left hand side of replacement rule).\n\nSecond argument of purify is Optional, with assigned Default value being a pattern matching all symbols that don't represent constants. Except[HoldPattern@Symbol[___], _Symbol] pattern is used instead of simple _Symbol to make sure that Symbol[\"symName\"], that can appear in held expressions, will not be matched. Not@MemberQ[Attributes[sym], Constant] Condition tests that symbol does not represent a Constant. Passing Symbol[\"symName\"] to Attributes function would lead to an error.\n\nI guess that using sym_Symbol /; AtomQ@Unevaluated[sym] is more popular to prevent matching of Symbol[...] expressions, but I prefer to handle it in pure pattern matcher, without calling evaluator until it's really necessary.\n\nAs third argument both functions accept standard level specification. This argument is also optional in purify, with default being {-1} which means \"leaves\" of expression tree, since that's only level in which symbols can be found.\n\nWith {-1} level specification Except[HoldPattern@Symbol[___], _Symbol] pattern is excessive, since Symbol[...] expressions are not leaves, but I wanted default values to work, in some sense, independent of each other, so if level specification would be changed (for example to All, which would be another reasonable default) default pattern would still work.\n\nBoth functions accept also Heads option that specifies whether heads of expressions should be included in replacements.\n\nSince I wanted any rule, given after first argument, to be interpreted as option even when positional optional arguments are not given, their patterns are wrapped with Shortest with appropriate priorities. Similar effect could be achieved by restricting possible values matched by patt and levelspec arguments.\n\n• Great answer! Thanks! Aug 25 '15 at 20:18\n• Wonderful, it is indeed neatly designed! +1:)\n– Wjx\nOct 13 '16 at 13:38\n\nI'm probably missing an important point, but what is wrong with\n\n(f[#] + g[#]^2)&[x]\n\nf[x]+g[x]^2\n\n• You're probably not missing anything. Simplest is best. Although it's possible there's a good reason why the OP wants to use Through. Aug 25 '15 at 4:04\n\nYou can achieve this defining an UpValue for g:\n\ng/:Power[g,2]:=g[#]^2&\n\n\nOr more generally:\n\ng/:Power[g,n_Integer]:=g[#]^n&\n\n\nUsing Through now works as wanted:\n\nThrough[(f + g^2)[x]]\n(Out=f[x]+g[x]^2)\n\n• Did you see the comment the OP made about attaching a minus sign to g^2? It would be good if you could generalize to that case, as well. Otherwise, I like this answer (+1). Aug 24 '15 at 22:59\n• Thanks! However, while this is great for a one off computation, I don't think this necessarily a useful result when I need to do this repeatedly. In particular, if one has two lists of functions {f1, f2, f3} and {g1, g2, g3} (and especially if the lists are long), and I want a result say {f1 - g1^2, f2 - g2^2, f3 - g3^2}, I'll need to use UpValue for all of these functions. Aug 24 '15 at 22:59\n• @march I actually happen to think both solutions are good, but yours is perhaps most useful if one wants to apply this repeatedly. I really did not anticipate that whether one tucks in the minus sign or not makes a difference to Through. But I agree, for the question asked (I didn't specify the repeatedly aspect), @glance has a good answer. Aug 24 '15 at 23:02\n• @user32416. Check out the difference between (-g[#]^2 &) // FullForm and -(g[#]^2 &) // FullForm, and you'll see why it matters. Aug 24 '15 at 23:20\n• @user32416. As for extending this answer, if you use functions that have Heads g, g, etc., then it is easily extended so that you don't have to define each one individually: g /: Power[g[a_], n_Integer] := g[a][#]^n&. Then the list of f[i] + g[i]^2's would all work. Aug 25 '15 at 3:21\n\nThe original version works just fine:\n\nThrough[(f + Composition[Power[#,2]&, g])[x]]\n\n\nor, for MMA ver. 10 and above,\n\nThrough[(f + (Power[#,2]&) @ g)[x]]\n\n\nresult in\n\n(* f[x] + g[x]^2 )\n\n\nAlternatively, you could do, from the beginning,\n\nThrough[(f + (g[#]^2 &))[x]]\n\n\nwhich is perhaps a little easier to parse since it doesn't use Composition.\n\nNow, this should work for more general functions. You just need to make sure that what gets attached to the [x] as a Head is something that can actually act as if it's the name of a function that will use x as an input. So, for instance, if you want to make the expression\n\nf[x] - g[x]^2\n\n\nUsing Through, and you try something like\n\nThrough[(f - (g[#]^2 &))[x]]\n\n\nthe result is somewhat unexpected:\n\n( f[x] + (-(g[#1]^2 &))[x] )\n\n\nThe reason this doesn't work is that f - (g[#]^2 &) is actually parsed as\n\nf - (g[#]^2 &) // FullForm\n( Plus[f, Times[-1, Function[Power[g[Slot], 2]]]] )\n\n\nMore simply, we have\n\nf + Times[-1, Function[g[#]^2]]]\n\n\nand since Times[__][x] doesn't evaluate as if x is the input of a function, this just returns\n\n(-(g[#1]^2 &))[x]\n\n\nor\n\nTimes[-1, Function[g[#]^2]]][x]\n\n\nWhat we want in the place of this is a pure function, i.e. something which has Function as a Head. The fix is straight-forward: attach the minus sign inside the function. So:\n\nThrough[(f + (-g[#]^2 &))[x]]\n( f[x] - g[x]^2 )\n\n\nMaybe I misunderstood this problem? My solution is much more simpler(and readable, cause I'm simply too stupid to understand @jkuczm's code. I'll appreciate that if you may kindly add some explanation?) than @jkuczm's solution, but they generate the same result........\n\nCode first:\n\np[e_] := If[AtomQ@e, If[NumericQ@e, e, e[##]], p /@ e]\nf[e_] := Evaluate[p[e]] &\n\n\nThe basic idea is quite simple:\n\n1. Every expression is a tree, the expression at the bottom level, if is not a number, shall be replaced to something like f->f[##].\n2. You should let it be a Function, not something with f[##] without &\n\np scan the expression tree and generate something like f[##] and f simply add an & to the incomplete expression generated.\n\nI've tested all the expression in @jkuczm's answer, they all generate the same result.\n\nWill this help?\n\n# Edit 1\n\nThe greatest advantage of this code is that it's quite expandable as well, you can even specify some constant element that should not be considered as functions. For example, you have something like f g while you want to consider f as some sort of constant or so. You can use the following code:\n\np[e_, ue_] :=\nIf[AtomQ@e, If[! FreeQ[ue, e] \|\| NumericQ[e], e, e[##]], p[#,ue]& /@ e];\nf[e_, ue_: {}] := Evaluate[p[e, ue]] &;\n\n\nThis code will still do the previous job, of course. But in this code, you can manually set ue in a list form. For Example, in this function ff+g k,you may want ff to be something like a constant. Then try this code:\n\nf[ff + g k, {ff}][x]\n\n(ff+g[x] k[x]*)\n\n\nGreat!\n\nAlso, sometimes you would like to keep some function in f[g][x] form. That will be okay--- Add an additional If before it will do the job:\n\np[e_, ue_,lf_] :=\nIf[!FreeQ[lf,Head@e],e[##],If[AtomQ@e, If[! FreeQ[ue, e] \|\| NumericQ[e], e, e[##]], p[#,ue,lf]& /@ e]];\nf[e_, ue_: {},lf_:{}] := Evaluate[p[e, ue,lf]] &;\n\n\nor maybe in f[g[x]][x]form\n\np[e_, ue_,lf_] :=\nIf[!FreeQ[lf,Head@e],(p[#,ue,lf]& /@ e)[##],If[AtomQ@e, If[! FreeQ[ue, e] \|\| NumericQ[e], e, e[##]], p[#,ue,lf]& /@ e]];\nf[e_, ue_: {},lf_:{}] := Evaluate[p[e, ue,lf]] &;\n\n\nThe greatest advantage of this form is that the matching will go in a tree form, which enables you to do almost everything at every level and every pary of the expression." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.7887928,"math_prob":0.95845824,"size":5027,"snap":"2021-43-2021-49","text_gpt3_token_len":1351,"char_repetition_ratio":0.12602031,"word_repetition_ratio":0.009975063,"special_character_ratio":0.28108215,"punctuation_ratio":0.13897596,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9931751,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-11-27T05:11:39Z\",\"WARC-Record-ID\":\"<urn:uuid:b058bb93-6e73-418b-8264-c986800d52d6>\",\"Content-Length\":\"200047\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:1a977807-dc0d-44b1-a9cd-3b304c2dd04e>\",\"WARC-Concurrent-To\":\"<urn:uuid:71bbd9ae-72d7-41cd-acea-576c4bdf6366>\",\"WARC-IP-Address\":\"151.101.193.69\",\"WARC-Target-URI\":\"https://mathematica.stackexchange.com/questions/92269/distributing-function-arguments-with-function-compositions-how-to-compute-f\",\"WARC-Payload-Digest\":\"sha1:FG6NN7K3KFPXTXQX6QZRPES5B6RF74ZL\",\"WARC-Block-Digest\":\"sha1:MZ7PE32R4KXEMDSZSQAXXMMIDWMUK7YG\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-49/CC-MAIN-2021-49_segments_1637964358118.13_warc_CC-MAIN-20211127043716-20211127073716-00020.warc.gz\"}"}
https://community.esri.com/t5/geoprocessing-questions/densify-y-value-seems-incorrect/td-p/380159	[ "# Densify Y-value seems incorrect?\n\n599\n0\n07-09-2013 01:12 PM", null, "New Contributor\nHello, this is my first time posting on forums.arcgis.com so please forgive me if I haven't formatted my question correctly or followed correct submission protocol.\n\nI am developing a desktop GIS product in C# using the ArcGis Runtime for WPF version 10.1.1\n\nI have written a function that uses Densify to insert a point every 1/n-th subsegment of a two-point segment (e.g. if I had a segment between (100,1) and (200,5) this function could insert points at (125,2), (150,3), and (175,4) (where n == 0.25).\n\nWhen I run this function, I get almost what I expect. The number of points and their X-values seem correct, but the Y-values of the inserted points seem drastically wrong. Here is the function (the parameter \"proportionFromStart\" is analogous to n in my above example, all Geometry is projected in ESRI.ArcGIS.Client.Projection.WebMercator)\n\n``` private MapPoint GetPointAlongSingleSegment(object polylineSegment, double proportionFromStart)\n{\nESRI.ArcGIS.Client.Geometry.Polyline pL = polylineSegment as ESRI.ArcGIS.Client.Geometry.Polyline;\n//control for extreme vaules\nif (pL.Paths.Count != 1 \|\| pL.Paths.Count != 2)\n{\nLog.Error(\"GetPointAlongSingleSegment called on a polyline that is not a single (two-point) segment\");\nreturn null;\n}\ndouble fullLength = ESRI.ArcGIS.Client.Geometry.Geodesic.Length(pL);\nESRI.ArcGIS.Client.Geometry.Geometry densifiedGeometry =\nESRI.ArcGIS.Client.Geometry.Geodesic.Densify(pL, (fullLength * proportionFromStart));\n///////...placed breakpoint here to inspect objects\n}\n```\n\nAnd here is the output when I inspect the original line (pL) and the densified line when proportionFromStart == 0.5:\n\npL.Paths\nCount = 2\n: {Point[X=-8932651.10126309, Y=4313679.64989647]}\n: {Point[X=-8932680.55891339, Y=4313877.57298654]}\n\n(densifiedGeometry as ESRI.ArcGIS.Client.Geometry.Polyline).Paths\nCount = 3\n: {Point[X=-8932651.10126309, Y=4313679.64989647]}\n: {Point[X=-8932666.30560504, Y=-11.7697564697751]}\n: {Point[X=-8932680.55891339, Y=4313877.57298654]}\n\nSo, the expected number of points were added (in this case, just the one geodesic midpoint), and the X-values of these points all look correct to me, but why is the Y-value of the added point (: {Point...) so strange? (The single point added by Densify has a Y-value of about -11.77, whereas the points on either side have much more common (for my data) \"in-the-millions\" values, roughly 4,313,679.65 and 4,313,877.57.\n\nI have tried this for many values of proportionFromStart between 0 and 1. In all cases, all inserted points have what appears to be correct X-values, but the Y-values are all very small and negative. The inserted Y-values are trending in the proper direction and seem evenly spaced around each other, but are orders-of-magnitude smaller than expected and have the wrong sign.\n\nAm I doing something wrong in the way I'm calling the Densify function? How should I interpret the inserted Y-values?\n\nIs there an easier way to achieve such point insertion within the WPF ArcGIS runtime? (It seems there may be options in other ESRI libraries, but I am confined to the ArcGIS Runtime for WPF.)\n\nThanks very much,\n\nThomas\n\nUPDATE:\n\nI discovered that, using almost all the same parameters, I can get the expected result if I call the Densify instance method of the Geometry service, so, this behavior seems likely tied to the static call. Here is the code that I'm using as a workaround (/some comments for brevity/):\n\n``` DensifyParameters densifyParameters = new DensifyParameters()\n{\nLengthUnit = LinearUnit.Meter,\nGeodesic = true,\nMaxSegmentLength = LengthOfGeometryInMeters(pL) * proportionFromStart\n};\nGraphic g = new Graphic();\ng.Geometry = pL;\nList<Graphic> gL = new List<Graphic>();\nESRI.ArcGIS.Client.Geometry.Geometry asyncDensGeo = null;\nasyncDensGeo = /our app's local geometry service/.Densify(gL, densifyParameters).Geometry;\n```\n\nUpon inspection, asyncDensGeo looks very much like densifiedGeometry (above) but with sensible Y-values. I don't have an apples-to-apples output available to paste, but, what I observed is that the X-values still look correct (although, they were, in fact, very slightly different (+/- 0.5 meters) from the static Densify), and the Y-values look equally correct, ascending in expected increments along the segment.\n\nThe only parameter that changed significantly was the maximum length parameter. To get expected results in the instance-Densify method, I had to use a fraction of the length-in-meters of the polyline. I tried using this same value in the static-Densify call, but got MANY too many points added, and, all of the injected points had strangely small, negative Y-values, just like before.\n\nSo, for now, we are using the service instance Densify method as a workaround, and avoiding the static\nESRI.ArcGIS.Client.Geometry.Geodesic.Densify\nuntil we can understand how to prevent the strange Y-values from appearing\nTags (3)\n0 Replies", null, "" ]	[ null, "https://community.esri.com/legacyfs/online/esri/avatars/a1028_27.png", null, "https://community.esri.com/skins/images/B41F29CF7E9150902B8A2F2CBD975936/responsive_peak/images/icon_anonymous_message.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.85990757,"math_prob":0.84019357,"size":4873,"snap":"2023-14-2023-23","text_gpt3_token_len":1241,"char_repetition_ratio":0.12610392,"word_repetition_ratio":0.0,"special_character_ratio":0.2632875,"punctuation_ratio":0.1846473,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.98122054,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-06-01T02:36:18Z\",\"WARC-Record-ID\":\"<urn:uuid:df0967d7-b724-4553-a24c-60c4757e7e23>\",\"Content-Length\":\"153850\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:6c769a14-2f68-4cc3-b3c1-970a3afb275f>\",\"WARC-Concurrent-To\":\"<urn:uuid:3d290de8-7884-494b-a6a0-7e8c2598a1e5>\",\"WARC-IP-Address\":\"13.32.151.62\",\"WARC-Target-URI\":\"https://community.esri.com/t5/geoprocessing-questions/densify-y-value-seems-incorrect/td-p/380159\",\"WARC-Payload-Digest\":\"sha1:ZFDLLKCGFHBNUMM3SXSUPVYFRJXOL2IQ\",\"WARC-Block-Digest\":\"sha1:E6BLOGC4AWZJTE2BUV6I2CWLHZV2S7QV\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-23/CC-MAIN-2023-23_segments_1685224647525.11_warc_CC-MAIN-20230601010402-20230601040402-00362.warc.gz\"}"}
https://www.educator.com/mathematics/algebra-1/eaton/linear-functions.php	[ "", null, "", null, "Dr. Carleen Eaton\n\nLinear Functions\n\nSlide Duration:\n\nSection 1: Basic Concepts\nVariables and Expressions\n\n11m 22s\n\nIntro\n0:00\nHistory of Algebra\n0:12\nOrigin of Word\n0:21\nReal World Problems\n0:35\nDefinitions\n0:58\nVariable\n1:03\nAlgebraic Expression\n1:37\nOperations\n2:02\nExample 1: Words into Expressions\n3:02\nExample 2: Words into Expressions\n5:20\nExample 3: Words into Expressions\n6:45\nExample 4: Words into Expressions\n9:46\nOrder of Operations\n\n15m 59s\n\nIntro\n0:00\nExample\n0:17\nDefinition\n0:57\nProcedure to Evaluate an Arithmetic Expression\n1:08\nGrouping Symbols (Parentheses, Brackets, Braces)\n1:19\nPowers\n1:42\nMultiply/Divide Left to Right\n1:57\n2:21\nExample: Fraction Bar\n2:49\nExample 1: Evaluate Arithmetic Expression\n3:45\nExample 2: Evaluate Arithmetic Expression\n7:28\nExample 3: Evaluate Arithmetic Expression\n10:11\nExample 4: Evaluate with Variables\n13:12\nDistributive Property\n\n9m 50s\n\nIntro\n0:00\nDistributive Property Statements\n0:23\nMoving Forward\n0:49\nRule for Subtraction\n1:14\nReverse Order\n1:40\nSeveral Numbers\n2:17\nExample 1: Evaluate Using Distributive Property\n2:56\nExample 2: Multiply Using Distributive Property\n4:10\nExample 3: Simplify Using Distributive Property\n4:59\nExample 4: Simplify Using Distributive Property\n7:03\nReal Number System\n\n17m 58s\n\nIntro\n0:00\nReal Number System\n0:31\nNatural Numbers\n0:39\nWhole Numbers\n1:11\nIntegers\n1:23\nRational Numbers\n1:52\nCannot Divide by Zero\n2:18\nDecimals\n2:27\nExample: Terminating or Repeating\n2:39\nReal Number System, Cont.\n3:37\nSquare Roots\n3:42\nExamples\n3:54\nIrrational Numbers\n4:36\nExamples\n5:02\nPerfect Square\n5:54\nReal Number System, Cont.\n6:49\nExample: Number Line\n7:02\nExample 1: Which Set of Numbers\n7:54\nExample 2: Graph on Number Line\n10:04\nExample 3: Approximate Irrational Number\n12:47\nExample 4: Order Largest to Smallest\n13:57\nFunctions and Graphs\n\n34m 39s\n\nIntro\n0:00\nFunctions\n0:15\nExample: Function\n0:29\nExample: Not Functions (Relations)\n1:15\nGraphs\n4:44\nVisual Display\n4:53\nExample: X and Y\n5:03\nCoordinate Pairs\n5:53\nDiscrete Function\n8:19\nContinuous Function\n8:55\nVertical Line Test\n10:55\nTest if Function\n11:12\nExample: Pass Through Points\n11:43\nDomain and Range\n14:13\nExample\n14:43\nExample 1: Function Given by Table\n16:24\nExample 2: Cost of Gas\n18:46\nExample 3: Cost of Gas\n23:15\nExample 4: Cost of Mail\n29:07\nSection 2: Solving Linear Equations\nFrom Sentences to Equations\n\n16m 5s\n\nIntro\n0:00\nReal World Applications\n0:18\nStrategy\n0:26\nUsing Variables\n0:32\nTranslate Phrases\n0:48\nIdentity Equality Words\n1:07\nExample 1: Write Equation\n1:32\nExample 2: Write Equation\n4:14\nExample 3: Sisters' Ages\n8:26\nExample 4: Surface Area of Cylinder\n12:52\n\n15m 24s\n\nIntro\n0:00\nTechniques\n0:21\n0:24\nExample\n0:37\nSubtraction Principle\n1:44\nExample\n1:48\nStrategy\n2:33\nIsolate the Variable\n2:41\nExample\n2:55\nExample 1: Solve Equation\n3:39\nExample 2: Solve Equation\n5:38\nExample 3: Word Problem\n7:38\nExample 4: Word Problem\n11:14\nMultiplication and Division Techniques\n\n15m 41s\n\nIntro\n0:00\nIsolating the Variable\n0:08\nTechniques\n0:34\nMultiplication Principle\n0:41\nExample\n0:57\nDivision Principle\n2:32\nExample\n2:47\nStrategy\n3:12\nExample\n3:30\nOpposite Operation\n3:53\nExample 1: Solve Equation\n5:07\nExample 2: Solve Equation\n6:50\nExample 3: Solve Equation\n10:05\nExample 4: Word Problem\n12:07\nTechniques for Multistep Equations\n\n14m 31s\n\nIntro\n0:00\nWhat are Multistep Equations\n0:06\n0:31\nStrategy\n0:43\nIdentify Last Operation\n0:47\nExample 1: Solve Equation\n1:51\nExample 2: Solve Equation\n5:27\nExample 3: Find Numbers\n7:39\nExample 4: Solve Equation\n11:27\nWhen the Variable is on Both Sides of the Equation\n\n20m 17s\n\nIntro\n0:00\nSolving More Complicated Equations\n0:28\nDistributive Property\n0:41\nReview of Distributive Property\n0:55\nFactoring\n1:28\nSubtracting\n1:50\n2:08\nPossible Outcomes\n2:45\nExactly One Solution\n2:52\nNo Solution\n3:08\nTrue for All Real Numbers\n4:45\nIdentities\n5:01\nExample 1: Solve Equation\n6:03\nExample 2: Solve Equation\n9:08\nExample 3: Solve Equation\n14:06\nExample 4: Solve Equation\n17:28\nRatios and Proportion\n\n16m 5s\n\nIntro\n0:00\nDefinitions\n0:07\nRatio\n0:10\nDifferent Representations\n0:14\nProportion\n0:33\nExample\n0:40\nCross Product\n1:08\nCross Multiplication\n1:32\nExample\n2:13\nRates\n3:33\nRates in Real Life\n3:46\nExample 1: Form a Proportion\n4:43\nExample 2: Cross Multiply\n7:15\nExample 3: How Long to Drive\n9:00\nExample 4: Cross Products\n12:13\nApplications of Percents\n\n13m 46s\n\nIntro\n0:00\nDefinitions\n0:15\nPercent of Increase\n0:27\nPercent of Decrease\n0:34\nExamples\n0:42\nSales Tax\n1:48\nDiscount\n2:44\nExample 1: Temperature Change\n3:12\nExample 2: Sales Tax\n5:44\nExample 3: Clothing Discount\n7:04\nExample 4: Sales and Discount\n9:15\nMore Than One Variable\n\n20m 38s\n\nIntro\n0:00\nMore Than One Variable\n0:21\nReal Life Examples\n0:30\nStrategy\n1:08\nPossible Techniques\n1:17\nTypical Application\n1:43\nSolving for a Different Variable\n1:59\nExample 1: Solve for Y\n5:06\nExample 2: Solve for Q\n7:38\nExample 3: Solve for H\n12:56\nExample 4: Solve for X\n16:04\nSection 3: Functions\nRelations\n\n16m 58s\n\nIntro\n0:00\nDefinition\n0:04\nRelation\n0:06\nTable\n0:18\nSet of Ordered Pairs\n1:01\nGraph\n1:38\nDomain and Range\n2:40\nExample: Relation\n2:51\n3:48\nInverse of a Relation\n4:42\nExample\n4:59\nExample 1: Relation as Table/Graph\n6:15\nExample 2: Domain and Range\n8:41\nExample 3: Table, Graph, Domain, Range\n10:36\nExample 4: Inverse of a Relation\n13:36\nFunctions\n\n19m 27s\n\nIntro\n0:00\nDefinition\n0:14\nReview of Relations\n0:27\nViolation of Function\n1:43\nExample: Function\n2:00\nVertical Line Test\n3:18\nExample\n3:41\nFunction Notation\n6:15\nUsing f(x)\n6:26\nExample: Value Assigned\n7:12\nExample 1: Relation a Function\n8:10\nExample 2: Relation a Function\n9:39\nExample 3: Using f(x) Notation\n12:20\nExample 4: g(x) Notation\n15:01\nLinear Functions\n\n20m 15s\n\nIntro\n0:00\nDefinition\n0:07\nStandard Form\n0:18\nExample\n0:52\nGraph and Intercepts\n2:39\nExample: Graph\n2:48\nX-Intercept\n2:56\nY-Intercept\n3:35\nGraphing Linear Equations\n4:29\nExample\n4:47\nLinear Functions\n7:51\nExample\n8:15\nExample 1: Linear\n10:16\nExample 2: Linear Equation\n12:58\nExample 3: Intercepts\n14:23\nExample 4: Equation from Intercepts\n16:47\nSection 4: Linear Functions and Their Graphs\nSlope and Rate of Change\n\n19m 46s\n\nIntro\n0:00\nRate of Change\n0:06\nOther Words\n0:14\nExample\n0:24\nSlope\n2:12\nTwo Points\n2:39\nSteepness of a Line\n2:57\nPossible Slopes\n4:29\nPositive Slope\n5:02\nNegative Slope\n5:29\nZero Slope (Horizontal Line)\n6:23\nUndefined Slope (Vertical Line)\n7:08\nExample 1: Rate of Change of Table\n8:19\nExample 2: Slope Through Points\n10:52\nExample 3: Increasing/Decreasing\n13:06\nExample 4: Slope Through Points\n16:02\nDirect Variation\n\n13m 54s\n\nIntro\n0:00\nDefinitions\n0:10\nConstant of Variation k\n0:21\nExample: Gas and Miles Driven\n0:59\nGraph\n1:50\nk is Slope\n2:04\nExamples\n2:27\nApplications\n2:47\nWrite, Graph, Solve\n2:58\nExample 1: Constant of Variation\n3:11\nExample 2: Graph Direct Variation\n4:59\nExample 3: Direct Variation\n6:50\nExample 4: Distance Car Travels\n9:18\nSlope Intercept Form of an Equation\n\n12m 6s\n\nIntro\n0:00\nSlope Intercept Form\n0:12\nm (Slope) and b (Y Intercept)\n0:31\nExample\n1:12\nExample 1: Slope Intercept Form Equation\n2:39\nExample 2: Graph the Equation\n5:11\nExample 3: Slope Intercept Form Equation\n6:51\nExample 4: Slope Intercept Form Equation\n8:50\nPoint Slope Form of an Equation\n\n9m 7s\n\nIntro\n0:00\nPoint Slope Form\n0:07\nManipulating to Other Forms\n0:35\nm (Slope), x1 y1 (Point)\n0:47\nExample 1: Point Slope Form Equation\n1:03\nExample 2: Point Slope Form Equation\n2:50\nExample 3: Point Slope Form Equation\n4:18\nExample 4: Point Slope Form Equation\n6:50\nParallel Lines and Perpendicular Lines\n\n18m 2s\n\nIntro\n0:00\nParallel Lines\n0:08\nExample\n0:15\nVertical Lines\n0:40\nPerpendicular Lines\n1:19\nNegative Reciprocal\n1:31\nExample\n2:05\nExample 1: Slope Intercept Form\n3:25\nExample 2: Parallel or Perpendicular\n6:15\nExample 3: Slope Intercept Form\n9:27\nExample 4: Slope Intercept Form\n12:35\nSection 5: Systems of Equations\nGraphing Systems of Equations\n\n22m 45s\n\nIntro\n0:00\nSystems of Equations\n0:10\nDefinition\n0:15\nExample\n0:31\nSolution\n0:47\nSolving by Graphing\n1:23\nPoints of Intersection\n1:36\nExample\n1:56\nNumber of Solutions\n3:09\nIndependent\n3:20\nDependent\n3:50\nInconsistent\n4:46\nExample 1: Solve by Graphing\n5:45\nExample 2: Solve by Graphing\n9:50\nExample 3: Solve by Graphing\n14:17\nExample 4: Solve by Graphing\n18:03\nSolving by Substituting\n\n22m 41s\n\nIntro\n0:00\nSubstitution\n0:09\nExample\n0:45\nNumber of Solutions\n2:47\nInfinite Solutions\n3:11\nNo Solutions\n4:28\nExample 1: Solve by Substitution\n5:44\nExample 2: Solve by Substitution\n10:01\nExample 3: Solve by Substitution\n15:17\nExample 4: Solve by Substitution\n19:41\n\n16m 13s\n\nIntro\n0:00\nFundamental Principle\n0:10\nExample\n0:23\nExample 1: Solve the System\n1:52\nExample 2: Solve the System\n5:53\nExample 3: Solve the System\n10:15\nExample 4: Solve the System\n14:08\nSection 6: Inequalities\n\n11m 34s\n\nIntro\n0:00\nFundamental Principle\n0:09\nExample\n0:36\nSolutions of Inequalities\n1:51\nInequality\n1:59\nSet Builder Notation\n2:02\nGraph on a Number Line\n2:08\nExamples\n2:18\nExample 1: Solve the Inequality\n4:59\nExample 2: Solve the Inequality\n7:00\nExample 3: Solve the Inequality\n8:10\nExample 4: Solve the Inequality\n9:47\nMultiplication & Division Techniques\n\n10m 49s\n\nIntro\n0:00\nFundamental Principle\n0:10\nOnly Positive Numbers\n0:23\nExample\n0:51\nFundamental Principle, Cont.\n2:01\nNegative Numbers\n2:12\nReverse Inequality Sign\n2:28\nExample\n2:48\nExample 1: Solve the Inequality\n4:26\nExample 2: Solve the Inequality\n5:45\nExample 3: Solve the Inequality\n6:50\nExample 4: Solve the Inequality\n8:28\nTechniques for Multistep Inequalities\n\n16m 56s\n\nIntro\n0:00\nSimilarity to Multistep Equations\n0:16\nNegative Numbers\n0:32\nExample\n0:49\nInequalities Containing Grouping Symbols\n1:24\nExample\n1:35\nSpecial Cases\n2:45\nExample: All Real Numbers\n3:04\nExample: Empty Set\n4:10\nExample 1: Solve the Inequality\n6:05\nExample 2: Solve the Inequality\n7:39\nExample 3: Solve the Inequality\n9:57\nExample 4: Solve the Inequality\n13:56\nCompound Inequalities\n\n21m 32s\n\nIntro\n0:00\nWhat is a Compound Inequality\n0:07\nJoined by 'And' or 'Or'\n0:16\nInequalities Combined by 'And'\n0:36\nIntersection/Overlap\n0:53\nExample\n1:08\nInequalities Combined by 'Or'\n4:23\nUnion\n4:41\nExample\n5:27\nExample 1: Solve the Inequality\n6:39\nExample 2: Solve the Inequality\n11:30\nExample 3: Solve the Inequality\n13:43\nExample 4: Solve the Inequality\n18:19\nEquations with Absolute Value\n\n24m 16s\n\nIntro\n0:00\nAbsolute Value\n0:06\nNumber Line\n0:22\nExample\n0:41\nAbsolute Value is N\n1:52\nAbsolute Value Function\n3:17\nExample\n3:40\ng(x) and f(x)\n4:31\nSolving Absolute Value Equations\n6:23\nAbsolute Value in Words\n6:39\nSplit Into Two Parts\n7:58\nSolve Both Equations\n8:22\nExample 1: Solve the Absolute Value\n10:34\nExample 2: Solve the Absolute Value\n13:09\nExample 3: Solve the Absolute Value\n14:52\nExample 4: Solve the Absolute Value\n20:23\nInequalities with Absolute Values\n\n17m 37s\n\nIntro\n0:00\nInequalities of the Form \|x\|< n\n0:07\nValues that Satisfy Both Inequalities\n0:46\nExample\n1:27\nInequalities of the Form \|x\|> n\n3:58\nValues that Satisfy Either Inequalities\n4:19\nExample\n4:47\nExample 1: Solve the Inequality\n6:38\nExample 2: Solve the Inequality\n9:54\nExample 3: Solve the Inequality\n12:05\nExample 4: Solve the Inequality\n14:50\nGraphing Inequalities with Two Variables\n\n24m 33s\n\nIntro\n0:00\nGraph\n0:08\nHalf Plane and Boundary\n0:51\nTechnique for Graphing\n1:57\nGraph Equation\n2:01\nSolid Line or Dashed Line\n2:07\nExample\n2:32\nChoosing a Test Point\n5:10\nExample\n5:26\nExample 1: Solve the Inequality\n7:49\nExample 2: Solve the Inequality\n11:37\nExample 3: Solve the Inequality\n15:44\nExample 4: Solve the Inequality\n19:10\nGraphing Systems of Inequalities\n\n24m 4s\n\nIntro\n0:00\nSystem of Inequalities\n0:05\nExample\n0:22\nSolving a System of Inequalities\n0:38\nSolution Set\n0:46\nGraph Each Inequality\n0:57\nArea of Overlap\n1:45\nExample 1: Solve the System of Inequalities\n2:44\nExample 2: Solve the System of Inequalities\n6:33\nExample 3: Solve the System of Inequalities\n11:40\nExample 4: Solve the System of Inequalities\n17:36\nSection 7: Polynomials\nMultiplying Monomials\n\n22m 19s\n\nIntro\n0:00\nWhat is a Monomial\n0:09\nExamples\n0:17\nPower\n0:55\nBase and Exponent\n1:52\nProperties of Exponents\n2:16\n2:25\nMultiply Exponents\n4:00\nProduct Exponent\n4:39\nSimplified Form\n7:26\nExamples\n7:47\nExample 1: Simplify the Monomial\n8:26\nExample 2: Simplify the Monomial\n10:32\nExample 3: Simplify the Monomial\n12:48\nExample 4: Simplify the Monomial\n17:33\nDividing Monomials\n\n24m 2s\n\nIntro\n0:00\nProperties of Exponents\n0:05\nDividing with Same Base\n0:15\nExample\n0:53\nQuotient Raised to Power\n2:22\nExample\n2:53\nRaising to 0 Power\n4:00\nExample\n4:21\nNegative Exponents\n5:45\nExample\n6:05\nExample 1: Simplify the Monomial\n7:33\nExample 2: Simplify the Monomial\n14:56\nExample 3: Simplify the Monomial\n13:30\nExample 4: Simplify the Monomial\n17:35\nPolynomials\n\n8m 56s\n\nIntro\n0:00\nWhat is a Polynomial\n0:07\nMonomial\n0:40\nBinomial\n1:15\nTrinomial\n1:25\nDegree of a Polynomial\n1:56\nExample: Degree of Monomial\n2:13\nExample: Degree of Polynomial\n2:47\nOrdering Polynomials\n3:32\nExample\n3:47\nExample 1: Trinomial or Binomial\n4:44\nExample 2: Find the Degree\n5:27\nExample 3: Increasing Powers\n6:11\nExample 4: Decreasing Powers\n7:27\n\n15m 51s\n\nIntro\n0:00\n0:07\nLike Terms\n0:18\nExample\n1:02\nSubtracting Polynomials\n2:44\nExample\n2:58\n5:11\nExample 2: Subtract Polynomials\n7:30\n9:35\n12:09\nMultiplying Polynomials by Monomials\n\n18m 17s\n\nIntro\n0:00\nDistributive Property\n0:07\nExample\n0:54\nSolving Equations\n1:36\nIsolate Variable and Solve\n1:46\nExample 1: Multiply\n1:59\nExample 2: Simplify\n3:33\nExample 3: Simplify\n7:20\nExample 4: Solve\n13:37\nMultiplying Polynomials\n\n18m 2s\n\nIntro\n0:00\nDistributive Property\n0:08\nExample\n0:54\nFOIL Method\n2:44\nFirst, Outer, Inner, Last\n3:20\nExample 1: Multiply\n5:32\nExample 2: Multiply\n7:27\nExample 3: Multiply\n9:41\nExample 4: Multiply\n13:56\nSpecial Products\n\n17m\n\nIntro\n0:00\nSquare of a Sum\n0:06\nExample\n1:09\nSquare of a Difference\n2:46\nExample\n3:22\nDifference of Two Squares\n4:50\nExample\n5:31\nExample 1: Multiply\n6:24\nExample 2: Multiply\n8:34\nExample 3: Multiply\n11:03\nExample 4: Multiply\n12:54\nSection 8: Factoring\nSpecial Product\n\n17m 51s\n\nIntro\n0:00\nPrime and Composite Numbers\n0:09\nPrime Number\n0:12\nComposite Number\n0:42\nFactored Forms\n1:39\nPrime Factored Form\n1:40\nFactored Form\n2:21\nGreatest Common Factor\n3:55\nExample: GCF for Number\n4:19\nExample: GCF for Monomial\n6:00\nExample 1: Prime Factored Form\n7:51\nExample 2: Factored Form\n9:34\nExample 3: GCF\n11:12\nExample 4: GCF\n13:28\nFactoring Using Greatest Common Factor\n\n25m 21s\n\nIntro\n0:00\nDistributive Property\n0:05\nExample: Binomial\n0:49\nExample: Trinomial\n2:18\nFactoring by Grouping\n4:17\nExample: Four Terms\n4:40\nZero Product Property\n8:21\nExample\n9:01\nExample 1: Factor the Polynomial\n10:38\nExample 2: Factor the Polynomial\n13:43\nExample 3: Factor the Polynomial\n19:59\nExample 4: Solve the Polynomial\n22:58\nFactoring Trinomials with Leading Coefficient of 1\n\n27m 11s\n\nIntro\n0:00\nFactoring Trinomials\n0:07\n0:11\nExample\n1:20\nRules for Signs\n2:42\nP and Q Both Positive\n2:55\nP and Q Both Negative\n3:39\nP and Q Opposite Signs\n4:30\nSolving Equations\n5:18\nExample\n6:44\nExample 1: Factor the Polynomial\n7:41\nExample 2: Factor the Polynomial\n12:33\nExample 3: Factor the Polynomial\n16:39\nExample 4: Solve the Polynomial\n21:35\nFactoring General Trinomials\n\n46m 9s\n\nIntro\n0:00\nFactoring Trinomials\n0:15\nExample\n2:42\nGrouping\n7:20\nExample\n7:35\nRules for Signs\n10:51\nSame as Leading Coefficient is 1\n11:05\nGreatest Common Factor\n12:29\nUse Whenever Possible\n12:41\nExample\n12:59\nPrime Polynomials\n13:58\nExample\n14:33\nSolving Equations\n16:55\nExample\n17:25\nExample 1: Factor the Polynomial\n18:46\nExample 2: Factor the Polynomial\n25:23\nExample 3: Factor the Polynomial\n32:37\nExample 4: Solve the Polynomial\n36:18\nFactoring the Difference of Two Squares\n\n24m 3s\n\nIntro\n0:00\nDifference of Two Squares\n0:08\nExample\n0:36\nFactoring Using Several Techniques\n2:23\nFactoring the GCF\n2:30\nExample\n3:22\nSolving Equations\n5:24\nExample\n5:50\nExample 1: Factor the Polynomial\n7:34\nExample 2: Factor the Polynomial\n9:11\nExample 3: Factor the Polynomial\n12:00\nExample 4: Solve the Polynomial\n18:31\nFactoring Perfect Squares\n\n18m 10s\n\nIntro\n0:00\nPerfect Squares\n0:07\nExample: Perfect Square Trinomials\n1:12\nSolving Equations\n2:57\nSquare Root Property\n3:09\nExample\n3:28\nExample 1: Factor the Polynomial\n5:09\nExample 2: Factor the Polynomial\n6:13\nExample 3: Solve the Polynomial\n8:43\nExample 4: Solve the Polynomial\n13:35\n\n35m 45s\n\nIntro\n0:00\nParabolas\n0:14\n0:28\nExamples\n1:05\nAbsolute Value of 'a'\n2:19\nParabolas That Open Upward\n3:14\nMinimum\n3:48\nExample\n3:57\nParabolas That Open Downward\n6:57\nExample\n7:17\nMaximum\n9:23\nVertex\n9:53\nExample\n10:40\nAxis of Symmetry\n14:16\nExample\n15:03\n19:54\n24:12\nExample 3: Vertex Maximum or Minimum\n28:32\nExample 4: Axis of Symmetry\n31:13\nSolving Equations by Graphing\n\n40m 42s\n\nIntro\n0:00\n0:08\nExample\n0:56\nTwo Distinct Solutions/Roots\n8:10\nRoots\n8:23\nExample: Graphs\n8:40\nOne Double Root\n9:19\nExample: One X-Intercept\n9:54\nNo Real Roots\n14:03\nExample\n14:53\nEstimating Solutions\n18:41\nExample: Not Integers\n19:18\nExample 1: Solve by Graphing\n20:18\nExample 2: Solve by Graphing\n26:36\nExample 3: Solve by Graphing\n30:18\nExample 4: Estimate by Graphing\n34:59\nSolving Equations by Completing the Square\n\n28m 13s\n\nIntro\n0:00\nPerfect Square Trinomials\n0:15\nExample\n0:36\nCompleting the Square\n4:55\nExample\n6:20\nCompleting the Square to Solve Equations\n9:19\nExample\n9:40\nWhen the Leading Coefficient is Not 1\n13:17\nExample\n14:01\nExample 1: Solve the Equation\n15:05\nExample 2: Complete the Square\n20:16\nExample 3: Solve by Completing the Square\n22:31\nExample 4: Solve by Completing the Square\n25:02\nSolving Equations Using the Quadratic Formula\n\n17m 17s\n\nIntro\n0:00\n0:17\nStandard Form\n0:24\nExample\n1:00\nDiscriminant\n3:14\nTwo Solutions and Both Real\n3:40\nOne Real Solution\n4:07\nNo Real Solutions\n4:28\nExample 1: Solve the Equation\n6:25\nExample 2: Solve the Equation\n8:42\nExample 3: Solve the Equation\n12:02\nExample 4: Number of Real Roots\n15:23\nSection 10: Radical Expressions and Equations\n\n41m 30s\n\nIntro\n0:00\n0:12\n0:29\nExample: Not Simplest Form\n1:16\nPrincipal Square Root (Positive)\n2:43\nProduct Property\n3:40\nExamples\n4:05\nSquare Roots of Variables with Even Powers\n7:01\n7:42\nDivide Exponent by 2\n7:57\nAbsolute Value of Result\n8:29\nExamples\n8:52\nQuotient Rule\n14:12\nExample\n14:31\nRationalizing Denominators\n16:08\nExample\n16:43\nConjugates\n18:33\nExample\n19:53\n20:58\nThree Criteria\n21:10\nExample 1: Simplify Expression\n21:57\nExample 2: Simplify Expression\n25:12\nExample 3: Simplify Expression\n31:37\nExample 4: Simplify Expression\n35:29\n\n21m 52s\n\nIntro\n0:00\n0:13\n0:28\nDistributive Property\n1:10\n4:24\nExample: Use FOIL\n4:44\nExample 1: Simplify Expression\n7:07\nExample 2: Simplify Expression\n8:51\nExample 3: Simplify Expression\n12:14\nExample 4: Simplify Expression\n16:06\n\n27m\n\nIntro\n0:00\n0:15\nExamples\n0:30\n1:13\n1:18\nSquare Both Sides\n1:38\nExample\n1:44\nExtraneous Solutions\n2:57\nExample: Check Solutions\n3:30\nExample 1: Solve Equation\n6:29\nExample 2: Solve Equation\n9:52\nExample 3: Solve Equation\n14:29\nExample 4: Solve Equation\n20:53\nPythagorean Theorem\n\n17m 24s\n\nIntro\n0:00\nRight Triangles\n0:06\nVertex\n0:32\nHypotenuse\n0:56\nLegs\n1:11\nPythagorean Theorem\n1:21\nGraphical Representation\n1:37\nExample\n2:39\nPythagorean Triples\n3:40\nExample\n3:56\nConverse of the Pythagorean Theorem\n4:36\nExample\n6:23\nExample 1: Length of Hypotenuse\n7:24\nExample 2: Length of Legs\n9:02\nExample 3: Area of Triangle\n12:00\nExample 4: Length of Side\n14:59\nDistance Formula\n\n26m 50s\n\nIntro\n0:00\nDistance Formula\n0:09\nSimilarity to Pythagorean Theorem\n0:21\nMissing Coordinates\n5:50\nExample\n6:22\nExample 1: Distance Between Points\n11:43\nExample 2: Distance Between Points\n14:05\nExample 3: Distance Between Points\n18:18\nExample 4: Missing Coordinate\n21:57\nSection 11: Rational Expressions and Equations\nInverse Variation\n\n24m 13s\n\nIntro\n0:00\nDirect Variation\n0:12\nInverse Variation\n0:24\nConstant of Variation k\n0:50\nY Varies Inversely as X\n0:59\nGraphing Inverse Variation\n3:09\nReal World Applications\n3:24\nExample\n3:59\nProduct Rule\n10:19\nAlternate Form\n11:10\nFinding Missing 4th Point\n11:24\nExample 1: Graph Inverse Variation\n11:36\nExample 2: Graph Inverse Variation\n14:47\nExample 3: Find Missing Point\n19:39\nExample 4: Find Missing Point\n21:53\nRational Expressions\n\n34m 22s\n\nIntro\n0:00\nRational Expressions\n0:10\nExamples\n0:28\nExcluded Values\n1:03\nDividing by 0\n1:29\nExample\n2:49\nSimplifying Rational Expressions\n7:12\nEliminating the GCF\n7:17\nExample: Regular Fraction\n7:30\nExample: Rational Expression\n8:12\nSimplifying and Excluded Values\n10:15\nOriginal Rational Expression\n10:24\nExample\n10:47\nExample 1: Find Excluded Values\n13:47\nExample 2: Simplify and Find Excluded Values\n16:10\nExample 3: Simplify and Find Excluded Values\n22:04\nExample 4: Simplify and Find Excluded Values\n26:29\nMultiplying Rational Expressions\n\n22m 58s\n\nIntro\n0:00\nProcedure\n0:08\nExamples\n0:29\nCancel Before Multiplication\n1:53\nExample\n2:04\nRational Expressions Containing Polynomials\n3:18\nExample\n3:46\nExample 1: Multiply Rational Expressions\n6:04\nExample 2: Multiply Rational Expressions\n9:11\nExample 3: Multiply Rational Expressions\n11:19\nExample 4: Multiply Rational Expressions\n17:36\nDividing Rational Expressions\n\n21m 49s\n\nIntro\n0:00\nProcedure\n0:10\nReciprocal of Expression\n0:22\nExample: Regular Fractions\n0:44\nExample: Rational Expressions\n1:46\nCancel Before Multiplying\n3:23\nWhy Cancel\n3:45\nExample\n4:15\nRational Expressions Containing Polynomials\n6:46\nExample\n7:06\nExample 1: Divide Rational Expressions\n9:15\nExample 2: Divide Rational Expressions\n13:11\nExample 3: Divide Rational Expressions\n15:39\nDividing Polynomials\n\n35m 57s\n\nIntro\n0:00\nDividing a Polynomial by a Monomial\n0:11\nExample: Regular Fractions\n0:36\nExample: Polynomials\n1:24\nDividing a Polynomial by a Binomial\n2:56\nExample: Dividend and Divisor\n3:30\nLong Division\n5:28\nExample: Regular Numbers\n5:49\nExample: Polynomials\n7:17\nMissing Terms\n12:20\nDefinition\n12:40\nExample\n12:55\nExample 1: Divide the Polynomials\n18:42\nExample 2: Divide the Polynomials\n20:54\nExample 3: Divide the Polynomials\n23:28\nExample 4: Divide the Polynomials\n28:52\nAdding and Subtracting Rational Expressions with Like Denominators\n\n17m 38s\n\nIntro\n0:00\n0:09\nExample: Regular Numbers\n0:19\nExample: Rational Expressions\n1:05\nSubtracting with Like Denominators\n2:35\nExample: Regular Fractions\n2:52\nExample: Rational Expressions\n3:05\n4:08\n4:35\nExample\n5:53\n7:54\nExample 2: Subtract Rational Expressions\n8:43\n10:39\nExample 4: Subtract Rational Expressions\n11:48\nAdding and Subtracting Rational Expressions with Unlike Denominators\n\n37m 16s\n\nIntro\n0:00\nLeast Common Multiple of Polynomials\n0:21\nExample: Regular Fractions\n0:42\nExample: Rational Expressions\n5:18\nEquivalent Rational Expressions Using LCM\n7:23\nExample\n8:09\n14:24\nSummary of Techniques\n14:32\nExample 1: Find the LCM\n15:09\n17:53\nExample 3: Subtract Rational Expressions\n22:19\n30:44\nComplex Fractions\n\n25m 38s\n\nIntro\n0:00\nMixed Expressions\n0:10\nAnalogy to Mixed Fractions\n0:23\nPolynomial and Rational Expression\n0:59\nExample: Combining\n1:55\nConverting to Rational Expression\n2:29\nComplex Fraction\n5:16\nExamples\n5:30\nSimplifying Complex Fractions\n6:08\nExample\n6:27\nExample 1: Write as Rational Expression\n9:43\nExample 2: Simplify Complex Fractions\n12:44\nExample 3: Simplify Complex Fractions\n15:03\nExample 4: Simplify Complex Fractions\n19:55\nRational Equations\n\n38m 9s\n\nIntro\n0:00\nDefinition\n0:11\nExample: Cross Multiplication\n0:39\nExample: Rational Expressions\n1:13\nSolving Rational Equations\n3:12\nMultiply by LCM of Denominators\n3:33\nExample\n4:02\nWork Problems\n7:19\nExample: Complete a Project\n8:17\nExtraneous Solutions\n12:41\nCheck All Solutions\n13:18\nExample\n13:54\nExample 1: Solve Rational Equation\n17:28\nExample 2: Solve Rational Equation\n19:45\nExample 3: Work Problem\n27:15\nExample 4: Solve Rational Equation\n31:10\nBookmark & Share Embed\n\n## Copy & Paste this embed code into your website’s HTML\n\nPlease ensure that your website editor is in text mode when you paste the code.\n(In Wordpress, the mode button is on the top right corner.)\n×\n• - Allow users to view the embedded video in full-size.\nSince this lesson is not free, only the preview will appear on your website.\n\n• ## Related Books", null, "1 answerLast reply by: Edwin WongThu Jun 27, 2013 5:33 PMPost by Edwin Wong on June 27, 2013At 9:44, you plotted the graph wrong.", null, "2 answersLast reply by: leo leyvaMon Jul 15, 2013 2:49 PMPost by Abel Gallegos on June 3, 2013Dr. Eaton, is Ax+By=C the same as as Ax+By+C=0 form of the formula?I Think both are used to show the form of lineal equations but I donÂ´t know if they are the same or if i should have Ax+By-C=0 instead,or just look to put the equation they way they ask me to. Thanks.", null, "4 answersLast reply by: Taylor WrightTue Jun 18, 2013 12:33 AMPost by Erika Porter on May 3, 2013On Exercise 2 if I put the problem 2/x-3/y=0 into standard form I get -3x+2y=0 which yields a straight line with coordinates such as (0,0),(1,1.5),(-1,-1.5),(2,3),(3,4.5).However, I understand that substituting zero for either the x and y variables in the denominators is undefined, couldn't it just be that the line travels through the origin?Thanks.\n\n### Linear Functions\n\n• A linear function is a function of the form f(x) = ax + b, where a and b are constants and a is nonzero. Its graph is a straight line. The x coordinate of the point at which the graph crosses the x axis is called the x-intercept. The y-intercept is defined similarly. Values of x for which f(x) = 0 are called zeros of f.\n• A linear equation can be written in the form ax + by = c for some constants a, b, and c, where either a or b is not 0. If these constants are integers, the equation is in standard form.\n• The graph of a linear equation is a straight line.\n\n### Linear Functions\n\nDetermine if the equation is linear:\n− 5x + 4y = 22\nyes\nDetermine if the equation is linear\n14 = 2xy + 5y + 9\nno\nDetermine if the equation is linear\n6s = 10 − [2/t]\n• t(6s) = ( 10 − [2/t] )t\n• 6st = 10t − 2\n• = 10t − 2\nno\nDetermine if the following is a linear equation:\n[4/x] + [5/y] = 0\nno\nFind the intercepts of the equation:\n[x/2] − [y/3] = 5\n• For the x intercept, let y = 0[x/2] − [0/3] = 5\n• [x/2] − 0 = 5\n• [x/2] = 5\n• x = 10\nx intercept = 10\n• For the y intercept, let x = 0\n[0/2] − [y/3] = 5\n• 0 − [y/3] = 5\n• − [y/3] = 5\n• − y = 15\n• y = 15\ny intercept = 15\nx intercept = 10\ny intercept = 15\nFind the intercepts of the equation:\n[g/7] − [h/21] = 5\n• For the g intercept, let h = 0\n[g/7] − [0/21] = 5\n• [g/7] − 0 = 5\n• [g/7] = 5\n• g = 35\ng intercept = 35\n• For the h intercept, let g = 0\n[0/7] − [h/21] = 5\n• 0 − [h/21] = 5\n• − [h/21] = 5\n• − h = 105\n• h = − 105\nh intercept = 105\ng intercept = 35\nh intercept = 105\nFind the intercepts of the equation:\n[2x/9] − [y/4] = 12\n• For the x intercept, let y = 0\n[2x/9] − [0/4] = 12\n• [2x/9] − 0 = 12\n• [2x/9] = 12\n• 2x = 108\n• x = 54\n• For the y intercept, let x = 0\n[2(0)/9] − [y/4] = 7\n• [0/9] − [y/4] = 7\n• 0 − [y/4] = 7\n• − [y/4] = 7\n• − y = 28\n• y = − 28\nx intercept = 54\ny intercept = −28\nFind the intercepts of the equation\n2x − 5y = 20\n• For the y intercept, let x = 0\n• 2(0) − 5y = 20\n• − 5y = 20\n• y = − 4\n• For the x intercept, let y = 0\n• 2x − 5(0) = 20\n• 2x = 20\n• x = 10\nx intercept = 10\ny intercept = −4\nDetermine the intercepts from the graph of the function", null, "• Note the tick mark intervals\nIntercept for the two equations is (1.5, − 0.5)\nDetermine the intercepts from the graph of the function", null, "• Note the tick mark intervals\nIntercept for the two equations is ( − 1, − 1[3/4])\n\n*These practice questions are only helpful when you work on them offline on a piece of paper and then use the solution steps function to check your answer.\n\n### Linear Functions\n\nLecture Slides are screen-captured images of important points in the lecture. Students can download and print out these lecture slide images to do practice problems as well as take notes while watching the lecture.\n\n• Intro 0:00\n• Definition 0:07\n• Standard Form\n• Example\n• Graph and Intercepts 2:39\n• Example: Graph\n• X-Intercept\n• Y-Intercept\n• Graphing Linear Equations 4:29\n• Example\n• Linear Functions 7:51\n• Example\n• Example 1: Linear 10:16\n• Example 2: Linear Equation 12:58\n• Example 3: Intercepts 14:23\n• Example 4: Equation from Intercepts 16:47\n\nOR\n\n### Start Learning Now\n\nOur free lessons will get you started (Adobe Flash® required)." ]	[ null, "https://www.educator.com/media/ss/algebra-1/cxt/ct/Alg1-3-3-0.jpg", null, "https://www.educator.com/media/lesson/poster/lores/mathematics-algebra-1-eaton/prof/Alg1-3-3-0.jpg", null, "https://www.educator.com/membership/upload/default.jpg", null, "https://www.educator.com/membership/upload/default.jpg", null, "https://www.educator.com/membership/upload/default.jpg", null, "https://www.educator.com/media/files/pq/algebra-1-eaton/images/ALG-IMG-3-3-9.jpg", null, "https://www.educator.com/media/files/pq/algebra-1-eaton/images/ALG-IMG-3-3-10.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.880023,"math_prob":0.9816489,"size":3554,"snap":"2021-31-2021-39","text_gpt3_token_len":1337,"char_repetition_ratio":0.14112677,"word_repetition_ratio":0.06725888,"special_character_ratio":0.41671357,"punctuation_ratio":0.09620253,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9966537,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],"im_url_duplicate_count":[null,8,null,5,null,null,null,null,null,null,null,5,null,5,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-09-25T19:09:55Z\",\"WARC-Record-ID\":\"<urn:uuid:21ad3cf6-badf-461c-b9b5-5531876241ea>\",\"Content-Length\":\"462514\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:6348a051-6a8d-4035-a91e-9dd60e6b84f1>\",\"WARC-Concurrent-To\":\"<urn:uuid:1358bec0-b0e0-476b-a8ab-3b121434558f>\",\"WARC-IP-Address\":\"104.27.194.88\",\"WARC-Target-URI\":\"https://www.educator.com/mathematics/algebra-1/eaton/linear-functions.php\",\"WARC-Payload-Digest\":\"sha1:WWF3HC7AVAQTXKHYA46KUGUQJ5FFQ5HZ\",\"WARC-Block-Digest\":\"sha1:4JAJ3I2EWSAO4TRQJJJQLWTHW5GEDUEF\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-39/CC-MAIN-2021-39_segments_1631780057733.53_warc_CC-MAIN-20210925172649-20210925202649-00227.warc.gz\"}"}
https://pocketdentistry.com/20-statistics-as-an-inductive-argument-and-other-statistical-concepts/	[ "", null, "# Statistics ≠ Scientific Method\n\nThe statistics used in most research papers are different from the statistics of everyday usage, such as reported census data or baseball batting averages that provide comprehensive information about the population involved. For example, in calculating a batting average, we know every time a player went to bat, and we know the player’s exact number of hits, so the batting average completely and accurately represents the player’s performance.\n\n# Golden rule of sample statistics\n\nA number of features of statistical reasoning about samples were not illustrated in the previous chapters. Some of these may be summed up in what I will call the golden rule: Any sample should be evaluated with respect to size, diversity, and randomness.2 The statistics in research reports are based on samples. The obvious questions to ask are: (1) How representative of the target population are the samples? Was the sample selected randomly, or were there factors present that could lead to biased selection? (2) How large is the sample? (3) How much diversity exists in the sample? Does it cover all of the groups that make up the population? Fallacies, as well as acceptable arguments, can arise from statistical inference.\n\n# What is a reasonable sample size?\n\nThere is no simple answer to this question, but two general considerations appear to be relevant: tradition and statistics.\n\nIn some research areas, experience shows that consistent and reliable results require a certain number of subjects or patients; for example, Beecher4 recommends at least 25 patients for studies on pain. These traditions probably develop because of practical considerations such as patient availability, as well as inherent statistical considerations such as subject variability. The underlying philosophy in this approach is that the replication of results is a more convincing sign of reliability than a low P value obtained in a single experiment. If a number of investigators find the same result, we can have reasonable confidence in the findings. Means of combining and reviewing studies are given in Summing Up by Light and Pillemer.5\n\nThere are problems with the traditional method of choosing an arbitrary and convenient number of subjects. If the sample is too large, the investigator wastes effort and the subjects are unnecessarily exposed to treatments that may not be optimal. However, most often the number of subjects is too small; the size of the sample is usually limited by subject availability. Thus, studies that use low numbers of subjects and report no treatment effect should be considered with skepticism. In fact, some journals have a policy of rejecting papers that accept null hypotheses. Such negative results papers end up in a file drawer. They neither contribute to scientific knowledge nor enhance the careers of their authors. These “file-drawer papers” emphasize the need to understand the relationship between sample size and the establishment of statistically significant differences. Failure to use an appropriate sample size leads to much wasted effort.\n\n# Role of the sample size and variance in establishing statistically significant differences between means in thettest\n\nThe size of an adequate sample is a complex question that will not be addressed in great detail here. However, some insight into the problem can be gained by examining the formula for the t test, which is perhaps the most common statistical test used in biologic research. It should be used when comparing the means of only two groups. The t test exists in several forms that depend on whether the samples are related (eg, the paired t test) or independent. Below is the formula used for a two-sided comparison when comparing the means of the measured values from two independent samples with roughly equal variances of unpaired subjects:", null, "where nA, nB = number in samples A and B, respectively;", null, "= means of samples A and B, respectively;", null, "= variance of groups A and B, respectively;", null, "= standard error (SE) of the difference between means; and nA + nB–2 = degrees of freedom.", null, "Table 20-1 Relationship of Streptococcus mutans biotype to DMFT*", null, "The critical value of t for 194 df at an α level of .05 ≈ 1.96.\n\nSince the calculated value of t = 2.59 > 1.96, we can reject the null hypothesis and conclude that there is a significant difference in DMFT between the e and non–e carriers.\n\nFrom the formula for the statistic, we realize the following:\n\n1. A large difference between means will increase the t value. This makes sense. Large effects should be easier to see. If the effect is large, the sample size required to distinguish the groups will be smaller.\n2. The t value is decreased when the variance is large. (Remember that variance is related to the spread of measured values around the mean.) A large variance tends to produce a small t value, making it harder to detect differences between groups.\n3. The t value is increased when the number in the sample is large. From the formula, it can be calculated that the decrease in the SE value is proportional to the square root of the sample number. Thus, if you increase the sample size by a factor of 10, you only decrease the SE by 3.16. This may be an inefficient way of reducing the error, but it works. Bakan7 notes that increasing the sample size (n) almost inevitably guarantees a significant result. Even very small alterations in experiment conditions might produce minute differences that will be detected by a statistical test made very sensitive by a large sample size.\n\nIn the dental sciences, the reverse is the more common problem; that is, frequently there is only a small number in the sample. Combined with a large variability in the subjects, this small sample often means that no difference is detected, even when it is likely that a real difference exists.\n\n# Effect-size approach\n\n1. Estimate what you think is an important (or important to detect) difference in means between the treated and control groups.\n2. Use the results of a pilot study or previously published information on the measurement to estimate the expected pooled standard deviation (SD) of a reasonably sized sample.\n3. Using the values found in (1) and (2) above, calculate the d statistic (formula given on page 252).\n4. Choose your level of confidence (5% or 1%).\n5. Look up the number of subjects needed in appendix 6.\n\nUsing the same approach, we can also work backward to decide if a paper’s authors used a reasonable sample size. This is particularly important if no effect was seen, because the sample may have been too small to produce a sensitive experiment. To check this possibility:\n\n1. Use the authors’ data to estimate the d statistic.\n2. Look up the table in appendix 6 to determine the number of subjects that should have been used.\n3. Compare the number from the table with the actual number used. Effect- and sample-size tables for more sophisticated designs can be found in Cohen’s8 book Statistical Power Analysis for the Behavioral Sciences.\n\nDao et al9 examined the choice of measures in myofacial pain studies. Based on the characteristics of the measurements, they calculated how many subjects would be required to observe significant groups differing from each other by specified amounts. Their technique was based on the statistical power analysis developed by Cohen8 and is similar to the effect-size calculation given above. Their values for within- and between-subject variance were obtained from a population referred to as University Research Clinic. The technique used to measure pain was a visual analogue scale (VAS), shown to be a rapid, easy, and valid method that provides a more sensitive and accurate representation of pain intensity than the descriptive scales.\n\nThey found that detecting a 15% difference in pain intensity between treatment and control groups in an experiment with 3 groups would require 242 subjects per group. However, to detect an 80% difference in pain intensity, only 8 subjects per group would be needed, and the total study size would be 24 subjects. Even with the sensitive VAS method to measure pain, the traditional approach of using 25 subjects and descriptive scales could probably distinguish only very large differences between groups (ie, ≈ 80% differences, if three groups were used).\n\n# A handy rule for the effect of sample size on confidence intervals\n\nVan Belle’s Statistical Rules of Thumb10 includes a chapter on calculating sample sizes and provides a number of other “rules of thumb” useful in performing practical statistical analysis. Figure 20-1, taken from van Belle,10 shows the half-width of confidence intervals with sample size. One can see that the width of the confidence interval decreases rapidly until 12 observations are reached and then decreases more slowly.\n\n# The Fallacy of Biased Statistics\n\nTo review briefly, descriptive statistics are simply efficient ways of describing populations. For our purposes, a population is a collection of all objects or events of a certain kind that—at least theoretically—could be observed. The specific group of objects (events, subjects) observed is the sample. Inferential statistics are concerned with the use of samples to make estimates and inferences about the larger population. This larger population from which the sample is selected is also called the parent population, or, perhaps more accurately, the target population. This is the population that we hope the sample represents, so that we can generalize our findings.", null, "Fig 20-1 Half-width confidence interval assuming a t statistic with n–1 df and sample size n. Confidence level curves are shown for confidence levels of 90%, 95%, and 99%. (Reprinted from van Belle9 with permission.)\n\nThe fallacy of biased statistics occurs when an inductive generalization is based on a sample that is known to be—or is strongly suspected to be—nonrepresentative of the parent population. This problem of nonrepresentative samples is associated with the randomness of sample selection and the spread of the sample. Gathering numbers to obtain information may be likened to an archer shooting at a target. The bull’s-eye represents the true value of the population in question. The place where the arrow hits represents one value from the sample. Bias is the consistent repeated divergence of the shots from the bull’s-eye. For an archer, this bias may be caused by a factor such as a wind blowing from one direction that causes the arrows to hit predominantly on one side of the target. In research experiments, bias may be caused by factors leading to nonrandom sampling. There are many examples of biased polls giving erroneous results. Perhaps the most famous is the Literary Digest poll that predicted, on the basis of a telephone survey and a survey of its subscribers, that a Republican victory was assured in the 1936 election.3 The number of people polled was huge—over two million—but the prediction was wrong because the people polled were not representative of the voting public. In fact, they were wealthier than average because, at that time, telephones were found mainly in the homes of the wealthy. Thus, the Literary Digest poll selected relatively wealthy people, who stated that they would vote Republican. Today, the public opinion polls conducted by the Gallup and Harris organizations interview only about 1,800 persons weekly to estimate the opinions of US residents age 18 and over, but these polls are reasonably accurate because the sample is chosen by a stratified random sampling method that is not biased.\n\nBias can appear in many different ways, as denoted by Murphy’s11 definition:\n\nBias is any trend in the choice of a sample, the making of measurements on it, the analysis or publication of findings, that tends to give or communicate an answer that differs systematically (/>" ]	[ null, "https://www.facebook.com/tr", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0280.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0281.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0282.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0283.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0284.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0285.jpg", null, "https://pocketdentistry.com/wp-content/uploads/285/e9780867155372_i0286.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.950082,"math_prob":0.92248017,"size":17739,"snap":"2020-45-2020-50","text_gpt3_token_len":3464,"char_repetition_ratio":0.13431068,"word_repetition_ratio":0.0038314175,"special_character_ratio":0.19279553,"punctuation_ratio":0.087189175,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9708318,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16],"im_url_duplicate_count":[null,null,null,2,null,2,null,2,null,2,null,2,null,2,null,2,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-10-24T05:26:43Z\",\"WARC-Record-ID\":\"<urn:uuid:55836e12-cd4d-4abe-a168-9ad4784a28bc>\",\"Content-Length\":\"77813\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:21bb3768-3bc4-415f-9c2b-808d4196dfd9>\",\"WARC-Concurrent-To\":\"<urn:uuid:913e7626-9669-4928-95b5-64873b86109b>\",\"WARC-IP-Address\":\"192.157.220.43\",\"WARC-Target-URI\":\"https://pocketdentistry.com/20-statistics-as-an-inductive-argument-and-other-statistical-concepts/\",\"WARC-Payload-Digest\":\"sha1:7MOQ4FP2HDUT5XUQX5XA7RRQ6H577TDJ\",\"WARC-Block-Digest\":\"sha1:WG5C6CEPSH4ZGK3P3VUISG46PDNFGFSU\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-45/CC-MAIN-2020-45_segments_1603107882102.31_warc_CC-MAIN-20201024051926-20201024081926-00147.warc.gz\"}"}
https://algotrading-investment.com/2020/06/01/the-concept-behind-the-pattern-completion-interval/	[ "# The Concept behind the Pattern Completion Interval (PCI)\n\nPattern Completion Interval is the emerging concept first introduced from this book. The concept was born after the extensive computerized research in tradable patterns in the financial market conducted by myself. Therefore, not many traders are aware of its existence yet. As you read this book, you will find out that it is extremely useful concept for your harmonic pattern trading. At the same time, the concept is not a rocket science. The concept is simple enough for any average trader for their practical trading. To understand the concept of the Pattern Completion Interval, we shall understand the term approximation first. Of course, everyone know the literal meaning of approximation. However, technically speaking, approximation make quite big influence every day in our life, but many people will not notice its impact unless you are the math geek crunching numbers all day in your job.\n\nWhether you agree or not, approximation arises naturally every day in our life. There can be plenty of examples but we shall start with most intuitive one. Let us use the sprint record of Usain Bolt to learn about approximation. The record-breaking sprint of Usain Bolt was the popular coverage in many Newspapers during the 2016 Olympics since he was winning his third gold medal in 100 meter sprint. Here is simple but interesting three numbers about Usain Bolt, the fastest man in the world.\n\nHeight: 1.96 meters (6 foot 5 inches)\n\nDistance: 100 meters\n\nTime: 9.58 seconds\n\nThese three numbers can be true but maybe not. I am not suspecting about legitimacy of Usain Bolt’s record like the drug test results in the Olympics. I am pointing out that the measuring instrument, whoever measured, can only approximately measure these numbers up to certain degree. It is not because the measuring person did his job poorly but just because the instrument have own limitation to measure these numbers. For example, the sprint time might be 9.5823 seconds instead of 9.58 seconds. Maybe expressing it into 9582.3 milliseconds, we can be slightly more precise. However, still we are not dead accurate. To be dead accurate, we need infinite number of decimals to describe these numbers. This is impossible. Most of time, we will always approximate regardless of what measurement unit we are using. Likewise, the height of Usain Bolt is only the approximation too. Precisely speaking it is impossible to tell if he is 1.963 meter tall or 1.962 meter tall. Besides the height and time approximation, you can probably find many other approximation examples in our daily life like weight, speed, calories, etc.\n\nHere is another example. From your High School, you will probably remember pi, the ratio of a circle’s circumference to its diameter up to 2 decimal places as 3.14. Once again, this is only approximation. Some scientists remember it up to five decimal places as 3.14159 if they work frequently with pi. In fact, even if we use 50 decimal places to describe it as:\n\npi = 3.14159265358979323846264338327950288419716939937510,\n\nwe are only approximating it. By now, you should realize that countless approximation influence in and out of your life. One negative example might be that my classmate in my old university in the United Kingdom, failed to achieve the First Class honor since his overall score was only 69.4. In British degree system, First Class honor is granted to the students achieving the overall score over 70. First class honor is the highest grade they can achieve under the British degree system. At the same time, the other mate scored 69.6 earned First Class honor. Apparently, the academic satisfaction for these two friends were very different. Even after graduate, when they find jobs or when they get married, when they do business, these Second Class and First Class label will definitely stick with them. Now you can probably imagine that our world is not as pretty and square as you think. Well the same thing goes to scanning of Harmonic Patterns from your chart too.\n\nPattern Completion interval build its concept over the approximation but nothing else. It is in fact based on the assumption that the measured ratio in the harmonic patterns are only an approximation. Ideally, the popular Gartley Pattern should consist of the ratios shown in Figure 2-1. It is because we assume that harmonic pattern should have the exact Fibonacci ratio in theory. However, when the Gartley pattern is detected by the pattern scanner, most of time the pattern will possess the approximated ratios, which closely match to the ideal Gartley pattern but not dead accurate. Well, one day you can be very lucky to find the perfect Gartly pattern with perfect ratio in your chart. This is very rare event. Even in this very rare event, the chance that your pattern will be truly perfect is very thin because the pattern scanner might round up the ratio AB/XA for 0.618 instead of 0.6181 or CD/BC for 1.272 instead of 1.2723. Approximation error is always there in our pattern detection task. We will never be able to get rid of them since we have only limited memories inside both human brains and computers.", null, "Figure 2-1: Structure of Gartley Pattern for Bullish and Bearish Pattern.\n\nSince this approximation exists every time in detecting harmonic pattern, we know that, we are less accurate every time when our pattern scanner measure the ratio 0.618 or 0.382 or other Fibonacci ratio from our chart. Well, this is very common facts in the scientific world. On the other hands, as this is so common, the scientist already gave a lot of thought in overcoming this approximation error rather than using infinite number of decimals to describe the measurement.\n\nSo how can we be overcome this approximation error? Typically, in practical application like engineering and statistics, people use tolerance as one possible way of describing the measurement. In technical term, tolerance is the total amount by which a specific dimension is permitted to vary. The tolerance is the difference between the maximum and minimum limits. Going back to our Usain Bolt’s sprint record. Instead of writing 9.58 seconds, we can write 9.58 seconds 0.005. This means that Usain Bolt’s record will not be greater than 9.585 seconds and it will not be smaller than 9.575 seconds. His record will fall somewhere in between 9.585 and 9.575. By assigning maximum and minimum tolerance limit, we can be more precise in recording his records. We can also avoid using the infinite decimal places to describe his record. Using infinite decimal places is impractical. Likewise, we can describe his height as 1.96 0.005. This means that his height will fall in between 1.965 and 1.955 meters.\n\nHow this tolerance can be related to the Pattern Completion Interval in our Harmonic Pattern trading? Well, Pattern Completion Interval is in fact no more than just the tolerance limit described above. It is indeed the upper and lower limit permitted to vary in detecting Harmonic Pattern. Since detecting Harmonic Pattern is quit visual task, it might be a good idea to show the pattern completion interval using a box like in Figure 2-2. In the AB=CD Bearish reversal Pattern in Figure 2-2, the upper limit is the maximum price level permitted for this pattern to be qualified as AB=CD Harmonic Pattern. If EURUSD goes beyond this Upper Limit, then the Pattern can not be qualified as the AB=CD pattern since the pattern is breaching the tolerance limit for the given Fibonacci ratio.\n\nIn general, the tolerance limit in many practical applications are specified in symmetric manner like 1.96 meters 0.005. Technically, we can assign symmetric Upper and Lower Limit for Pattern Completion Interval too. However, either one limit between Lower Limit and Upper Limit is relevant for our trading depending our trading direction. For example, for Bearish Reversal Pattern, we only need to concern about Upper Limit since we want to know when the Harmonic Pattern will fail to form from the price moving too high. Likewise, for Bullish Reversal Pattern, we only need to concern about Lower Limit.", null, "Figure 2-2: Bearish AB=CD Pattern for EURUSD.\n\nAnother peculiar thing to discuss is that unlike our height and time example from Usain Bolt’s sprint, our pattern detection task involves several ratios and not just single ratio. For the Bearish AB=CD pattern in Figure 2-2, we will measure the ratio BC/AB and CD/BC together to check if these ratio are held near 0.618 and 1.271 respectively. Alternatively we can also check if the ratio is held near 0.786 and 1.618 respectively. Since we are checking two ratios, in fact we are concerning about 4 points for our pattern detection in our case of AB=CD pattern detection. Although the most important tolerance limit will be based on the final point D, one can still have the tolerance limits at the point A, B and C too. However, the tolerance limits at the point A, B and C are much less useful for our trading. In our operational definition, the Pattern Completion Interval is the tolerance limit at the final point D.\n\nPattern Completion interval and tolerance concept should clear up the most commonly asked questions from junior traders like:\n\n• Why detected Harmonic Patterns have the ratios different from the ideal one?\n• I am seeing the wrong patterns in my chart. Can I only see the ideal patterns in my chart?\n• My pattern is dead accurate. If I trade with this pattern, can I have success rate of 96%?\n\nAlthough we use the analogy of tolerance to illustrate the concept of the Pattern Completion Interval. In the course of our research, the concept of pattern completion interval was actually drawn from the concept of the prediction interval and confidence interval from statistics. For simple example, consider the simple regression with prediction interval and confidence interval shown in Figure 2-3. The fitted line on the constructed regression equation is the point prediction for the given x values. If we are using this regression equation to predict future y values according to the given x values, you can see that the point prediction from the given fitted line will not accurately predict the future outcome from Figure 2-3. In fact, most of time, prediction from regression equation will offer us some reference points to consider but they will be quite far out from actual future outcome.\n\nInstead of relying on this point prediction, statistician use prediction interval to illustrate worst and best case of your prediction in probabilistic sense. For example, 95% prediction interval means that future outcome will fall within this interval 95% of time. With the prediction interval, it is much easier to assess your risk of making wrong prediction than just using the point prediction alone. Likewise, the confidence interval is the similar concept to prediction interval. Instead of concerning the point prediction, Confidence interval concern our choice of parameters in our mathematical model. Since we can only estimate our parameters based on our sampled data, confidence interval help us to assess our risk associated with our choice of parameters. As before, 95% confidence interval means that the true population parameters will fall within this interval 95% of time. For both prediction interval and confidence interval, 90%, 95% and 99% are the common intervals to use. However, some industries use some other intervals like 80%.\n\nWe found that our Pattern Completion Interval shares many common ideas with prediction Interval and confidence interval. However, it is difficult to tell which one is closer to Pattern Completion Interval. The Pattern Completion Interval helps us to assess the risk associated with the Harmonic Pattern formation. If we view the harmonic pattern detection task as the prediction of turning point, then the Pattern Completion Interval offer the similar functionality to prediction interval to users. However, the Pattern Completion Interval does not offer us any probabilistic information like prediction and confidence interval do. Since we assume the Fibonacci ratio as an absolute measure for the Harmonic Pattern formation, the typical concern rising over the choice of parameters, which is necessary for many other practical applications, fade away. Since this book focus on the practical side, it make more sense to concern about the functionality of Pattern Completion Interval for traders.", null, "Figure 2-3: Illustration of simple Regression equation with confidence interval and prediction interval.\n\nBelow is the landing page for Harmonic Pattern Plus, Harmonic Pattern Scenario Planner and Profitable Pattern Scanner in MetaTrader. All these products are also available from www.mql5.com too." ]	[ null, "https://algotrading-investment.com/wp-content/uploads/2020/06/Figure-2-1_-Structure-of-Gartley-Pattern-for-Bullish-and-Bearish-Pattern..png", null, "https://algotrading-investment.com/wp-content/uploads/2020/06/Figure-2-2_-Bearish-ABCD-Pattern-for-EURUSD..png", null, "https://algotrading-investment.com/wp-content/uploads/2020/06/Figure-2-3_-Illustration-of-simple-Regression-equation-with-confidence-interval-and-prediction-interval..png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.9200272,"math_prob":0.9276119,"size":13712,"snap":"2022-40-2023-06","text_gpt3_token_len":2784,"char_repetition_ratio":0.1444412,"word_repetition_ratio":0.026496116,"special_character_ratio":0.20383605,"punctuation_ratio":0.10711493,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9600364,"pos_list":[0,1,2,3,4,5,6],"im_url_duplicate_count":[null,4,null,4,null,4,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-02-03T23:22:20Z\",\"WARC-Record-ID\":\"<urn:uuid:1f001590-fea7-4f08-bc73-f29043aa8b67>\",\"Content-Length\":\"99773\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:15f4982c-33b6-47f5-887f-a1631b775c30>\",\"WARC-Concurrent-To\":\"<urn:uuid:150f5df0-7352-4307-a6ca-ced57bc07cf7>\",\"WARC-IP-Address\":\"217.160.0.250\",\"WARC-Target-URI\":\"https://algotrading-investment.com/2020/06/01/the-concept-behind-the-pattern-completion-interval/\",\"WARC-Payload-Digest\":\"sha1:5R6WJ6ZVW77ZRVG3PABG4C5WIT5AUMPD\",\"WARC-Block-Digest\":\"sha1:4I7FM7UFTC6K7RNZZRGDCGU5FC65F7VX\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-06/CC-MAIN-2023-06_segments_1674764500076.87_warc_CC-MAIN-20230203221113-20230204011113-00326.warc.gz\"}"}
https://brainmass.com/business/black-scholes-model/black-scholes-model-option-pricing-230989	[ "Explore BrainMass\n\n# Black-Scholes Model - Option Pricing\n\nThis content was COPIED from BrainMass.com - View the original, and get the already-completed solution here!\n\n1. RED DOT currently sells for \\$56, its volatility is 35% interest rates 2%. Use the Black and Scholes equations to compute the value of a call and a put. The strike price is \\$55 and the options expire in 220 days.\n\n2. Check the answer with the bsm calculator\n\n3. Compute the . delta-theta-gamma approximation for a value of a call after 25 days for a stock price of \\$60. Compare this to the actual call premium computed based on the new price and time to expiration. Does the approximation work? Shortly discuss.\n\n4. You are a market maker who purchases one put contract (use info from #1) you would like to hedge your risk. Describe the portfolio you would establish to control stock. . Compute price risk.\n\n5. Based on your answer to #4 compute your one-day holding profit if the new stock price is \\$58. And If the stock price is \\$52.\n\n6. Based on the information from #1 set up a bear spread using calls with K = \\$55 and \\$65 (use software in the excel file attached to compute values). What are the combined Delta, vega, and Theta of your position? Then shortly explain the sign on each Greek.\n\nPlease see the attached files with the problems.\n\nText of the problems.doc - text of the problems\n\nBlackScholes.xls - option price calculator" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8804691,"math_prob":0.80084425,"size":1665,"snap":"2020-45-2020-50","text_gpt3_token_len":391,"char_repetition_ratio":0.115593016,"word_repetition_ratio":0.0,"special_character_ratio":0.24204203,"punctuation_ratio":0.124242425,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9666756,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-10-20T03:52:40Z\",\"WARC-Record-ID\":\"<urn:uuid:695b1781-050c-438c-9234-cd896d601cf7>\",\"Content-Length\":\"41778\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:06980153-99e2-4a51-8df2-fe471c5fdaf6>\",\"WARC-Concurrent-To\":\"<urn:uuid:4c0ea2f0-261c-40a1-b217-643d45e095d1>\",\"WARC-IP-Address\":\"65.39.198.123\",\"WARC-Target-URI\":\"https://brainmass.com/business/black-scholes-model/black-scholes-model-option-pricing-230989\",\"WARC-Payload-Digest\":\"sha1:F3BDVYANHR532MNXSCGGS6CV7NDX7MMA\",\"WARC-Block-Digest\":\"sha1:MQUTRVZKDKKPGXAAEGHT3YIZQE57EQXP\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-45/CC-MAIN-2020-45_segments_1603107869785.9_warc_CC-MAIN-20201020021700-20201020051700-00499.warc.gz\"}"}
https://kotlin-dev.ml/post/advent-of-code-2021-1/	[ "# Advent of Code 2021 in Kotlin - Day 1", null, "## Introduction\n\nWe start with Day 1 problem for which the solution is based on the template from the last year Advent of Code. Let’s begin to see some cool features of modern language - Kotlin 😎.\n\n## Solution\n\nWe solve the problem in pretty straightforward way - we analyze the input data in windows of different sizes. In the first part it’s enough to analyze the windows of size = 2 and count how many of them contains increase.\n\nIn the second part, we add extra step before counting the difference - we need to calculate the sums of windows of size = 3. Then, the solution is the same as in the first part.\n\n### Day1.kt\n\nobject Day1 : AdventDay() {\noverride fun solve() {\nval depths = reads<Int>() ?: return\ndepths.asSequence().countIncreases().printIt()\ndepths.asSequence().countSumIncreases().printIt()\n}\n\nprivate fun Sequence<Int>.countIncreases() = windowed(size = 2)\n.count { (prev, curr) -> curr > prev }\n\nprivate fun Sequence<Int>.countSumIncreases(size: Int = 3) = windowed(size)\n.map { it.sum() }\n.countIncreases()\n}\n\n\n## Extra notes\n\nLet’s see that we used Sequence<T> when solving the problem. It’s worth recalling that multiple operations on items in iterables should be implemented with usage of sequences because only in this way we can use the functional programming style and not cause the quadratic complexity of our solutions.\n\nAlso in countIncreases we could use the zipWithNext function, but it’s not required because of the feature of lists in Kotlin standard library. I want to recall that they can be destructured with componentN() functions as Pair<K, V> and that’s what we do in (prev, curr) -> curr > prev lambda definition. It’s worth mentioning that these componentN() functions can be defined also in our classes, so keep this in your mind when designing some Kotlin library API that could benefit from using these constructs 😉.", null, "###### Student of Computer Science\n\nMy interests include robotics (mainly with Arduino), mobile development for Android (love Kotlin) and Java SE/EE applications development." ]	[ null, "https://kotlin-dev.ml/post/advent-of-code-2021-1/featured_hu97e7c5a1426bc74b31a25fd0842f2eaf_1737208_720x2500_fit_q100_h2_lanczos.webp", null, "https://kotlin-dev.ml/authors/admin/avatar_hu1f2ae029604c9dcbbfa91c3c41c1f5ea_20682_270x270_fill_q100_lanczos_center.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.83244807,"math_prob":0.8412338,"size":1874,"snap":"2023-14-2023-23","text_gpt3_token_len":433,"char_repetition_ratio":0.105882354,"word_repetition_ratio":0.013157895,"special_character_ratio":0.23159018,"punctuation_ratio":0.102639295,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9575767,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,2,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-06-06T02:36:42Z\",\"WARC-Record-ID\":\"<urn:uuid:ebd298d5-4878-4e85-8f91-67d232ebea44>\",\"Content-Length\":\"16405\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:3bdea699-d45e-4546-be28-8fede379e654>\",\"WARC-Concurrent-To\":\"<urn:uuid:9f60510e-7a63-44fc-bcfb-6765f055d68f>\",\"WARC-IP-Address\":\"104.21.17.145\",\"WARC-Target-URI\":\"https://kotlin-dev.ml/post/advent-of-code-2021-1/\",\"WARC-Payload-Digest\":\"sha1:SRNQCQVP6OHAWLJF73ZY7IISXZBAFJ74\",\"WARC-Block-Digest\":\"sha1:UNNQJYMGC4454CFP2EAUFXFK2N7HJG75\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-23/CC-MAIN-2023-23_segments_1685224652207.81_warc_CC-MAIN-20230606013819-20230606043819-00195.warc.gz\"}"}
https://www.spec2000.net/16-eclife.htm	[ "Publication History: This article is based on \"Crain's Petrophysical Pocket Pal\" by E. R. (Ross) Crain, P.Eng., first published in 1987, and updated annually until 2016. This webpage version is the copyrighted intellectual property of the author. Do not copy or distribute in any form without explicit permission.", null, "Decline Rate and Economic Life\nIn order to determine the economic potential of a well, it is necessary to predict the production profile and economic life of a well from the reserves and flow capacity established by log data. Some assumptions must be made, as usual. These are the final production rate (Qa) below which it is uneconomic to produce the well, the annual exponential decline rate (D) and the initial deliverability (Qd).\n\nIn some jurisdictions, initial flow rate may be restricted by market demand or legislative control, or by good engineering judgment, common sense, or facilities restrictions. If this kind of production occurs, we assume the initial production rate (Qi) to be constant until this rate equals the well's ability to produce. Thereafter, production will decline at the exponential rate.", null, "DECline - Exponential Decline Rate Calculation\nThis routine presumes that recoverable reserves are known from some other source, such as volumetric analysis from log data, decline curve analysis, or material balance calculations. Set R in the equations below to equal Roil or Rgas, then proceed.\n\nThe production rate on decline is defined as Qa = Qd * exp (XTd). Thus solving for (XTd):\n1: (XTd) = ln (Qf / Qd)\n\nThe instantaneous decline rate (E) is found by.\n2: E = -365 * Qd (1 - exp (XTd)) / R\n\nThe annual decline rate is.\n3: D = exp (E) - 1\n\nLife of well on decline is found as follows.\n4: IF Qi >= Qd\n5: THEN Td = (XTd) / E\n\nIf the well is restricted to a constant rate.\n6: IF Qi < Qd\n7: THEN (XTd) = ln (Qf / Qi)\n8: AND Td = (XTd) / E\n\nThe reserves produced on decline are.\n9: Rd = -365 * Qi * (1 - exp (XTd)) / E\n\nThe reserves produced at constant rate are.\n10: Rc = R - Rd\n\nThe life at constant rate is.\n11: Tcon = Rc / Qi / 365\n\nThe total economic life is.\n12: Tec = Tc + Td\n\nWhere:\nD = annual decline rate (fractional)\nE = instantaneous decline rate (fractional)\nQd = initial well deliverability (bopd, mcf/d or m3/d)\nQa = economic limit or abandonment flow rate (bopd, mcf/d or m3/d)\nQi = initial production rate (bopd, mcf/d or m3 /d)\nR = recoverable reserves of well (bbl, mcf or m3)\nRc = reserves produced during constant rate (bbl, mcf or m3)\nRd = reserves produced during decline (bbl, mcf or m3)\nTcon = constant rate life (years)\nTd = decline life (years)\nTec = total economic life of well (years)\nX = instantaneous decline rate (fractional)\n(XTd) = decline factor (fractional)\n\nRECOMMENDED PARAMETERS: None.\n\nNUMERICAL EXAMPLE:\n1. Assume data as follows:\nReserves: Roil = 2.210^6 bbl/section\nDeliverability: QI = 1800 bopd\nEconomic Limit: QF = 10 bopd\n\n(XTd) = ln (10 / 1800) = -5.193\nE = -365 1800 * (1 - exp (-5.193)) / 2.210^6) = -0.297\nD = exp (-0.297) - 1 = -0.257\nTd = -5.194 / (-0.297) = 17.5 years = 210 months\nRd = -365 1800 * (1 - exp (-5.193)) / (-0.297) = 2.210^6 bbl\nRc = (2.2 - 2.2)10^6 = 0.0 bbl\nTcon = 0 / 1800 / 365 = 0.0 years\nTec = 0 + 17.5 = 17.5 years = 210 months\n\n2. If the initial flow rate was restricted to 1000 bopd:\n(XTd) = ln (10 / 1000) = -4.605\nTd = -4.605 / (-0.297) = 15.5 years = 186 months\nRd = -365 * 1000 * (1 - exp (-4.605)) / (-0.297) = 1.2 * 10 ^ 6 bbl\nRc = (2.2 - 1.2)10^6 = 1.010^6 bbl\nTcon = 1.0*10^6 / 1000 / 365 = 2.7 years = 32 months\nTec = 15.5 + 2.7 = 18.2 years = 218 months\n\nThe constant rate lengthens the life and reduces the profitability of the well, as will be seen in the next section.\n\nPage Views ---- Since 01 Jan 2015" ]	[ null, "https://www.spec2000.net/images/1leafsml.jpg", null, "https://www.spec2000.net/images/1leafsml.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8696389,"math_prob":0.9963061,"size":3708,"snap":"2021-31-2021-39","text_gpt3_token_len":1211,"char_repetition_ratio":0.122300215,"word_repetition_ratio":0.04526167,"special_character_ratio":0.35625675,"punctuation_ratio":0.14248367,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9975608,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-07-24T12:01:47Z\",\"WARC-Record-ID\":\"<urn:uuid:b8cb31f5-b1f4-488a-a429-aafd8258a9d0>\",\"Content-Length\":\"20959\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:89b3c3e8-cc54-4698-996f-b34ed6d43a37>\",\"WARC-Concurrent-To\":\"<urn:uuid:c1dd64d8-13d3-438e-ae33-6f8191544cf4>\",\"WARC-IP-Address\":\"173.209.39.73\",\"WARC-Target-URI\":\"https://www.spec2000.net/16-eclife.htm\",\"WARC-Payload-Digest\":\"sha1:53YF7PCMA773KLK7HPUXRBV6DZT6ZVNS\",\"WARC-Block-Digest\":\"sha1:CIHDHBABHJ4H47PFPFFHEMDFKSTD4KE3\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-31/CC-MAIN-2021-31_segments_1627046150264.90_warc_CC-MAIN-20210724094631-20210724124631-00293.warc.gz\"}"}
http://www.logistics-business-review.com/2019/10/22/the-key-facts-on-treehouse-foods-inc-ths-2019-10-22/	[ "# The Key Facts On Treehouse Foods, Inc. (\\$THS) (2019-10-22)\n\nREPORTING FOR 2019-10-22 \| LOGISTICS-BUSINESS-REVIEW.COM: We have done an in-depth analysis of how THS has been trading over the last 2 weeks and the past day especially. On its latest session, Treehouse Foods, Inc. (\\$THS) opened at 53.93, reaching a high of 54.895 and a low of 53.905 before closing at a price of 54.03. There was a total volume of 252521.\n\nVOLUME INDICATORS FOR TREEHOUSE FOODS, INC. (\\$THS): We saw an accumulation-distribution index of 322.83482, an on-balance volume of -53.92, chaikin money flow of 1.05181 and a force index of -0.39035. There was an ease of movement rating of 0.00085, a volume-price trend of 0.15437 and a negative volume index of 1000.0.\n\nVOLATILITY INDICATORS FOR TREEHOUSE FOODS, INC. (\\$THS): We noted an average true range of 0.86106, bolinger bands of 54.25697, an upper bollinger band of 53.16803, lower bollinger band of 53.905, a bollinger high band indicator of 1.0, bollinger low band indicator of 1.0, a central keltner channel of 54.24333, high band keltner channel of 53.27833, low band keltner channel of 55.20833, a high band keltner channel indicator of 1.0 and a low band keltner channel indicator of 1.0. There was a donchian channel high band of 53.905, a donchian channel low band of 53.905, a donchian channel high band indicator of 1.0, and a donchian channel low band indicator of 1.0.\n\nTREND INDICATORS FOR TREEHOUSE FOODS, INC. (\\$THS): We calculated a Moving Average Convergence Divergence (MACD) of -0.00864, a MACD signal of -0.0048, a MACD difference of -0.00384, a fast Exponential Moving Average (EMA) indicator of 53.905, a slow Exponential Moving Average (EMA) indicator of 53.905, an Average Directional Movement Index (ADX) of unknown, an ADX positive of 20.0, an ADX negative of 20.0, a positive Vortex Indicator (VI) of 1.0, a negative VI of 1.0, a trend vortex difference of 0.42851, a trix of 0.47649, a Mass Index (MI) of 1.0, a Commodity Channel Index (CCI) of -66.66667, a Detrended Price Oscillator (DPO) of -0.16643, a KST Oscillator (KST) of 3.09696 and a KST Oscillator (KST Signal) of 3.09696 (leaving a KST difference of -1.79108). We also found an Ichimoku rating of 54.4125, an Ichimoku B rating of 54.4125, a Ichimoku visual trend A of 54.83496, an Ichimoku visual trend B of 54.57753, an Aroon Indicator (AI) up of 4.0 and an AI indicator down of 4.0. That left a difference of -4.0.\n\nMOMENTUM INDICATORS FOR TREEHOUSE FOODS, INC. (\\$THS): We found a Relative Strength Index (RSI) of 50.0, a Money Flow Index (MFI) of 100.0, a True Strength Index (TSI) of 100.0, an ultimate oscillator of 86.94012, a stochastic oscillator of 102.59067, a stochastic oscillator signal of 102.59067, a Williams %R rating of 2.59067 and an awesome oscillator of -0.11025.\n\nRETURNS FOR TREEHOUSE FOODS, INC. (\\$THS): There was a daily return of 0.3097, a daily log return of -0.71678 and a cumulative return of -0.71422.\n\nWhat the heck does all of this mean? If you are new to technical analysis, the above may be gibberish to you, and that’s OK (though we do advise learning these things). The bottom line is that AS OF 2019-10-22 (if you are reading this later, the analysis will be out of date), here is what our deep analysis of technical indicators are telling us for Treehouse Foods, Inc. (\\$THS)…\n\nDISCLAIMER: We are not registered investment advisers and the above analysis should be taken at face value only. We strongly advise against buying or selling Treehouse Foods, Inc. (\\$THS) based solely on our analysis above, and are not responsible for any losses that you may incur if you choose make any investment decisions based on the above." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.826039,"math_prob":0.86452353,"size":3611,"snap":"2021-04-2021-17","text_gpt3_token_len":1098,"char_repetition_ratio":0.1275298,"word_repetition_ratio":0.051409617,"special_character_ratio":0.32290223,"punctuation_ratio":0.1799517,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9593655,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-04-18T08:29:43Z\",\"WARC-Record-ID\":\"<urn:uuid:e9dcd9c9-9a91-45ae-837f-a03f965dbcea>\",\"Content-Length\":\"22615\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:ab7dfeea-0edf-4364-87e3-49268e429623>\",\"WARC-Concurrent-To\":\"<urn:uuid:f379bfcc-a116-44dc-b96e-e8a63598097d>\",\"WARC-IP-Address\":\"199.201.110.119\",\"WARC-Target-URI\":\"http://www.logistics-business-review.com/2019/10/22/the-key-facts-on-treehouse-foods-inc-ths-2019-10-22/\",\"WARC-Payload-Digest\":\"sha1:VNLFLMU2RSHQTJJR2K6A7CRKTFOHIALK\",\"WARC-Block-Digest\":\"sha1:4UQ4TBLAZE7NF2PDYTUCQCHY7NEQYPU5\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-17/CC-MAIN-2021-17_segments_1618038469494.59_warc_CC-MAIN-20210418073623-20210418103623-00473.warc.gz\"}"}
https://scientificallysound.org/2017/05/11/independent-t-test-in-r/	[ "## Independent t-test in R", null, "As scientists, we often want to know if the difference between two groups is important or significant.\n\nFor example, you may have data on leg strength from students who came to class wearing dress shoes or running shoes. How would you decide if there was a difference in strength between these two groups? How would you quantify the size of this difference?\n\nAs one of the most widely used statistical tests in science, the student t-test should be familiar to most readers. In this post, we will learn how to perform an independent t-test in R. “Independent” refers to the fact that the data we are comparing comes from two independent groups.\n\n### The dataset: Environmental impact of pork and beef\n\nWe will first create a fictional dataset on the environmental impact (measured in kilograms of carbon dioxide) of pork and beef production.\n\n```# Number of animals in each group\nn = 30\nnames=c(rep(\"pork\", n) , rep(\"beef\", n))\n# Draw samples from two different populations\nvalue=c(sample(0:500, n, replace=T), sample(100:600, n, replace=T))\n# Create a dataframe\ndata=data.frame(names,value)\n```\n\nThe data we created is shown in the figure below.\n\nFigure 1: Grey dots represent each animal in our sample. The means and standard deviations are also plotted.", null, "### Difference between two independent groups\n\nOur figure indicates that, for the current sample of beef and pork, beef has approximately 100 kg more environmental impact. We can verify this by using the `summary` command:\n\n```summary(data\\$value[data\\$names=='pork'])\nMin. 1st Qu. Median Mean 3rd Qu. Max.\n0.0 163.0 271.0 262.0 396.2 476.0\nsummary(data\\$value[data\\$names=='beef'])\nMin. 1st Qu. Median Mean 3rd Qu. Max.\n115.0 273.0 370.5 353.6 452.0 593.0\n```\n\nOur visual inspection was pretty close. The mean value for the pork group is 262 kg whereas it is 353.6 kg for the beef group.\n\nTo test whether this difference is statistically significant, we will perform an independent t-test. The basic structure of the test is `t.test(group1_data, group2_data)`. Here is how to apply it to our data:\n\n```t.test(data\\$value[data\\$names=='pork'], data\\$value[data\\$names=='beef'])\n```\n\nThe output of this test is:\n\n``` Welch Two Sample t-test\n\ndata: data\\$value[data\\$names == \"pork\"] and data\\$value[data\\$names == \"beef\"]\nt = -2.3774, df = 57.304, p-value = 0.02079\nalternative hypothesis: true difference in means is not equal to 0\n95 percent confidence interval:\n-168.68251 -14.45082\nsample estimates:\nmean of x mean of y\n262.0333 353.6000\n```\n\n### Interpreting the output\n\nThe output of the t-test is quite informative. It provides us with the t-value (`t`), the degrees of freedom for the test (`df`), and the `p-value`. Because the `p-value` is below the threshold of 0.05, we can report that there is a statistically significant difference in the environmental impact between beef and pork.\n\nThe R output also provides us with the 95% confidence interval of the difference between groups as well as the mean of each group. Based on these values, we can conclude that the mean [95% CI] difference in kilograms of carbon dioxide between beef and pork is 91.6 [14.5 to 168.7]. This means that if we carried out 100 experiments, we would expect the mean difference of 95 of these experiments to be between 14.5 and 168.7 kg. An alternative interpretation is that we can be 95% certain that the (true) difference in means between the population of all beef and all pork falls between 14.5 and 168.7 kg.\n\nI am no expert in the field of environmental impact so it is difficult for me to interpret these values (especially since I made them up!). However, the 95% confidence interval seems large. A true difference of 15 kg might be inconsequential and of no scientific interest, whereas a difference of 169 kg might be cause for concern. One way to help readers understand our results would be to contrast them with more familiar forms of environmental impact. For example, would could say that, over the period of a year, the difference in environmental impact between beef and pork is equivalent to having an addition 50 diesel-fulled cars on the road.\n\nWhen reporting results, we should not simply state there was a significant difference between groups. We should provide the reader with our estimate of the size of the effect (i.e., the mean difference), as well as the uncertainty of our estimate (i.e., the 95% confidence interval). Finally, we should interpret these values for the reader based on previous results, known standards, etc.\n\n### One comment\n\n• Informative article providing good understanding of underlying numbers. Thanks!\n\nLike" ]	[ null, "https://scientificallysoundorg360.files.wordpress.com/2016/01/r1.png", null, "https://scientificallysoundorg360.files.wordpress.com/2017/05/rplot01.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.90674126,"math_prob":0.96415466,"size":4423,"snap":"2021-43-2021-49","text_gpt3_token_len":1049,"char_repetition_ratio":0.12672551,"word_repetition_ratio":0.019607844,"special_character_ratio":0.25706533,"punctuation_ratio":0.13391878,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9916644,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-10-18T06:45:22Z\",\"WARC-Record-ID\":\"<urn:uuid:7dbdf4a7-7552-4276-b20d-9ad18183a0fb>\",\"Content-Length\":\"115414\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:52a2ec18-0091-44a4-ab25-7c602a424c05>\",\"WARC-Concurrent-To\":\"<urn:uuid:2a5c0848-a21a-440f-807e-fd5575daa65b>\",\"WARC-IP-Address\":\"192.0.78.25\",\"WARC-Target-URI\":\"https://scientificallysound.org/2017/05/11/independent-t-test-in-r/\",\"WARC-Payload-Digest\":\"sha1:MNU3GAFR2MZ3KF2XOOELJTXTX2MVXVAE\",\"WARC-Block-Digest\":\"sha1:I7ROYLXNTZHL7RGV72AJNUDIWI6OMVY7\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-43/CC-MAIN-2021-43_segments_1634323585199.76_warc_CC-MAIN-20211018062819-20211018092819-00395.warc.gz\"}"}
http://bergthenerd.com/math/3rd-grade-math/	[ "# 4th & 5th Grade Math\n\n4th Grade Units (Based upon Oregon Common Core Standards for Mathematics):\n\nOperations and Algebraic Thinking\n\n• Use the four operations with whole numbers to solve problems.\n• Gain familiarity with factors and multiples.\n• Generate and analyze patterns.\n\nNumber and Operations in Base Ten\n\n• Generalize place value understanding for multi-digit whole numbers.\n• Use place value understanding and properties of operations to perform multi-digit arithmetic.\n\nNumber and Operations – Fractions\n\n• Extend understanding of fraction equivalence and ordering.\n• Build fractions from unit fractions by applying and extending previous understandings of operations on whole numbers.\n• Understand decimal notation for fractions, and compare decimal fractions.\n\nMeasurement and Data\n\n• Solve problems involving measurement and conversion of measurements from a larger unit to a smaller unit.\n• Represent and interpret data.\n• Geometric measurement: understand concepts of angle and measure angles.\n\nGeometry\n\n• Draw and identify lines and angles, and classify shapes by properties of their lines and angles.\n\n5th Grade Units (Based upon Oregon Common Core Standards for Mathematics):\n\nOperations and Algebraic Thinking\n\n• Write and interpret numerical expressions.\n• Analyze patterns and relationships.\n\nNumber and Operations in Base Ten\n\n• Understand the place value system.\n• Perform operations with multi-digit whole numbers and with decimals to hundredths.\n\nNumber and Operations – Fractions\n\n• Use equivalent fractions as a strategy to add and subtract fractions.\n• Apply and extend previous understandings of multiplication and division to multiply and divide fractions.\n\nMeasurement and Data\n\n• Convert like measurement units within a given measurement system.\n• Represent and interpret data.\n• Geometric measurement: understand concepts of volume and relate volume to multiplication and to addition.\n\nGeometry\n\n• Graph points on the coordinate plane to solve real-world and mathematical problems.\n• Classify two-dimensional figures into categories based on their properties." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8366917,"math_prob":0.97060466,"size":2050,"snap":"2023-14-2023-23","text_gpt3_token_len":358,"char_repetition_ratio":0.15640274,"word_repetition_ratio":0.1632653,"special_character_ratio":0.17658536,"punctuation_ratio":0.094462544,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9980639,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-03-21T08:33:54Z\",\"WARC-Record-ID\":\"<urn:uuid:9addd34a-afaa-43a8-a3f8-25552397c397>\",\"Content-Length\":\"108835\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:ab81bfce-140f-40ca-bac8-438d1bfab403>\",\"WARC-Concurrent-To\":\"<urn:uuid:158a0eaa-4bcf-4414-8237-1911e0ce0c7a>\",\"WARC-IP-Address\":\"69.163.165.215\",\"WARC-Target-URI\":\"http://bergthenerd.com/math/3rd-grade-math/\",\"WARC-Payload-Digest\":\"sha1:FYZPMFBZJVODCCZA7T7NNQ3CHDQDQWIN\",\"WARC-Block-Digest\":\"sha1:ZYTJ4W5KLBRFXJ5V24L53X2POBGTI4GE\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-14/CC-MAIN-2023-14_segments_1679296943637.3_warc_CC-MAIN-20230321064400-20230321094400-00493.warc.gz\"}"}
https://lists.cam.ac.uk/pipermail/cl-isabelle-users/2010-November/msg00125.html	[ "# Re: [isabelle] Changing unification depth\n\n```On Sun, 28 Nov 2010, John Munroe wrote:\n\n```\nI've tried it with \"writeln (Int.toString search_bnd)\" instead and I get a reading of 60 as well, even after I've changed it to 5 with \"declare [[unify_search_bound=5]]\". I've looked at some of the unifiers and they are definitely deeper than 5 levels, e.g.,\n```\n%a::nat => nat.\na (a (a (a (a (a\n(a (a (a (a (a (a (a (a (a (a (a (a (a\n(a (a (a (a (a (a (a (a (a (a (a (a (a\n(a (a (a (a (a (a (a (a (a (a (a (a (a\n(a (a (a (a (a (a (a (a (a (a (a (a ((h::(nat => bool) => nat)\n(s::nat => bool))))))))))))))))))))))))))))))))))))))))))))))))))))))))))\n```\n```\n```\nThat's very strange. Are you sure you have the correct context in your example? One where the \"declare [[unify_search_bound=5]]\" is effective?\n```\nCan you show a self-contained snippet of theory source text?\n\nMakarius\n\n```\n\nThis archive was generated by a fusion of Pipermail (Mailman edition) and MHonArc." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.9377339,"math_prob":0.9676786,"size":923,"snap":"2021-43-2021-49","text_gpt3_token_len":323,"char_repetition_ratio":0.28618065,"word_repetition_ratio":0.3151515,"special_character_ratio":0.3943662,"punctuation_ratio":0.11734694,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9999379,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-12-03T10:38:25Z\",\"WARC-Record-ID\":\"<urn:uuid:acb31c31-4069-4c7d-9ec0-076e3eea81f3>\",\"Content-Length\":\"6192\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:a6e7d5bc-6eaa-4b1f-ad25-c92c348cc4df>\",\"WARC-Concurrent-To\":\"<urn:uuid:e4e8832d-0dae-4975-9b25-0d0919d310f9>\",\"WARC-IP-Address\":\"131.111.8.15\",\"WARC-Target-URI\":\"https://lists.cam.ac.uk/pipermail/cl-isabelle-users/2010-November/msg00125.html\",\"WARC-Payload-Digest\":\"sha1:WTUUR5J3W5IGT7A7OIISQ5BL3MSMPFQW\",\"WARC-Block-Digest\":\"sha1:7K6UQMCN4HHCXKHJCMYJ5K3IEMDWAJPX\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-49/CC-MAIN-2021-49_segments_1637964362619.23_warc_CC-MAIN-20211203091120-20211203121120-00587.warc.gz\"}"}
https://pure.ncue.edu.tw/en/publications/applying-envelope-theory-and-deviation-function-to-tooth-profile-	[ "# Applying envelope theory and deviation function to tooth profile design\n\nResearch output: Contribution to journalArticlepeer-review\n\n11 Citations (Scopus)\n\n## Abstract\n\nIn this work, a mathematical model of an elastic conjugate element is presented, using envelope theory and a deviation function. A basic deformation curve in a two-dimensional system is defined, and determined by the maximum deformation of the originally generated curve. The set of these points of maximum deformation in the moving coordinate frame determines the deviation of the originally generated curve. The degree of deviation is described by a deviation function. A deviation function is chosen to reshape the originally generated curve. The reshaped curve is called a basic deformation curve. If the basic deformation curve is known, an envelope associated with them can be determined. The results are applied to rotary gear pump design. The reshaped curve is superior to the originally generated curve. The reshaped curve has lower deformation, von-Mises stress, and greater bending strength than the originally generated curve. This investigation indicates that envelope theory and deviation function can avoid singular points of conjugate elements, using an example.\n\nOriginal language English 262-274 13 Mechanism and Machine Theory 42 3 https://doi.org/10.1016/j.mechmachtheory.2006.04.009 Published - 2007 Mar 1\n\n## All Science Journal Classification (ASJC) codes\n\n• Bioengineering\n• Mechanics of Materials\n• Mechanical Engineering\n• Computer Science Applications" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.87131965,"math_prob":0.5981567,"size":1427,"snap":"2021-04-2021-17","text_gpt3_token_len":274,"char_repetition_ratio":0.15038651,"word_repetition_ratio":0.048543688,"special_character_ratio":0.1899089,"punctuation_ratio":0.07929515,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.95719844,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-01-27T00:47:01Z\",\"WARC-Record-ID\":\"<urn:uuid:452a740f-cadc-40de-80f9-cf4cc98cc571>\",\"Content-Length\":\"48032\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:25ec9254-ead2-4b8d-b662-8bd8d6ed8cd7>\",\"WARC-Concurrent-To\":\"<urn:uuid:1b2b4e2e-75b1-4aa2-8710-c6128b05c889>\",\"WARC-IP-Address\":\"18.139.148.124\",\"WARC-Target-URI\":\"https://pure.ncue.edu.tw/en/publications/applying-envelope-theory-and-deviation-function-to-tooth-profile-\",\"WARC-Payload-Digest\":\"sha1:4DOEEAQKH3D2H2VBDTHFWPVL5NTBXE5E\",\"WARC-Block-Digest\":\"sha1:B3GSYEB7PM5OSSJ43I4F4GZYKSKVKNUG\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-04/CC-MAIN-2021-04_segments_1610704804187.81_warc_CC-MAIN-20210126233034-20210127023034-00185.warc.gz\"}"}
http://ocamlgraph.lri.fr/doc/index_modules.html	[ "# Index of modules\n\n A Abstract [Imperative.S] Abstract Imperative Unlabeled Graphs. Abstract [Persistent.S] Abstract Persistent Unlabeled Graphs. AbstractLabeled [Imperative.S] Abstract Imperative Labeled Graphs. AbstractLabeled [Persistent.S] Abstract Persistent Labeled Graphs. Algo [Strat] Implements strategy algorithms on graphs B B [Merge] Extension for the module `X`. BellmanFord [Path] Bfs [Traverse] Breadth-first search Bfs [Sig_pack.S] Breadth-first search Bron_Kerbosch [Clique] Builder Graph builders in order to persistent/imperative graphs sharing a same signature. C CMPProduct [Util] Cartesian product of two comparable types. CVS [Cliquetree.CliqueTree] Set of original vertices ChaoticIteration Fixpoint computation with widenings using weak topological orderings as defined by François Bourdoncle and implemented in `WeakTopological`. Check [Path] Check for a path. Choose [Oper] Choose an element in a graph Classic Some classic graphs Classic [Sig_pack.S] Classic graphs Clique Graph cliques CliqueTree [Cliquetree.CliqueTree] The clique tree graph type CliqueTree [Cliquetree] CliqueTreeE [Cliquetree.CliqueTree] CliqueTreeV [Cliquetree.CliqueTree] Clique tree vertex type CliqueV [Cliquetree.CliqueTree] Original graph vertex Cliquetree Construction of the clique tree of a graph and recognition of chordal graphs. Coloring `k`-coloring of undirected graphs. CommonAttributes [Graphviz] The `CommonAttributes` module defines attributes for graphs, vertices and edges that are available in the two engines, dot and neato. Components Strongly connected components. Components [Sig_pack.S] Strongly connected components Concrete [Imperative.S] Imperative Unlabeled Graphs. Concrete [Persistent.S] Persistent Unlabeled Graphs. ConcreteBidirectional [Imperative.Digraph] Imperative Unlabeled, bidirectional graph. ConcreteBidirectional [Persistent.Digraph] Imperative Unlabeled, bidirectional graph. ConcreteBidirectionalLabeled [Imperative.Digraph] Imperative Labeled and bidirectional graph. ConcreteBidirectionalLabeled [Persistent.Digraph] Imperative Labeled and bidirectional graph. ConcreteLabeled [Imperative.S] Imperative Labeled Graphs. ConcreteLabeled [Persistent.S] Persistent Labeled Graphs. Contraction Edge contraction for directed, edge-labeled graphs D DGraphContainer DGraphModel Abstract graph model DGraphRandModel DGraphSubTree DGraphTreeLayout DGraphTreeModel This functor creates a model centered on a vertex from a graph DGraphView View classes. DGraphViewItem View items for the different elements of a graph. DataV [Util] Create a vertex type with some data attached to it Delaunay Delaunay triangulation. Dfs [Traverse] Depth-first search Dfs [Sig_pack.S] Depth-first search Digraph [Pack] Directed imperative graphs with edges and vertices labeled with integer. Digraph [Imperative.Matrix] Imperative Directed Graphs implemented with adjacency matrices. Digraph [Imperative] Imperative Directed Graphs. Digraph [Persistent] Persistent Directed Graphs. Dijkstra [Path] Dominator Dominators Dot [DGraphContainer] Dot Parser for DOT file format. Dot [Graphviz] DotAttributes [Graphviz] `DotAttributes` extends `CommonAttributes` and implements `ATTRIBUTES`. DotG [DGraphModel] Dot_ast AST for DOT file format. E E [DGraphSubTree.Tree] E [DGraphSubTree.G] E [ChaoticIteration.G] E [Graphml.G] E [Contraction.G] E [Fixpoint.G] E [Gmap.E_SRC] E [Gml.G] E [Prim.G] E [Flow.G_FORD_FULKERSON] E [Flow.G_GOLDBERG_TARJAN] E [Kruskal.G] E [Path.G] E [Sig_pack.S] Edges E [Sig.G] Edges have type `E.t` and are labeled with type `E.label`. Edge [Gmap] Provide a mapping function from a mapping of edges. F Fixpoint Fixpoint computation implemented using the work list algorithm. Float [Delaunay] Delaunay triangulation with floating point coordinates FloatPoints [Delaunay] Points with floating point coordinates Flow Algorithms on flows Ford_Fulkerson [Flow] G G [DGraphRandModel] G [Minsep.MINSEP] Implementation of a graph G [Builder.S] GView [DGraphContainer.S] Generic [Kruskal] Functor providing an implementation of Kruskal's minimum-spanning-tree algorithm using a user-defined union-find algorithm. Gmap Graph mapping. Gml Parser and pretty-printer for GML file format. Goldberg_Tarjan [Flow] Graph [Pack] Undirected imperative graphs with edges and vertices labeled with integer. Graph [Imperative.Matrix] Imperative Undirected Graphs implemented with adjacency matrices. Graph [Imperative] Imperative Undirected Graphs. Graph [Persistent] Persistent Undirected Graphs. GraphAttrs [DGraphRandModel] Graphml Generic GraphMl Printer Graphviz Interface with GraphViz H H [Coloring.Make] Hash tables used to store the coloring H [Path.BellmanFord] HE [XDot.Make] HTProduct [Util] Cartesian product of two hashable types. HV [XDot.Make] HVV [Path.Johnson] I I [Merge] Extension for the module `G`. I [Md] I [Mcs_m.MaximalCardinalitySearch] I [Minsep] Implementation for an imperative graph. I [Oper] Basic operations over imperative graphs I [Rand.Planar] Random imperative planar graphs I [Rand] Random imperative graphs I [Classic] Classic Imperative Graphs I [Builder] Imperative Graphs Builders. Imperative [Nonnegative] Imperative Imperative Graph Implementations. Int [Delaunay] Delaunay triangulation with integer coordinates IntPoints [Delaunay] Points with integer coordinates J Johnson [Path] K Kruskal Kruskal's minimum-spanning-tree algorithm. L Leaderlist The leader list algorithm; it generates a list of basic blocks from a directed graph. M M [ChaoticIteration.Make] Map used to store the result of the analysis Make [DGraphContainer] Make [DGraphView] Make [DGraphSubTree] Make [DGraphTreeLayout] Make [DGraphModel] This functor creates a model from a graph Make [XDot] Instantiates a module which creates graph layouts from xdot files Make [ChaoticIteration] Make [WeakTopological] Make [Mincut] Make [Contraction] Make [Leaderlist] Make [Fixpoint] Make [Dominator] Make [Prim] Functor providing an implementation of Prim's minimum-spanning-tree algorithm. Make [Kruskal] Functor providing an implementation of Kruskal's minimum-spanning-tree algorithm. Make [Topological] Functor providing topological iterators over a graph. Make [Coloring] Provide a function for `k`-coloring a graph. Make [Components] Functor providing functions to compute strongly connected components of a graph. Make [Oper] Basic operations over graphs Make [Rand.Planar] Random planar graphs Make [Rand] Random graphs Make [Delaunay] Generic Delaunay triangulation MakeFromDotModel [DGraphTreeLayout] Make_from_dot_model [DGraphSubTree] Make_graph [Dominator] Make_stable [Topological] Provide the same features than `Topological.Make`, except that the resulting topological ordering is stable according to vertices comparison: if two vertices `v1` and `v2` are topologically equal, `v1` is presented first to the iterator if and only if `G.V.compare v1 v2 <= 0`. Mark [Coloring.GM] Mark [Coloring] Provide a function for `k`-coloring a graph with integer marks. Mark [Traverse.GM] Mark [Traverse] Graph traversal with marking. Mark [Sig_pack.S] Vertices contains integers marks, which can be set or used by some algorithms (see for instance module `Marking` below) Mark [Sig.IM] Mark on vertices. Marking [Sig_pack.S] Graph traversal with marking Matrix [Imperative] Imperative graphs implemented as adjacency matrices. MaximalCardinalitySearch [Mcs_m] Mcs_m Maximal Cardinality Search (MCS-M) algorithm Md Minimum Degree algorithm Merge Provides functions to extend any module satisfying one of the signatures Sig.P, Sig.I and Builder.S . Mincut Minimal cutset of a graph Minsep Minimal separators of a graph N Neato [Graphviz] NeatoAttributes [Graphviz] The `NeatoAttributes` module defines attributes for graphs, nodes and edges that are available in the neato engine. Neighbourhood [Oper] Neighbourhood of vertex / vertices Nonnegative Weighted graphs without negative-cycles. O OTProduct [Util] Cartesian product of two ordered types. Oper Basic operations over graphs P P [Merge] Extension for the module `G`. P [Md] P [Mcs_m.MaximalCardinalitySearch] P [Minsep] Implementation for a persistent graph P [Oper] Basic operations over persistent graphs P [Rand.Planar] Random persistent planar graphs P [Rand] Random persistent graphs P [Classic] Classic Persistent Graphs P [Builder] Persistent Graphs Builders. Pack Immediate access to the library: provides implementation of imperative graphs labeled with integer as well as algorithms on such graphs. Parse [Dot] Provide a parser for DOT file format. Parse [Gml] Provide a parser for GML file format. Path Paths PathCheck [Sig_pack.S] Path checking Persistent [Nonnegative] Persistent graphs with negative-cycle prevention Persistent Persistent Graph Implementations. Planar [Rand] Prim Functor providing an implementation of Prim's minimum-spanning-tree algorithm. Print [Graphml] Graphml Printer given a graph and required info Print [Gml] Provide a pretty-printer for GML file format. R Rand Random graph generation. Rand [Sig_pack.S] Random graphs S S [Dominator.S] S [Delaunay.Triangulation] Sig Signatures for graph implementations. Sig_pack Immediate access to the library: contain a signature gathering an imperative graph signature and all algorithms. Strat Strategies SubTreeDotModelMake [DGraphTreeModel] Creates a model centered on a vertex from a dot model SubTreeMake [DGraphTreeModel] This functor creates a model centered on a vertex from a graph T TView [DGraphContainer.S] Topological Topological order. Topological [Sig_pack.S] Topological order Traverse Graph traversal. Tree [DGraphContainer.S] Tree [DGraphTreeModel.S] Tree [DGraphSubTree.S] Tree [DGraphTreeLayout.MakeFromDotModel] TreeManipulation [DGraphTreeModel.S] U Undirected [Components] Util Some useful operations. V V [DGraphSubTree.Tree] V [DGraphSubTree.G] V [ChaoticIteration.G] V [WeakTopological.G] V [Clique.G] V [Mincut.G] V [Contraction.G] V [Leaderlist.G] V [Fixpoint.G] V [Strat.G] V [Minsep.G] V [Gmap.V_SRC] V [Gml.G] V [Dominator.G] V [Prim.G] V [Flow.G_FORD_FULKERSON] V [Flow.G_GOLDBERG_TARJAN] V [Kruskal.G] V [Topological.G] V [Coloring.GM] V [Coloring.G] V [Traverse.GM] V [Traverse.G] V [Path.G] V [Components.U] V [Components.G] V [Sig_pack.S] Vertices V [Sig.G] Vertices have type `V.t` and are labeled with type `V.label` (note that an implementation may identify the vertex with its label) VSetset [Minsep.MINSEP] Implementation of a set of `Vertex_Set` Vertex [Gmap] Provide a mapping function from a mapping of vertices. Vertex_Set [Minsep.MINSEP] Implementation of a set of vertex Vertex_Set [Oper.Neighbourhood] W WeakTopological Weak topological ordering of the vertices of a graph, as described by François Bourdoncle. X XDot Reads layout information from xdot ASTs XDotDraw Parses xdot drawing operations" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.62155354,"math_prob":0.6640746,"size":10994,"snap":"2020-10-2020-16","text_gpt3_token_len":3008,"char_repetition_ratio":0.15141037,"word_repetition_ratio":0.07185185,"special_character_ratio":0.20602147,"punctuation_ratio":0.120453194,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9581357,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-02-25T18:43:55Z\",\"WARC-Record-ID\":\"<urn:uuid:c5199f0f-37e0-4ba3-93a2-d9b7e8b517a6>\",\"Content-Length\":\"41754\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:00ebf449-da06-4bf9-ad02-8e193968066e>\",\"WARC-Concurrent-To\":\"<urn:uuid:5cd50917-e11b-48ac-8fec-46691fc465fd>\",\"WARC-IP-Address\":\"129.175.15.11\",\"WARC-Target-URI\":\"http://ocamlgraph.lri.fr/doc/index_modules.html\",\"WARC-Payload-Digest\":\"sha1:PKGXX3Q7DLV7VJ5DBFAZK7DL7W5HZE3Q\",\"WARC-Block-Digest\":\"sha1:QE3BDG4EFJEFG7MT3ZGELVZC7NS5SHST\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-10/CC-MAIN-2020-10_segments_1581875146127.10_warc_CC-MAIN-20200225172036-20200225202036-00179.warc.gz\"}"}
https://theolivebook.com/types-of-sat-math-questions/	[ "# Types of SAT Math Questions on the SAT Test", null, "The dozens of math questions on the SAT can be broken down into four types of math questions: Heart of Algebra, Problem Solving and Data Analysis, Passport to Advanced Math, and Additional Topics in Math.\n\nUnderstanding the content that falls under these four question categories will help you study for the SAT with greater focus. And with more focused practice, you’re more likely to see an increase in your SAT score.\n\nACT, SAT Math Practice Questions with Explanations\n\n## Four Types of Questions on the SAT Math Section\n\n### Heart of Algebra\n\nHeart of Algebra questions cover linear algebra and manipulation of equations.\n\nFor the Heart of Algebra questions (roughly 33% of total questions) you may need to:\n\n• Find distance on a number line, between points on a coordinate plane, or in terms of absolute value\n• Use word to symbol translation and linear equations and inequalities to solve real-world problems in context\n• Manipulate and evaluate variable expressions and equations (including absolute value)\n• Solve linear and quadratic inequalities and match with appropriate graphs\n• Find and interpret slope and intercepts from equations, word problems and graphs (also using properties of parallel and perpendicular lines)\n• Match, interpret, and analyze information from graphs in the coordinate plane\n• Solve and interpret systems of linear equations and linear inequalities both in context of real-world problems and without context\n\n### Problem Solving and Data Analysis\n\nThese questions cover your understanding of numbers, data, and rational problem solving.\n\nFor Problem Solving and Data Analysis concepts (roughly 29% of total questions) you will need to:\n\n• Solve multi-step problems using ratios, proportions, rate, percentages, and/or conversion of units of measure\n• Refer to data, charts, frequency tables, and graphs to interpret information\n• Demonstrate knowledge of measures of central tendency and distribution (mean, median, mode, range), how to compute each, and how to compute for a missing data point given a measure of central tendency\n• Compute probabilities of an event, its complement, and combinations (conditional and joint probability) in context\n• Demonstrate knowledge of the fundamental counting principle and Venn Diagrams\n• Understand the fundamentals of statistics (random sampling, distribution, standard deviation, confidence interval, and interpretation of results)\n• Interpret key features and relationships between variables in graphs\n• Understand differences between linear, quadratic, and exponential relationships in context (frequently as simple and compound interest or growth/decay)\n• Extend patterns, both arithmetic and geometric, increasing and decreasing by common factors or ratios\n\n#### Get a New Practice Question Each Week\n\nEnter your email below to get a new ACT/SAT practice question delivered to your inbox each Wednesday.\n\nThese questions test your ability to solve complex equations.\n\nPassport to Advanced Math concepts (roughly 28% of total questions) may test your ability to:\n\n• Manipulate exponents in powers of 10, and scientific notation, and apply properties of rational exponents\n• Demonstrate knowledge of the real number system – rational, irrational, and complex numbers\n• Add, subtract, multiply, and divide polynomials\n• Create and interpret quadratic or exponential functions in context\n• Analyze, solve, and graph quadratic or other nonlinear equations and systems\n• Manipulate expressions and equations with exponents, integer and rational powers, radicals, and fractions with variables in the denominator\n• Interpret and evaluate functions and composite functions\n• Interpret functions and their graphs\n• Identify intercepts and maximum and minimum values\n• Find domain and range and asymptotes\n• Understand increasing and decreasing, end behavior, and transformations/translations\n• Write functions that are directly or inversely proportional or exponential\n\nAdditional Topics in Math questions (roughly 10% of total questions) frequently combine multiple geometry concepts into one question in context. These concepts include your ability to:\n\n• Calculate lengths and midpoints of line segments (overlapping segments and those in the coordinate plane)\n• Compute perimeter and area of polygons and circumference and area of circles\n• Use properties of parallel lines, other angle properties, and similar figures and ratios to find missing angle measures or side lengths/distances\n• Use properties of isosceles and right triangles to compute unknown side lengths and angle measures (symmetry, Pythagorean theorem, etc…)\n• Demonstrate knowledge of right triangles (30o, 60o, 90o; 45o, 45o, 90o) and apply trigonometric ratios (sine, cosine, tangent) to solve for missing values\n• Manipulate between area, volume, and surface area\n• Understand the trigonometry of the unit circle and basic trig identities to solve problems involving radians and angle measures\n• Understand circle relationships such as central and inscribed angles, arc length and sector area, tangents and chords\n• Create the equation of a circle in the coordinate plane by finding the center and radius\n• Manipulate (add, subtract, multiply, divide, simplify) complex numbers (i=-1)" ]	[ null, "https://theolivebook.com/wp-content/uploads/2021/01/sat-math-problems-1024x512.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8662836,"math_prob":0.95542014,"size":6097,"snap":"2021-43-2021-49","text_gpt3_token_len":1202,"char_repetition_ratio":0.12358444,"word_repetition_ratio":0.010881393,"special_character_ratio":0.18664917,"punctuation_ratio":0.0950951,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9987466,"pos_list":[0,1,2],"im_url_duplicate_count":[null,2,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-10-27T16:19:00Z\",\"WARC-Record-ID\":\"<urn:uuid:b862034a-a4f6-43f8-8cbf-f3e63a6c35c7>\",\"Content-Length\":\"89888\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:eb42c53f-1574-4b71-bad5-053c67def351>\",\"WARC-Concurrent-To\":\"<urn:uuid:775bb271-7aea-4065-8545-ee24823eb056>\",\"WARC-IP-Address\":\"173.205.127.160\",\"WARC-Target-URI\":\"https://theolivebook.com/types-of-sat-math-questions/\",\"WARC-Payload-Digest\":\"sha1:K3BPSIQCS3G6WNG7MVVSOHVNATA6XW3J\",\"WARC-Block-Digest\":\"sha1:YDZ44U75FDPW5N6FLDRALXBFBVZJIAQG\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-43/CC-MAIN-2021-43_segments_1634323588216.48_warc_CC-MAIN-20211027150823-20211027180823-00423.warc.gz\"}"}
https://answers.everydaycalculation.com/gcf/990-900	[ "Solutions by everydaycalculation.com\n\n## What is the GCF of 990 and 900?\n\nThe gcf of 990 and 900 is 90.\n\n#### Steps to find GCF\n\n1. Find the prime factorization of 990\n990 = 2 × 3 × 3 × 5 × 11\n2. Find the prime factorization of 900\n900 = 2 × 2 × 3 × 3 × 5 × 5\n3. To find the gcf, multiply all the prime factors common to both numbers:\n\nTherefore, GCF = 2 × 3 × 3 × 5\n4. GCF = 90\n\nMathStep (Works offline)", null, "Download our mobile app and learn how to find GCF of upto four numbers in your own time:" ]	[ null, "https://answers.everydaycalculation.com/mathstep-app-icon.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.78551096,"math_prob":0.99895173,"size":609,"snap":"2020-10-2020-16","text_gpt3_token_len":201,"char_repetition_ratio":0.12561983,"word_repetition_ratio":0.0,"special_character_ratio":0.43842363,"punctuation_ratio":0.07826087,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9966435,"pos_list":[0,1,2],"im_url_duplicate_count":[null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-04-01T21:25:35Z\",\"WARC-Record-ID\":\"<urn:uuid:a067c1fc-bc3b-4601-9277-04575359ccb1>\",\"Content-Length\":\"6109\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:7962302e-51e2-4535-bc93-e8d4f82090c0>\",\"WARC-Concurrent-To\":\"<urn:uuid:145c62b0-1199-4d09-9dc0-e699d1ed33cc>\",\"WARC-IP-Address\":\"96.126.107.130\",\"WARC-Target-URI\":\"https://answers.everydaycalculation.com/gcf/990-900\",\"WARC-Payload-Digest\":\"sha1:THMDJG63WZLKKF3V4DHT5D2MPHMIYTLO\",\"WARC-Block-Digest\":\"sha1:GLMHDL342KH6WJKYI5KPDH32ZAJXOWKA\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-16/CC-MAIN-2020-16_segments_1585370506121.24_warc_CC-MAIN-20200401192839-20200401222839-00138.warc.gz\"}"}
https://catcoding.me/p/findsum/	[ "", null, "## 一个小题目\n\n2010-08-02\n\n``````//1 到 100 000\n#include <iostream>\n#include <math.h>\n\nusing namespace std;\n#define N 100000\ntypedef long long LL;\n\nLL a;\nLL b;\nLL vec[N];\nint cnt;\nLL MAX_MUL;\n\nvoid Find(const LL* vec)\n{\nint sum=0;\nLL mul=1;\nLL Now=1;\nfor(int i=0;i<cnt;i++)\n{\nsum+=vec[i];\nwhile(mul%vec[i]!=0)\nmul=(++Now);\nmul/=vec[i];\n}\nwhile(Now<100000)\nmul=(++Now);\nLL diff=((1+N)N)/2-sum;\ncout<<diff<<\" \"<<mul<<endl;\nLL a=(diff+sqrt(diffdiff-4mul))/2;\ncout<<a<<\" \"<<diff-a<<endl;\n}\n\nint main()\n{\nsrand(time(NULL));\na=(rand()%100000)+1;\nb=(rand()%100000)+1;\ncnt=0;\nfor(int i=1;i<=N;i++)\n{\nif(i!=a&&i!=b)\nvec[cnt++]=i;\n}\ncout<<a<<\" \"<<b<<\" \"<<endl;\ncout<<a+b<<\" \"<<ab<<endl;\nFind(vec);\n}``````\n\n``````void Find(const LL* vec)\n{\ndouble sum=0;\ndouble square_sum=0;\nfor(int i=0;i<cnt;i++)\n{\nsum+=vec[i];\nsquare_sum+=(vec[i]vec[i]);\n}\ndouble diff=((1+N)N)/2-sum;\ndouble square_sum_diff=\n((double)N(N+1)(2(double)N+1))/6 - square_sum;\ncout<<diff<<\" \"<<square_sum_diff<<endl;\na=(2(diff)+sqrt(8square_sum_diff-4diff*diff))/4;\ncout<<a<<\" \"<<diff-a<<endl;\n}``````", null, "" ]	[ null, "https://catcoding.me/css/images/logo.png", null, "https://catcoding.me/images/wechat-qr-code.jpg", null ]	{"ft_lang_label":"__label__zh","ft_lang_prob":0.5313605,"math_prob":0.9998359,"size":1499,"snap":"2022-40-2023-06","text_gpt3_token_len":810,"char_repetition_ratio":0.12909698,"word_repetition_ratio":0.013605442,"special_character_ratio":0.41694462,"punctuation_ratio":0.1450151,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":1.0000045,"pos_list":[0,1,2,3,4],"im_url_duplicate_count":[null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-09-28T10:23:27Z\",\"WARC-Record-ID\":\"<urn:uuid:6ee0110d-33d0-439b-ae35-d5174bc92844>\",\"Content-Length\":\"25565\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:abd2d7cd-6f1d-4d58-9bd1-16c32e5734a0>\",\"WARC-Concurrent-To\":\"<urn:uuid:ac65d3a2-6966-4193-b676-2da96e9bc0c7>\",\"WARC-IP-Address\":\"185.199.108.153\",\"WARC-Target-URI\":\"https://catcoding.me/p/findsum/\",\"WARC-Payload-Digest\":\"sha1:IHJQ76IDM2GLY5GYER347S65XLI3BEYC\",\"WARC-Block-Digest\":\"sha1:WHJIX23NRRWPTQGLBX2ZELGVHFZUXGK3\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-40/CC-MAIN-2022-40_segments_1664030335190.45_warc_CC-MAIN-20220928082743-20220928112743-00245.warc.gz\"}"}
https://leanprover-community.github.io/archive/stream/113489-new-members/topic/Nodup.20Indices.html	[ "## Stream: new members\n\n### Topic: Nodup Indices\n\n####", null, "Marcus Rossel (Jan 31 2021 at 18:41):\n\nHow would you prove this lemma?\n\nimport data.list.indexes\nimport data.list.nodup\n\nexample (l : list ℕ) (p : ℕ → Prop) [decidable_pred p] : (l.find_indexes p).nodup :=\nbegin\nrw list.find_indexes_eq_map_indexes_values,\nsuffices h : (list.indexes_values p l).nodup, from list.nodup_map sorry h,\nrw list.indexes_values_eq_filter_enum,\nsuffices h : l.enum.nodup, from list.nodup_filter _ h,\n-- ...?\nend\n\n\nI've been able to reduce it to showing that l.enum.nodup, but I don't know how to continue from here. And also I feel like there must be some easier way to show this result.\nIs there anything I'm missing?\nThanks\n\n####", null, "Riccardo Brasca (Jan 31 2021 at 18:46):\n\nWhy is this true? If the list has duplicates and p is always true...\n\n####", null, "Kevin Buzzard (Jan 31 2021 at 18:48):\n\n#eval [1,1,1,1].find_indexes (λ n, true) -- [0, 1, 2, 3]\n\n\n####", null, "Marcus Rossel (Jan 31 2021 at 18:49):\n\nRiccardo Brasca said:\n\nWhy is this true? If the list has duplicates and p is always true...\n\nI was assuming that list.find_indexes would return the indices of all those elements in the list that satisfy some predicate. So any given index would show up at most once, making the list nodup.\n\n####", null, "Riccardo Brasca (Jan 31 2021 at 18:51):\n\nAh sure, it finds the indexes, not the elements! Sorry, my fault\n\n####", null, "Adam Topaz (Jan 31 2021 at 18:55):\n\nI would prove that the list this function produces is strictly increasing as a separate lemma, and go from there.\n\n####", null, "Marcus Rossel (Jan 31 2021 at 19:33):\n\nI would prove that the list this function produces is strictly increasing as a separate lemma, and go from there.\n\nI've separated this subproof out into its own lemma:\n\nlemma list.enum_cons_mem {α : Type} {l : list α} {hd : ℕ × α} {tl : list (ℕ × α)} :\nl.enum = hd :: tl → hd ∉ tl :=\nbegin\nsorry\nend\n\n\nBut I'm failing at actually applying it:\n\nlemma list.find_indexes_nodup {α : Type} (p : α → Prop) [decidable_pred p] (l : list α) :\n(l.find_indexes p).nodup :=\nbegin\nrw list.find_indexes_eq_map_indexes_values,\nsuffices h : (list.indexes_values p l).nodup, from list.nodup_map sorry h,\nrw list.indexes_values_eq_filter_enum,\nsuffices h : l.enum.nodup, from list.nodup_filter _ h,\ninduction l.enum with hd tl ih,\ncase list.nil { simp },\ncase list.cons {\napply list.nodup_cons.mpr,\nsuffices h : hd ∉ tl, from and.intro h ih,\nhave h : l.enum = hd :: tl, from sorry,\nexact list.enum_cons_mem h\n}\nend\n\n\nI don't know how to fix the second sorry. I thought a refl would work, but it seems that the fact that l.enum = hd :: tl isn't being propagated into the induction.\n\n####", null, "Adam Topaz (Jan 31 2021 at 19:56):\n\n@Marcus Rossel What I had in mind is splitting up as follows.\nI bet mathlib already has something like this to_func thing...\n\nimport order.basic\nimport data.list.indexes\nimport data.list.nodup\n\ndef list.to_func {α : Type} (l : list α) : fin l.length → α := λ i, l.nth_le i.1 i.2\n\nlemma foo (l : list ℕ) (p : ℕ → Prop) [decidable_pred p] : strict_mono (l.find_indexes p).to_func := sorry\n\nlemma bar {l : list ℕ} : strict_mono l.to_func → l.nodup := sorry\n\nexample (l : list ℕ) (p : ℕ → Prop) [decidable_pred p] : (l.find_indexes p).nodup := bar \\$ foo _ _\n\n\n####", null, "Ryan Lahfa (Jan 31 2021 at 20:03):\n\nMarcus Rossel said:\n\nI would prove that the list this function produces is strictly increasing as a separate lemma, and go from there.\n\nI've separated this subproof out into its own lemma:\n\nlemma list.enum_cons_mem {α : Type} {l : list α} {hd : ℕ × α} {tl : list (ℕ × α)} :\nl.enum = hd :: tl → hd ∉ tl :=\nbegin\nsorry\nend\n\n\nBut I'm failing at actually applying it:\n\nlemma list.find_indexes_nodup {α : Type} (p : α → Prop) [decidable_pred p] (l : list α) :\n(l.find_indexes p).nodup :=\nbegin\nrw list.find_indexes_eq_map_indexes_values,\nsuffices h : (list.indexes_values p l).nodup, from list.nodup_map sorry h,\nrw list.indexes_values_eq_filter_enum,\nsuffices h : l.enum.nodup, from list.nodup_filter _ h,\ninduction l.enum with hd tl ih,\ncase list.nil { simp },\ncase list.cons {\napply list.nodup_cons.mpr,\nsuffices h : hd ∉ tl, from and.intro h ih,\nhave h : l.enum = hd :: tl, from sorry,\nexact list.enum_cons_mem h\n}\nend\n\n\nI don't know how to fix the second sorry. I thought a refl would work, but it seems that the fact that l.enum = hd :: tl isn't being propagated into the induction.\n\nIt looks like to me you're trying to prove something false in the induction\n\n####", null, "Ryan Lahfa (Jan 31 2021 at 20:03):\n\nMaybe I may be wrong but doing induction on l.enum is like: take an arbitrary list and prove what I want I think\n\n####", null, "Ryan Lahfa (Jan 31 2021 at 20:04):\n\nIf you do it on l, it might work, as you will prove (0, hd) notin enum_from 1 tl and (enum_from 1 tl).nodup\n\n####", null, "Ryan Lahfa (Jan 31 2021 at 20:06):\n\nAnd the first is provable because you can show the first component of enum_from 1 tl is greater or equal than 1, thus (0, something) cannot be there, and the second is just the fact that applying an injective function to a nodup list won't change its nodup property, and you just translate the first component of the induction hypothesis, there might be a lot better way to do it though\n\n####", null, "Ryan Lahfa (Jan 31 2021 at 20:16):\n\nThough, indeed, this is a bit strange\n\n####", null, "Yakov Pechersky (Jan 31 2021 at 22:18):\n\nlemma nodup_zip_of_left {α β : Type} {l : list α} (h : nodup l) (l' : list β) :\nnodup (l.zip l') :=\nbegin\ninduction l with hd tl hl generalizing l',\n{ simp },\n{ cases l' with hd' tl',\n{ simp },\n{ rw [nodup_cons] at h,\nrw [zip_cons_cons, nodup_cons],\nexact ⟨λ H, h.left (mem_zip H).left, hl h.right _⟩ } }\nend\n\nlemma nodup_zip_of_right {α β : Type} (l : list α) {l' : list β} (h : nodup l) :\nnodup (l.zip l') :=\nbegin\ninduction l' with hd tl hl generalizing l,\n{ simp },\n{ cases l with hd' tl',\n{ simp },\n{ rw [nodup_cons] at h,\nrw [zip_cons_cons, nodup_cons],\nexact ⟨λ H, h.left (mem_zip H).left, hl _ h.right⟩ } }\nend\n\n@[simp] lemma nodup_enum {l : list α} : nodup l.enum :=\nby { rw enum_eq_zip_range, exact nodup_zip_of_left (nodup_range _) _ }\n\n\n####", null, "Yakov Pechersky (Jan 31 2021 at 22:18):\n\nYou said you needed l.enum.nodup -- there you go.\n\n####", null, "Yakov Pechersky (Jan 31 2021 at 22:18):\n\nThat's after import list.range\n\n@Marcus Rossel\n\n####", null, "Marcus Rossel (Feb 01 2021 at 09:44):\n\nWow, thanks! @Yakov Pechersky\nI feel like some of this should make its way into Mathlib, since IMHO find_indexes being nodup should be easily available and not require 4 lemmata. Does anyone know how I could get the ball rolling on that?\n\n####", null, "Kevin Buzzard (Feb 01 2021 at 09:53):\n\nIf you have a github account then announce what it is and ask the maintainers for push access to non-master branches of mathlib, and then put the lemmas in an appropriate place on a branch of mathlib and then make a PR\n\n####", null, "Yakov Pechersky (Feb 01 2021 at 13:59):\n\nThe initial premise that find_indexes is nodup is faulty (using your proof strategy), as you can tell by the fact that you have to sorry the proof that prod.fst is injective. Because it isn't.\n\n####", null, "Yakov Pechersky (Feb 01 2021 at 16:16):\n\nHere you go:\n\nimport data.list.indexes\nimport data.list.range\n\nopen list\n\nvariables {α β γ δ ε : Type}\n\n@[simp] lemma foldr_with_index_nil (f : ℕ → α → β → β) (b : β) : foldr_with_index f b nil = b := rfl\n\n@[simp] lemma foldr_with_index_singleton (f : ℕ → α → β → β) (b : β) (a : α) :\nfoldr_with_index f b [a] = f 0 a b := rfl\n\n@[simp] lemma function.uncurry_comp_prod_map_id_left (f : α → β → γ) (g : δ → α) :\nfunction.uncurry f ∘ prod.map g id = function.uncurry (f ∘ g) :=\nby { ext ⟨d, e⟩, simp }\n\nlemma foldr_with_index_cons (f : ℕ → α → β → β) (b : β) (a : α) (l : list α) :\nfoldr_with_index f b (a :: l) = f 0 a (foldr_with_index (f ∘ nat.succ) b l) :=\nby simp [foldr_with_index_eq_foldr_enum, enum_eq_zip_range, range_succ_eq_map, zip_map_left]\n\n@[simp] lemma find_indexes_nil (p : α → Prop) [decidable_pred p] : find_indexes p nil = nil := rfl\n\n@[simp] lemma find_indexes_cons_true (p : α → Prop) [decidable_pred p] (a : α) (l : list α)\n(h : p a) :\nfind_indexes p (a :: l) = 0 :: (find_indexes p l).map nat.succ :=\nbegin\nsuffices : map (prod.fst ∘ prod.map nat.succ id) (filter ((p ∘ prod.snd) ∘ prod.map nat.succ id)\n((range l.length).zip l)) = map (nat.succ ∘ prod.fst)\n(filter (p ∘ prod.snd) ((range l.length).zip l)),\n{ simpa [find_indexes_eq_map_indexes_values, indexes_values_eq_filter_enum, enum_eq_zip_range,\nrange_succ_eq_map, h, filter, zip_map_left, filter_of_map] },\ncongr\nend\n\n@[simp] lemma find_indexes_cons_false (p : α → Prop) [decidable_pred p] (a : α) (l : list α)\n(h : ¬ p a) :\nfind_indexes p (a :: l) = (find_indexes p l).map nat.succ :=\nbegin\nsuffices : map (prod.fst ∘ prod.map nat.succ id) (filter ((p ∘ prod.snd) ∘ prod.map nat.succ id)\n((range l.length).zip l)) = map (nat.succ ∘ prod.fst)\n(filter (p ∘ prod.snd) ((range l.length).zip l)),\n{ simpa [find_indexes_eq_map_indexes_values, indexes_values_eq_filter_enum, enum_eq_zip_range,\nrange_succ_eq_map, h, filter, zip_map_left, filter_of_map] },\ncongr\nend\n\n@[simp] lemma nodup_find_indexes (l : list ℕ) (p : ℕ → Prop) [decidable_pred p] : (l.find_indexes p).nodup :=\nbegin\ninduction l with hd tl hl,\n{ simp },\n{ by_cases h : p hd;\nsimpa [h, nat.succ_ne_zero] using nodup_map nat.succ_injective hl }\nend\n\n\nLast updated: May 16 2021 at 05:21 UTC" ]	[ null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null, "https://leanprover-community.github.io/archive/assets/img/zulip2.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.6019461,"math_prob":0.70729685,"size":9206,"snap":"2021-21-2021-25","text_gpt3_token_len":2909,"char_repetition_ratio":0.14116496,"word_repetition_ratio":0.4428833,"special_character_ratio":0.3275038,"punctuation_ratio":0.22809593,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9902238,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],"im_url_duplicate_count":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-05-16T08:00:55Z\",\"WARC-Record-ID\":\"<urn:uuid:50ac935b-c351-4cad-80b9-93ff09b0791f>\",\"Content-Length\":\"54403\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:bc0afb8b-ec2e-4fbb-804e-1a5f874d320b>\",\"WARC-Concurrent-To\":\"<urn:uuid:8cb27663-7088-4ca8-89e1-28347e5c4ae8>\",\"WARC-IP-Address\":\"185.199.109.153\",\"WARC-Target-URI\":\"https://leanprover-community.github.io/archive/stream/113489-new-members/topic/Nodup.20Indices.html\",\"WARC-Payload-Digest\":\"sha1:Y76VQFBMF3WUI5M7D6GQCIDZZ2SWVJKM\",\"WARC-Block-Digest\":\"sha1:XTBK5B5D5MJDCF627YWW3JGIOBWLR3IX\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-21/CC-MAIN-2021-21_segments_1620243992516.56_warc_CC-MAIN-20210516075201-20210516105201-00272.warc.gz\"}"}
https://docs.itascacg.com/3dec700/common/models/ssoft/doc/modelssoft.html	[ "FLAC3D Theory and Background • Constitutive Models\n\n# Strain-Softening/Hardening Mohr-Coulomb (SSoft) Model\n\nThis model is based on the Mohr-Coulomb model with nonassociated shear and associated tension flow rules, as described earlier. The difference, however, lies in the possibility that the cohesion, friction, dilation, and tensile strength may soften or harden after the onset of plastic yield. In the Mohr-Coulomb model, those properties are assumed to remain constant. Here, the user can define the cohesion, friction and dilation as piecewise-linear functions of a hardening parameter measuring the plastic shear strain. A piecewise-linear softening law for the tensile strength can also be prescribed in terms of another hardening parameter measuring the plastic tensile strain. The code measures the total plastic shear and tensile strains by incrementing the hardening parameters at each timestep, and causes the model properties to conform to the user-defined functions.\n\nFormulations\n\nThe yield and potential functions, plastic flow rules, and stress corrections are identical to those of the Mohr-Coulomb model.\n\nHardening Parameters\n\nThe two hardening parameters for this model ($${\\kappa}^s$$ and $${\\kappa}^t$$) are defined as the sum of some incremental measures of plastic shear and tensile strain for the zone, respectively. The zone-shear and tensile-hardening increments are calculated as the volumetric average of hardening increments over all tetrahedra involved in the zone.\n\nThe shear-hardening increment for a particular tetrahedron is a measure of the second invariant of the plastic shear-strain increment tensor for the step, given as\n\n(1)$\\Delta {\\kappa}^s = {{1}\\over{\\sqrt 2}} \\sqrt{(\\Delta {\\epsilon}_1^{p_s} - \\Delta {\\epsilon}_m^{p_s})^2 + (\\Delta {\\epsilon}_m^{p_s})^2 + (\\Delta {\\epsilon}_3^{p_s} - \\Delta {\\epsilon}_m^{p_s})^2}$\n\nwhere $$\\Delta {\\epsilon}_m^{p_s}$$ is the mean plastic strain increment,\n\n(2)$\\Delta {\\epsilon}_m^{p_s} = {{1}\\over{3}} (\\Delta {\\epsilon}_1^{p_s} + \\Delta {\\epsilon}_3^{p_s})$\n\nThe tetrahedron tensile-hardening increment is the magnitude of the plastic tensile-strain increment,\n\n(3)$\\Delta {\\kappa}^t = \|\\Delta {\\epsilon}_3^{p_t}\|$\n\nPlastic-Strain Increments\n\nThe plastic-strain increments involved in the preceding formula may be derived from the definition $$\\Delta {\\underline{\\epsilon}}_i^p = \\lambda {{\\partial g}\\over{\\partial {\\underline{\\sigma}}_i}}$$ of the flow rule. They have the form\n\n(4)$\\Delta {\\epsilon}_1^{p_s} = {\\lambda}^s$\n(5)$\\Delta {\\epsilon}_3^{p_s} = - {\\lambda}^s N_{\\psi}$\n(6)$\\Delta {\\epsilon}_3^{p_t} = {\\lambda}^t$\n\nwhere $${\\lambda}^s$$ and $${\\lambda}^t$$ are given by the Mohr-Coulomb model.\n\nUser-Defined Functions for Cohesion, Friction, Dilation, and Tensile Strength\n\nUser-defined functions for zone yielding parameters can be determined by back-analysis of the post-failure behavior of a material. Consider a one-dimensional stress-strain curve, $$\\sigma$$ versus $$\\epsilon$$, which softens upon yield and attains some residual strength (Figure 1).\n\nThe curve is linear to the point of yield; in that range, the strain is elastic only: $$\\epsilon = \\epsilon^e$$. After yield, the total strain is composed of elastic and plastic parts: $$\\epsilon = \\epsilon^e + \\epsilon^p$$. In the softening/hardening model, the user defines the cohesion, friction, dilation, and tensile strength variance as a function of the plastic portion, $$\\epsilon^p$$, of the total strain. These functions, which could in reality be sketched as indicated in Figure 2, are approximated in FLAC3D as sets of linear segments (Figure 3).", null, "Figure 2: Variation of cohesion (a) and friction angle (b) with plastic strain.\n\nHardening and softening behaviors for the cohesion, friction, and dilation in terms of the shear parameter $$\\Delta \\epsilon^{ps}$$ (see Equation (1)) are provided by the user in the form of tables. Each table contains pairs of values: one for the parameter, and one for the corresponding property value. It is assumed that the property varies linearly between two consecutive parameter entries in the table. Softening of the tensile strength is described in a similar manner, using the parameter $$\\Delta \\epsilon^{pt}$$ (see Equation (2)).\n\nImplementation Procedure\n\nThe implementation of the strain-softening/hardening model in FLAC3D/3DEC proceeds as indicated in the Mohr-Coulomb model description. After determination of the new stresses for the step, the hardening parameters for the zone are updated following the procedure described above. If appropriate, these parameters are then used to determine new values for the zone cohesion, friction, dilation, and tensile strength.\n\nNote that the tensile strength of the material can only decrease. Also, for material with friction, the value cannot exceed the maximum value $${\\sigma}_{max}^t$$.\n\nstrain-softening model properties\n\nUse the following keywords with the :zone property (FLAC3D) or block zone property (3DEC) command to set these properties of the strain-softening/hardening Mohr-Coulomb model.\n\nstrain-softening\nbulk f\n\nelastic bulk modulus, $$K$$\n\ncohesion f\n\ncohesion, $$c$$\n\ndilation f.\n\ndilation angle, $$\\psi$$. The default is 0.0.\n\nfriction f\n\ninternal angle of friction, $$\\phi$$\n\npoisson f\n\nPoisson’s ratio, $$\\nu$$\n\nshear f\n\nelastic shear modulus, $$G$$\n\ntension f\n\ntension limit, $$\\sigma^t$$. The default is 0.0.\n\nyoung f\n\nYoung’s modulus, $$E$$\n\nflag-brittle b (a)\n\nIf true, the tension limit is set to 0 in the event of tensile failure. The default is false.\n\ntable-cohesion s (a)\n\nname of the table relating cohesion to plastic shear strain\n\ntable_dilation s (a)\n\nname of the table relating dilation angle to plastic shear strain\n\ntable-friction s (a)\n\nname of the table relating friction angle to plastic shear strain\n\ntable-tension s (a)\n\nname of the table relating tension limit to plastic tensile strain\n\nstrain-shear-plastic f (r)\n\naccumulated plastic shear strain\n\nstrain-tension-plastic f (r)\n\naccumulated plastic tensile strain\n\nKey\n\n• Only one of the two options is required to define the elasticity: bulk modulus $$K$$ and shear modulus $$G$$, or, Young’s modulus $$E$$ and Poisson’s ratio $$\\nu$$. When choosing the latter, Young’s modulus $$E$$ must be assigned in advance of Poisson’s ratio $$\\nu$$.\n• The tension cut-off is $${\\sigma}^t = min({\\sigma}^t, c/\\tan \\phi)$$." ]	[ null, "https://docs.itascacg.com/3dec700/_images/modelssoft-2.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8173906,"math_prob":0.9969282,"size":6118,"snap":"2023-40-2023-50","text_gpt3_token_len":1459,"char_repetition_ratio":0.15636244,"word_repetition_ratio":0.028985508,"special_character_ratio":0.22278522,"punctuation_ratio":0.101983,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.99975866,"pos_list":[0,1,2],"im_url_duplicate_count":[null,1,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-12-11T18:24:41Z\",\"WARC-Record-ID\":\"<urn:uuid:a3c5de21-1221-4631-beeb-7b6f3fc1626a>\",\"Content-Length\":\"31246\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:bc122970-09ad-418c-ba38-2efb342cbd12>\",\"WARC-Concurrent-To\":\"<urn:uuid:4522892c-4dd8-449d-b301-e838c02709cb>\",\"WARC-IP-Address\":\"104.26.7.29\",\"WARC-Target-URI\":\"https://docs.itascacg.com/3dec700/common/models/ssoft/doc/modelssoft.html\",\"WARC-Payload-Digest\":\"sha1:5DFO52OXZBDATHEURTRHAOIKAW5JI22Z\",\"WARC-Block-Digest\":\"sha1:PSQBCZK25UL2PCTG4W2HOR7B5QOS3NDF\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-50/CC-MAIN-2023-50_segments_1700679516047.98_warc_CC-MAIN-20231211174901-20231211204901-00462.warc.gz\"}"}
https://scienceteacherprogram.org/astronomy/SPapsidero08.html	[ "Our Solar System to Scale\n\nSara Papsidero\n\nPACE High School, Manhattan\n\nSummer Research Program for Science Teachers\n\nAugust 2008\n\nDuration: 2 periods\n\nAim: How massive is our Solar System and the planets within?\n\nObjectives:\n\n· Students will be able to calculate the diameter of planets to a smaller scale\n\n· Students will be able to calculate the distance from the sun to each planet to scale.\n\n· Students will understand how massive the planets are and the vastness of the solar system.\n\nMaterials: Lab sheet, Planet Guides, chart paper, colored paper, scissors, compasses, metric rulers, markers, pencils, glue\n\nProcedure:\n\nBell Ringer-\n\nWhat are the three characteristics which make a planet a planet?\n\n1. Planets are massive enough to retain a spherical shape.\n\n2. Planets only revolve around the sun.\n\n3. Planets are in control of their own orbit. They are not controlled by any other body but the Sun.\n\nWhy is Pluto no longer a planet?\n\nPluto is controlled by Neptune’s gravitational influence as well as the Sun’s. It is now considered a ‘Dwarf Planet’.\n\nLab Introduction\n\n1. Read directions of Lab through Part A- Size of Planets.\n\n2. Each student will complete the first of the two hypotheses.\n\n3. Practice calculating the scale diameter the Moon.\n\n7000km=1cm\n\nMoon’s diameter 3, 746 km 7000 km\n\n______________ = _____________\n\nX 1cm\n\n7000km x = 3746 km cm\n\nMoon’s scale diameter X = 0.535 cm\n\nX = 0.5 cm – to the nearest tenth.\n\n4. Students will be placed in cooperative pairs and will begin working on Procedure A while teacher walks around for assistance.\n\nClosure\n\n· Students will be asked to reflect upon their first hypothesis and briefly discuss as a class.\n\n· Students will be asked to calculate the scale the sun would be if they know the diameter to be 1,394,000 km. They will then see how large the sun actually is compared to the planets.\n\nOutcome/Homework:\n\nStudents will complete Part A of Lab. Students will also answer discussion questions that pertain to Part A if they are done early or for homework if there is not enough time.\n\nNext day:\n\n· Class discussion about Part A of Lab and/or finish Part A.\n\n· Begin Part B- Relative Distance of Planets.\n\nNew York State Standards\n\nStandard 4: Performance Indicators 1.2a & 1.2c" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.830687,"math_prob":0.8289808,"size":2031,"snap":"2021-43-2021-49","text_gpt3_token_len":515,"char_repetition_ratio":0.13172175,"word_repetition_ratio":0.034188036,"special_character_ratio":0.24766125,"punctuation_ratio":0.121890545,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9652471,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-10-20T06:08:31Z\",\"WARC-Record-ID\":\"<urn:uuid:78416650-c6ba-4fde-8ff2-76833204095f>\",\"Content-Length\":\"17791\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:d08e9b83-9109-4afa-98ec-72b3fc1a275e>\",\"WARC-Concurrent-To\":\"<urn:uuid:067165a3-fe98-4e1f-8df3-67b6c8c188fa>\",\"WARC-IP-Address\":\"216.239.138.151\",\"WARC-Target-URI\":\"https://scienceteacherprogram.org/astronomy/SPapsidero08.html\",\"WARC-Payload-Digest\":\"sha1:GFUGLRA7SLTTVCBP33YNPZBNCRHJYJ6N\",\"WARC-Block-Digest\":\"sha1:7QVJBWDVGXM26RFCZ7AEN6LVOA2NWBZR\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-43/CC-MAIN-2021-43_segments_1634323585302.91_warc_CC-MAIN-20211020055136-20211020085136-00683.warc.gz\"}"}
http://de.metamath.org/qleuni/wcon3.html	[ "", null, "Quantum Logic Explorer < Previous Next > Nearby theorems Mirrors > Home > QLE Home > Th. List > wcon3 GIF version\n\nTheorem wcon3 209\n Description: Weak contraposition.\nHypothesis\nRef Expression\nwcon3.1 (ab) = 1\nAssertion\nRef Expression\nwcon3 (ab ) = 1\n\nProof of Theorem wcon3\nStepHypRef Expression\n1 ax-a1 30 . . . . 5 b = b\n21ax-r1 35 . . . 4 b = b\n32lbi 97 . . 3 (ab ) = (ab)\n4 wcon3.1 . . 3 (ab) = 1\n53, 4ax-r2 36 . 2 (ab ) = 1\n65wcon1 207 1 (ab ) = 1\n Colors of variables: term Syntax hints: = wb 1 ⊥ wn 4 ≡ tb 5 1wt 8 This theorem was proved from axioms: ax-a1 30 ax-a2 31 ax-r1 35 ax-r2 36 ax-r4 37 ax-r5 38 This theorem depends on definitions: df-b 39 df-a 40 This theorem is referenced by: wlecon 395 wcomd 418 wfh1 423\n Copyright terms: Public domain W3C validator" ]	[ null, "http://de.metamath.org/qleuni/l46-7icon.gif", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.5096998,"math_prob":0.9678929,"size":803,"snap":"2023-40-2023-50","text_gpt3_token_len":418,"char_repetition_ratio":0.12765957,"word_repetition_ratio":0.044692736,"special_character_ratio":0.4645081,"punctuation_ratio":0.13714285,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9831549,"pos_list":[0,1,2],"im_url_duplicate_count":[null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-12-02T15:11:52Z\",\"WARC-Record-ID\":\"<urn:uuid:f004f5c9-611f-4dd3-9380-b92a887d30fb>\",\"Content-Length\":\"7966\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:3355cf00-68af-4c93-b25b-fd30d2dfc31d>\",\"WARC-Concurrent-To\":\"<urn:uuid:22ce98fb-6b32-4aa0-a41c-4af461131f2b>\",\"WARC-IP-Address\":\"78.47.47.15\",\"WARC-Target-URI\":\"http://de.metamath.org/qleuni/wcon3.html\",\"WARC-Payload-Digest\":\"sha1:WTON3MZMFEZ5ACDZBS3XSGQ5YJATF2QI\",\"WARC-Block-Digest\":\"sha1:IF6ML3TC6QONHM2WDTLEYRIHKNOQIB2N\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-50/CC-MAIN-2023-50_segments_1700679100427.59_warc_CC-MAIN-20231202140407-20231202170407-00014.warc.gz\"}"}
https://www.jiskha.com/questions/971628/the-figure-below-presents-the-eqe-of-a-triple-junction-solar-cell-with-junctions-a-b-and	[ "# Solar Energy Please Help\n\nThe figure below presents the EQE of a triple junction solar cell with junctions A, B and C under short circuited (V = 0 V) condition.\n\na) What is the bandgap (in eV) of the absorber layer of the junction A?\n\nb) What is the bandgap (in eV) of the absorber layer of the junction B?\n\nc) What is the bandgap (in eV) of the absorber layer of the junction C?\n\nd) Which of the following statements is TRUE?\n\n1)Junction C acts as the top cell, Junction B as the middle cell, and Junction A as the bottom cell.\n\n2)Junction B acts as the top cell, Junction C as the middle cell, and Junction A as the bottom cell.\n\n3)Junction A acts as the top cell, Junction B as the middle cell, and Junction C as the bottom cell.\n\nEach junction is illuminated under standard test conditions. Given the photon fluxes below, calculate the short-circuit current density (in mA/cm2) of each (separate) junction (A, B and C):\n\nϕ=9.3∗1020m−2s−1 for 300nm<λ<650nm\n\nϕ=8.4∗1020m−2s−1 for 650nm<λ<850nm\n\nϕ=1.4∗1021m−2s−1 for 850nm<λ<1250nm\n\ne) Jsc of Junction A:\n\nf) Jsc of Junction B:\n\ng) Jsc of Junction C:\n\nh) The Voc of each junction in V can be roughly estimated by the equation\n\nVoc=Egap(J)2q=Egap(eV)2\nwhere q is the elementary charge, Egap(J) is the bandgap energy expressed in Joules, and Egap(eV) is the bandgap energy expressed in eV. Assume a fill factor of FF=0.75. What is then the efficiency (in %) of the triple junction solar cell?\n\n1. 👍\n2. 👎\n3. 👁\n1. d) Junction A acts as the top cell, Junction B as the middle cell, and Junction C as the bottom cell.\n\n1. 👍\n2. 👎\n2. Can you also give out the rest of the answers?? thanks\n\n1. 👍\n2. 👎\n3. Someone has the others results please???\n\n1. 👍\n2. 👎\n4. Hey guys i exchange the answers of this question with the assignment 5...\njust let me know\n\n1. 👍\n2. 👎\n5. hi\n\nanyone have the answers to this Q\n\n1. 👍\n2. 👎\n6. Add the missing figures please\n\n1. 👍\n2. 👎\n7. a 1447\nb.45\nc.25\n\n1. 👍\n2. 👎\n8. None is true answer sorry\n\n1. 👍\n2. 👎\n9. This is the link to the image\n\npostimg org/image/fsra4o0h1/\n\n1. 👍\n2. 👎\n10. Please help...\n\n1. 👍\n2. 👎\n11. The figure below presents the EQE of a triple junction solar cell with junctions A, B and C under short circuited (V = 0 V) condition.\nEQE table is:\n\nA: EQE = 0.7 wavelength= 300 to 650 nm\nB: EQE = 0.9 Wavelength= 650 to 850 nm\nC: EQE = 0.8 Wavelength= 850 to 1250 nm\n\na) What is the bandgap (in eV) of the absorber layer of the junction A?\n\nb) What is the bandgap (in eV) of the absorber layer of the junction B?\n\nc) What is the bandgap (in eV) of the absorber layer of the junction C?\n\nd) Which of the following statements is TRUE?\n\nJunction C acts as the top cell, Junction B as the middle cell, and Junction A as the bottom cell.\nJunction B acts as the top cell, Junction C as the middle cell, and Junction A as the bottom cell.\nJunction A acts as the top cell, Junction B as the middle cell, and Junction C as the bottom cell\n\nTRIPLE JUNCTION SOLAR CELL - III\nEach junction is illuminated under standard test conditions. Given the photon fluxes below, calculate the short-circuit current density (in mA/cm2) of each (separate) junction (A, B and C):\n\nϕ=9.3∗1020m−2s−1 for 300nm<λ<650nm\n\nϕ=8.4∗1020m−2s−1 for 650nm<λ<850nm\n\nϕ=1.4∗1021m−2s−1 for 850nm<λ<1250nm\n\ne) Jsc of Junction A:\n\nf) Jsc of Junction B:\n\ng) Jsc of Junction C:\n\nTRIPLE JUNCTION SOLAR CELL - IV\nh) The Voc of each junction in V can be roughly estimated by the equation\n\nVoc=Egap(J)2q=Egap(eV)2\nwhere q is the elementary charge, Egap(J) is the bandgap energy expressed in Joules, and Egap(eV) is the bandgap energy expressed in eV. Assume a fill factor of FF=0.75. What is then the efficiency (in %) of the triple junction solar cell?\n\n1. 👍\n2. 👎\n12. bandgaps:\na) 1.9\nb) 1.46\nc) 0.992\n\n1. 👍\n2. 👎\n13. @foxman thinks\n\n1. 👍\n2. 👎\n14. plz answer\ne,f,g,h parts\n\n1. 👍\n2. 👎\n15. Please answer e,f,g,h\n\n1. 👍\n2. 👎\n16. e) 10.4302\nf) 12.1125\ng) 17.9444\n\n1. 👍\n2. 👎\n17. H. 17.022\n\n1. 👍\n2. 👎\n18. d) Which of the following statements is TRUE?\n\n1-Junction C acts as the top cell,\n2-Junction B as the middle cell, and\n3-Junction A as the bottom cell.\nJunction B acts as the top cell, Junction C as the middle cell, and Junction A as the bottom cell. Junction A acts as the top cell, Junction B as the middle cell, and Junction C as the bottom cell.\nPlease help\n\n1. 👍\n2. 👎\n19. d) Junction A top\nJunction B middle\nJunction C bottom\n\n1. 👍\n2. 👎\n20. Que.4-- C\n\n1. 👍\n2. 👎\n21. To find the answer is pretty simple. E= hc/λq\nWhere,\nh is the planck's constant\nc is the speed light in vacuum\nλ is the wavelength\nq is the elementary charge\n\n1. 👍\n2. 👎\n\n## Similar Questions\n\n1. ### Solar Energy Help ASAP\n\nThe current density of an ideal p-n junction under illumination can be described by: J(V)=Jph−J0(eqVkT−1) where Jph is the photo-current density, J0 the saturation-current density, q the elementary charge, V the voltage, k the\n\n2. ### Solar Energy please help\n\nSolar simulators are used to study the performance of solar cells in the lab. In the figure below (left picture), the spectral power density of a solar simulator is shown with the blue line. The spectral power density of this\n\n3. ### Physics\n\nA given solar cell has the following specifications: Isc=4A Voc=0.7V 36 identical cells with the above specifications are to be interconnected to create a PV module. 1- What is the open-circuit voltage (in V) of the PV module if\n\n4. ### Solar Energy Please Help\n\nFigure 1 shows a simplication of the AM1.5 solar spectrum at 1000W/m2. The spectrum is divided in three spectral ranges: A for 0nm\n\n1. ### Solar Energy Help ASAP\n\nA solar cell with dimensions 12cm x 12cm is illuminated at standard test conditions. The cell presents the following external parameters: Voc=0.8V,Isc=3A,Vmp=0.75V,Imp=2.5A Calculate the fill factor in percentage [%]: Calculate\n\n2. ### Solar Energy Help ASAP\n\nLet's assume that solar light reaches a silicon solar cell with an angle of incidence of θi=0o. For simplicity, let's consider the refractive index of silicon to be nSi=3.5. The refractive index of air is nair=1. What percentage\n\n3. ### Science\n\nWhich of the following is a problem with using solar power as a main source of energy? A. People do not yet have the technology to use solar power*** B. The sun is not close enough to provide solar energy C. Power from solar\n\n4. ### Solar energy please help\n\n1-Consider an organic solar cell consisting of a TiO2 semiconductor with an ionization energy 7.8eV and a polymer with an electron affinity 3.4eV. Which of the followning band diagrams corresponds to the organic solar cell. The\n\n1. ### solar energy please help\n\nIn this section, we talked about combining a solar cell with a photoelectrode to form a photoelectrochemical device. Why do we add a solar cell in the system? a)Because the photoelectrode is not able to produce any voltage\n\n2. ### solar cells\n\nImagine that you are in the lab and you can decide the thickness of the Si layer of your solar cell. You want to optimize the solar cell performance for a wavelength of λ=1000nm, for which the absorption coefficient is\n\n3. ### CIGS AND CDTE FABRICATION\n\nDuring manufacturing of a CIGS device, the metal back contact is deposited first, while in case of the CdTe solar cells, the back contact is deposited in the last processing step. What are the configurations of both cells: a) Both\n\n4. ### physics help\n\nAt a certain location, the solar power per unit area reaching the Earth's surface is 180 W/m2 averaged over a 24-hour day. Suppose you live in a solar powered house whose average power requirement is 3.2 kW. At what rate must" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.81297445,"math_prob":0.91881704,"size":3244,"snap":"2021-21-2021-25","text_gpt3_token_len":980,"char_repetition_ratio":0.17561728,"word_repetition_ratio":0.1767516,"special_character_ratio":0.2651048,"punctuation_ratio":0.0867347,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.99125046,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-06-21T01:00:45Z\",\"WARC-Record-ID\":\"<urn:uuid:3918d8e0-e004-49d8-96fa-6162b669e4b0>\",\"Content-Length\":\"58089\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:e9c28625-91a2-401d-ab1f-9d2843b0739c>\",\"WARC-Concurrent-To\":\"<urn:uuid:cf24c294-3342-4d31-b32f-e401f91a75d3>\",\"WARC-IP-Address\":\"66.228.55.50\",\"WARC-Target-URI\":\"https://www.jiskha.com/questions/971628/the-figure-below-presents-the-eqe-of-a-triple-junction-solar-cell-with-junctions-a-b-and\",\"WARC-Payload-Digest\":\"sha1:LA62GVXEHYB33IQKE2ASYSEFDSXR7TUT\",\"WARC-Block-Digest\":\"sha1:FETDE43FYCQG27WGUYYQLDWF7X6YJ5HB\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-25/CC-MAIN-2021-25_segments_1623488259200.84_warc_CC-MAIN-20210620235118-20210621025118-00121.warc.gz\"}"}
https://www.thedirtbag.com/how-much-mulch-do-you-need-for-your-garden/	[ "# How Much Mulch Do You Need for Your Garden?\n\nRegardless of which type of mulch you prefer for your garden or landscaping, you’ll need to do some calculating to determine how much to purchase.", null, "Guess wrong, and you’ll either come up short or end up with a surplus. Here’s how to do the math to make sure you get the amount right.\n\n## Calculating the Mulch Needs of a Rectangular Garden\n\nWhat size is your garden bed? To determine how many cubic feet of mulch you need, we must start with calculating the square footage of the area you wish to cover.\n\nFor square or rectangular beds, this calculation begins with measuring the length and the width of the bed, in feet. Multiply these two numbers to determine the area, or the square footage of your garden bed. Here’s an example:\n\nGarden Length = 20 feet\nGarden Width = 15 feet\nSquare footage = 20 × 15 = 300 square feet\n\nNext, you need to decide how deep you want to layer the mulch. Two or three inches is typically an effective depth for most vegetable gardens or flower beds.\n\nNow take the square footage of your bed and multiply by your desired depth. Using the example above and assuming a 3-inch depth (0.25 feet), the total amount of mulch needed would be 300*0.25 = 75 cubic feet.\n\n## Calculating the Mulch Needs of a Round Garden Bed\n\nBut what if you have a round garden bed?\n\nTo find the area, you’ll need to measure the diameter, or the number of feet across. Divide this in half to get the radius of your bed. Now, take the radius and square it, or multiply it by itself. Then, multiply this figure by pi, or 3.14, to calculate the square footage. Here’s an example:\n\nGarden diameter = 14 feet\nGarden radius = 14 ÷ 2 = 7 feet\nSquare the radius = 7 x 7 = 49 feet\nSquare footage = 49 × 3.14 = 153.86\n\nAs with a rectangular or square garden, you need to decide on a mulch depth and multiply by your square footage. So, if we assume a 3-inch depth (0.25 feet), the total amount needed for our example would be 38.5 cubic feet.\n\n## Take the Size of Your Garden and Figure How Much Mulch You Need\n\nThe last step is to convert your desired square footage of mulch into cubic yards, as The Dirt Bag sells mulch by the cubic yard.\n\nTo make the conversion, divide your total by 27, as one cubic yard of mulch is 27 cubic feet. Then, round up to the nearest whole number to calculate the number of bags of mulch you need to cover your soil.\n\nSo, here’s the math for our rectangular garden example:\n\n75 cubic feet ÷ 27 = 2.78 cubic yards\n\nRounding up, a total of three bags of mulch would be needed to cover a three-inch depth.\n\nAs for the round garden example:\n\n38.5 cubic feet ÷ 27 = 1.42 cubic yards\n\nIn this case, two bags of mulch would provide ample coverage.\n\nNow, if you’re not too keen on math, don’t worry. You can always use the handy-dandy coverage calculator on The Dirt Bag website. We offer bagged mulch as well as bulk mulch products, all available for delivery throughout Northern Utah. For every product we offer, including garden soil, topsoil, compost, play sand and landscape rock, simply look to the top right corner of the screen and click on the yellow “How much do I need” calculator button.\n\nThe Dirt Bag, located in West Jordan, Utah, makes it easy for you to order all the products you need for your garden and landscaping needs. Give us a call or visit us online today to order your Utah mulch delivery." ]	[ null, "https://www.thedirtbag.com/wp-content/uploads/2016/09/Garden-Mulch-Calculator.jpg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.9055021,"math_prob":0.9805414,"size":3304,"snap":"2022-27-2022-33","text_gpt3_token_len":802,"char_repetition_ratio":0.14151515,"word_repetition_ratio":0.025848143,"special_character_ratio":0.2457627,"punctuation_ratio":0.11173975,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9860845,"pos_list":[0,1,2],"im_url_duplicate_count":[null,2,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-07-05T09:42:29Z\",\"WARC-Record-ID\":\"<urn:uuid:ddb03389-10c4-48c2-8acb-9d6790c79e50>\",\"Content-Length\":\"75845\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:91a86e7a-d164-4ba2-b1d5-468fac329964>\",\"WARC-Concurrent-To\":\"<urn:uuid:91e10a1a-2d96-4e31-9b33-76765def7afb>\",\"WARC-IP-Address\":\"107.180.55.20\",\"WARC-Target-URI\":\"https://www.thedirtbag.com/how-much-mulch-do-you-need-for-your-garden/\",\"WARC-Payload-Digest\":\"sha1:3LWLJNQY2QZWF3PIAKLEFZT3CHLXH74Q\",\"WARC-Block-Digest\":\"sha1:YJH64ZLUCXCOJMEGNLLUWFA4WVIL2YGU\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-27/CC-MAIN-2022-27_segments_1656104542759.82_warc_CC-MAIN-20220705083545-20220705113545-00077.warc.gz\"}"}
https://cs.stackexchange.com/questions/106570/how-to-find-examples-of-best-cases-for-sorting-algorithms	[ "# How to find examples of best cases for sorting algorithms?\n\nI am asked to give a table of 8 elements that are to be sorted by the following algorithms and to produce their best cases. 1) Selection sort 2) Bubble sort 3) Insertion sort 4) Fusion sort\n\nIf I give an already sorted table ex: {1,2,3,4,5,6,7,8} shouldn't it already be the best case for all of them? If I can be considered a best case for each?\n\n• \"If I can be considered a best case for each?\" What do you mean by that sentence? Please edit your question to clarify. Apr 6 '19 at 19:24\n\nBubble sort can \"stop early\" should the array already be sorted. Other algorithms have their own advantages or applications, but none of the algorithms mentioned in your question - other than bubble sort - can \"stop early\".\n\nTherefore for any input Insertion & Selection runtime will be $$\\Omega (n^2)$$, and Mergesort $$\\Omega(nlog(n))$$, so the order of elements doesn't matter at all.\n\n$$\\bullet$$ If you perform bubble sort on an already sorted array, the algorithm can stop when not performing any swaps, and run at $$O(n)$$\n\n$$\\bullet$$ Merge sort (to which you refer as 'fusion sort' from some reason) is the only algorithm that requires $$O(nlog(n))$$ rather than $$O(n^2)$$\n\n$$\\bullet$$ Insertion sort is useful when receiving the array online (one element at a time) and maintaining it sorted. Its noteworthy that since you maintain a sorted array, new elements can be inserted via binary search, which make the insertion sort perform $$O(nlog(n))$$ comparisons, but still cost $$O(n^2)$$ due to moving elements.\n\n$$\\bullet$$ Selection sort is very easy to implement and intuitive to explain\n\n• By the way, you can use \\log to denote $\\log$ such as in $O(n\\log n)$. Apr 6 '19 at 19:37\n• It may not be a bad idea to add a linear check if the array is sorted in any step (which can make both insertion and selection also linear in best case), but not sure OP meant modified algorithms. I did not think of a binsearch insertion, that is an insteresting point and i will edit it in. Thanks.\n– lox\nApr 6 '19 at 19:44\n• An insertion algorithm that compares the last element in the result array with the new element will run $O(n)$ on $1,2,3,\\cdots,n$. (Of course, binary search for insertion is a very interesting variation.) Even if \"new elements can be inserted via binary search\", that does not make it run in $O(n\\log n)$. Binary search reduces the number of comparisons; however, the steps that are needed for the actual insertion take $\\Theta(n^2)$ in average. Apr 6 '19 at 19:52\n• You're right. edited it. No, i didn't implement any variation of insertion sort\n– lox\nApr 6 '19 at 19:56\n• Upvoted, although this answer still misses some finer (or pedantic) details. Apr 7 '19 at 20:15" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.8939848,"math_prob":0.9597417,"size":1079,"snap":"2021-31-2021-39","text_gpt3_token_len":246,"char_repetition_ratio":0.12372093,"word_repetition_ratio":0.0,"special_character_ratio":0.2381835,"punctuation_ratio":0.067010306,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.99598813,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-09-28T14:54:27Z\",\"WARC-Record-ID\":\"<urn:uuid:0b6608c8-26d3-4245-a05a-1c899f071283>\",\"Content-Length\":\"176151\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:2de03a2a-7035-45fa-98dc-69e0ea1a43f1>\",\"WARC-Concurrent-To\":\"<urn:uuid:15e813c7-6704-4123-b388-296da66fa45c>\",\"WARC-IP-Address\":\"151.101.193.69\",\"WARC-Target-URI\":\"https://cs.stackexchange.com/questions/106570/how-to-find-examples-of-best-cases-for-sorting-algorithms\",\"WARC-Payload-Digest\":\"sha1:63T5OO6BLBNPO2JCEYQPFL43ZTGXQZ5I\",\"WARC-Block-Digest\":\"sha1:4NQTXSXK5OBHULDD4AJSQFQGCG7PYT32\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-39/CC-MAIN-2021-39_segments_1631780060803.2_warc_CC-MAIN-20210928122846-20210928152846-00364.warc.gz\"}"}
https://www.triangle-calculator.com/?a=3&a1=0&3dd=3D&a2=3&b=-2&b1=1&b2=4&c=7&c1=2&c2=5&3d=1&what=vc	[ "Triangle calculator VC\n\nPlease enter the coordinates of the three vertices\n\nObtuse scalene triangle.\n\nSides: a = 9.11104335791 b = 4.89989794856 c = 5.19661524227\n\nArea: T = 9.89994949366\nPerimeter: p = 19.20655654874\nSemiperimeter: s = 9.60327827437\n\nAngle ∠ A = α = 128.9422441269° = 128°56'33″ = 2.25504701457 rad\nAngle ∠ B = β = 24.72333108842° = 24°43'24″ = 0.43215031769 rad\nAngle ∠ C = γ = 26.33442478469° = 26°20'3″ = 0.4659619331 rad\n\nHeight: ha = 2.1733221472\nHeight: hb = 4.04114518843\nHeight: hc = 3.81103173777\n\nMedian: ma = 2.17994494718\nMedian: mb = 7\nMedian: mc = 6.83773971656\n\nInradius: r = 1.03108985636\nCircumradius: R = 5.85767073009\n\nVertex coordinates: A[3; 0; 3] B[-2; 1; 4] C[7; 2; 5]\nCentroid: CG[2.66766666667; 1; 4]\nExterior(or external, outer) angles of the triangle:\n∠ A' = α' = 51.0587558731° = 51°3'27″ = 2.25504701457 rad\n∠ B' = β' = 155.2776689116° = 155°16'36″ = 0.43215031769 rad\n∠ C' = γ' = 153.6665752153° = 153°39'57″ = 0.4659619331 rad\n\nHow did we calculate this triangle?\n\n1. We compute side a from coordinates using the Pythagorean theorem", null, "2. We compute side b from coordinates using the Pythagorean theorem", null, "3. We compute side c from coordinates using the Pythagorean theorem", null, "Now we know the lengths of all three sides of the triangle and the triangle is uniquely determined. Next we calculate another its characteristics - same procedure as calculation of the triangle from the known three sides SSS.", null, "4. The triangle circumference is the sum of the lengths of its three sides", null, "5. Semiperimeter of the triangle", null, "6. The triangle area using Heron's formula", null, "7. Calculate the heights of the triangle from its area.", null, "8. Calculation of the inner angles of the triangle using a Law of Cosines", null, "", null, "", null, "", null, "", null, "" ]	[ null, "https://www.triangle-calculator.com/tex/e3b/e3b0126060328.svg", null, "https://www.triangle-calculator.com/tex/97b/97b4510e247d6.svg", null, "https://www.triangle-calculator.com/tex/16f/16f50ea62f0eb.svg", null, "https://www.triangle-calculator.com/tex/1e5/1e5b8ed7dd12b.svg", null, "https://www.triangle-calculator.com/tex/ea2/ea201101e1d05.svg", null, "https://www.triangle-calculator.com/tex/272/2728eacd0c6ee.svg", null, "https://www.triangle-calculator.com/tex/9c1/9c130777aadd7.svg", null, "https://www.triangle-calculator.com/tex/97f/97f9f0061dfb5.svg", null, "https://www.triangle-calculator.com/tex/d1e/d1e12ae569edb.svg", null, "https://www.triangle-calculator.com/tex/2f7/2f73c49dda072.svg", null, "https://www.triangle-calculator.com/tex/04a/04a52421ed83c.svg", null, "https://www.triangle-calculator.com/tex/d32/d3265683759e5.svg", null, "https://www.triangle-calculator.com/tex/bd7/bd75f6a633398.svg", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.70541716,"math_prob":0.99920326,"size":1771,"snap":"2019-43-2019-47","text_gpt3_token_len":622,"char_repetition_ratio":0.14827392,"word_repetition_ratio":0.020905923,"special_character_ratio":0.45962733,"punctuation_ratio":0.18911175,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9999585,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26],"im_url_duplicate_count":[null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2019-10-17T16:16:37Z\",\"WARC-Record-ID\":\"<urn:uuid:1a5af91e-d1bc-4029-8eec-96a34c40e58d>\",\"Content-Length\":\"21097\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:34b8b367-5063-4f68-af33-31df7861a588>\",\"WARC-Concurrent-To\":\"<urn:uuid:cc431605-b38d-4c61-9d4d-6a41c3e3688c>\",\"WARC-IP-Address\":\"104.28.12.22\",\"WARC-Target-URI\":\"https://www.triangle-calculator.com/?a=3&a1=0&3dd=3D&a2=3&b=-2&b1=1&b2=4&c=7&c1=2&c2=5&3d=1&what=vc\",\"WARC-Payload-Digest\":\"sha1:IJOV634JA3LLFYWTTQ2NZTFBZDX43GKH\",\"WARC-Block-Digest\":\"sha1:VJJBXG7LEL2BCEXK5RUAGUR34EZ3Y2JR\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2019/CC-MAIN-2019-43/CC-MAIN-2019-43_segments_1570986675409.61_warc_CC-MAIN-20191017145741-20191017173241-00375.warc.gz\"}"}
https://flylib.com/books/en/1.389.1/pi_model_operated_in_the_lc_region.html	[ "# Pi-Model Operated in the LC Region\n\nSuppose you intend to model a transmission line operating at a frequency at or above the LC region boundary. Constrain the line to a length l sufficiently short that the total line delay t d remains less than 1/6 of the signal risetime t r .\n\nEquation D.12", null, "The next equations determine the effect of constraint [D.12] on the magnitude of the length-adjusted propagation coefficient l g . In the LC region the inductive reactance w L by definition exceeds R , so you may safely approximate the magnitude of the coefficient l g by omitting the R .\n\nEquation D.13", null, "The midpoint of the spectrum associated with the rising and falling edges of the signal driving the line is related to the rise and fall time t r .\n\nEquation D.14", null, "Evaluating [D.13] at w edge , and recognizing that for an LC-mode transmission line the effective line delay t d equals", null, ",\n\nEquation D.15", null, "At a ratio of t d / t r = 1/6 the coefficient l l LCregion equals .366, at which value the pi-model error given by [D.11] ( assuming the ratios Z S / Z C and Z C / Z L to each be less than 3.8) works out to about 3%. At a ratio t d / t r = 1/3 the error soars to 25%. Above t d / t r = 1/2 the pi model loses all useful predictive power.", null, "High-Speed Signal Propagation[c] Advanced Black Magic\nISBN: 013084408X\nEAN: N/A\nYear: 2005\nPages: 163", null, "" ]	[ null, "https://flylib.com/books/1/389/1/html/2/files/xdequ12.gif", null, "https://flylib.com/books/1/389/1/html/2/files/xdequ13.gif", null, "https://flylib.com/books/1/389/1/html/2/files/xdequ14.gif", null, "https://flylib.com/books/1/389/1/html/2/files/745equ01.gif", null, "https://flylib.com/books/1/389/1/html/2/files/xdequ15.gif", null, "https://flylib.com/icons/blank_book.jpg", null, "https://flylib.com/media/images/top.png", null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.80835927,"math_prob":0.98895484,"size":1727,"snap":"2020-24-2020-29","text_gpt3_token_len":440,"char_repetition_ratio":0.11375508,"word_repetition_ratio":0.01986755,"special_character_ratio":0.23508975,"punctuation_ratio":0.07647059,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9990381,"pos_list":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],"im_url_duplicate_count":[null,5,null,5,null,5,null,5,null,5,null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-07-12T00:34:39Z\",\"WARC-Record-ID\":\"<urn:uuid:2c5f7a73-e09a-42cf-8703-bc9e00aa39a1>\",\"Content-Length\":\"34444\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:81db6f9f-5b6c-4c03-b226-9372a3d6a8bc>\",\"WARC-Concurrent-To\":\"<urn:uuid:ad1f291a-fbfb-4aea-9a22-ca4abf63c2fc>\",\"WARC-IP-Address\":\"179.43.157.53\",\"WARC-Target-URI\":\"https://flylib.com/books/en/1.389.1/pi_model_operated_in_the_lc_region.html\",\"WARC-Payload-Digest\":\"sha1:AYPS666BXWQXIWBK7YP4CTPE5XAQQ3OS\",\"WARC-Block-Digest\":\"sha1:5BVKI2FEBZQACR7SMOF3IDAZMK5765OJ\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-29/CC-MAIN-2020-29_segments_1593657129257.81_warc_CC-MAIN-20200711224142-20200712014142-00070.warc.gz\"}"}
https://www.nagwa.com/en/videos/964182829165/	[ "# Video: Finding the Sum of an Infinite Number of Terms of a Geometric Sequence given the Values of Two Terms\n\nFind the sum of an infinite number of terms of a geometric sequence given the first term is 26/5 and the fourth term is −650/343.\n\n03:31\n\n### Video Transcript\n\nFind the sum of an infinite number of terms of a geometric sequence given the first term is 26 over five and the fourth term is negative 650 divided by 343.\n\nThe question gives us a geometric sequence with first term 26 over five and fourth term negative 650 divided by 343. We recall that geometric sequence has the property that, to get the next term in the sequence, we multiply the previous term by a constant ratio 𝑟. We see that this tells us our first term is just the constant 𝑎 and our fourth term is this constant 𝑎 multiplied by the ratio 𝑟 cubed.\n\nWe can use this to find the ratio 𝑟 of the geometric sequence given to us in the question. The first term is 26 over five. So we’ll set 𝑎 equal to 26 over five. And our fourth term is equal to negative 650 divided by 343. So this is equal to 𝑎 multiplied by 𝑟 cubed. We can substitute 𝑎 is equal to 26 over five into our equation for the fourth term. This gives us that negative 650 divided by 343 is equal to 26 over five multiplied by 𝑟 cubed.\n\nNow we’ll multiply both sides for our equation by five and divide by 26. This gives us that 𝑟 cubed is equal to negative 650 multiplied by five divided by 343 multiplied by 26. This simplifies to give us negative 125 divided by 343 is equal to 𝑟 cubed.\n\nFinally, we can take the cube roots of both sides of our equation to get that 𝑟 is equal to the cube root of negative 125 divided by 343, which is equal to negative five over seven.\n\nNow the question wants us to find the sum of an infinite number of terms of our geometric sequence. We recall that, for a geometric series with initial value 𝑎 and ratio of successive terms 𝑟, if the absolute value of 𝑟 is less than one. Then the sum from 𝑛 equals zero to ∞ of 𝑎 multiplied by 𝑟 to the 𝑛th power is equal to 𝑎 divided by one minus 𝑟.\n\nWe’ve already shown that the initial term of our geometric series 𝑎 is equal to 26 over five and the ratio of successive terms 𝑟 is equal to negative five over seven. And the absolute value of our ratio 𝑟 is the absolute value of negative five over seven, which is just equal to five over seven, which is less than one.\n\nSo since the absolute value of our ratio 𝑟 is less than one, we can calculate the sum of an infinite number of terms of our geometric series by using the formula 𝑎 divided by one minus 𝑟. Using this, we have the sum of an infinite number of terms of our geometric series is equal to the sum from 𝑛 equals zero to ∞ of 26 over five multiplied by negative five over seven all raised to the 𝑛th power. And this is equal to 26 over five divided by one minus negative five over seven.\n\nWe can rewrite our denominator as seven over seven plus five over seven, which is just equal to 12 divided by seven. Next, instead of dividing by the fraction 12 over seven, we’re going to multiply by the reciprocal. This gives us 26 over five multiplied by seven divided by 12. We can cancel out a shared factor of two in the numerator and the denominator. Finally, we can evaluate this to be equal to 91 divided by 30.\n\nTherefore, we’ve shown that the sum of an infinite number of terms of the geometric series with first term 26 over five and fourth term negative 650 divided by 343 is equal to 91 divided by 30." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.9323,"math_prob":0.9980881,"size":3221,"snap":"2020-34-2020-40","text_gpt3_token_len":836,"char_repetition_ratio":0.17656201,"word_repetition_ratio":0.19620253,"special_character_ratio":0.24029805,"punctuation_ratio":0.06442167,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9999809,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-09-20T08:44:29Z\",\"WARC-Record-ID\":\"<urn:uuid:20d3c8bd-4f2d-4ab4-a43f-d62220bb7a7f>\",\"Content-Length\":\"28964\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:cad67482-9038-47b8-999a-cfb8216c33db>\",\"WARC-Concurrent-To\":\"<urn:uuid:dfe690d9-92ad-4f69-b822-2809b00731cf>\",\"WARC-IP-Address\":\"23.23.60.1\",\"WARC-Target-URI\":\"https://www.nagwa.com/en/videos/964182829165/\",\"WARC-Payload-Digest\":\"sha1:AMTVQCINHTF5WJ2D7DEL7DE5EN4DXIOF\",\"WARC-Block-Digest\":\"sha1:TWMZYGZOSLFJBRDK2MN4RJVVYEAMGPCC\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-40/CC-MAIN-2020-40_segments_1600400196999.30_warc_CC-MAIN-20200920062737-20200920092737-00276.warc.gz\"}"}
https://apache-singa.readthedocs.io/en/master/module.html	[ "# Loss¶\n\nThis script includes Module class for python users to use Computational Graph in their model.\n\nclass singa.module.Module\n\nBases: object\n\nBase class for your neural network modules.\n\nExample usage:\n\nimport numpy as np\nfrom singa import opt\nfrom singa import tensor\nfrom singa import device\nfrom singa.module import Module\n\nclass Model(Module):\ndef __init__(self):\nsuper(Model, self).__init__()\n\nself.sgd = opt.SGD(lr=0.01)\n\ndef forward(self, x):\ny = self.conv1(x)\ny = self.conv2(y)\nreturn y\n\ndef loss(self, out, y):\n\ndef optim(self, loss):\nself.sgd.backward_and_update(loss)\n\neval()\n\nSets the module in evaluation mode.\n\nforward(input)\n\nDefines the computation performed at every call.\n\nShould be overridden by all subclasses.\n\nParameters\n\ninput – the input training data for the module\n\nReturns\n\nthe outputs of the forward propagation.\n\nReturn type\n\nout\n\ngraph(mode=True, sequential=False)\n\nTurn on the computational graph. Specify execution mode.\n\nloss(args, kwargs)\n\nDefines the loss function performed when training the module.\n\non_device(device)\n\nSets the target device.\n\nThe following training will be performed on that device.\n\nParameters\n\ndevice (Device) – the target device\n\noptim(args, **kwargs)\n\nDefines the optim function for backward pass.\n\ntrain(mode=True)\n\nSet the module in evaluation mode." ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.53296864,"math_prob":0.752613,"size":1500,"snap":"2021-31-2021-39","text_gpt3_token_len":382,"char_repetition_ratio":0.12098931,"word_repetition_ratio":0.018779343,"special_character_ratio":0.252,"punctuation_ratio":0.18214285,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.95560855,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-09-20T17:54:29Z\",\"WARC-Record-ID\":\"<urn:uuid:b19ff399-3c61-4a06-9cea-6b139b19882c>\",\"Content-Length\":\"22035\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:d9f29636-77a0-4d56-9202-7edb23ce9cd6>\",\"WARC-Concurrent-To\":\"<urn:uuid:53159080-0427-46fe-952f-c4bccf38f4ce>\",\"WARC-IP-Address\":\"104.17.33.82\",\"WARC-Target-URI\":\"https://apache-singa.readthedocs.io/en/master/module.html\",\"WARC-Payload-Digest\":\"sha1:3AAWCNLZMGQGTGRXQ2SKNZJWT4423IGC\",\"WARC-Block-Digest\":\"sha1:VFDUCB3GEUM3GBR5RRNH6CEEJ7OXYUR3\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-39/CC-MAIN-2021-39_segments_1631780057083.64_warc_CC-MAIN-20210920161518-20210920191518-00336.warc.gz\"}"}
https://www.colorhexa.com/013d24	[ "# #013d24 Color Information\n\nIn a RGB color space, hex #013d24 is composed of 0.4% red, 23.9% green and 14.1% blue. Whereas in a CMYK color space, it is composed of 98.4% cyan, 0% magenta, 41% yellow and 76.1% black. It has a hue angle of 155 degrees, a saturation of 96.8% and a lightness of 12.2%. #013d24 color hex could be obtained by blending #027a48 with #000000. Closest websafe color is: #003333.\n\n• R 0\n• G 24\n• B 14\nRGB color chart\n• C 98\n• M 0\n• Y 41\n• K 76\nCMYK color chart\n\n#013d24 color description : Very dark cyan - lime green.\n\n# #013d24 Color Conversion\n\nThe hexadecimal color #013d24 has RGB values of R:1, G:61, B:36 and CMYK values of C:0.98, M:0, Y:0.41, K:0.76. Its decimal value is 81188.\n\nHex triplet RGB Decimal 013d24 `#013d24` 1, 61, 36 `rgb(1,61,36)` 0.4, 23.9, 14.1 `rgb(0.4%,23.9%,14.1%)` 98, 0, 41, 76 155°, 96.8, 12.2 `hsl(155,96.8%,12.2%)` 155°, 98.4, 23.9 003333 `#003333`\nCIE-LAB 21.84, -25.074, 10.492 2, 3.471, 2.234 0.26, 0.451, 3.471 21.84, 27.18, 157.294 21.84, -18.801, 12.992 18.631, -13.447, 5.934 00000001, 00111101, 00100100\n\n# Color Schemes with #013d24\n\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #3d011a\n``#3d011a` `rgb(61,1,26)``\nComplementary Color\n• #013d06\n``#013d06` `rgb(1,61,6)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #01383d\n``#01383d` `rgb(1,56,61)``\nAnalogous Color\n• #3d0601\n``#3d0601` `rgb(61,6,1)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #3d0138\n``#3d0138` `rgb(61,1,56)``\nSplit Complementary Color\n• #3d2401\n``#3d2401` `rgb(61,36,1)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #24013d\n``#24013d` `rgb(36,1,61)``\n• #1a3d01\n``#1a3d01` `rgb(26,61,1)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #24013d\n``#24013d` `rgb(36,1,61)``\n• #3d011a\n``#3d011a` `rgb(61,1,26)``\n• #000000\n``#000000` `rgb(0,0,0)``\n• #000b06\n``#000b06` `rgb(0,11,6)``\n• #012415\n``#012415` `rgb(1,36,21)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #015633\n``#015633` `rgb(1,86,51)``\n• #026f42\n``#026f42` `rgb(2,111,66)``\n• #028850\n``#028850` `rgb(2,136,80)``\nMonochromatic Color\n\n# Alternatives to #013d24\n\nBelow, you can see some colors close to #013d24. Having a set of related colors can be useful if you need an inspirational alternative to your original color choice.\n\n• #013d15\n``#013d15` `rgb(1,61,21)``\n• #013d1a\n``#013d1a` `rgb(1,61,26)``\n• #013d1f\n``#013d1f` `rgb(1,61,31)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #013d29\n``#013d29` `rgb(1,61,41)``\n• #013d2e\n``#013d2e` `rgb(1,61,46)``\n• #013d33\n``#013d33` `rgb(1,61,51)``\nSimilar Colors\n\n# #013d24 Preview\n\nThis text has a font color of #013d24.\n\n``<span style=\"color:#013d24;\">Text here</span>``\n#013d24 background color\n\nThis paragraph has a background color of #013d24.\n\n``<p style=\"background-color:#013d24;\">Content here</p>``\n#013d24 border color\n\nThis element has a border color of #013d24.\n\n``<div style=\"border:1px solid #013d24;\">Content here</div>``\nCSS codes\n``.text {color:#013d24;}``\n``.background {background-color:#013d24;}``\n``.border {border:1px solid #013d24;}``\n\n# Shades and Tints of #013d24\n\nA shade is achieved by adding black to any pure hue, while a tint is created by mixing white to any pure color. In this example, #000302 is the darkest color, while #effff8 is the lightest one.\n\n• #000302\n``#000302` `rgb(0,3,2)``\n• #00160d\n``#00160d` `rgb(0,22,13)``\n• #012a19\n``#012a19` `rgb(1,42,25)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\n• #01502f\n``#01502f` `rgb(1,80,47)``\n• #02643b\n``#02643b` `rgb(2,100,59)``\n• #027746\n``#027746` `rgb(2,119,70)``\n• #028a52\n``#028a52` `rgb(2,138,82)``\n• #039d5d\n``#039d5d` `rgb(3,157,93)``\n• #03b168\n``#03b168` `rgb(3,177,104)``\n• #03c474\n``#03c474` `rgb(3,196,116)``\n• #04d77f\n``#04d77f` `rgb(4,215,127)``\n• #04eb8b\n``#04eb8b` `rgb(4,235,139)``\n• #07fb95\n``#07fb95` `rgb(7,251,149)``\n• #1bfb9e\n``#1bfb9e` `rgb(27,251,158)``\n• #2efca6\n``#2efca6` `rgb(46,252,166)``\n• #41fcae\n``#41fcae` `rgb(65,252,174)``\n• #54fcb6\n``#54fcb6` `rgb(84,252,182)``\n• #68fdbf\n``#68fdbf` `rgb(104,253,191)``\n• #7bfdc7\n``#7bfdc7` `rgb(123,253,199)``\n• #8efdcf\n``#8efdcf` `rgb(142,253,207)``\n• #a2fdd7\n``#a2fdd7` `rgb(162,253,215)``\n• #b5fedf\n``#b5fedf` `rgb(181,254,223)``\n• #c8fee8\n``#c8fee8` `rgb(200,254,232)``\n• #dcfef0\n``#dcfef0` `rgb(220,254,240)``\n• #effff8\n``#effff8` `rgb(239,255,248)``\nTint Color Variation\n\n# Tones of #013d24\n\nA tone is produced by adding gray to any pure hue. In this case, #1e201f is the less saturated color, while #013d24 is the most saturated one.\n\n• #1e201f\n``#1e201f` `rgb(30,32,31)``\n• #1b2320\n``#1b2320` `rgb(27,35,32)``\n• #192520\n``#192520` `rgb(25,37,32)``\n• #162820\n``#162820` `rgb(22,40,32)``\n• #142a21\n``#142a21` `rgb(20,42,33)``\n• #122c21\n``#122c21` `rgb(18,44,33)``\n• #0f2f22\n``#0f2f22` `rgb(15,47,34)``\n• #0d3122\n``#0d3122` `rgb(13,49,34)``\n• #0b3322\n``#0b3322` `rgb(11,51,34)``\n• #083623\n``#083623` `rgb(8,54,35)``\n• #063823\n``#063823` `rgb(6,56,35)``\n• #033b24\n``#033b24` `rgb(3,59,36)``\n• #013d24\n``#013d24` `rgb(1,61,36)``\nTone Color Variation\n\n# Color Blindness Simulator\n\nBelow, you can see how #013d24 is perceived by people affected by a color vision deficiency. This can be useful if you need to ensure your color combinations are accessible to color-blind users.\n\nMonochromacy\n• Achromatopsia 0.005% of the population\n• Atypical Achromatopsia 0.001% of the population\nDichromacy\n• Protanopia 1% of men\n• Deuteranopia 1% of men\n• Tritanopia 0.001% of the population\nTrichromacy\n• Protanomaly 1% of men, 0.01% of women\n• Deuteranomaly 6% of men, 0.4% of women\n• Tritanomaly 0.01% of the population" ]	[ null ]	{"ft_lang_label":"__label__en","ft_lang_prob":0.54608417,"math_prob":0.80993956,"size":3648,"snap":"2023-40-2023-50","text_gpt3_token_len":1632,"char_repetition_ratio":0.13007684,"word_repetition_ratio":0.007352941,"special_character_ratio":0.56085527,"punctuation_ratio":0.23378076,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9905304,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-12-09T17:58:59Z\",\"WARC-Record-ID\":\"<urn:uuid:aa080402-0e8c-4e60-afea-1ec6e425aa8a>\",\"Content-Length\":\"36106\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:d3bf1083-fde1-40fe-967e-100b0c7a0329>\",\"WARC-Concurrent-To\":\"<urn:uuid:f75efa29-de94-4972-a689-64bd06e76cc4>\",\"WARC-IP-Address\":\"178.32.117.56\",\"WARC-Target-URI\":\"https://www.colorhexa.com/013d24\",\"WARC-Payload-Digest\":\"sha1:Z4IANO4725M5JA4IKO6B54ZZ4AAJ6HDC\",\"WARC-Block-Digest\":\"sha1:ZC3QX4ZTXFFWK3VXZBTEVBDJJRVJGDAG\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-50/CC-MAIN-2023-50_segments_1700679100942.92_warc_CC-MAIN-20231209170619-20231209200619-00554.warc.gz\"}"}