SHARE
TWEET

Untitled

a guest Dec 15th, 2019 93 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.awt.BorderLayout;
  2. import java.awt.Color;
  3.  
  4. import javax.swing.JFrame;
  5. import javax.swing.JPanel;
  6.  
  7. public class myFrame extends JFrame{
  8.     public  static int y[];
  9.     public  static int x[];
  10.     public  static int y1[];
  11.     public static int n = 5;
  12.    
  13.     public myFrame () {  
  14.            super("График");
  15.            JPanel jcp = new JPanel(new BorderLayout());
  16.            setContentPane(jcp);
  17.            jcp.add(new drawingComponent (), BorderLayout.CENTER);    
  18.            jcp.setBackground(Color.gray);
  19.            setSize(500, 400);
  20.            setLocationRelativeTo(null);
  21.            setDefaultCloseOperation(EXIT_ON_CLOSE);
  22.     }      
  23. }
  24.  
  25.  
  26. //////////////////////////////////////////////////////////////////////
  27.  
  28.  
  29.  
  30. import java.awt.Color;
  31. import java.awt.Graphics;
  32. import java.awt.Graphics2D;
  33.  
  34. import javax.swing.JPanel;
  35.  
  36. public class drawingComponent extends JPanel{
  37.     int xg[] =  myFrame.x;
  38.     int yg[] =  myFrame.y;
  39.     int yg1[] =  myFrame.y1;
  40.     int ng = myFrame.n;
  41.        
  42.     @Override
  43.     protected void paintComponent(Graphics gh) {  
  44.         Graphics2D drp = (Graphics2D)gh;
  45.         drp.drawLine(20, 340, 20, 20);
  46.         drp.drawLine(20, 340, 460, 340);
  47.         drp.setColor(Color.RED);
  48.         drp.drawPolyline(xg, yg, ng);
  49.         drp.setColor(Color.BLACK);
  50.         drp.drawPolyline(xg, yg1, ng);
  51.     }
  52. }
  53.  
  54.  
  55. ////////////////////////////////////////////////////////////////////
  56.  
  57.  
  58.  
  59. public abstract class scheme {
  60.     protected int N, M, n;
  61.     protected double h, tau, a;
  62.     protected double[][] temp;
  63.     protected double[] U1;
  64.    
  65.     protected scheme(double h, double tau) {
  66.         this.h = h;
  67.         this.tau = tau;
  68.         this.N = (int)(1/h);
  69.         this.M = (int)(1/tau);
  70.         temp = new double[N+1][M+1];
  71.     }
  72.     protected abstract void run();
  73.     protected void paint() {
  74.         if(n == 0) { n = 11;}
  75.         double[] U = new double[n];
  76.         double[] T = new double[n];
  77.         for(int i = 0; i < n; i++) {
  78.             U[i] = temp[(int)(N/2)][i*M/(n-1)];
  79.             T[i] = (M/(n-1))*tau*i;
  80.             System.out.print(U[i]);
  81.             System.out.print(' ');
  82.             System.out.println(U1[i]);
  83.         }
  84.         int[] X = new int[n];
  85.         for(int i = 0; i < n; i++) {
  86.             X[i] = (int) (440*T[i]) + 20;
  87.         }
  88.         double Umax = U[0];
  89.         double Umin = U[0];
  90.         for(int i = 0; i < n; i++) {
  91.             if(Umax < U[i]) {Umax = U[i];}
  92.             if(Umax < U1[i]) {Umax = U1[i];}
  93.             if(Umin > U[i]) {Umin = U[i];}
  94.             if(Umin > U1[i]) {Umin = U1[i];}
  95.         }
  96.         myFrame.n = n;
  97.         myFrame.y = doubleToInt(U, n, Umin, Umax);
  98.         myFrame.y1 = doubleToInt(U1, n, Umin, Umax);
  99.         myFrame.x = X;
  100.         new myFrame().setVisible(true);
  101.     }
  102.     private int[] doubleToInt(double[] U, int n, double min, double max) {
  103.         int[] Y = new int[n];
  104.         for(int i = 0; i < n; i++) {
  105.             Y[i] = 340 - (int) (320*(U[i] - min)/(max - min));
  106.         }
  107.         return Y;
  108.     }
  109.     protected void error() {
  110.         double error = 0;
  111.         for(int i = 0; i < N+1; i++) {
  112.             for(int j = 0; j < M+1; j++) {
  113.                 double er = Math.abs(temp[i][j] - solution(j*tau, i*h));
  114.                 if(er > error) {
  115.                     error = er;
  116.                 }
  117.             }
  118.         }
  119.         System.out.println(error);
  120.     }
  121.     protected abstract double f(double t, double x);
  122.     protected abstract double solution(double t, double x);
  123. }
  124.  
  125.  
  126.  
  127. ///////////////////////////////////////////////////////////////////////////////
  128.  
  129.  
  130. public class exTerm extends scheme{
  131.  
  132.     public exTerm(double h, double tau) {
  133.         super(h, tau);
  134.         a = 0.037;
  135.         n = 11;
  136.         run();
  137.         paint();
  138.         error();
  139.     }
  140.     @Override
  141.     protected void run() {
  142.         for(int i = 0; i < N+1; i++) {
  143.             temp[i][0] = solution(0, i*h);
  144.         }
  145.         for(int j = 1; j < M+1; j++) {
  146.             temp[0][j] = solution(j*tau, 0);
  147.             temp[N][j] = solution(j*tau, 1);
  148.             for(int i = 1; i < N; i++) {
  149.                 temp[i][j] = temp[i][j-1] + a*(temp[i+1][j-1] - 2*temp[i][j-1] + temp[i-1][j-1])*tau/(h*h) + tau*f((j-1)*tau, i*h);
  150.             }
  151.         }
  152.         U1 = new double[n];
  153.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  154.     }
  155.    
  156.     @Override
  157.     protected double f(double t, double x) {
  158.         double result = (-9)*Math.pow(t, 2) + 6*t*x - a*(24*Math.pow(x, 2) - 2*Math.exp(x));
  159.         return result;
  160.     }
  161.     @Override
  162.     protected double solution(double t, double x) {
  163.         double result = 2*Math.pow(x, 4) + (-3)*Math.pow(t, 3) + 3*Math.pow(t, 2)*x - 2*Math.exp(x);
  164.         return result;
  165.     }
  166. }
  167.  
  168.  
  169. //////////////////////////////////////////////////////////////////////////////
  170.  
  171.  
  172.  
  173. public class imTerm extends scheme{
  174.     private double A, B, C;
  175.    
  176.     protected imTerm(double h, double tau) {
  177.         super(h, tau);
  178.         a = 0.034;
  179.         n = 11;
  180.         A = a*tau/(h*h);
  181.         B = (-1)*(1 + 2*a*tau/(h*h));
  182.         C = A;
  183.         run();
  184.         paint();
  185.         error();
  186.     }
  187.     @Override
  188.     protected void run() {
  189.         for(int i = 0; i < N+1; i++) {
  190.             temp[i][0] = solution(0, i*h);
  191.         }
  192.         for(int j = 1; j < M+1; j++) {
  193.             double[] F = new double[N+1];
  194.             for(int i = 0; i < N+1; i++) {
  195.                 F[i] = (-1)*(temp[i][j-1] + tau*f(j*tau, i*h));
  196.             }
  197.             F[0] -= solution(tau*j, 0)*A;
  198.             F[N] -= solution(tau*j, 1)*A;
  199.             calc(F, j);
  200.             temp[0][j] = solution(j*tau, 0);
  201.             temp[N][j] = solution(j*tau, 1);
  202.         }
  203.         U1 = new double[n];
  204.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  205.     }
  206.     private void calc(double[] F, int j) {
  207.         int n = N+1;
  208.         double[] p = new double[n-1], q = new double[n-1], X = new double[n];
  209.         p[0] = C/B;
  210.         q[0] = F[0]/B;
  211.         for(int i = 1; i < n-1; i++) {
  212.             p[i] = C/(B - p[i-1]*A);
  213.             q[i] = (F[i] - q[i-1]*A)/(B - p[i-1]*A);
  214.         }
  215.         X[n-1] = (F[n-1] - q[n-2]*A)/(B - p[n-2]*A);
  216.         for(int i = n-2; i >= 0; i--) {
  217.             X[i] = q[i] - p[i]*X[i+1];
  218.         }
  219.         for(int i = 0; i < N+1; i++) {
  220.             temp[i][j] = X[i];
  221.         }
  222.     }
  223.     @Override
  224.     protected double f(double t, double x) {
  225.         double result = (-9)*Math.pow(t, 2) + 6*t*x - a*(24*Math.pow(x, 2) - 2*Math.exp(x));
  226.         return result;
  227.     }
  228.     @Override
  229.     protected double solution(double t, double x) {
  230.         double result = 2*Math.pow(x, 4) + (-3)*Math.pow(t, 3) + 3*Math.pow(t, 2)*x - 2*Math.exp(x);
  231.         return result;
  232.     }
  233.  
  234. }
  235.  
  236.  
  237. ///////////////////////////////////////////////////////////////////////////////////
  238.  
  239.  
  240. public class KNTerm extends scheme{
  241.     double A, B, C;
  242.    
  243.     protected KNTerm(double h, double tau) {
  244.         super(h, tau);
  245.         a = 0.02;
  246.         n = 11;
  247.         A = a*tau/(2*h*h);
  248.         B = (-1)*(1 + a*tau/(h*h));
  249.         C = A;
  250.         run();
  251.         paint();
  252.         error();
  253.     }
  254.     @Override
  255.     protected void run() {
  256.         for(int i = 0; i < N+1; i++) {
  257.             temp[i][0] = solution(0, i*h);
  258.         }
  259.         for(int j = 1; j < M+1; j++) {
  260.             double[] F = new double[N+1];
  261.             for(int i = 1; i < N; i++) {
  262.                 F[i-1] = (-1)*(temp[i-1][j-1]*(a*tau/(2*h*h)) + temp[i][j-1]*(1 - a*tau/(h*h)) + temp[i+1][j-1]*(a*tau/(2*h*h)) + tau*f(j*tau, i*h));
  263.             }
  264.             F[0] -= solution(tau*j, 0)*a*tau/(2*h*h);             ////1.4268
  265.             F[N-2] -= solution(tau*j, 1)*a*tau/(2*h*h);
  266.             calc(F, j);
  267.             temp[0][j] = solution(j*tau, 0);
  268.             temp[N][j] = solution(j*tau, 1);
  269.         }
  270.         U1 = new double[n];
  271.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  272.     }
  273.     private void calc(double[] F, int j) {
  274.         int n = N-1;
  275.         double[] p = new double[n-1], q = new double[n-1], X = new double[n];
  276.         p[0] = C/B;
  277.         q[0] = F[0]/B;
  278.         for(int i = 1; i < n-1; i++) {
  279.             p[i] = C/(B - p[i-1]*A);
  280.             q[i] = (F[i] - q[i-1]*A)/(B - p[i-1]*A);
  281.         }
  282.         X[n-1] = (F[n-1] - q[n-2]*A)/(B - p[n-2]*A);
  283.         for(int i = n-2; i >= 0; i--) {
  284.             X[i] = q[i] - p[i]*X[i+1];
  285.         }
  286.         for(int i = 1; i < N; i++) {
  287.             temp[i][j] = X[i-1];
  288.         }
  289.     }
  290.     @Override
  291.     protected double f(double t, double x) {
  292.         double result = (-9)*Math.pow(t, 2) + 6*t*x - a*(24*Math.pow(x, 2) - 2*Math.exp(x));
  293.         return result;
  294.     }
  295.     @Override
  296.     protected double solution(double t, double x) {
  297.         double result = 2*Math.pow(x, 4) + (-3)*Math.pow(t, 3) + 3*Math.pow(t, 2)*x - 2*Math.exp(x);
  298.         return result;
  299.     }
  300.  
  301. }
  302.  
  303.  
  304. ////////////////////////////////////////////////////////////////////
  305.  
  306.  
  307. public class exDiff extends scheme{
  308.    
  309.     public exDiff(double h, double tau) {
  310.         super(h, tau);
  311.         a = 0.034;
  312.         n = 11;
  313.         run();
  314.         paint();
  315.         error();
  316.     }
  317.     @Override
  318.     protected void run() {
  319.         for(int i = 0; i < N+1; i++) {
  320.             temp[i][0] = solution(0, i*h);
  321.         }
  322.         for(int j = 1; j < M+1; j++) {
  323.             temp[0][j] = solution(j*tau, 0);
  324.             temp[N][j] = solution(j*tau, 1);
  325.             for(int i = 1; i < N; i++) {
  326.                 temp[i][j] = temp[i][j-1] - a*(temp[i][j-1] - temp[i-1][j-1])*tau/h + tau*f((j-1)*tau, i*h);   
  327.             }
  328.         }
  329.         U1 = new double[n];
  330.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  331.     }
  332.     @Override
  333.     protected double f(double t, double x) {
  334.         double result = a*(2*Math.PI - Math.PI*Math.sin(Math.PI*x)) - Math.PI*Math.cos(2*Math.PI*t) - 3.5;
  335.         return result;
  336.     }
  337.     @Override
  338.     protected double solution(double t, double x) {
  339.         double result = Math.cos(Math.PI*x) - 0.5*Math.sin(2*Math.PI*t) + 2*Math.PI*x - 3.5*t;
  340.         return result;
  341.     }
  342. }
  343.  
  344.  
  345. /////////////////////////////////////////////////////////////
  346.  
  347.  
  348. public class imDiff extends scheme{
  349.     private double A, B, C;
  350.    
  351.     protected imDiff(double h, double tau) {
  352.         super(h, tau);
  353.         a = 0.001;
  354.         n = 11;
  355.         A = -a*tau/h;
  356.         B = (1 + a*tau/h);
  357.         C = 0;
  358.         run();
  359.         paint();
  360.         error();
  361.     }
  362.     @Override
  363.     protected void run() {
  364.         for(int i = 0; i < N+1; i++) {
  365.             temp[i][0] = solution(0, i*h);
  366.         }
  367.         for(int j = 1; j < M+1; j++) {
  368.             double[] F = new double[N+1];
  369.             for(int i = 0; i < N+1; i++) {
  370.                 F[i] = (temp[i][j-1] + tau*f(j*tau, i*h));
  371.             }
  372.             F[0] -= solution(tau*j, 0)*A;
  373.             F[N] -= solution(tau*j, 1)*A;
  374.             calc(F, j);
  375.             temp[0][j] = solution(j*tau, 0);
  376.             temp[N][j] = solution(j*tau, 1);
  377.         }
  378.         U1 = new double[n];
  379.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  380.     }
  381.     private void calc(double[] F, int j) {
  382.         int n = N+1;
  383.         double[] p = new double[n-1], q = new double[n-1], X = new double[n];
  384.         p[0] = C/B;
  385.         q[0] = F[0]/B;
  386.         for(int i = 1; i < n-1; i++) {
  387.             p[i] = C/(B - p[i-1]*A);
  388.             q[i] = (F[i] - q[i-1]*A)/(B - p[i-1]*A);
  389.         }
  390.         X[n-1] = (F[n-1] - q[n-2]*A)/(B - p[n-2]*A);
  391.         for(int i = n-2; i >= 0; i--) {
  392.             X[i] = q[i] - p[i]*X[i+1];
  393.         }
  394.         for(int i = 1; i < N+1; i++) {
  395.             temp[i][j] = X[i];
  396.         }
  397.     }
  398.     @Override
  399.     protected double f(double t, double x) {
  400.         double result = a*(2*Math.PI - Math.PI*Math.sin(Math.PI*x)) - Math.PI*Math.cos(2*Math.PI*t) - 3.5;
  401.         return result;
  402.     }
  403.  
  404.     @Override
  405.     protected double solution(double t, double x) {
  406.         double result = Math.cos(Math.PI*x) - 0.5*Math.sin(2*Math.PI*t) + 2*Math.PI*x - 3.5*t;
  407.         return result;
  408.     }
  409.  
  410. }
  411.  
  412.  
  413. //////////////////////////////////////////////////////////////////////////
  414.  
  415.  
  416. public class lacksDiff extends scheme{ 
  417.    
  418.     public lacksDiff(double h, double tau) {
  419.         super(h, tau);
  420.         a = 0.4;
  421.         n = 11;
  422.         run();
  423.         paint();
  424.         error();
  425.     }
  426.     @Override
  427.     protected void run() {
  428.         for(int i = 0; i < N+1; i++) {
  429.             temp[i][0] = solution(0, i*h);
  430.         }
  431.         for(int j = 1; j < M+1; j++) {
  432.             temp[0][j] = solution(j*tau, 0);
  433.             temp[N][j] = solution(j*tau, 1);
  434.             for(int i = 1; i < N; i++) {
  435.                 temp[i][j] = 0.5*(temp[i+1][j-1] + temp[i-1][j-1]) + (temp[i-1][j-1] - temp[i+1][j-1])*(a*tau/(2*h));  
  436.             }
  437.         }
  438.         U1 = new double[n];
  439.         for(int i = 0; i < n; i++) { U1[i] = solution(i*(double)1/(n-1), 0.5);}
  440.     }
  441.     @Override
  442.     protected double f(double t, double x) {
  443.         double result = 0;
  444.         return result;
  445.     }
  446.     @Override
  447.     protected double solution(double t, double x) {
  448.         double result = Math.cos(2*Math.PI*(x - a*t)) + Math.pow((x - a*t), 3);
  449.         return result;
  450.     }
  451. }
  452.  
  453.  
  454. ///////////////////////////////////////////////////////////////////////////////////
  455.  
  456.  
  457. public class entryPoint {
  458.     public static void main(String[] args) {
  459.         //exTerm scheme = new exTerm(0.05, 0.01);
  460.         //imTerm scheme = new imTerm(0.01, 0.01);
  461.         //KNTerm scheme = new KNTerm(0.001, 0.001);
  462.         ////////////////////////////////////////
  463.         //exDiff scheme = new exDiff(0.01, 0.01);
  464.         //imDiff scheme = new imDiff(0.01, 0.01);
  465.         //lacksDiff scheme = new lacksDiff(0.001, 0.001);
  466.     }
  467. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top