{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# This website's logo\n", "> Symbolic computation with Wolfram Language kernel\n", "\n", "- toc: true \n", "- badges: true\n", "- comments: false\n", "- categories: [jupyter]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"least\n", "\n", "## Introduction\n", "\n", "This will only work if you have Mathematica installed in your machine. Python can interface with Wolfram Mathematica, taking advantage of its awesome power.\n", "\n", "The curve inside the square is a parabola:\n", "$$\n", "y = ax^2 + bx + c\n", "$$\n", "\n", "This parabola passes through the points $(0.3, 0)$ and $(1, 1)$, and it's derivative at $(0.3, 0)$ is zero. We use Mathematica to figure out what are the parameters $a,b,c$. Finally, we transpose the line when plotting, i.e., $x$ is in the vertical axis, and $y$ is in the horizontal axis.\n", "\n", "## The code" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Equations may not give solutions for all \"solve\" variables.\n", "Equations may not give solutions for all \"solve\" variables.\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAF5CAYAAAB6A1o9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAea0lEQVR4nO3d/X/P9eLH8ec2zDRjzEXRUJ1QHRW5Gl3q5roIGzFmVxgWzlzEOjnnlMWi0LDsMJq5yuXRlYobKjqpKSfpcNNZt+Sy2HE1M/b5/nDOt9upxC4+n8/r83l9Hvc/4PN63vrh4d3789n77edwOOTn5+cQAMA6/qYHAABch8gDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYrJIrPtTh4PH0AMz79ttvtXTpUmVnZys/P9/0HCNcEnkAMKWwsFAbNmzQ4sWLtWXLFp+/6CTyALyew+FQXl6eFi9erOXLl6ugoMD0JI9B5AF4rZMnTyo3N1eLFy/WP/7xD9NzPBKRB+BVLl++rHfffVeLFy/W3/72NxUXF5ue5BINGzbUoEGDNGPGjAp9jp8rXuTt6/fAADjfwYMHlZ2draVLl+rIkSOm57hESEiIIiMjFR0drQceeED+/v7y8/Or0GdyJQ/AY128eFFr167VwoULtWPHDtNzXKJy5crq0aOHBg0apJ49e6pq1apO/XwiD8DjfPnll8rKylJOTo5Onz5teo5LdOzYUdHR0YqMjFStWrVcdg6RB+ARzp8/r1WrVikrK0sff/yx6Tku0axZM0VHR2vgwIFq0qSJW84k8gCMysvLU1ZWlnJzc3X27FnTc5yubt26GjhwoKKjo9WyZcsK32MvKyIPwO3OnDmj5cuXKysrS3l5eabnOF2VKlXUq1cvxcTEqEuXLqpUyVxqiTwAt3A4HPr444+VlZWlVatW6cKFC6YnOV379u0VExOjqKgohYaGmp4jicgDcLFTp04pJydHWVlZ2rdvn+k5ThceHq7BgwdryJAhuv32203P+RUiD8DpHA6Hdu7cqczMTL3++usqKioyPcmpbrjhBvXr108xMTF68MEH5e/vuQ/0JfIAnObMmTNatmyZMjMzrXvMgJ+fnx5++GHFxMSoT58+Cg4ONj2pVIg8gArbs2ePFixYoOXLl+v8+fOm5zjV7373O8XExGjw4MEKDw83PafMiDyAcrlw4YJWr16tBQsW6JNPPjE9x6lq1qypAQMGKCYmRm3btnX7zx6dicgDKJOvv/5amZmZWrp0qVWP9PX391fnzp0VGxurxx9/3OmPFzCFyAO4rkuXLmnDhg1asGCBtm3bZnqOU916662Ki4vTkCFD1LBhQ9NznI7IA/hN+fn5WrhwoRYtWqQTJ06YnuM01apVU2RkpOLi4nT//fd79e2Y6yHyAH6mpKREmzdvVkZGht5++22rHh3evn17xcXFKSoqSiEhIabnuAWRByBJOn36tLKzszV//nwdOnTI9BynqVevnmJiYhQbG6tmzZqZnuN2RB7wcXv37lVGRoaWLVumwsJC03OcolKlSurZs6fi4uLUtWtXVa5c2fQkY4g84IOKi4u1fv16ZWRk6IMPPjA9x2nuuOMOxcXFKTo6WvXq1TM9xyMQecCHHDt2TAsXLlRmZqaOHj1qeo5TBAcH68knn1RCQoJat25t9Zeo5UHkAcs5HA7t2rVLGRkZWrNmjTUvvm7btq0SExPVv39/r3nEgAlEHrBUYWGhVqxYoYyMDO3Zs8f0HKeoWbOmBg8erMTERP3+9783PccrEHnAMt9++63mzZunRYsW6dSpU6bnOMUDDzygxMRE9e3bV0FBQabneBUiD1jA4XDoo48+0pw5c7Ru3TqVlJSYnlRhYWFhGjp0qBISEtS0aVPTc7wWkQe82KVLl7R69WrNnj1bn332mek5TvHoo48qMTFRvXr1UmBgoOk5Xo/IA17oxIkTevXVVzV//nwdO3bM9JwKu/HGGxUbG6v4+HjdcsstpudYhcgDXmTv3r2aM2eOcnNzvf5tS35+furevbsSExPVo0cPoy+7thn/VQEPV1JSojfffFOzZ8/W1q1bTc+psPr16yshIUEJCQlq1KiR6TnWI/KAhzp79qyys7M1d+5cK54l06lTJ40YMUK9evXy6ccMuBuRBzxMfn6+5s6dq0WLFunMmTOm51RIaGioYmNjNWzYMH4hYwiRBzzE7t27NXPmTK1Zs8brfwLZrl07JSUlKTIykt+1G0bkAYNKSkr0xhtvaNasWdqxY4fpORUSHBys6OhoDR8+XPfcc4/pOfgvIg8YUFhYqJycHM2aNUsHDhwwPadCWrRooaSkJA0aNEjVq1c3PQe/QOQBNzp58qTmz5+vefPm6eTJk6bnlFtgYKCioqKUlJSkdu3a8eRHD0bkATf45z//qZdffllLly7VxYsXTc8pt/DwcI0cOVLx8fEKCwszPQelQOQBF3E4HPrwww81c+ZMbdq0yavflfroo49q9OjR6tmzpwICAkzPQRkQecDJrly5og0bNig9PV2ffPKJ6TnlFhwcrKFDh2rkyJFq3ry56TkoJyIPOElRUZFycnKUnp6ugwcPmp5Tbs2aNdPo0aM1ePBghYSEmJ6DCiLyQAWdPXtWr776ql566SWvfaWev7+/Hn/8cY0ePVqPPPIIX6RahMgD5XTixAnNnTtX8+bNU0FBgek55VK7dm0lJiZqxIgRPEfGUkQeKKN//etfmjVrlhYtWuS1v5Rp1aqVkpOT1b9/f1WtWtX0HLgQkQdKae/evZoxY4ZWrVqlK1eumJ5TZv7+/urbt6/GjBmjiIgIbsn4CCIPXMP//wxy+vTpeuutt0zPKZeaNWsqMTFRo0aN4paMDyLywFU4HA698847ev7557Vz507Tc8qladOmGjNmjIYMGaIbbrjB9BwYQuSB/1FSUqKNGzfq+eefV15enuk55dKlSxeNGTNGXbp0kb+/v+k5MIzIA/rPHzCtXr1a06ZN0759+0zPKbOgoCANGTJETz31lO644w7Tc+BBiDx8WnFxsXJzc5WWluaVf8DUsGFDjR49WomJiapVq5bpOfBARB4+qaioSEuWLNH06dOVn59vek6ZtWvXTmPHjlWfPn14lR6uicjDp1y4cEFZWVlKT0/XkSNHTM8pEz8/Pz3xxBNKSUlRRESE6TnwEkQePuHs2bNasGCBZs2apRMnTpieUyZBQUGKi4vT2LFjddttt5meAy9D5GG1c+fOKSMjQzNnztSPP/5oek6Z1KtXT8nJyRoxYoRq165teg68FJGHlc6dO6d58+bpxRdf9Lq4N2/eXCkpKRo0aBCPHECFEXlY5fz585o/f77S09P1ww8/mJ5TJg8//LDGjx+vrl278vt2OA2RhxUuXLigBQsWKD093avuuQcEBKh///5KSUlRy5YtTc+BhYg8vFphYaEyMzM1Y8YMHT9+3PScUgsODlZiYqLGjh2r8PBw03NgMSIPr1RYWKiFCxdq+vTpOnbsmOk5pRYWFqYxY8Zo5MiR/PES3ILIw6sUFRUpKytLaWlpXvUWpkaNGmnChAmKjY1VtWrVTM+BDyHy8AqXL1/WsmXL9Kc//Unffvut6Tmldtddd+npp59WVFQUf5kKI4g8PFpJSYnWrl2rZ599Vl9//bXpOaXWsWNHPf300+revTsv54BRRB4e6f+f556amqo9e/aYnlNqPXv21KRJk9SxY0fTUwBJRB4e6IMPPtCUKVP04Ycfmp5SKgEBARo4cKAmTpyou+66y/Qc4GeIPDzGZ599pmeeeUbvvPOO6SmlEhgYqPj4eE2YMEGNGzc2PQe4KiIP4/bv369nn31Wa9asMT2lVKpVq6YRI0YoJSVFN910k+k5wDUReRhz+PBhTZ06VUuWLFFJSYnpOddVvXp1JScna+zYsapTp47pOUCpEHm4XUFBgWbMmKHZs2fr4sWLpudcV2hoqMaNG6fRo0crNDTU9BygTIg83KaoqEgLFizQc889p1OnTpmec11169ZVSkqKkpKSVL16ddNzgHIh8nC5kpISrVy5UqmpqV7xqr0GDRpo4sSJSkhI4K9T4fWIPFxqy5YtmjhxovLy8kxPua5GjRpp8uTJGjp0qAIDA03PAZyCyMMlvvjiC02aNEmbN282PeW6wsPD9cwzzygmJkZVqlQxPQdwKiIPpzp8+LBSU1OVk5Mjh8Nhes41hYeHKzU1VUOHDiXusBaRh1OcO3dO6enpmjlzpgoLC03PuaaGDRsqNTVVsbGx3JaB9Yg8KqSkpESvvfaapkyZ4vGP/m3QoIGmTJmi+Ph44g6fQeRRbjt27NC4ceM8/kvVm266SZMnT1ZCQgIvxobPIfIos0OHDmnixIlat26d6SnXVL9+fU2ePFnDhg0j7vBZRB6lVlBQoOeff15z585VcXGx6Tm/KSwsTJMnT1ZSUpKCgoJMzwGMIvK4rsuXL2vhwoWaOnWqfvjhB9NzflNISIjGjx+vsWPH8heqwH8ReVzTtm3blJycrC+//NL0lN8UFBSk5ORkTZw4UbVr1zY9B/AoRB5X9d1332n8+PFavXq16Sm/qXLlyho2bJhSU1N14403mp4DeCQij5+5ePGiZs2apbS0NF24cMH0nKvy9/fX4MGDNXXqVDVp0sT0HMCjEXlI+s87VTdt2qRx48bpm2++MT3nN/Xt21d/+ctfdMcdd5ieAngFIg8dOHBAY8aM8ejX7nXu3FnTpk3TfffdZ3oK4FX8TQ+AOWfPntWkSZN01113eWzgW7Zsqffff1+bN28m8EA5cCXvgxwOh15//XWNGzdOR44cMT3nqho3bqy0tDT1799f/v5ciwDlReR9zKFDhzRq1CiPfQRw7dq19cwzzygpKYnnywBOQOR9RFFRkWbMmKG0tDQVFRWZnvMrVatW1bhx4zRp0iTVqFHD9BzAGkTeB2zZskUjR47UgQMHTE/5FX9/f8XGxurPf/6zGjRoYHoOYB0ib7Fjx47pD3/4g1asWGF6ylX17NlT06dP15133ml6CmAtIm+hK1euKDMzU6mpqfr3v/9tes6v3HPPPXrppZf08MMPm54CWI/IW+aLL75QYmKidu/ebXrKr9SvX1/Tpk1TTEyMAgICTM8BfAK/TbNEYWGhpkyZovvuu8/jAl+1alWlpqbqwIEDiouLI/CAG3Elb4Ht27crMTFRBw8eND3lVwYOHKgXXnhB4eHhpqcAPokreS9WUFCgYcOG6aGHHvK4wLdv3167du1Sbm4ugQcM4kreS61fv16jRo3yuJdnh4eHa8aMGerfv7/8/PxMzwF8HpH3MkeOHFFycrLHvV81KChIU6ZMUUpKCq/cAzwIkfcSDodDixcvVkpKisf9LDIyMlIzZ87ktgzggYi8Fzh8+LASExM97kmRd955p+bOnatHHnnE9BQAv4EvXj2Yw+FQdna2xz0KuEaNGpo9e7b27NlD4AEPx5W8h/r+++81bNgwvfXWW6an/ExcXJxeeOEF1a1b1/QUAKVA5D2Mw+FQTk6OxowZo4KCAtNzftKmTRu98soratOmjekpAMqAyHuQo0ePavjw4dq0aZPpKT+pVauWZsyYobi4OF7eAXghIu8hVq1apaSkJJ0+fdr0lJ/ExsYqPT1dYWFhpqcAKCcib1hBQYFGjx6t3Nxc01N+cueddyozM1MdO3Y0PQVABfH/3wZt27ZNLVq08JjAV6tWTenp6dqzZw+BByxB5A0oKirSpEmT9Mgjj+i7774zPUeS1Lt3b+3fv18TJkxQ5cqVTc8B4CTcrnGzffv2adCgQfriiy9MT5EkNWrUSK+88ooee+wx01MAuABX8m5SUlKiOXPmqFWrVh4ReH9/f40fP1779u0j8IDFuJJ3g+PHj2vIkCF69913TU+R9J/X7/31r39Vq1atTE8B4GJcybvYe++9p7vvvtsjAl+1alVNnz5dn3zyCYEHfASRd5Hi4mJNnjxZXbp00fHjx03P0UMPPaS9e/dq0qRJfLEK+BBu17hAfn6+nnzySX388cemp6hGjRqaNWuW4uLieIkH4IO4kneytWvX6p577vGIwPft21f79+9XfHw8gQd8FJF3ksLCQiUlJalfv37GX+pRp04drVmzRmvWrNGNN95odAsAs7hd4wQHDx5Uv379tHfvXtNTFBUVpYyMDNWpU8f0FAAegCv5Clq/fr3uu+8+44EPCwvT6tWrtWrVKgIP4CdEvpwuX76sCRMmqE+fPjpz5ozRLX379tW+ffsUGRlpdAcAz8PtmnI4evSoBgwYoB07dhjdUbt2bc2bN09RUVF8sQrgqoh8GW3fvl39+/c3/tv33r17KzMzU/Xq1TO6A4Bn43ZNKTkcDr344ovq1KmT0cAHBwcrOztb69atI/AArosr+VI4f/684uPjtWrVKqM7OnTooNdee0233HKL0R0AvAdX8teRn5+vDh06GA18pUqVNG3aNG3fvp3AAygTruSvYdu2bYqMjNQPP/xgbEPTpk2Vm5vLA8UAlAtX8lfhcDiUkZGhRx991GjgR40apby8PAIPoNy4kv+FoqIijRo1SosWLTK2oU6dOlqyZIm6d+9ubAMAOxD5/3H8+HH16dNHO3fuNLahU6dOysnJ4ZkzAJyC2zX/tW/fPrVt29ZY4AMCApSWlqbNmzcTeABOw5W8/vP2pn79+hl7PEF4eLhWrFihiIgII+cDsJfPX8kvXLhQ3bp1Mxb4J554Qp9//jmBB+ASPhv5K1euaPz48Ro+fLiuXLni9vMDAwM1b948rV27VqGhoW4/H4Bv8MnbNefPn1d0dLQ2bNhg5PxbbrnlpzdIAYAr+VzkT5w4oR49eujTTz81cv7jjz+upUuXqmbNmkbOB+BbfOp2zaFDhxQREWEk8P7+/po+fbrWr19P4AG4jc9cyefl5albt246ceKE28+uV6+eVq5cqYceesjtZwPwbT5xJf/+++/rwQcfNBL4jh07Ki8vj8ADMML6yK9YsULdu3fXuXPn3H72uHHjtHXrVt10001uPxsAJMtv18yZM0djx451+7mBgYHKysrS4MGD3X42APwvKyPvcDj03HPPaerUqW4/u0GDBlq/fr1at27t9rMB4Jesi7zD4dDEiRM1c+ZMt58dERGhtWvXqn79+m4/GwCuxqp78iUlJRo5cqSRwCcmJmrr1q0EHoBHseZK/vLly4qLi1NOTo5bz61UqZLmzp2rESNGyM/Pz61nA8D1WBH5S5cuaeDAgVq7dq1bz61Ro4bWrl2rTp06ufVcACgtr498UVGR+vXrpzfeeMOt5zZp0kRvvvmmmjdv7tZzAaAsvPqe/KVLlxQZGen2wEdEROjvf/87gQfg8bw28pcuXVJUVJQ2bdrk1nMHDBigLVu2qE6dOm49FwDKwysjX1xcrAEDBmjjxo1uPffZZ5/V8uXLVbVqVbeeCwDl5XX35IuLi/Xkk09q/fr1bjszICBAixYtUkxMjNvOBABn8KrIX758WdHR0W79FU21atW0Zs0adevWzW1nAoCzeE3kS0pKNGzYMK1evdptZ4aFhenNN99UmzZt3HYmADiTV0Te4XBo/Pjxys7OdtuZjRs31ubNm3X77be77UwAcDav+OI1LS1NL7/8stvOu/vuu7Vz504CD8Dr+TkcDvn5+Tmc+aEOh/M+bt68eRo9erTTPu967r//fm3atEk1atRw25kA8Fsq+rgUj4788uXLNWjQIKd8Vml07txZ69evV7Vq1dx2JgBci7WRf//999WtWzddvnzZCYuur3fv3lq5cqUCAwPdch4AlIaVkd+7d686duyos2fPOmnRtQ0cOFBLlixR5cqV3XIeAJRWRSPvcV+8Hj58WN27d3db4BMTE/Xaa68ReABW8qjInzlzRj169ND333/vlvOeeuopvfrqqwoICHDLeQDgbh4T+eLiYvXr10979+51y3nJycmaPXs2L/oAYDWPiLzD4dCoUaP03nvvueW8UaNGac6cOQQegPU8IvLz589XVlaWW85KSkrSK6+8QuAB+ATjv67ZunWrOnfurCtXrjhzwlUNHz5c8+fPl7+/R/zbBgDX5dU/ofzmm2/UunVrnTp1ypnHX1V8fLwWLlxI4AF4Fa+N/NmzZxUREaEvv/zSmUdfVWRkpFasWMGvaAB4Ha/8nbzD4dDQoUPdEvjOnTtr2bJlBB6ATzIS+Zdeeknr1q1z+TkRERFat26dqlSp4vKzAMATuf12zUcffaQHH3zQ5V+0tmjRQtu2bVNoaKhLzwEAV/Kqe/InT57Uvffe6/K/aG3cuLF27dql+vXru/QcAHA1r7knf+XKFUVHR7s88KGhoXr77bcJPADIjZFPS0vTu+++69IzqlSpoo0bN6pZs2YuPQcAvIVbbtd89NFHeuCBB1RSUuLMY35l5cqV6t+/v0vPAAB38vjbNWfOnFF0dLTLA5+enk7gAeAXXB75p556Svn5+S49IyEhQePHj3fpGQDgjVx6u+b1119XVFSUMz/6Vzp27KgtW7bwW3gAVvLYn1AePnxYLVq00OnTp5350T9z880369NPP1XdunVddgYAmOSR9+QdDoeGDRvm0sAHBQVp48aNBB4ArsElkc/NzdXbb7/tio/+SXZ2tu69916XngEA3s4lt2tq1arl0scHp6SkaObMmS77fADwFB55T96V2rdvr+3bt6ty5cqmpwCAy/lU5GvXrq09e/bo5ptvNj0FANzCI794dQU/Pz8tW7aMwANAGXhN5KdMmaKuXbuangEAXsUrbte0bdtWH374oSpVqmR6CgC4lfX35G+44QZ9/vnnuu2220xPAQC3s/6e/Jw5cwg8AJSTR1/J9+7dW+vWravwv2QA4K2svV0TFhamr776SnXq1DE9BQCMsfZ2zdy5cwk8AFSQR17JP/bYY9q4cSO3aQD4POtu14SEhOirr75SgwYNTE8BAOOsu12Tnp5O4AHASTzqSr5NmzbatWuX/P097t8eADDCmit5Pz8/ZWRkEHgAcCKPKWpCQoJat25tegYAWMUjbteEhobqwIEDCgsLMzkDADyOFbdrpk6dSuABwAWMX8k3adJE+/fvV2BgoKkJAOCxvP5Kftq0aQQeAFzE6JV8y5YttXv3bn5RAwC/wauv5F944QUCDwAuZOxKvl27dtq5cyfPpwGAa/DaK/k//vGPBB4AXMzIlXyrVq20e/duIg8A1+GVV/KpqakEHgDcwO1X8rfeeqsOHDjAF64AUApedyU/ZswYAg8AbuLWK/mQkBAdPnxY1atXd8dxAOD1vOpKPj4+nsADgBu59Ur+66+/VtOmTd1xFABYwWuu5Dt06EDgAcDN3Bb5+Ph4dx0FAPgvt9yuCQ4O1tGjRxUcHOzKYwDAOl5xu6Z3794EHgAMcEvko6Ki3HEMAOAXXH67JiQkRCdOnODFIABQDh5/u6ZXr14EHgAMcUvkAQBmuPR2TUBAgH788UfVqFHDFR8PANbz6Ns1ERERBB4ADHJp5Lt27erKjwcAXIdLI9+pUydXfjwA4Dpcdk8+KChIBQUFqlKlirM/GgB8hsfek2/Tpg2BBwDDXBb5Dh06uOqjAQCl5LLIt23b1lUfDQAoJZdF/u6773bVRwMASsklX7yGhISooKCgwl8YAICv88gvXlu0aEHgAcADuCTyzZs3d8XHAgDKyCWRb9KkiSs+FgBQRkQeACxG5AHAYi6J/M033+yKjwUAlJFLfkJZVFTEIw0AwAkq+ktFl0Te4XDZK2MBwKd45O/kAQCegcgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYjMgDgMWIPABYrJIrPtTPz88VHwsAKCOu5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYkQeACxG5AHAYn4Oh8P0BgCAi/wfiV2p9pGcjJwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from wolframclient.language import wl\n", "from wolframclient.evaluation import WolframLanguageSession\n", "from wolframclient.language import wl, wlexpr\n", "\n", "w = 20\n", "plt.rc('axes', linewidth=w)\n", "fig=plt.figure(1, (5, 5))\n", "\n", "fig.subplots_adjust(left=0.0, right=1.0, top=1.0, bottom=0.0,\n", " hspace=0, wspace=0)\n", "ax = plt.Axes(fig, [0., 0., 1., 1.])\n", "fig.add_axes(ax)\n", "\n", "session = WolframLanguageSession()\n", "session.evaluate(wlexpr('y[x_] := a x^2 + b x + c'))\n", "session.evaluate(wlexpr('p1 = {0.3, 0}'))\n", "session.evaluate(wlexpr('p2 = {1, 1}'))\n", "session.evaluate(wlexpr('sol1 = Solve[ {y[p1[[1]]] == p1[[2]], y[p2[[1]]] == p2[[2]]}, {a, b, c}][[1]]'))\n", "session.evaluate(wlexpr('sol2 = Solve[(D[(y[x] /. sol1), x] /. x -> 0.3) == 0, a][[1]]'))\n", "par = list(session.evaluate(wlexpr('{a, b, c} /. sol1 /. sol2')))\n", "\n", "x0 = 0.3\n", "x=np.linspace(x0, 1, 1001)\n", "a, b, c = par# [2.08163, -1.24898, 0.167347]\n", "y = lambda x: a*x**2 + b*x + c\n", "\n", "c1 = 'white' # bottom right\n", "c2 = 'white' # top left\n", "\n", "\n", "\n", "# c1 = '#6c7053' # bottom right\n", "# c2 = '#6e0014' # top left\n", "# ax.fill_between(y(x), x, y2=0, facecolor=c1,\n", "# edgecolor='black') # bottom right\n", "# ax.fill_between(y(x), x, y2=1, facecolor=c2,\n", "# edgecolor=\"black\", linewidth=10) # top left\n", "\n", "ax.plot(y(x), x, color=\"black\", lw=w)\n", "\n", "ax.set_xlim([0,1])\n", "ax.set_ylim([0,1])\n", "ax.set_xticks([])\n", "ax.set_yticks([])\n", "\n", "fig.savefig(\"./python_figures/site-logo.png\", resolution=600, transparent=True, bbox_inches=\"tight\")\n", "fig.savefig(\"./python_figures/site-logo.svg\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Equations may not give solutions for all \"solve\" variables.\n", "Equations may not give solutions for all \"solve\" variables.\n" ] } ], "source": [ "session = WolframLanguageSession()\n", "session.evaluate(wlexpr('y[x_] := a x^2 + b x + c'))\n", "session.evaluate(wlexpr('p1 = {0.3, -0.02}'))\n", "session.evaluate(wlexpr('p2 = {1, 1}'))\n", "session.evaluate(wlexpr('sol1 = Solve[ {y[p1[[1]]] == p1[[2]], y[p2[[1]]] == p2[[2]]}, {a, b, c}][[1]]'))\n", "session.evaluate(wlexpr('sol2 = Solve[(D[(y[x] /. sol1), x] /. x -> 0.3) == 0, a][[1]]'))\n", "par = list(session.evaluate(wlexpr('{a, b, c} /. sol1 /. sol2')))\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2.0816326530612246, -1.2489795918367346, 0.16734693877551027]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "par" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 1 }