{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as pp" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "N_g = int( round( np.random.uniform( low = 3, high = 7 ) ) )\n", "print( N_g )" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "groups = []\n", "\n", "r = 5\n", "dr = r / 5\n", "\n", "theta = 2 * np.pi / ( N_g - 1 )\n", "dtheta = theta / 5\n", "\n", "for i in range( N_g ):\n", " \n", " if i == 0:\n", " center = np.array( [ 0.0, 0.0 ] )\n", " else:\n", " curr_r = np.random.uniform( low = r - dr, high = r + dr )\n", " \n", " curr_theta = np.random.uniform(\n", " low = ( i - 1 ) * theta - dtheta,\n", " high = ( i - 1 ) * theta + dtheta\n", " )\n", " \n", " center = curr_r * np.array( [ np.cos( curr_theta ), np.sin( curr_theta ) ] )\n", " \n", " points = []\n", " for j in range( int( round( np.random.uniform( low = 5, high = 15 ) ) ) ):\n", " \n", " curr_r = np.random.uniform( low = 0, high = r / 2 )\n", " \n", " curr_theta = np.random.uniform(\n", " low = 0,\n", " high = 2 * np.pi\n", " )\n", " \n", " p_center = center + curr_r * np.array( [ np.cos( curr_theta ), np.sin( curr_theta ) ] )\n", " v = np.random.uniform( low = 2, high = 4 )\n", " h = np.random.uniform( low = 2, high = 4 )\n", " points.append( ( ( h, v ), p_center ) )\n", " \n", " groups.append( ( center, points ) )" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pp.figure( figsize = ( 10, 10 ) )\n", "\n", "colors = [ 'blue', 'red', 'black', 'cyan', 'green', 'orange', 'gray' ]\n", "\n", "i = 0\n", "for c in groups:\n", "# pp.scatter( *c[ 0 ], marker = \"x\", color = colors[ i ] )\n", " \n", " for p in c[ 1 ]:\n", " \n", " pp.gca().add_patch(\n", " pp.Rectangle(\n", " ( p[ 1 ][ 0 ], p[ 1 ][ 1 ] ),\n", " p[ 0 ][ 0 ] , p[ 0 ][ 1 ],\n", " color = colors[ i ],\n", " alpha = 0.1\n", " )\n", " )\n", "# pp.plot(\n", "# [ \n", "# p[ 1 ][ 0 ],\n", "# p[ 1 ][ 0 ] + p[ 0 ][ 0 ],\n", "# p[ 1 ][ 0 ] + p[ 0 ][ 0 ],\n", "# p[ 1 ][ 0 ] \n", "# ],\n", "# [ \n", "# p[ 1 ][ 1 ],\n", "# p[ 1 ][ 1 ],\n", "# p[ 1 ][ 1 ] + p[ 0 ][ 1 ],\n", "# p[ 1 ][ 1 ] + p[ 0 ][ 1 ] \n", "# ],\n", "# color = colors[ i ]\n", "# )\n", "# pp.scatter( *p[ 1 ], color = colors[ i ] )\n", " \n", " i = i + 1\n", "\n", "pp.axis( ( -10, 10, -10, 10 ) )\n", " \n", "pp.show()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def zero_trunc( x ):\n", " if x >= 0.0:\n", " return x\n", " else:\n", " return 0.0\n", "\n", "def O_ij( x, h, i, j ):\n", " \n", " if x[ i ] >= x[ j ]:\n", " \n", " return ( zero_trunc( h[ j ] ** 2.0 - ( x[ i ] - x[ j ] ) ** 2.0 ) ** 2.0 ) / ( h[ j ] ** 4.0 )\n", " \n", " else:\n", " return ( zero_trunc( h[ i ] ** 2.0 - ( x[ i ] - x[ j ] ) ** 2.0 ) ** 2.0 ) / ( h[ i ] ** 4.0 )\n", "\n", "def E_O( xy, h, v ):\n", " \n", " x = xy[ : : 2 ]\n", " y = xy[ 1 : : 2 ]\n", " n = int( xy.shape[ 0 ] / 2 )\n", " \n", " retval = 0.0\n", " \n", " for i in range( n ):\n", " \n", " curr_xi = x[ i ]\n", " curr_yi = y[ i ]\n", " \n", " curr_hi = h[ i ]\n", " curr_vi = v[ i ]\n", " \n", " for j in range( i + 1, n ):\n", " \n", " curr_xj = x[ j ]\n", " curr_yj = y[ j ]\n", "\n", " curr_hj = h[ j ]\n", " curr_vj = v[ j ]\n", " \n", " retval += O_ij( x, h, i, j ) * O_ij( y, v, i, j )\n", " \n", " return 2.0 * retval / ( n * ( n + 1 ) )" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def gera_xyhv( groups ):\n", " \n", " xy = []\n", " h = []\n", " v = []\n", " \n", " for g in groups:\n", " \n", " for p in g[ 1 ]:\n", " \n", " h.append( p[ 0 ][ 0 ] )\n", " v.append( p[ 0 ][ 1 ] )\n", " xy.append( p[ 1 ][ 0 ] )\n", " xy.append( p[ 1 ][ 1 ] )\n", " \n", " return( np.array( xy ), np.array( h ), np.array( v ) )" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "( xy, h, v ) = gera_xyhv( groups )" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.08946818762626481\n" ] } ], "source": [ "print( E_O( xy, h, v ) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$$\n", "\\sum_{i = 0}^{n - 1}\\sum_{j = i + 1}^{n - 1}1 = \\sum_{i = 0}^{n - 1}n - 1 - ( i + 1 ) + 1 = \\sum_{i = 0}^{n - 1}n - i - 1\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Seja $j = n - 1 - i$, então:\n", "$$\n", "\\sum_{i = 0}^{n - 1}\\sum_{j = i + 1}^{n - 1}1 = \\sum_{j = n - 1}^0 j = \\sum_{j = 0}^{n - 1} j\n", "$$" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def calcula_L( groups ):\n", " \n", " n_verts = 0\n", " for g in groups:\n", " for p in g[ 1 ]:\n", " n_verts += 1\n", " \n", " L = np.eye( n_verts )\n", " \n", " curr_idx = 0\n", " for g in groups:\n", " \n", " curr_n = len( g[ 1 ] )\n", " \n", " for i in range( curr_n ):\n", " for j in range( i + 1, curr_n ):\n", " L[ curr_idx + i, curr_idx + j ] = -1.0 / ( curr_n - 1.0 )\n", " L[ curr_idx + j, curr_idx + i ] = L[ curr_idx + i, curr_idx + j ]\n", " \n", " curr_idx += curr_n\n", " \n", " return L\n", " \n", "L = calcula_L( groups )" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "delta_x = L @ xy[ : : 2 ]\n", "delta_y = L @ xy[ 1 : : 2 ]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def E_N( xy, w ):\n", " \n", " retval = np.linalg.norm( L @ xy[ : : 2 ] - w * delta_x ) ** 2\n", " retval += np.linalg.norm( L @ xy[ 1 : : 2 ] - w * delta_y ) ** 2\n", " \n", " retval *= ( L.shape[ 0 ] ** 2 ) / \\\n", " ( 2.0 * ( np.linalg.norm( delta_x ) ** 2 ) + np.linalg.norm( delta_y ) ** 2 )\n", " \n", " return retval" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0\n" ] } ], "source": [ "print( E_N( xy / 2.0, 0.5 ) )" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "import scipy.optimize" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "res = scipy.optimize.minimize( E_O, xy, ( h, v ) )" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ -42.30722678 85.97017328 2.64308081 -61.81827828 -26.32355969\n", " 25.20718784 -80.95467565 -16.77509433 -55.05285084 -11.01288943\n", " 31.74369084 -14.19879609 14.07567587 -70.05793448 -38.30556668\n", " 1.0031023 12.17971643 2.70089429 0.36339466 -100.43271758\n", " 26.54648417 -45.7806287 63.9845504 44.27708055 41.23762484\n", " -2.97389535 63.53371268 50.81203328 6.70768413 -87.73217062\n", " 0.76025928 56.2482034 45.39588912 -38.02015855 -51.41956357\n", " 46.70444719 68.73070703 49.83845741 15.94543022 9.99950355\n", " 42.4898151 57.25410262 -74.3451693 29.88713488 -59.84903865\n", " 7.88965919 1.12891111 -14.38141334 11.03887298 68.07765425\n", " -9.34765233 -42.28738927 -83.15027197 -28.65493445 39.74474273\n", " 2.2659919 45.01439826 45.50940431 -46.28602389 -24.16996902\n", " 113.37234714 27.91901023 -32.34259225 -49.32260423 94.42799472\n", " 30.584592 -42.90923333 -4.04346519 110.41113588 -28.54397655\n", " -90.23233522 41.43820173 -50.69651372 -23.75184769 3.78423378\n", " 54.78412852 -52.97849242 10.018625 -9.85524112 55.39515771\n", " 70.69621289 -79.70259997 -59.74042001 -78.35325845 -45.0011785\n", " -11.01334338]\n" ] } ], "source": [ "print( res.x )" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pp.figure( figsize = ( 10, 10 ) )\n", "\n", "colors = [ 'blue', 'red', 'black', 'cyan', 'green', 'orange', 'gray' ]\n", "\n", "i = 0\n", "j = 0\n", "for c in groups:\n", " \n", " for p in c[ 1 ]:\n", " \n", " pp.gca().add_patch(\n", " pp.Rectangle(\n", " ( res.x[ 2 * j ], res.x[ 2 * j + 1 ] ),\n", " p[ 0 ][ 0 ] , p[ 0 ][ 1 ],\n", " color = colors[ i ],\n", " alpha = 1.0\n", " )\n", " )\n", " \n", " j = j + 1\n", " \n", " i = i + 1\n", "\n", "pp.axis( ( -150, 150, -150, 150 ) )\n", " \n", "pp.show()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0\n" ] } ], "source": [ "print( E_O( res.x, h, v ) )" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def obj_fun( z, alpha ):\n", " # z contém xy e w\n", " \n", " xy = z[ : -1 ]\n", " w = z[ -1 ]\n", " \n", " return alpha * E_N( xy, w ) + ( 1.0 - alpha ) * E_O( xy, h, v )" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "res = scipy.optimize.minimize( obj_fun, np.concatenate( ( xy, np.ones( ( 1, ) ) ) ), ( 0.9 ) )" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pp.figure( figsize = ( 10, 10 ) )\n", "\n", "colors = [ 'blue', 'red', 'black', 'cyan', 'green', 'orange', 'gray' ]\n", "\n", "i = 0\n", "j = 0\n", "for c in groups:\n", " \n", " for p in c[ 1 ]:\n", " \n", " pp.gca().add_patch(\n", " pp.Rectangle(\n", " ( res.x[ 2 * j ], res.x[ 2 * j + 1 ] ),\n", " p[ 0 ][ 0 ] , p[ 0 ][ 1 ],\n", " color = colors[ i ],\n", " alpha = 1.0\n", " )\n", " )\n", " \n", " j = j + 1\n", " \n", " i = i + 1\n", "\n", "pp.axis( ( -100, 100, -100, 100 ) )\n", " \n", "pp.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "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.6.9" } }, "nbformat": 4, "nbformat_minor": 2 }