Keresés

Részletes keresés

hiper fizikus Creative Commons License 2020.05.28 0 0 21

ez is nagyon jó

És van valamid az akadályok kerülgetésére is ?

Előzmény: Törölt nick (20)
Törölt nick Creative Commons License 2020.05.28 0 1 20

Most már tud távolság alapján legrövidebb utat választani.

A szürke a legkevesebb elágazáson kerestrül vezető út, a zöld pedig a legkisebb megtett távolsághoz tartozó.

Feltüntetve az elágazások száma.

Előzmény: hiper fizikus (11)
Törölt nick Creative Commons License 2020.05.27 0 0 19

Itt most minden csomópontnak van egy számszerű paramétere: hány lépés távolságra van az indulási helytől. Node.

Értelemszerűen ha több lehetőség van, azok közül a legkisebb.

Most ezt le kell cserélnem valahogy távolságra...

Előzmény: hiper fizikus (18)
hiper fizikus Creative Commons License 2020.05.27 0 0 18

remek vagy

Tegnap az egyik weblapon azt magyarázták hogy négyzetekre is lehet bontani a kontinuumot, mint a kockáspapír, és ezeket a négyzeteket aztán szomszédsági alapon bejárni az akadályok között .

Előzmény: Törölt nick (17)
Törölt nick Creative Commons License 2020.05.27 0 0 17

Először meg kellett oldanom, hogy az utak ne keresztezzék egymást.

Két egyenes helyett két szakasz metszéspontjának számítása.

A keresztezés miatt elhagyott szakaszok sárgával szerepelnek. A szakaszok találkozásának helyét fekete kör jelzi.

 

 

A kezdeti pontból indul egy hullámfront a célpont felé.

Ez a módszer a legkevesebb elágazát találja meg.

Tovább kell fejlesztenem, hogy a legrövidebb utat is megtalálhassa.

Előzmény: hiper fizikus (11)
Törölt nick Creative Commons License 2020.05.26 0 1 16

Összedobtam gyorsan egyet. (Persze ezen még lehet optimalizálni.)

Előzmény: hiper fizikus (11)
hiper fizikus Creative Commons License 2020.05.25 0 1 15

de igen

Előzmény: NevemTeve (12)
Törölt nick Creative Commons License 2020.05.25 0 0 14

Egy rokon terület: huzalozó algoritmusok.

(A különbség annyi, hogy az kvázi folytonos térben dolgozik. Vagy legalább jóval finomabb raszterezéssel.)

Előzmény: hiper fizikus (11)
Törölt nick Creative Commons License 2020.05.25 0 1 13

Madách szavaival: "Már bennem élt, mi mostan létesült." :D

Előzmény: NevemTeve (12)
NevemTeve Creative Commons License 2020.05.25 0 0 12

(Csak nem megint egy újabb tudományterület, amit két nap alatt megismersz, és további két nap alatt jelentős felfedezésekkel gazdagítasz?)

Előzmény: hiper fizikus (11)
hiper fizikus Creative Commons License 2020.05.25 0 0 11

Mit tudtok, mit lehet tudni, milyenek az útkereső algoritmusok ?

Törölt nick Creative Commons License 2020.03.15 0 0 10

Sajnos van benne két hiba, mert a k változóval szerveztt ciklust nem lett volna szabad másolnom.

De a hiba csak akkor jön elő, ha K<N. Vagyis amikor a "bázisvektorok" száma nagyobb a dimenziószámnál.

Előzmény: Törölt nick (9)
Törölt nick Creative Commons License 2020.03.07 0 0 9

Vektor regresszió:

 

  class nRegr

  {

    private const int N = 32;
    private const int K = 1024;
    //
    private static Random r = null;
    private static double sx1, sxy, sy1, sxx, sxi, sxj;
    private static double[] c = null;  // megadott együtthatók
    private static double[] y = null;  // megadott függvényértékek
    private static double[] a = null;  // számított együtthatók
    private static double[] v = null;  // segédvektor (jobb)
    private static double[,] x = null; // etalon függvényértékek
    private static double[,] m = null; // számított együttható mátrix
    //
    public static void Main( string[] args )
    {
      int i, j, k, d;
      double p, q;
      //
      r = new Random( (int)( DateTime.Now.Ticks & 0xFFFF ) );
      c = new double[N];
      for ( i = 0; i < N; ++i ) // megadott együtthatók
      {
        c[i] = r.Next( 1, 9 ) + r.NextDouble();
        Console.WriteLine( "{0}", c[i] );
      }
      x = new double[N,K];
      for ( i = 0; i < N; ++i ) // etalon függvényértékek
      {
        for ( k = 0; k < K; ++k )
        {
          d = r.Next( 1, 5 );
          if ( ( ( k % N ) != i ) || ( d < 2 ) ) // hézagos spektrum
          {
            x[i,k] = 0.0;
          }
          else
          {
            x[i,k] = r.NextDouble();
          }
        }
      }
      y = new double[K];
      for ( k = 0; k < K; ++k ) // megadott függvényértékek
      {
        y[k] = 0.0;
        for ( i = 0; i < N; ++i )
        {
          y[k] += c[i] * x[i,k];
        }
        //
        #if DISTURB
        y[k] += r.NextDouble();
        #endif
      }
      Console.WriteLine();
      //
      v = new double[N];
      a = new double[N];
      for ( i = 0; i < N; ++i ) // segédvektor (jobb)
      {
        sx1 = sy1 = sxy = 0.0;
        v[i] = 0.0;
        for ( k = 0; k < K; ++k )
        {
          sx1 += x[i,k];
          sy1 += y[k];
          sxy += x[i,k] * y[k];
        }
        v[i] = ( K * sxy ) - ( sx1 * sy1 );
        a[i] = v[i]; // megőrizzük az eredetit
      }
      //
      m = new double[N,K];
      for ( i = 0; i < N; ++i ) // számított együttható mátrix
      {
        sxi = 0.0;
        for ( k = 0; k < K; ++k )
        {
          sxi += x[i,k];
        }
        //
        for ( j = 0; j < N; ++j )
        {
          sxj = sxx = 0.0;
          m[i,j] = 0.0;
          for ( k = 0; k < K; ++k )
          {
            sxj += x[j,k];
            sxx += x[i,k] * x[j,k];
          }
          m[i,j] += ( K * sxx ) - ( sxi * sxj );
        }
      }
      //
      for ( i = 0; i < N; ++i ) // mátrix invertálás
      {
        q = m[i,i];
        if ( 0.0 != q )
        {
          for ( k = 0; k < K; ++k )
          {
            m[i,k] /= q;
          }
          a[i] /= q;
        }
        else
        {
          Console.WriteLine( "Hiba: {0}", i );
        }
        //
        for ( j = 0; j < N; ++j )
        {
          if ( i != j )
          {
            p = m[j,i];
            for ( k = 0; k < K; ++k )
            {
              m[j,k] -= p * m[i,k];
            }
            a[j] -= p * a[i];
          }
        }
      }
      //
      for ( i = 0; i < N; ++i ) // eredmények kiírása
      {

        /*
        Console.WriteLine( "{0}: {1:F3} {2:F3} {3:F3}", i, c[i], a[i], ( c[i] - a[i] ) );

        */
        Console.Write( "{0:D2}: ", i+1 );
        Console.Write( "{0} ", c[i].ToString( "+0.000;-0.000;+0.000" ) );
        Console.Write( "{0} ", a[i].ToString( "+0.000;-0.000;+0.000" ) );
        Console.Write( "{0} ", ( c[i] - a[i] ).ToString( "+0.000;-0.000;+0.000" ) );
        Console.WriteLine();
      }
      //
      Console.Write( "Press any key to continue . . . " );
      Console.ReadKey( true );
    }

}

 

Törölt nick Creative Commons License 2020.01.12 0 0 8

Kicsit szebb megjelenésben a harmadfokú képlet:

 

A - munkaregiszter (tömb).

P&Q - átmeneti segédváltozók.

A végeredmény az utolsó sor.

Előzmény: Törölt nick (7)
Törölt nick Creative Commons License 2020.01.11 0 0 7

Futási eredmény 4 gyökhely esetén.

 

A: 0 0 0 0 +1

P: 0 0 0 +1 0
Q: 0 0 0 0 -x1
A: 0 0 0 +1 -x1

P: 0 0 +1 -x1 0
Q: 0 0 0 -x2 +x1*x2
A: 0 0 +1 -x1-x2 +x1*x2

P: 0 +1 -x1-x2 +x1*x2 0
Q: 0 0 -x3 +x1*x3+x2*x3 -x1*x2*x3
A: 0 +1 -x1-x2-x3 +x1*x2+x1*x3+x2*x3 -x1*x2*x3

P: +1 -x1-x2-x3 +x1*x2+x1*x3+x2*x3 -x1*x2*x3 0
Q: 0 -x4 +x1*x4+x2*x4+x3*x4 -x1*x2*x4-x1*x3*x4-x2*x3*x4 +x1*x2*x3*x4
A: +1 -x1-x2-x3-x4 +x1*x2+x1*x3+x2*x3+x1*x4+x2*x4+x3*x4
    -x1*x2*x3-x1*x2*x4-x1*x3*x4-x2*x3*x4 +x1*x2*x3*x4

Előzmény: Törölt nick (6)
Törölt nick Creative Commons License 2020.01.11 0 0 6

Polinom együtthatóinak kiszámítása megadott gyökhelyek alapján - képlet szerint.

Előjelváltások egy új modell szerint. (Ez a matematika számítógépes modellezése.)

 

C#

using System;
using System.Collections.Generic;
namespace frmpoli
{
  class Program
  {
    static List<item>[] a;    // work array
    static List<item>[] p, q; // tmp
    static int r;               // number of roots
    public static void Main( string[] args )
    {
      int i;
      r = 4;
      initA();
      for ( i = 0; i < r; ++i )
      {
        timesX();
        timesR( i+1 );
        Add();
      }
    }
    private static void show( int row )
    {
      int i;
      List<item>[] l = null;
      switch ( row )
      {
        case 0: // a
          Console.Write( "A: " );
          l = a;
          break;
        case 1: // p
          Console.Write( "P: " );
          l = p;
          break;
        case 2: // q
          Console.Write( "Q: " );
          l = q;
          break;
      }
      for ( i = r; 0 <= i; --i )
      {
        if ( null == l[i] )
          Console.Write( "0 " );
        else
          if ( 0 < l[i].Count )
          {
            foreach ( item s in l[i] )
            {
              if ( s.g < 0 )
                Console.Write( "-" );
              else
                Console.Write( "+" );
              Console.Write( "{0}", s.i );
            }
            Console.Write( " " );
          }
          else
          Console.Write( "0 " );
      }
      Console.WriteLine();
    }
    private static void initA()
    {
      int i;
      a = new List<item>[r+1];
      for ( i = 0; i <= r; ++i )
        a[i] = new List<item>();
      a[0].Add( new item( "1", +1 ) );
      show( 0 );
      Console.WriteLine();
    }
    private static void timesX()
    {
      int i;
      p = new List<item>[r+1];
      for ( i = 0; i < r; ++i )
        p[i+1] = a[i];
      p[0] = new List<item>();
      show( 1 );
    }
    private static void timesR( int root )
    {
      int i;
      string z = "x" + root.ToString();
      q = new List<item>[r+1];
      for ( i = 0; i <= r; ++i )
        q[i] = new List<item>();
      for ( i = 0; i <= r; ++i )
      {
        if ( null != a[i] )
        {
          foreach ( item s in a[i] )
          {
            if ( s.i.Equals( "1" ) && ( 1 == s.g )  )
              q[i].Add( new item( "x" + root, -1 ) );
            else
            {
              if ( s.g < 0 )
              {
                q[i].Add( new item( s.i + "*x" + root, +1 ) );
              }
              else
              {
                q[i].Add( new item( s.i + "*x" + root, -1 ) );
              }
            }
          }
        }
      }
      show( 2 );
    }
    private static void Add()
    {
      int i;
      a = new List<item>[r+1];
      for ( i = 0; i <= r; ++i )
        a[i] = new List<item>();
      for ( i = 0; i <= r; ++i )
      {
        if ( null != p[i] )
        {
          if ( 0 < p[i].Count )
          {
            foreach ( item s in p[i] )
              a[i].Add( s );
          }
        }
        if ( null != q[i] )
        {
          if ( 0 < q[i].Count )
          {
            foreach ( item s in q[i] )
              if ( s.g < 0 )
                a[i].Add( new item( s.i, -1 ) );
              else
                a[i].Add( s );
          }
        }
      }
      show( 0 );
      Console.WriteLine();
    }
  }
  class item
  {
    public string i; // item text
    public int    g; // sign
    public item()
    {
      i = "";
      g = +1;
    }
    public item( string str, int sgn )
    {
      i = str;
      g = sgn;
    }
  }
}

Előzmény: Törölt nick (5)
Törölt nick Creative Commons License 2020.01.08 0 0 5

Majd módosítom a lista elem típusát, és lesz benne egy előjel flag, azt fogom alternálni negatívval szorzásnál.

 

A zárójel tonnákat azzal küszöböltem ki, hogy minden tagot külön tárolok egy lista elemeiben.

Előzmény: lxt (4)
lxt Creative Commons License 2020.01.08 0 0 4

Az előjelváltás egy tipikus probléma – még az egészek esetében is.

Törölt nick Creative Commons License 2020.01.08 0 0 3

Polinom együtthatóinak kiszámítása megadott gyökhelyek alapján - képlet szerint.

Az előjelváltások még nem tökéletesek. :(

 

Együtthatók: a1, a2, a3 ...

Gyökök: x1, x2, x3 ...

xn + a1 xn-1 + a2 xn-2 + ... + an-1 x + an = (x-x1)*(x-x2)*(x-x3)*...*(x-xn)

 

C#

using System;
using System.Collections.Generic;
namespace frmpoli
{
  class Program
  {
    static List<string>[] a;    // work array
    static List<string>[] p, q; // tmp
    static int r;               // number of roots
    public static void Main( string[] args )
    {
      int i;
      r = 4;
      initA();
      for ( i = 0; i < r; ++i )
      {
        timesX();
        timesR( i+1 );
        Add();
      }
    }
    private static void initA()
    {
      int i;
      bool f = true;
      a = new List<string>[r+1];
      for ( i = 0; i <= r; ++i )
        a[i] = new List<string>();
      a[0].Add( "1" );
      Console.Write( "A: " );
      for ( i = r; 0 <= i; --i )
      {
        if ( null == a[i] )
          Console.Write( "0 " );
        else
          if ( 0 < a[i].Count )
          {
            foreach ( string s in a[i] )
            {
              if ( f )
                f = false;
              else
                Console.Write( "+" );
              Console.Write( "{0}", s );
            }
            Console.Write( " " );
          }
          else
          Console.Write( "0 " );
      }
      Console.WriteLine();
      Console.WriteLine();
    }
    private static void timesX()
    {
      int i;
      bool f = true;
      p = new List<string>[r+1];
      for ( i = 0; i < r; ++i )
        p[i+1] = a[i];
      p[0] = new List<string>();
      Console.Write( "P: " );
      for ( i = r; 0 <= i; --i )
      {
        f = true;
        if ( null == p[i] )
          Console.Write( "0 " );
        else
          if ( 0 < p[i].Count )
          {
            foreach ( string s in p[i] )
            {
              if ( f )
                f = false;
              else
                Console.Write( "+" );
              Console.Write( "{0}", s );
            }
            Console.Write( " " );
          }
          else
          Console.Write( "0 " );
      }
      Console.WriteLine();
    }
    private static void timesR( int root )
    {
      int i;
      bool f = true;
      string z = "x" + root.ToString();
      q = new List<string>[r+1];
      for ( i = 0; i <= r; ++i )
        q[i] = new List<string>();
      for ( i = 0; i <= r; ++i )
      {
        if ( null != a[i] )
        {
          foreach ( string s in a[i] )
          {
            q[i].Add( "-" + s + "*x" + root );
          }
        }
      }
      Console.Write( "Q: " );
      for ( i = r; 0 <= i; --i )
      {
        f = true;
        if ( null == q[i] )
          Console.Write( "0 " );
        else
          if ( 0 < q[i].Count )
          {
            foreach ( string s in q[i] )
            {
              if ( f )
                f = false;
              else
                Console.Write( "+");
              Console.Write( "{0}", s );
            }
            Console.Write( " " );
          }
          else
          Console.Write( "0 " );
      }
      Console.WriteLine();
    }
    private static void Add()
    {
      int i;
      bool f = true;
      a = new List<string>[r+1];
      for ( i = 0; i <= r; ++i )
        a[i] = new List<string>();
      for ( i = 0; i <= r; ++i )
      {
        if ( null != p[i] )
        {
          if ( 0 < p[i].Count )
          {
            foreach ( string s in p[i] )
              a[i].Add( s );
          }
        }
        if ( null != q[i] )
        {
          if ( 0 < q[i].Count )
          {
            foreach ( string s in q[i] )
              a[i].Add( s );
          }
        }
      }
      Console.Write( "A: " );
      for ( i = r; 0 <=i; --i )
      {
        f = true;
        if ( null == a[i] )
          Console.Write( "0 " );
        else
          if ( 0 < a[i].Count )
          {
            foreach ( string s in a[i] )
            {
              if ( f )
                f = false;
              else
                Console.Write( "+" );
              Console.Write( "{0}", s );
            }
            Console.Write( " " );
          }
          else
          Console.Write( "0 " );
      }
      Console.WriteLine();
      Console.WriteLine();
    }
  }
}

Futási eredmény 4 gyökhely esetén.

A: 0 0 0 0 1

P: 0 0 0 1 0
Q: 0 0 0 0 -1*x1
A: 0 0 0 1 -1*x1

P: 0 0 1 -1*x1 0
Q: 0 0 0 -1*x2 --1*x1*x2
A: 0 0 1 -1*x1+-1*x2 --1*x1*x2

P: 0 1 -1*x1+-1*x2 --1*x1*x2 0
Q: 0 0 -1*x3 --1*x1*x3+--1*x2*x3 ---1*x1*x2*x3
A: 0 1 -1*x1+-1*x2+-1*x3 --1*x1*x2+--1*x1*x3+--1*x2*x3 ---1*x1*x2*x3

P: 1 -1*x1+-1*x2+-1*x3 --1*x1*x2+--1*x1*x3+--1*x2*x3 ---1*x1*x2*x3 0
Q: 0 -1*x4 --1*x1*x4+--1*x2*x4+--1*x3*x4 ---1*x1*x2*x4+---1*x1*x3*x4+---1*x2*x3*x4 ----1*x1*x2*x3*x4
A: 1 -1*x1+-1*x2+-1*x3+-1*x4 --1*x1*x2+--1*x1*x3+--1*x2*x3+--1*x1*x4+--1*x2*x4+--1*x3*x4

---1*x1*x2*x3+---1*x1*x2*x4+---1*x1*x3*x4+---1*x2*x3*x4 ----1*x1*x2*x3*x4

 

Előzmény: Törölt nick (1)
hiper fizikus Creative Commons License 2020.01.08 0 0 2

Az algoritmusokról ajánlhatnál nekünk releváns linkeket .

Előzmény: Törölt nick (1)
Törölt nick Creative Commons License 2020.01.08 0 0 1

Polinom együtthatóinak kiszámítása megadott gyökhelyek alapján.

Együtthatók: a1, a2, a3 ...

Gyökök: x1, x2, x3 ...

xn + a1 xn-1 + a2 xn-2 + ... + an-1 x + an = (x-x1)*(x-x2)*(x-x3)*...*(x-xn)

 

C#

using System;
namespace numpoli
{
  class Program
  {
    static double[] a;    // work array
    static double[] p, q; // tmp
    static double[] r;    // initial roots
    public static void Main( string[] args )
    {
      r = new double[] { 3, 5, 7, 9 };
      initA();
      foreach ( double root in r )
      {
        timesX();
        timesR( root );
        Add();
      }
    }
    private static void initA()
    {
      int i;
      int n = r.Length;
      a = new double[r.Length+1];
      a[0] = 1;
      Console.Write( "A: " );
      for ( i = n; 0 <=i; --i )
        Console.Write( "{0} ", a[i] );
      Console.WriteLine();
      Console.WriteLine();
    }
    private static void timesX()
    {
      int i;
      int n = r.Length;
      p = new double[n+1];
      for ( i = 0; i < n; ++i )
        p[i+1] = a[i];
      Console.Write( "P: " );
      for ( i = n; 0 <=i; --i )
        Console.Write( "{0} ", p[i] );
      Console.WriteLine();
    }
    private static void timesR( double root )
    {
      int i;
      int n = r.Length;
      q = new double[n+1];
      for ( i = 0; i <= n; ++i )
        q[i] = -root * a[i];
      Console.Write( "Q: " );
      for ( i = n; 0 <=i; --i )
        Console.Write( "{0} ", q[i] );
      Console.WriteLine();
    }
    private static void Add()
    {
      a = new double[r.Length+1];
      int i;
      int n = r.Length;
      for ( i = 0; i <= n; ++i )
        a[i] = p[i] + q[i];
      Console.Write( "A: " );
      for ( i = n; 0 <=i; --i )
        Console.Write( "{0} ", a[i] );
      Console.WriteLine();
      Console.WriteLine();
    }
  }
}

 

Valamikor évtizedekkel ezelőtt ezt megcsináltam már képlettel is...

Előzmény: Törölt nick (-)
dühös biciklis Creative Commons License 2020.01.08 0 1 0

Nullázás algoritmusát ismered?

Előzmény: Törölt nick (-)
Törölt nick Creative Commons License 2020.01.08 0 0 topiknyitó

Mindenféle algoritmusok gyülekezőhelye itt.

Ha kedveled azért, ha nem azért nyomj egy lájkot a Fórumért!