canye1984

用C#写一个机器人基础知识类

1.工业机器人

运动学

1.DH参数

2.自由度

3.坐标系

4.坐标系转换

5.正算与反算

6.雅可比矩阵

7.轨迹规划

8.Blend算法

9.速度，加速度，位置

动力学

1.负载

2.力反馈

3.柔性

4.刚性

控制理论

1.boxcar

2.反馈模型

硬件

1.马达

2.编码器

3.减速器

4.驱动

5.控制器

6.电源

7.连接部件

通讯

1.ftp

2.soap

3.socket

4.profit bus

5.can

6.tcp

7.modbus

系统

vxwork系统

    /// 
    /// 根据给的点获得数据
    /// 

    public class Val3
    {
        #region 公共变量
        /// 
        /// 产品Frame
        /// 
        public static double[] RecipeFrame = new double[6];
        /// 
        ///产品偏移
        /// 
        public static double[] RecipeOffset = new double[6];
        /// 
        /// 工具信息
        /// 
        public static double[] Tool = new double[6];

        /// 
        /// 路径FRAME
        /// 
        public static double[] TrajFrame = new double[6];
        /// 
        /// 路径偏移
        /// 
        public static double[] TrajOffset = new double[6];
        /// 
        /// 圆的直径
        /// 
        public static double TrajDiameter = 0;

        public static double Blend = 0;

        public static double RecipeSpeed = 0;

        public static double TrajSpeed = 0;


        //

        public static double[][] Point;

        public static double[][] SaftyPoint;

        public static double[][] BeforePoint;

        public static double[][] AfterPoint;

        public static double[][] BeforeSpeed;

        public static double[][] SaftySpeed;

        public static double[,] DH;
        public static double[,] DH160L = new double[,] { { 150, 825, 0,  0,   0,  0 },
                                                         { 0,    0,  0,  0,   0,  0 }, 
                                                         { 0,    0,  0,  925, 0,  110}, 
                                                         { -90,  0,  90, -90, 90, 0 }, 
                                                         { 0,    0,  0,  0,   0,  0 }, 
                                                         { 0,  -90,  90, 0,   0,  0 }
                                                       };
        //a,0,d.

        #endregion

        #region 公共函数
        public static double[] Joint2Point(double[] Joint, double[,] DH)
        {

            if (!IsJoint(Joint) || DH == null || DH.Length != 36)
            {
                return null;
            }
            double[] Trsf0 = new double[] { 0, 0, 0, 0, 0, Joint[0] + DH[5, 0] };
            double[] Trsf1 = new double[] { DH[0, 0], DH[1, 0], DH[2, 0], DH[3, 0], DH[4, 0], Joint[1] + DH[5, 1] };
            double[] Trsf2 = new double[] { DH[0, 1], DH[1, 1], DH[2, 1], DH[3, 1], DH[4, 1], Joint[2] + DH[5, 2] };
            double[] Trsf3 = new double[] { DH[0, 2], DH[1, 2], DH[2, 2], DH[3, 2], DH[4, 2], Joint[3] + DH[5, 3] };
            double[] Trsf4 = new double[] { DH[0, 3], DH[1, 3], DH[2, 3], DH[3, 3], DH[4, 3], Joint[4] + DH[5, 4] };
            double[] Trsf5 = new double[] { DH[0, 4], DH[1, 4], DH[2, 4], DH[3, 4], DH[4, 4], Joint[5] + DH[5, 5] };
            double[] Trsf6 = new double[] { DH[0, 5], DH[1, 5], DH[2, 5], DH[3, 5], DH[4, 5], 0 };

            double[] Buff = TrsfTrsf(Trsf0, Trsf1);
            Buff = TrsfTrsf(Buff, Trsf2);
            Buff = TrsfTrsf(Buff, Trsf3);
            Buff = TrsfTrsf(Buff, Trsf4);
            Buff = TrsfTrsf(Buff, Trsf5);
            return TrsfTrsf(Buff, Trsf6);

        }

        private static double[] StandardTrsf(double[] Trsf)
        {

            if (Trsf == null || Trsf.Length != 6)
                return null;
            double[] Res = new double[6];
            Res[0] = Trsf[0] / 1000.0;
            Res[1] = Trsf[1] / 1000.0;
            Res[2] = Trsf[2] / 1000.0;


            Res[3] = Trsf[3] / 180.0 * Math.PI;
            Res[4] = Trsf[4] / 180.0 * Math.PI;
            Res[5] = Trsf[5] / 180.0 * Math.PI;

            return Res;

        }
        public static double[] Point2Joint(double[] Trsf, double[,] DH, bool[] Pose)
        {

            if (!IsTrsf(Trsf) || DH == null || DH.Length != 36 || Pose == null || Pose.Length < 3)
            {
                return null;
            }
            double[] Joint = new double[6];
            double[] Trsf0 = new double[] { 0, 0, 0, 0, 0, Joint[0] + DH[5, 0] };
            double[] Trsf1 = new double[] { DH[0, 0], DH[1, 0], DH[2, 0], DH[3, 0], DH[4, 0], Joint[1] + DH[5, 1] };
            double[] Trsf2 = new double[] { DH[0, 1], DH[1, 1], DH[2, 1], DH[3, 1], DH[4, 1], Joint[2] + DH[5, 2] };
            double[] Trsf3 = new double[] { DH[0, 2], DH[1, 2], DH[2, 2], DH[3, 2], DH[4, 2], Joint[3] + DH[5, 3] };
            double[] Trsf4 = new double[] { DH[0, 3], DH[1, 3], DH[2, 3], DH[3, 3], DH[4, 3], Joint[4] + DH[5, 4] };
            double[] Trsf5 = new double[] { DH[0, 4], DH[1, 4], DH[2, 4], DH[3, 4], DH[4, 4], Joint[5] + DH[5, 5] };
            double[] Trsf6 = new double[] { DH[0, 5], DH[1, 5], DH[2, 5], DH[3, 5], DH[4, 5], 0 };

            double[] Buff = TrsfTrsf(Trsf, InverseTrsf(Trsf6));
            if (Buff == null)
            {
                return null;

            }
            if (Pose[0])
            {
                Joint[0] = Math.Atan2(Buff[1], Buff[0]) - Math.Atan2(DH[1, 0], -Math.Sqrt(Buff[0] * Buff[0] + Buff[1] * Buff[1] - DH[1, 0] * DH[1, 0]));
            }
            else
            {

                Joint[0] = Math.Atan2(Buff[1], Buff[0]) - Math.Atan2(DH[1, 0], Math.Sqrt(Buff[0] * Buff[0] + Buff[1] * Buff[1] - DH[1, 0] * DH[1, 0]));
            }
            Joint[0] = Joint[0] * 180 / Math.PI;



            return Joint;


        }

        /// 
        /// 三点求用户坐标系,rz求出来有点异常
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetFrame(double[] Zero, double[] Xaxis, double[] Yaxis)
        {
            //1.参数是否合法
            if (!IsTrsf(Zero) || !IsTrsf(Yaxis) || !IsTrsf(Xaxis))
            {
                return null;
            }
            try
            {
                //2。三点不能共线
                double a = Distance(Xaxis, Yaxis);
                double b = Distance(Zero, Yaxis);
                double c = Distance(Zero, Xaxis);
                if (a == b + c || c == a + b || b == a + c)
                {
                    return null;

                }

                //3建立两个向量
                double[] OX = new double[] { -Zero[0] + Xaxis[0], -Zero[1] + Xaxis[1], -Zero[2] + Xaxis[2] };
                double[] OY = new double[] { -Zero[0] + Yaxis[0], -Zero[1] + Yaxis[1], -Zero[2] + Yaxis[2] };

                double[] Vz = GetNormalVector(OX, OY);
                //  double[] Vx = GetNormalVector(OY, Vz);
                double[] Vx = UnitVer(OX);
                double[] Vy = GetNormalVector(Vz, Vx);

                if (Vz == null || Vx == null || Vy == null)
                {

                    return null;
                }

                double[,] frame = new double[4, 4];

                frame[0, 0] = Vx[0];
                frame[1, 0] = Vx[1];
                frame[2, 0] = Vx[2];
                frame[3, 0] = 0;


                frame[0, 1] = Vy[0];
                frame[1, 1] = Vy[1];
                frame[2, 1] = Vy[2];
                frame[3, 1] = 0;


                frame[0, 2] = Vz[0];
                frame[1, 2] = Vz[1];
                frame[2, 2] = Vz[2];
                frame[3, 2] = 0;

                frame[0, 3] = Zero[0] / 1000.0;
                frame[1, 3] = Zero[1] / 1000.0;
                frame[2, 3] = Zero[2] / 1000.0;
                frame[3, 3] = 1;


                return Matrix2Trsf(frame);

            }
            catch
            {
                return null;

            }



        }


        /// 
        /// Trsf相乘
        /// 
        /// 
        /// 
        /// 
        public static double[] TrsfTrsf(double[] TrsfA, double[] TrsfB)
        {
            if (!IsTrsf(TrsfA) || !IsTrsf(TrsfB))
            {

                return null;
            }

            try
            {

                return Matrix2Trsf(MatrixMatrix(Trsf2Matrix(TrsfA), Trsf2Matrix(TrsfB)));

            }

            catch
            {
                return null;

            }


        }

        /// 
        /// 两向量获得法向量
        /// 
        /// 
        /// 
        /// 

        private static double[] GetNormalVector(double[] VectA, double[] VectB)
        {
            if (VectA == null || VectB == null || VectA.Length < 3 || VectB.Length < 3)
            {
                return null;
            }
            double[] Normal = new double[3];
            Normal[0] = VectA[1] * VectB[2] - VectA[2] * VectB[1];
            Normal[1] = VectA[2] * VectB[0] - VectA[0] * VectB[2];
            Normal[2] = VectA[0] * VectB[1] - VectA[1] * VectB[0];

            return UnitVer(Normal);
        }
        /// 
        /// 两矩阵相乘
        /// 
        /// 
        /// 
        /// 
        private static double[,] MatrixMatrix(double[,] MatrixA, double[,] MatrixB)
        {
            if (MatrixA == null || MatrixB == null || MatrixA.Length != 16 || MatrixB.Length != 16)
            {
                return null;
            }

            try
            {

                double[,] MatrixC = new double[4, 4];
                for (int i = 0; i < 4; i++)
                {
                    for (int j = 0; j < 4; j++)
                    {
                        MatrixC[i, j] = 0;

                        for (int k = 0; k < 4; k++)
                        {
                            MatrixC[i, j] = MatrixC[i, j] + MatrixA[i, k] * MatrixB[k, j];
                        }
                    }
                }
                return MatrixC;
            }
            catch
            {
                return null;
            }




        }
        /// 
        ///  计算两点间的距离
        /// 
        /// 
        /// 
        /// 
        public static double Distance(double[] TrsfA, double[] TrsfB)
        {



            if (!IsTrsf(TrsfA) || !IsTrsf(TrsfB))
            {
                return -1;
            }

            try
            {
                double x = (TrsfA[0] - TrsfB[0]) * (TrsfA[0] - TrsfB[0]);
                double y = (TrsfA[1] - TrsfB[1]) * (TrsfA[1] - TrsfB[1]);
                double z = (TrsfA[2] - TrsfB[2]) * (TrsfA[2] - TrsfB[2]);



                return Math.Sqrt(x + y + z);

            }
            catch
            {
                return -1;
            }



        }
        /// 
        /// Trsf到矩阵
        /// 
        /// 
        /// 
        private static double[,] Trsf2Matrix(double[] Trsf)
        {

            if (!IsTrsf(Trsf))
            {
                return null;
            }

            double angle = 0;
            double[,] data = new double[4, 4];
            data[0, 0] = 1;
            data[0, 1] = 0;
            data[0, 2] = 0;
            data[0, 3] = Trsf[0] / 1000.0;

            data[1, 0] = 0;
            data[1, 1] = 1;
            data[1, 2] = 0;
            data[1, 3] = Trsf[1] / 1000.0;

            data[2, 0] = 0;
            data[2, 1] = 0;
            data[2, 2] = 1;
            data[2, 3] = Trsf[2] / 1000.0;

            data[3, 0] = 0;
            data[3, 1] = 0;
            data[3, 2] = 0;
            data[3, 3] = 1;


            angle = Trsf[3] * Math.PI / 180.0;
            double[,] rx = new double[4, 4];
            rx[0, 0] = 1;
            rx[0, 1] = 0;
            rx[0, 2] = 0;
            rx[0, 3] = 0;

            rx[1, 0] = 0;
            rx[1, 1] = Math.Cos(angle);
            rx[1, 2] = Math.Sin(angle) * (-1);
            rx[1, 3] = 0;

            rx[2, 0] = 0;
            rx[2, 1] = Math.Sin(angle) * (1);
            rx[2, 2] = Math.Cos(angle);
            rx[2, 3] = 0;

            rx[3, 0] = 0;
            rx[3, 1] = 0;
            rx[3, 2] = 0;
            rx[3, 3] = 1;



            angle = Trsf[4] * Math.PI / 180.0;
            double[,] ry = new double[4, 4];
            ry[0, 0] = Math.Cos(angle);
            ry[0, 1] = 0;
            ry[0, 2] = Math.Sin(angle) * (1);
            ry[0, 3] = 0;

            ry[1, 0] = 0;
            ry[1, 1] = 1;
            ry[1, 2] = 0;
            ry[1, 3] = 0;

            ry[2, 0] = Math.Sin(angle) * (-1);
            ry[2, 1] = 0;
            ry[2, 2] = Math.Cos(angle);
            ry[2, 3] = 0;

            ry[3, 0] = 0;
            ry[3, 1] = 0;
            ry[3, 2] = 0;
            ry[3, 3] = 1;

            angle = Trsf[5] * Math.PI / 180.0;
            double[,] rz = new double[4, 4];

            rz[0, 0] = Math.Cos(angle);
            rz[0, 1] = Math.Sin(angle) * (-1);
            rz[0, 2] = 0;
            rz[0, 3] = 0;

            rz[1, 0] = Math.Sin(angle) * (1);
            rz[1, 1] = Math.Cos(angle);
            rz[1, 2] = 0;
            rz[1, 3] = 0;

            rz[2, 0] = 0;
            rz[2, 1] = 0;
            rz[2, 2] = 1;
            rz[2, 3] = 0;

            rz[3, 0] = 0;
            rz[3, 1] = 0;
            rz[3, 2] = 0;
            rz[3, 3] = 1;

            return MatrixMatrix(MatrixMatrix(MatrixMatrix(data, rx), ry), rz);


        }
        /// 
        /// 判断是否trsf
        /// 
        /// 
        /// 
        private static bool IsTrsf(double[] point)
        {

            return point != null && point.Length == 6;

        }
        /// 
        /// 判断是否Joint
        /// 
        /// 
        /// 
        public static bool IsJoint(double[] joint)
        {
            return IsTrsf(joint);
        }

        /// 
        /// 矩阵转换
        /// 
        /// 
        /// 
        private static double[] Matrix2Trsf(double[,] Matrix)
        {
            if (Matrix == null || Matrix.Length != 16 || Matrix[3, 0] != 0 || Matrix[3, 1] != 0 || Matrix[3, 2] != 0 || Matrix[3, 3] != 1)
            {

                return null;
            }

            try
            {
                double[] Res = new double[6];
                Res[0] = Matrix[0, 3] * 1000;
                Res[1] = Matrix[1, 3] * 1000;
                Res[2] = Matrix[2, 3] * 1000;



                //matrix[0,2]必须小于1大于-1
                //n 0 a
                if (Matrix[0, 2] < (-1.0 + Math.Pow(1, -5) * Math.Pow(1, -5) / 2.0))
                {
                    Res[3] = 0;
                    Res[4] = -Math.PI / 2.0;
                    Res[5] = Math.Atan2(Matrix[0, 0], Matrix[0, 1]);


                }
                else if (Matrix[0, 2] > (1.0 - Math.Pow(1, -5) * Math.Pow(1, -5) / 2.0))
                {
                    Res[3] = 0;
                    Res[4] = Math.PI / 2.0;
                    Res[5] = Math.Atan2(Matrix[0, 0], -1 * Matrix[0, 1]);

                }
                else
                {
                    double l_sign = 1.0;
                    Res[4] = Math.Asin(Matrix[0, 2]);
                    if ((Matrix[2, 2] < 0.0) && (Matrix[0, 0] < 0.0) && ((Math.Abs(Matrix[0, 2]) > Math.Pow(1, -10)) || (Math.Abs(Matrix[2, 1]) > Math.Pow(1, -10))))
                    {
                        if (Res[4] >= 0.0)
                        {
                            Res[4] = Math.PI - Res[4];
                        }
                        else
                        {
                            Res[4] = -Math.PI - Res[4];
                        }
                        l_sign = -1.0;
                    }
                    Res[3] = Math.Atan2(-l_sign * Matrix[1, 2], l_sign * Matrix[2, 2]);
                    Res[5] = Math.Atan2(-l_sign * Matrix[0, 1], l_sign * Matrix[0, 0]);



                }

                Res[3] = Res[3] * 180.0 / Math.PI;
                Res[4] = Res[4] * 180.0 / Math.PI;
                Res[5] = Res[5] * 180.0 / Math.PI;

                return Res;

            }

            catch
            {

                return null;

            }

        }

        /// 
        /// 转换求逆
        /// 
        /// 
        /// 
        public static double[] InverseTrsf(double[] Trsf)
        {
            if (!IsTrsf(Trsf))
            {
                return null;
            }

            double angle = 0;
            double[,] data = new double[4, 4];
            data[0, 0] = 1;
            data[0, 1] = 0;
            data[0, 2] = 0;
            data[0, 3] = Trsf[0] / 1000.0 * (-1);

            data[1, 0] = 0;
            data[1, 1] = 1;
            data[1, 2] = 0;
            data[1, 3] = Trsf[1] / 1000.0 * (-1);

            data[2, 0] = 0;
            data[2, 1] = 0;
            data[2, 2] = 1;
            data[2, 3] = Trsf[2] / 1000.0 * (-1);

            data[3, 0] = 0;
            data[3, 1] = 0;
            data[3, 2] = 0;
            data[3, 3] = 1;


            angle = Trsf[3] * Math.PI / 180.0;
            double[,] rx = new double[4, 4];
            rx[0, 0] = 1;
            rx[0, 1] = 0;
            rx[0, 2] = 0;
            rx[0, 3] = 0;

            rx[1, 0] = 0;
            rx[1, 1] = Math.Cos(angle);
            rx[1, 2] = Math.Sin(angle);
            rx[1, 3] = 0;

            rx[2, 0] = 0;
            rx[2, 1] = Math.Sin(angle) * (-1);
            rx[2, 2] = Math.Cos(angle);
            rx[2, 3] = 0;

            rx[3, 0] = 0;
            rx[3, 1] = 0;
            rx[3, 2] = 0;
            rx[3, 3] = 1;



            angle = Trsf[4] * Math.PI / 180;
            double[,] ry = new double[4, 4];
            ry[0, 0] = Math.Cos(angle);
            ry[0, 1] = 0;
            ry[0, 2] = Math.Sin(angle) * (-1);
            ry[0, 3] = 0;

            ry[1, 0] = 0;
            ry[1, 1] = 1;
            ry[1, 2] = 0;
            ry[1, 3] = 0;

            ry[2, 0] = Math.Sin(angle) * (1);
            ry[2, 1] = 0;
            ry[2, 2] = Math.Cos(angle);
            ry[2, 3] = 0;

            ry[3, 0] = 0;
            ry[3, 1] = 0;
            ry[3, 2] = 0;
            ry[3, 3] = 1;

            angle = Trsf[5] * Math.PI / 180;
            double[,] rz = new double[4, 4];

            rz[0, 0] = Math.Cos(angle);
            rz[0, 1] = Math.Sin(angle) * (1);
            rz[0, 2] = 0;
            rz[0, 3] = 0;

            rz[1, 0] = Math.Sin(angle) * (-1);
            rz[1, 1] = Math.Cos(angle);
            rz[1, 2] = 0;
            rz[1, 3] = 0;

            rz[2, 0] = 0;
            rz[2, 1] = 0;
            rz[2, 2] = 1;
            rz[2, 3] = 0;

            rz[3, 0] = 0;
            rz[3, 1] = 0;
            rz[3, 2] = 0;
            rz[3, 3] = 1;

            return Matrix2Trsf(MatrixMatrix(MatrixMatrix(MatrixMatrix(rz, ry), rx), data));

        }
        /// 
        /// 
        /// 
        /// 
        /// 
        private static double[] UnitVer(double[] Normal)
        {

            if (Normal == null || Normal.Length < 3)
            {
                return null;
            }
            double R = Math.Sqrt(Normal[0] * Normal[0] + Normal[1] * Normal[1] + Normal[2] * Normal[2]);
            if (R == 0)
            {
                return null;
            }
            double[] point = new double[3];
            point[0] = Normal[0] / R;
            point[1] = Normal[1] / R;
            point[2] = Normal[2] / R;
            return point;

        }

        /// 
        /// 三点求外接圆心
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetCircleCenter(double[] Trsf1, double[] Trsf2, double[] Trsf3)
        {

            if (GetFrame(Trsf1, Trsf2, Trsf3) == null)
                return null;





            return null;


        }

        /// 
        /// 三点求外接圆的半径
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double GetCircleRadius(double[] Trsf1, double[] Trsf2, double[] Trsf3)
        {
            double[] Center = GetCircleCenter(Trsf1, Trsf2, Trsf3);

            if (Center == null)
            {
                return 0;
            }

            double len = (Center[0] - Trsf1[0]) * (Center[0] - Trsf1[0]) + (Center[1] - Trsf1[1]) * (Center[1] - Trsf1[1]) + (Center[2] - Trsf1[2]) * (Center[2] - Trsf1[2]);
            return Math.Sqrt(len);

        }

        /// 
        /// 四点求球心
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetBallCenter(double[] Trsf1, double[] Trsf2, double[] Trsf3, double[] Trsf4)
        {

            if (GetFrame(Trsf1, Trsf2, Trsf3) == null)
                return null;





            return null;


        }

        /// 
        /// 四点求球的半径
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double GetBallRadius(double[] Trsf1, double[] Trsf2, double[] Trsf3, double[] Trsf4)
        {
            double[] Center = GetBallCenter(Trsf1, Trsf2, Trsf3, Trsf4);

            if (Center == null)
            {
                return 0;
            }

            double len = (Center[0] - Trsf1[0]) * (Center[0] - Trsf1[0]) + (Center[1] - Trsf1[1]) * (Center[1] - Trsf1[1]) + (Center[2] - Trsf1[2]) * (Center[2] - Trsf1[2]);
            return Math.Sqrt(len);

        }


        /// 
        /// 技术来源http://zh.wikipedia.org/zh-cn/%E8%B2%9D%E8%8C%B2%E6%9B%B2%E7%B7%9A
        ///         
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[,] GetBlendPoints(double[] Trsf1, double[] Trsf2, double[] Trsf3, int Count)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || !IsTrsf(Trsf3) || Count < 0)
            {
                return null;

            }
            double[,] Res = new double[Count, 6];
            double t = 1.0 / Count;
            for (int i = 0; i < Count; i++)
            {
                t = 1.0 / Count * i;
                for (int j = 0; j < 6; j++)
                {
                    Res[i, j] = (1 - t) * (1 - t) * Trsf1[j] + 2 * t * Trsf2[j] + t * t * Trsf3[j];

                }
            }
            return Res;


        }

        private static double[] GetStartBlend(double[] Trsf1, double[] Trsf2, double reach)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || reach < 0)
            {
                return null;

            }
            double len = Distance(Trsf1, Trsf2);
            double[] Res = new double[6];
            for (int i = 0; i < 6; i++)
            {

                Res[i] = reach / len * (Trsf1[i] - Trsf2[i]) + Trsf2[i];
            }

            return Res;

        }
        private static double[] GetEndBlend(double[] Trsf1, double[] Trsf2, double leave)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || leave < 0)
            {
                return null;

            }
            double len = Distance(Trsf1, Trsf2);
            double[] Res = new double[6];
            for (int i = 0; i < 6; i++)
            {

                Res[i] = leave / len * (Trsf2[i] - Trsf1[i]) + Trsf1[i];
            }

            return Res;

        }
        public static double[,] CartBlend(double[] Start, double[] Center, double[] end, double reach, double leave, int Count)
        {


            return GetBlendPoints(GetStartBlend(Start, Center, reach), Center, GetEndBlend(Start, Center, leave), Count);
        }








        public static bool[] GetPose(double[] Joint,double[,] DH)
        {
            if (!IsJoint(Joint))
            {
                return null;
            }
            bool[] Res = new bool[3];
            double[] d = new double[3];
            d[0] = DH[2, 3]+DH[2,5]+DH[0,1];
            d[1]=DH[2,3];
            d[2]=DH[0,0];


            Res[0]=((d[0]*Math.Sin(Joint[1]+d[1]*Math.Sin(Joint[1]+Joint[2]+d[2]))<0));

            Res[1] = (Joint[2] >= 0);

            Res[2] = (Joint[4] >= 0);
            return Res;
        
        }
        #endregion

    }

C#中的PLINQ和LINQ的效率对比搬砖的诗人Z C#c#linq 开发语言
PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
程序员开发技术整理 laizhixue 学习前端框架
前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
C#学习笔记 2301_79022588 学习笔记
一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
C# CsvHelper 使用 GeGe&YoYo 工具类 c#开发语言
C#CsvHelper使用1.简介CsvHelper是一个用于读写CSV文件的.NET库。极其快速，灵活且易于使用。CsvHelper建立在.NETStandard2.0之上，几乎可以在任何地方运行。Github地址：https://github.com/joshclose/csvhelper2.模块3.读取测试类publicclassFoo{publicintID{get;set;}public
C#杨辉三角形 wenchm c#算法数据结构
目录1.杨辉三角形定义2.用数组实现10层的杨辉三角形3.使用List泛型链表集合设计10层的杨辉三角形（1）代码解释：（2）算法中求余的作用4.使用List泛型链表集合设计10层的等腰的杨辉三角形1.杨辉三角形定义杨辉三角是一个由数字排列成的三角形数表，其最本质的特征是它的两条边都是由数字1组成的，而其余的数则等于它上方的两个数之和。杨辉三角有两种常用的表示形式。2.用数组实现10层的杨辉三角形
C#使用ASP.NET Core Razor Pages构建网站（二）林祖师 C#c#asp.net 开发语言
上一篇文章讲了HTTP协议的基本概念、客户端Web开发技术以及ASP.NETCore框架的关键特点和创建项目方法链接：C#使用ASP.NETCoreRazorPages构建网站（一）接下来继续了解ASP.NETCoreRazorPages构建网站的后续内容了解RazorPagesRazorPages允许开发人员轻松地将HTML标记和C#代码混合在一起，这是使用.cshtml扩展名的原因。默认情况下
c#IQueryable和IEnumberable的区别彭小彭~ c#基础 c#
IQueryable和IEnumerable是C#中处理集合的两个重要接口，常用于LINQ查询。它们有一些关键区别，适用于不同的场景：1.执行查询的位置IEnumerable:当你对一个IEnumerable序列使用LINQ操作时，这些操作是在本地内存中执行的。如果IEnumerable表示数据库中的数据（例如，使用EntityFramework时），那么整个数据集首先会被加载到内存中，然后再应用
游戏客户客户端面经 Unity游戏开发游戏游戏开发求职程序员
C#和C++的类的区别C#List添加100个Obj和100int内存是怎么变化的重载和重写的区别，重载是怎么实现的重写是怎么实现的？虚函数表是类的还是对象的用过哪些C++的STLVector底层是怎么实现的Vector添加一百次数据内存是怎么变化Map的底层，红黑树的查询和插入的时间复杂程度，Unordermap的底层实现是什么List的底层是怎么实现的场景里面有6个玩家扮演贪吃蛇进行3v3，场
c# 与c++类型对应关系让您看见未来 c++c#c#开发语言
c#c++ubytecharshortshortint32int32_tlongint64_tfloatfloatdoubledoubleIntPt,[]void*
APP UI自动化测试思路总结程序员老鹰 ui 测试工具开发语言软件测试经验分享程序人生程序员
首先想要说明一下，APP自动化测试可能很多公司不用，但也是大部分自动化测试工程师、高级测试工程师岗位招聘信息上要求的，所以为了更好的待遇，我们还是需要花时间去掌握的，毕竟谁也不会跟钱过不去。接下来，一起总结一下APPUI自动化测试的思路吧。一，开发语言选择通常用于自动化测试的编程语言有：Python、Java、Javascript、Ruby、C#、PHP等。一般我们会选择自己熟悉的编程语言来编写自
C#关键字 namespace xklcy C#关键字 c#开发语言
namespace关键字用于声明包含一组相关对象的作用域。可以使用命名空间来组织代码元素并创建全局唯一类型。在命名空间中，可以声明零个或多个以下类型：class类interface接口struct结构体enum枚举delegate委托namespace可以声明嵌套的命名空间（文件范围的命名空间声明除外）以下示例显示如何在嵌套命名空间中调用静态方法。namespaceSomeNameSpace{pu
moba客户端开发面经 Unity游戏开发面试游戏开发 unity
1、Lua：元表是什么，怎么实现对象继承2、OPP是什么3、mvc结构4、C#:list和array区别和使用场景5、项目：（1）ui框架类设计，ui层级管理怎么做，对象初始化内存占用这样做高，资源是怎么加载的（2）背包数据室怎么加载的，mvc怎么使用的，怎么性能优化的（3）ui的一些优化方式，动静分离，不使用透明，排序减少batch6、帧同步和状态同步介绍：（1）用什么协议，这俩什么区别（2）网
KMP算法（java、C#）以明志、 c#算法 java
文章目录kmp中的nextVal（代码用next数组表示）获取匹配成功的主串下标程序入口（示例）kmp中的nextVal（代码用next数组表示）namespaceTestmain{publicclassGetNext{int[]next;publicint[]getNextArray(char[]ch){next=newint[ch.Length];inti=0,j=-1;next[0]=-1;
C#面：throw 和throw ex 的区别那个那个鱼 C#面试题 c#开发语言 c#.net
throw关键字：用于抛出当前异常，并保留原始的异常堆栈信息。当使用throw关键字时，当前异常的堆栈信息将被保留，这对于调试和追踪异常非常有用。例如：try{//一些可能引发异常的代码}catch(Exceptionex){//处理异常throw;//重新抛出当前异常，保留原始的异常堆栈信息}throwex关键字：也用于抛出当前异常，但会重置异常的堆栈信息。当使用throwex关键字时，当前异常
二、C#选择排序算法哒哒咦哒哒·· c#排序算法数据结构算法
简介选择排序算法的基本思想是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。选择排序（SelectionSort）原理介绍选择排序（SelectionSort）是一种简单的排序算法，其实现原理如下：遍历待排序数组，从第一个元素开始。假设当前遍历的元素为最
C#、ASP、ASP.NET、.NET、ASP.NET CORE区别、ASP.NET Core其概念和特点、ASP.NET Core个人心得体会 lijingguang C#c#
C#是一种面向对象的编程语言，主要用于开发跨平台的应用程序。它是.NET框架的一部分，并且可以在.NET平台上运行。ASP（ActiveServerPages）是一种用于构建动态Web页面的技术，使用VBScript或JScript作为服务器端脚本语言。它是早期的Microsoft技术，现已逐渐过时。ASP.NET是微软推出的下一代Web应用程序开发技术，它提供了更强大、更高效的功能和工具。ASP
C#编写LINQ查询林祖师 C#c#linq 开发语言
虽然在前面的文章里编写了一些LINQ查询，但是没有解释LINQ是如何工作的，现在，我们花点时间来正确的理解它们。LINQ有多个组成部分，有些是必须的，而有些是可选的。扩展方法：包括Where、Select、OrderBy等。这些扩展方法使得对集合和数据源进行查询操作变得更加直观和易于理解。表达式：在LINQ中，表达式通常指Lambda表达式，即匿名函数。Lambda表达式允许我们在LINQ查询中编
C#常见的.Net类型（二）林祖师 C#c#.net 开发语言
目录一、在集合中存储多个对象理解集合的选择1.列表2.字典3.堆栈4.队列5.集二、使用Span、索引和范围Span索引范围处理类型和属性1.特性2.创建自定义特性3.反射一、在集合中存储多个对象处理集合的常见类型类型描述List动态大小的数组，可以按索引访问Dictionary键值对集合，根据键进行快速查找Queue先进先出的队列集合Stack后进先出的栈集合HashSet不包含重复元素的集合L
C#使用Entity Framework Core处理数据库（三）林祖师 C#c#开发语言学习
EntityFrameworkCore（EFCore）是一个轻量级、跨平台的对象关系映射（ORM）框架，用于在.NET应用程序中处理数据库操作。它提供了一种将数据库中的数据映射到.NET对象模型的方法，使开发人员可以使用面向对象的方式进行数据库操作，而无需直接编写SQL语句。上一篇文章讲了在C#中EFCore查询和加载模式：C#使用EntityFrameworkCore处理数据库（二）接下来讲讲使
C# Path 类周杰伦fans 学习C#的笔记 c#
在C#中，Path类位于System.IO命名空间中，提供了一组用于操作和处理文件路径的静态方法。Path类可以用于处理文件名、目录名和路径等相关操作。下面是一些Path类常用的方法和示例说明：Path.Combine：用于组合多个字符串片段来创建一个有效的路径字符串。stringdirectory="C:\\Users";stringfilename="file.txt";stringfullP
C#学习汇总林祖师 C#c#学习开发语言
C#学习汇总1.C#编程基础C#语法C#使用变量2.控制程序流程和转换类型C#控制台应用程序C#选择语句和迭代语句C#类型转换3.编写函数C#编写函数4.使用面向对象C#构建类库C#在字段中存储数据C#写入和调用方法C#使用属性和索引器控制访问5.实现接口和继承类C#接口和泛型C#学习继承6.使用常见的.NET类型C#常见的.Net类型（一）C#常见的.Net类型（二）7.处理文件、流C#处理文件
Uni-app开发Canvas当子组件示例，点点绘制图形他在时间门外 uni-app javascript 前端
前言使用Uni-app实现封装一个Canvas渲染的子组件，实现通过传入两点绘制一条完整的路程具体逻辑看我发的后端和数据库设计C#根据两点名称，寻找两短路程的最优解，【有数据库设计，完整代码】即使不了解具体逻辑，该文章同样可以帮助想要实现使用Canvas当子组件，以及点点绘制图形问题的疑惑注意事项问题一：在使用canvas开发时为什么图形没有渲染1.注意画布的尺寸canvas标签默认宽度300px
C# 的一些好用的语法糖介绍搬砖的诗人Z C#c#windows 开发语言
C#中有很多语法糖（Syntacticsugar），它们是一些语言特性，使得编写代码更加简洁、易读、更具表现力。Lambda表达式：Lambda表达式允许你编写简洁的匿名函数。例如：Funcadd=(a,b)=>a+b;自动属性：简化了属性的定义。编译器会自动创建私有字段并生成getter和setter方法。publicintAge{get;set;}集合初始化器：允许你初始化集合类型，使得代码更
C#在字段中存储数据林祖师 C#c#开发语言
定义字段在C#中，定义字段需要指定字段的类型和名称。字段是类或结构体的成员变量，用于存储数据。以下是一个简单的示例：publicclassMyClass{publicstringname;}可以对字段使用任何类型，包括数组和集合。使用enum类型存储值可以使用enum类型来存储一组相关的值。enum类型是一种枚举类型，它允许你为一组相关的值赋予有意义的名称。以下是一个简单的示例：publicenu
C#(C Sharp)学习笔记_变量常量与作用域【十二】 tiamo_16 C#学习笔记 c#学习
变量变量是用来存储数据值的标识符。你可以将变量视为内存中的一个位置，这个位置可以保存不同类型的数据。同时，变量也被称作为类中的成员变量在C#中声明变量时，你需要指定变量的类型，这告诉编译器你打算在变量中存储什么类型的数据。常量在C#中，常量（也称为字面量或常量值）是一种在编译时确定并在程序执行期间不可更改的值。常量可以是任何基本数据类型（如整数、浮点数、字符等）的值，也可以是字符串、枚举类型或引用
c# 的ref 和out ISDF-工软未来 C#c#开发语言
在C#中，ref和out是用于方法参数的关键字，它们都允许在方法调用中对参数进行修改。ref关键字用于传递参数的引用。当使用ref关键字声明一个参数时，实际上是在告诉编译器此参数在调用方法之前必须被赋值。ref参数传递的是参数的引用地址，方法内部对引用地址的修改将影响到方法外部的参数值。函数内部可以赋值，也可以不赋值，但是调用之前必须初始化给值。publicvoidModifyValue(refi
Github 2024-03-09 开源项目日报Top10 老孙正经胡说 github 开源 Github趋势分析开源项目 Python Golang
根据GithubTrendings的统计，今日(2024-03-09统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3HTML项目1CSS项目1Swift项目1C#项目1C++项目1JupyterNotebook项目1TypeScript项目1JavaScript项目1Ryujinx:任天堂Switch模拟器创建周期：2223天开发语言：C#协议类
C#--StreamWriter和StreamReader对象及常用函数海绵波波107 C#c#数据库服务器
目录StreamReaderReadLine()Split（）StreamWriterWriteLine（）Flush()Close()StreamReaderStreamReader是C#中用于从流（如文件、内存流等）中读取文本数据的类。它提供了多种方法来读取不同类型的数据。以下是一些StreamReader类的常用方法：StreamReader(Stream):构造函数，创建一个新的Strea
C#控制台应用程序林祖师 C#c#开发语言
C#控制台应用程序时基于文本的，在命令行中运行。它们通常执行需要编写的脚本的简单任务，例如编译文件或加密配置文件的一部分。一、向用户显示输出控制台应用程序执行的两个最常见的任务是写入和读取数据，前者使用WriteLine、Write方法来输出数据。使用编号的位置参数进行格式化生成格式化字符串的一种方式是使用编号的位置参数。WriteLine、Writede的方法就支持这一特性，对于不支持这一特性的
C#写入和调用方法林祖师 C#c#开发语言
一、编写方法在C#中，方法是在类或结构体内部定义的代码块，用于执行特定的操作。方法通常包括以下几个要素：访问修饰符：指定方法的访问级别，如public、private、protected等。返回类型：指定方法返回的数据类型，可以是任何有效的C#数据类型，甚至可以是void，表示不返回任何值。方法名称：方法的标识符，用于在其他地方调用该方法。参数列表：可选部分，包含传递给方法的数据。方法体：包含实际
rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
这是我自己想到的问题，结果去知呼提问，还没等别人回答，我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
java编程思想 -- 数据的初始化百合不是茶 java 数据的初始化
1.使用构造器确保数据初始化 /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
[航天与宇宙]为什么发射和回收航天器有档期 comsci
地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁... 所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
linux下批量替换文件内容商人shang linux 替换
1、网络上现成的资料　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
网页在线天气预报 oloz 天气预报
网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
SpringMVC和Struts2比较杨白白 springMVC
1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
refuse copy, lazy girl! 小桔子 copy
妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
apache与php整合 aichenglong php apache web
一 apache web服务器 1 apeche web服务器的安装 1)下载Apache web服务器 2)配置域名(如果需要使用要在DNS上注册) 3)测试安装访问http://localhost/验证是否安装成功 2 apache管理 1)service.msc进行图形化管理 2)命令管理，配
Maven常用内置变量 AILIKES maven
Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
java的类和对象百合不是茶 JAVA面向对象类对象
java中的类： java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决 java使用 class 类名来创建类，在Java中类名要求和构造方法，Java的文件名是一样的创建一个A类： class A{ } java中的类：将某两个事物有联系的属性包装在一个类中，再通
JS控制页面输入框为只读 bijian1013 JavaScript
在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
AngularJS与服务器交互 bijian1013 JavaScript AngularJS $http
对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
[Maven学习笔记八]Maven常用插件应用 bit1129 maven
常用插件及其用法位于：http://maven.apache.org/plugins/ 1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin 1. Jetty Pl
【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
UI设计中我们为什么需要设计动效 brotherlamp UI ui教程 ui视频 ui资料 ui自学
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用你的产品。
Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan java spring
参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
数据库连接池的工作原理 chicony 数据库连接池
随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
java 关键字 CrazyMizzz java
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：（1）访问修饰符 public,private,protected p
Hive中的排序语法 daizj 排序 hive order by DISTRIBUTE BY sort by
Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
单态设计模式 dcj3sjt126com 设计模式
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{ // 保存类实例在此属性中 private static&
svn locked dcj3sjt126com Lock
post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
ARM寄存器学习 e200702084 数据结构 C++c C#F#
无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。 ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
常用编码资料 gengzg 编码
List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
进程 vs. 线程 hongtoushizi 线程 linux 进程
我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。如果用多线程实现
Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linux crontab
一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来：第一段代表分钟 0—59 第二段代表小时 0—23 第三段代表日期 1—31 第四段代表月份 1—12 第五段代表星期几，0代表星期日 0—6 如： */1 * * * * 每分钟执行一次。 *
KMP算法详解 hm4123660 数据结构 C++算法字符串 KMP
字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。假设主串s="ababcabcacbab",模式串为t="
枚举类型的单例模式 zhb8015 单例模式
E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
Kafka+Storm+HDFS ssydxa219 storm
cd /myhome/usr/stormbin/storm nimbus &bin/storm supervisor &bin/storm ui &Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
Java获取本地服务器的IP 中华好儿孙 java Web 获取服务器ip地址
System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo

用C#写一个机器人基础知识类

你可能感兴趣的:(C#)