[WikiDyd] [TitleIndex] [WordIndex

Języki i metodyka programowania 2

Wykłady z wiosny 2011: W1 (21 lutego) - W4 ( marca)

W1: 20 lutego 2011

Wykład był poświęcony dokładnemu omówieniu projektu. Rozmawialiśmy o przeznaczeniu programu triangle, o algorytmach niezbędnych do realizacji projektu i o zasadach wykonywania i oceniania projektów.

W2: 27 lutego 2011

Wstęp do Javy. Pisaliśmy pierwsze klasy:

   1 public class Hello {
   2   public static int main( String args ) {
   3     System.out.println( "Cześć!" );
   4     return 0;
   5   }
   6   public static void main( String [] args ) {
   7     System.out.println( "To jest dobry main!" );
   8     return;
   9   }
  10 }

   1 public class Echo {
   2         public static void main( String [] args ) {
   3                 for( int i= 0; i < args.length; i++ ) {
   4                         System.out.println( i + 1 + ": " + args[i] );
   5                 }
   6         }
   7 }

   1 public class Pkt {
   2 /** Punkt 2D **/
   3         private double x;
   4         private double y;
   5 
   6         private static long ileJestPkt= 0;
   7 
   8         public Pkt( double x, double y ) {
   9                 this.x = x;
  10                 this.y = y;
  11                 ileJestPkt++;
  12         }
  13 
  14         public Pkt( double c ) {
  15                 x= y= c;
  16                 ileJestPkt++;
  17         }
  18 
  19         public Pkt() {
  20                 ileJestPkt++;
  21         }
  22 
  23         public void move( double dx, double dy ) {
  24                 x += dx;
  25                 y += dy;
  26         }
  27 
  28         public void setX( double newX ) {
  29                 x = newX;
  30         }
  31 
  32         public void setY( double newY ) {
  33                 y = newY;
  34         }
  35 
  36         public double getX() {
  37                 return x;
  38         }
  39 
  40         public double getY() {
  41                 return y;
  42         }
  43 
  44         public String toString() {
  45                 return "("+x+","+y+")";
  46   }
  47 
  48   public static long ilePkt() {
  49                 return ileJestPkt;
  50         }
  51 }

   1 public class TestPkt {
   2 /** Klasa do testowania klasy Pkt (Punkt 2D)
   3 */
   4 
   5         public static void main( String [] args ) {
   6                 Pkt [] t = new Pkt[100];
   7                 for( int i= 0; i < Integer.parseInt( args[0] ); i++ )
   8                         t[i] = new Pkt( );
   9 
  10                 for( int i= 0; i < Pkt.ilePkt(); i+= 2 )
  11                         t[i].move( 1, 0 );
  12 
  13                 for( int i= 1; i < Pkt.ilePkt(); i+= 2 )
  14                         t[i].move( 0, 1);
  15 
  16                 for( int i= 0; i < Pkt.ilePkt(); i++ )
  17                         System.out.println( t[i] );
  18         }
  19 }

W3: 5 marca 2011

Rozmawialiśmy o zasadach podziału projektu na klasy - jako przykład, który będziemy dalej rozwijać napisaliśmy pierwszą wersję klasy opisującej dwuwymiarową siatkę złożoną z trójkątów:

   1 public class Mesh {
   2         private double [][] xy;
   3         private int [][] ele;
   4         private int [] v_attr;
   5   private double [] e_attr;
   6         private int n_vertices;
   7         private int n_elems;
   8 
   9         public Mesh() {
  10                 n_vertices = 0;
  11                 n_elems = 0;
  12         }
  13 
  14         public Mesh( int nv, int ne ) {
  15                 n_vertices = 0;
  16                 n_elems = 0;
  17                 xy = new double[nv][2];
  18                 v_attr = new int[nv];
  19                 ele = new int [ne][3];
  20                 e_attr = new double [ne];
  21         }
  22 
  23         void add_vertex( double x, double y, int attr ) {
  24                 if( xy == null || n_vertices == xy.length ) {
  25                         int new_xy_size = n_vertices > 0 ? 2*n_vertices : 32;
  26                         double [][] n_xy = new double[new_xy_size][2];
  27                         int [] n_v_attr = new int[new_xy_size];
  28                         for( int i= 0; i < n_vertices; i++ ) {
  29                                 n_xy[i][0]= xy[i][0];
  30                                 n_xy[i][1]= xy[i][1];
  31                                 n_v_attr[i]= v_attr[i];
  32                         }
  33                         xy = n_xy;
  34                         v_attr = n_v_attr;
  35                 }
  36                 xy[n_vertices][0] = x;
  37                 xy[n_vertices][1] = y;
  38                 v_attr[n_vertices] = attr;
  39                 n_vertices++;
  40         }
  41 
  42         void add_elem( int n1, int n2, int n3, double e_attribute ) {
  43                 if( ele == null || n_elems == ele.length ) {
  44                         int new_e_size = n_elems > 0 ? n_elems*2 : 64;
  45                         int n_ele[][] = new int[new_e_size][3];
  46                         double n_e_attr[] = new double[new_e_size];
  47                         for( int i= 0; i < n_elems; i++ ) {
  48                                 n_ele[i][0] = ele[i][0];
  49                                 n_ele[i][1] = ele[i][1];
  50                                 n_ele[i][2] = ele[i][2];
  51                                 n_e_attr[i]= e_attr[i];
  52                         }
  53                         e_attr= n_e_attr;
  54                         ele= n_ele;
  55                 }
  56                 ele[n_elems][0]= n1;
  57                 ele[n_elems][1]= n2;
  58                 ele[n_elems][2]= n3;
  59                 e_attr[n_elems]= e_attribute;
  60                 n_elems++;
  61         }
  62 
  63         void move( double dx, double dy ) {
  64                 for( int i= 0; i < n_vertices; i++ ) {
  65                         xy[i][0] += dx;
  66                         xy[i][1] += dy;
  67                 }
  68         }
  69 
  70         public int getNVertices() {
  71                 return n_vertices;
  72         }
  73 
  74         public int getNElements() {
  75                 return n_elems;
  76         }
  77 
  78         public double getX( int i ) {
  79                 return xy[i][0];
  80         }
  81 
  82         public double getY( int i ) {
  83                 return xy[i][1];
  84         }
  85 
  86         public int getVAttr( int i ) {
  87                 return v_attr[i];
  88         }
  89 
  90         public int getENode( int e, int v ) {
  91                 return ele[e][v];
  92         }
  93 
  94         public double getEAttr( int e ) {
  95                 return e_attr[e];
  96         }
  97 
  98         public String toString() {
  99                 return "Mesh( "+n_vertices+" vetrices, "+n_elems+" elements)";
 100         }
 101 
 102         public static void main( String [] argv ) {
 103                 Mesh m = new Mesh();
 104 
 105                 for( int i= 0; i < Integer.parseInt(argv[0]); i++ )     
 106                         m.add_vertex( 0.0, 0.0, 1 );
 107 
 108                 for( int i= 0; i < Integer.parseInt(argv[1]); i++ )     
 109                         m.add_elem( 1, 2, 3, 0.555 );
 110 
 111                 try {
 112                         MeshIO.meshWriter( m, "test" );
 113                 }
 114                 catch( java.io.IOException e ) {
 115                         System.err.println( "Wystąpił błąd: " + e.getMessage() );
 116                 }
 117 
 118                 System.out.println( m );
 119         }
 120 }

i klasę-pojemnik metod do czytania/pisania siatek

   1 import java.io.*;
   2 
   3 public class MeshIO {
   4         public static void meshWriter( Mesh m, String fileName )
   5                 throws IOException
   6         {
   7                 File of = new File( fileName + ".node" );
   8 
   9                 FileWriter fw= new FileWriter( of );
  10 
  11                 fw.write( m.getNVertices() + " 2 0 1\n" );
  12                 for( int i= 0; i < m.getNVertices(); i++ ) 
  13                         fw.write( (i+1) + " " + m.getX(i) + " " + m.getY(i) + " " + m.getVAttr(i) + "\n" );
  14 
  15                 fw.close();
  16 
  17                 System.err.println( "Siatka zapisana!" );
  18 
  19         }
  20 }

2015-09-23 06:44