【C++ 程序】 TVJ Matrix Laboratory (v 1.1)

最新推荐文章于 2023-05-30 19:57:51 发布
最新推荐文章于 2023-05-30 19:57:51 发布
阅读量450 收藏
点赞数 1
分类专栏： 【C++】 自编程序 文章标签： c++ 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50012998/article/details/109753175
版权

简介

这是一个用 Visual C++做的关于线性代数（尤其是与矩阵相关的计算）的小软件。
图标
版本
系统要求：Windows

应用程序(exe)下载

链接：https://download.csdn.net/download/weixin_50012998/13120843

Help

What is new in v 1.1

  1. 修改好了 v 1.0 中的bug
  2. 增加了求逆矩阵的功能
  3. 增加了帮助（Help）选项

功能选择

输入功能模式
1求行列式
2求转置矩阵
3求逆矩阵
4矩阵乘法
5解线性方程组
其他结束程序

输入要求

  • 行列式：每行输入行列式的一行，输完一行回车回车后输入下一行。当最后一次换行后输出。
  • 转置矩阵：每行输入行列式的一行，输完一行回车回车后输入下一行。当最后一次换行后输入"end"后输出。
  • 求逆矩阵：每行输入行列式的一行，输完一行回车回车后输入下一行。当最后一次换行后输出。
  • 矩阵乘法：先输入矩阵A。每行输入行列式的一行，输完一行回车回车后输入下一行。当最后一次换行后输入"end"后开始输入矩阵B。每行输入行列式的一行，输完一行回车回车后输入下一行。当最后一次换行后输入"end"后输出。
  • 解线性方程组：输入线性方程组的增广矩阵（且方程数必须等于未知数数量），当最后一次换行（自动识别方程数与未知数数量相等）后输出。
  • 结束程序：按任意键关闭。

新功能图片示例

1
2

其他图片示例见我的博客 【C++ 程序】 TVJ Matrix Laboratory (v 1.0)中的输出示例。

程序

Source.cpp

#include <iostream>
#include <Windows.h>
#include <conio.h>
#include "Cinvec.h"
#include "Det.h"
#include "Formula.h"
#include "Inverse.h"
#include "Multiply.h"
#include "Transpose.h"
using namespace std;

void set_size()
{
	CONSOLE_FONT_INFOEX cfi;
	cfi.cbSize = sizeof cfi;
	cfi.nFont = 0;
	cfi.dwFontSize.X = 0; // the width of the character
	cfi.dwFontSize.Y = 22;// the height of the character
	cfi.FontFamily = FF_DONTCARE;
	cfi.FontWeight = FW_NORMAL; // weight
	wcscpy_s(cfi.FaceName, L"Raster"); // set font, this place is the Raster font
	SetCurrentConsoleFontEx(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi);
}

void set_green()
{
	// set the colour green
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
}

void set_yellow()
{
	// set the colour yellow
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
}

void set_white()
{
	// set the colour white
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
}

int main(int argc, char** argv)
{
	set_size();
	set_green();
	cursor("hide");
	cout << "TVJ Matrix Laboratory (v 1.1)\nTeddy van Jerry\n==============================\n" << endl;
	MessageBox(NULL, L"This is TVJ Matrix Laboratory (v 1.1)\nDesigned by Teddy van Jerry\n2020.11\n\nPlease make sure that your input is legal!",
		L"Information", MB_ICONINFORMATION);
	int choice_help = MessageBox(NULL, L"Want to see HELP?", L"TVJ Matrix Laboratory", MB_YESNO | MB_ICONINFORMATION);
	if (choice_help == IDYES)
	{
		// go to my CSDN blog
		ShellExecute(NULL, L"open", L"explorer.exe", L"https://blog.csdn.net/weixin_50012998/article/details/109753175", NULL, SW_SHOW);
	}
	while (1)
	{
		/*
		cout << "Please choose the mode:" << endl;
		cout << "1. Determinant" << endl;
		cout << "2. Transpose" << endl;
		cout << "3. Inverse" << endl;
		cout << "4. Multiply" << endl;
		cout << "5. Solve linear formulas" << endl;
		cout << "Others: Exit" << endl;
		*/

		cursor("hide");
		MessageBox(NULL, L"Please choose the mode:\n1. Determinant\n2. Transpose\n3. Inverse\n4. Multiply\n5. Solve linear formulas\nOthers: Exit",
			L"TVJ Matrix Laboratory", MB_ICONINFORMATION);
		char n = _getch();
		cout << "\r";
		
		switch (n)
		{
		case '1':
			set_yellow();
			cout << "MODE 1: Determinant" << endl;
			set_white();
			cursor("show");
			det();
			break;
		case '2':
			set_yellow();
			cout << "MODE 2: Transpose" << endl;
			set_white();
			cursor("show");
			transpose();
			break;
		case '3':
			set_yellow();
			cout << "MODE 3: Inverse" << endl;
			set_white();
			cursor("show");
			inverse();
			break;
		case '4':
			set_yellow();
			cout << "MODE 4: Multiply" << endl;
			set_white();
			cursor("show");
			multiply();
			break;
		case '5':
			set_yellow();
			cout << "MODE 5: Solve linear formulas" << endl;
			set_white();
			cursor("show");
			formula();
			break;
		default:
			set_white();
			cout << "ALL RIGHTS RESERVED (C) 2020 Teddy van Jerry" << endl;
			cout << "\n-----------------------------------------------------------------\nPress any key to exit." << endl;
			n = _getch();
			return 0; // exit
		}
	}
	return 0;
}

Algebraic cofactor.h

#ifndef _ALGEBRAIC_COFACTOR_
#define _ALGEBRAIC_COFACTOR_
#include "Det.h"

double exclude(std::deque<std::deque<double>> deq, int i, int j)
{
	int Sign = ((i + j) % 2 == 0) ? 1 : -1;
	std::deque<std::deque<double>> temp = deq;
	for (int k = i - 1; k >= 0; k--)
	{
		for (int t = 0; t != temp[0].size(); t++)
		{
			temp[k + 1][t] = temp[k][t];
		}
	}
	temp.pop_front();
	for (int t = j - 1; t >= 0; t--)
	{
		for (int k = 0; k != temp.size(); k++)
		{
			temp[k][t + 1] = temp[k][t];
			if (t == 0)temp[k].pop_front();
		}
	}
	if (j == 0)
	{
		for (int k = 0; k != temp.size(); k++)
		{
			temp[k].pop_front();
		}
	}
	return (Sign * det_is(temp) == -0) ? 0 : Sign * det_is(temp);
}

#endif // !_ALGEBRAIC_COFACTOR_

Cinvec.h

#ifndef _CINVEC_
#define _CINVEC_
#include <iostream>
#include <vector>
#include <string>
#include <sstream> // std::istringstream
#include <deque>
#include <conio.h>

int index[] = { 0,0,0 }; // define

std::vector<double> cinvec_d(std::string cin_d, int& N)
{
	getline(std::cin, cin_d);
	std::vector<double> vd;
	if (cin_d == "end")
	{
		N = 1;
		return vd;
	}
	std::istringstream is(cin_d);
	double i;
	while (is >> i)
		vd.push_back(i);
	return vd;
}

std::deque<double> cindeq_d(std::string cin_d, int& N)
{
	getline(std::cin, cin_d);
	std::deque<double> vd;
	if (cin_d == "end")
	{
		N = 1;
		return vd;
	}
	std::istringstream is(cin_d);
	double i;
	while (is >> i)
		vd.push_back(i);
	return vd;
}

void cinvec_s(std::deque<std::deque<double>>& det)
{
	unsigned n = 0;
	std::string str;
	// input
	while (1)
	{
		getline(std::cin, str);
		std::istringstream is(str);
		std::deque<double> row;
		double i;
		while (is >> i)
			row.push_back(i);
		if (!row.empty())
		{
			det.push_back(row);
			n = (row.size() > n) ? row.size() : n;
			if (det.size() >= n) break;
		}
	}
}

#endif // !_CINVEC_

Cursor.h

#ifndef _CURSOR_HS_
#define _CURSOR_HS_
#include <Windows.h>
#include <string>

void cursor(std::string str)
{
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO cci;

	for (auto& c : str)
		c = tolower(c);

	if (str == "hide")
	{
		// hide the cursor
		GetConsoleCursorInfo(hOut, &cci);
		cci.bVisible = FALSE;
		SetConsoleCursorInfo(hOut, &cci);
	}
	else if (str == "show")
	{
		// show the cursor
		GetConsoleCursorInfo(hOut, &cci);
		cci.bVisible = TRUE;
		SetConsoleCursorInfo(hOut, &cci);
	}
}

#endif // !_CURSOR_

Det.h

#ifndef _DET_
#define _DET_
#include <deque>

double sign = 1;

void change_sequence(unsigned& n, std::deque<std::deque<double>>& d)
{
//  int have_or_not = 0; // to indicate if there is none-zero number in the first column
	if (d[0][0] == 0)
	{
		for (unsigned i = 1; i != n; i++)
		{
			if (d[i][0] != 0)
			{
				for (int j = 0; j != n; j++)
					std::swap(d[i][j], d[0][j]); // swap lines
				sign = -sign;
				break;
			}
		}
	}
	if (d[0][0] == 0) // if none of them is not zero
	{
		n = 1;
		d = { {0} };
	}
}

void shrink(unsigned& n, std::deque<std::deque<double>>& d)
{
	if (n != 1 && n != 2)
	{
		for (unsigned i = 1; i != n; i++)
			for (unsigned j = n - 1; j != 0; j--)
				d[i][j] -= d[0][j] * d[i][0] / d[0][0];
		sign *= d[0][0];
		for (unsigned i = 1; i != n; i++)
			d[i].pop_front();
		d.pop_front();
		n--;
	}
}

double det_is(std::deque<std::deque<double>> d)
{
	unsigned n = d.size();
	double ret = 0;
	while (n > 2)
	{
		change_sequence(n, d);
		shrink(n, d);
	}
	if (n == 1)
	{
		ret = sign * d[0][0];
		sign = 1;
	}
	else
	{
		ret = sign * (d[0][0] * d[1][1] - d[0][1] * d[1][0]);
		sign = 1;
	}
	return ret;
}

void det()
{
	std::cout << "Please input a determinant:\n" << std::endl;
	std::deque<std::deque<double>> det;
	cinvec_s(det);
	std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
	std::cout << "det = " << ((det_is(det) != -0) ? det_is(det) : 0) << std::endl;
	std::cout << "\n=================================================================\n" << std::endl;
	sign = 1;
}

#endif // !_DET_

Formula.h

#ifndef _FORMULA_
#define _FORMULA_
#include "Cinvec.h"
#include "Fraction.h"
#include "Cursor.h"
#include <Windows.h>

void formula()
{
	int num;
	unsigned m = 0;
	std::deque<std::deque<double>> mat;
	std::deque<std::deque<std::deque<double>>> D;

	// instruction
	std::cout << "Please input in this sequence:\n"
		<< "a_11 * x_1 + a_12 * x_2 + ... + a_1n * x_n = b_1\n"
		<< "a_21 * x_1 + a_22 * x_2 + ... + a_2n * x_n = b_2\n"
		<< "...\n"
		<< "a_n1 * x_1 + a_n2 * x_2 + ... + a_nn * x_n = b_n"
		<< "\n" << std::endl;

	// input
	while (1)
	{
		std::deque<double> row;
		while (std::cin >> num)
		{
			row.push_back(num);
			if (getchar() == '\n') break;
		}
		mat.push_back(row);
		m = (row.size() > m) ? row.size() : m;
		if (mat.size() >= m - 1) break;
	}

	for (unsigned i = 0; i < m; i++)
	{
		std::deque<std::deque<double>> temp = mat; // D[m - 1][m]
		for (unsigned j = 0; j != m - 1; j++)
		{
			if (i) temp[j][i - 1] = mat[j][m - 1];
			temp[j].pop_back();
		}
		D.push_back(temp);
	}

	cursor("hide");

	// calculate & print
	double D0 = det_is(D[0]);
	if (D0 != 0)
	{
		std::cout << "\n-----------------------------------------------------------------\n"
			<< "By default you view the solution in the FRACTION form.\n"
			<< "You can switch to DECIMAL by any keyboard press except Enter.\n"
			<< "Press Enter to end the calculation.\n"
			<< "-----------------------------------------------------------------\n" << std::endl;
		for (unsigned i = 1; i < m; i++)
		{
			std::cout << "x_" << i << " = " << decimal_to_fraction(det_is(D[i]) / D0) << std::endl;
		}
		while (1)
		{
			if (_kbhit())
			{
				if (_getch() != '\r') // not Enter
				{
					// This is used to get the second char,
					// because some keyboard presses have two chars.
					if (_getch());
					// return to the front of the line (\r)
					// cover the initial input by pressing the keyboard
					std::cout << "\r\t\r\n-----------------------------------------------------------------\n" << std::endl;
					for (unsigned i = 1; i < m; i++)
					{
						std::cout << "x_" << i << " = " << det_is(D[i]) / D0 << std::endl;
					}
				}
				else std::cout << "\r";
				std::cout << "\n=================================================================" << std::endl;
				break;
			}
		}
	}
	else
	{
		std::cout << "\n-----------------------------------------------------------------" << std::endl;
		std::cout << "\nNo finite solution!" << std::endl;
		std::cout << "\n=================================================================" << std::endl;
	}
	std::cout << std::endl;

	cursor("show");
}
#endif // !_FORMULA_

Fraction.h

#ifndef _FRACTION_
#define _FRACTION_
#include <string>
#include <vector>

constexpr double epsilon = 1E-10;

std::string decimal_to_fraction(double n)
{
	std::string fra = "";
	std::string sgn = (n >= 0) ? "" : "-";
	n = fabs(n);
	if (n - static_cast<int>(n) < epsilon)
	{
		fra = std::to_string(static_cast<int>((sgn == "") ? n : -n));
		return fra;
	}
	else if (n - static_cast<int>(n) > 1 - epsilon)
	{
		fra = std::to_string(static_cast<int>((sgn == "") ? n + 1 : -n - 1));
		return fra;
	}
	else
	{
		std::vector<int> denominator;
		for (int i = 2; i <= 100000; i++)
			denominator.push_back(i);
		for (auto c : denominator) // every prime numbers within 1000
		{
			if (c * n - static_cast<int>(c * n) < epsilon)
			{
				fra = sgn + std::to_string(static_cast<int>(c * n)) + "/" + std::to_string(c);
				return fra;
			}
			if (c * n - static_cast<int>(c * n) > 1 - epsilon)
			{
				fra = sgn + std::to_string(static_cast<int>(c * n) + 1) + "/" + std::to_string(c);
				return fra;
			}
		}
	}
	return std::to_string((sgn == "") ? n : -n);
}

int cal_length(double n)
{
	double temp = n;
	int alr = 1;
	for (int i = 0; i != 9; i++)
	{
		if ((fabs(temp)) < 1)
		{
			alr = max(i, 1);
			break;
		}
		else temp /= 10;
	}
	for (int i = alr; i != 9; i++)
	{
		if (fabs(n - static_cast<int>(n)) < epsilon || fabs(n - static_cast<int>(n)) > 1 - epsilon)
		{
			i = (n >= 0) ? i : i + 1;
			return (i == alr) ? i : i + 1;
		}
		else n *= 10;
	}
	return (n >= 0) ? 9 : 10; // the default length
}

#endif // !_FRACTION_

Inverse.h

#ifndef _INVERSE_
#define _INVERSE_
#include "Cinvec.h"
#include "Algebraic cofactor.h"
#include "Cursor.h"
#include <iomanip>

std::deque<std::deque<double>> inverse_is(std::deque<std::deque<double>> A)
{
	std::deque<std::deque<double>> A_1 = A;
	if (A.size() == 1)
	{
		A_1[0][0] = 1 / A[0][0];
	}
	else
	{
		for (int i = 0; i != A.size(); i++)
		{
			for (int j = 0; j != A.size(); j++)
			{
				A_1[j][i] = exclude(A, i, j) / det_is(A);
			}
		}
	}
	return A_1;
}

void inverse()
{
	std::deque<std::deque<double>> A;
	std::cout << "Please input an n-order Matrix:\n" << std::endl;
	cinvec_s(A);
	cursor("hide");
	std::cout << "\n-----------------------------------------------------------------" << std::endl;
	if (fabs(det_is(A)) < epsilon)
	{
		std::cout << "\nIt is a singular matrix." << std::endl;
	}
	else
	{
		std::cout << "By default you view the result in the FRACTION form.\n"
			<< "You can switch to DECIMAL by any keyboard press except Enter.\n"
			<< "Press Enter to end the calculation.\n"
			<< "-----------------------------------------------------------------\n" << std::endl;
		std::cout << "The inversed matrix is:\n" << std::endl;
		std::deque<std::deque<double>> A_1 = inverse_is(A);
		int length = 0;
		for (int i = 0; i != A_1.size(); i++)
		{
			for (int j = 0; j != A_1.size(); j++)
			{
				length = max(length, decimal_to_fraction(A_1[i][j]).length());
			}
		}
		std::cout << "┌" << std::setw(A_1.size() * (length + 1) + 2) << "┐" << std::endl;
		for (auto c1 : A_1)
		{
			std::cout << "│";
			for (auto c2 : c1)
			{
				std::cout << std::setw(length + 1) << decimal_to_fraction(c2);
			}
			std::cout << "│" << std::endl;
		}
		std::cout << "└" << std::setw(A_1.size() * (length + 1) + 2) << "┘" << std::endl;

		while (1)
		{
			if (_kbhit())
			{
				if (_getch() != '\r') // not Enter
				{
					// This is used to get the second char,
					// because some keyboard presses have two chars.
					if (_getch());
					// return to the front of the line (\r)
					// cover the initial input by pressing the keyboard
					std::cout << "\r\t\r\n-----------------------------------------------------------------\n" << std::endl;
					length = 0;
					for (int i = 0; i != A_1.size(); i++)
					{
						for (int j = 0; j != A_1.size(); j++)
						{
							length = max(length, cal_length(A_1[i][j]));
						}
					}
					std::cout << "┌" << std::setw(A_1.size() * (length + 1) + 2) << "┐" << std::endl;
					for (auto c1 : A_1)
					{
						std::cout << "│";
						for (auto c2 : c1)
						{
							std::cout << std::setw(length + 1) << c2;
						}
						std::cout << "│" << std::endl;
					}
					std::cout << "└" << std::setw(A_1.size() * (length + 1) + 2) << "┘" << std::endl;
				}
				break;
			}
		}
	}
	std::cout << "\n=================================================================\n" << std::endl;
}
#endif // ! _INVERSE_

Multiply.h

#ifndef _MULTIPLY_
#define _MULTIPLY_
#include "Cinvec.h"
#include "Fraction.h"
#include <iomanip>

void multiply()
{
	unsigned m = 0, s = 0, t = 0, n = 0;
	std::vector<std::vector<double>> A, B, C; //A[m][s], B[t][n], C[m][n]

	int index = 0;
	std::string str;
	std::vector<double> row1;
	std::cout << "Please input Matrix A, input 'end' after finishing inputting.\n" << std::endl;
	do
	{
		row1 = cinvec_d(str, index);
		s = (row1.size() > s) ? row1.size() : s;
		if (!row1.empty())A.push_back(row1);
		row1.clear();
	} while (index == 0);
	m = A.size();

	index = 0;
	std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
	std::cout << "Please input Matrix B, input 'end' after finishing inputting.\n" << std::endl;
	std::vector<double> row2;
	do
	{
		row2 = cinvec_d(str, index);
		n = (row2.size() > n) ? row2.size() : n;
		if (!row2.empty()) B.push_back(row2);
		row2.clear();
	} while (index == 0);
	t = B.size();

	// define C
	for (int i3 = 0; i3 != m; i3++)
	{
		std::vector<double> dvec;
		for (int j3 = 0; j3 != n; j3++)
			dvec.push_back(0);
		C.push_back(dvec);
	}

	// calculate

	int length = 0;
	if (s == t)
	{
		for (int i3 = 0; i3 != m; i3++)
		{
			for (int j3 = 0; j3 != n; j3++)
			{
				for (int k = 0; k != s; k++)
				{
					if (C.size() == m && C[i3].size() == n)
					{
						C[i3][j3] += A[i3][k] * B[k][j3];
						length = max(length, cal_length(C[i3][j3]));
					}
					else
					{
						std::cout << "\nError!" << std::endl;
						std::cout << "\n=================================================================\n" << std::endl;
						return;
					}
				}
			}
		}
		std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
		std::cout << "Matrix A * B =\n" << std::endl;
		std::cout << "┌" << std::setw(m * (length + 1) + 2) << "┐" << std::endl;
		for (auto c1 : C)
		{
			std::cout << "│";
			for (auto c2 : c1)
			{
				std::cout << std::setw(length + 1) << c2;
			}
			std::cout << "│" << std::endl;
		}
		std::cout << "└" << std::setw(m * (length + 1) + 2) << "┘" << std::endl;
	}
	else
	{
		std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
		std::cout << "\nError!" << std::endl;
	}
	std::cout << "\n=================================================================\n" << std::endl;
}
#endif // !_MULTIPLY_

Transpose.h

#ifndef _TRANSPOSE_
#define _TRANSPOSE_
#include "Cinvec.h"
#include "Fraction.h"
#include <iomanip>

void transpose()
{
	int m = 0, s = 0;
	std::deque<std::deque<double>> to_T; // to_T[m][s]
	std::cout << "Please input a Matrix, input 'end' after finishing inputting.\n" << std::endl;

	int index = 0;
	std::string str;
	std::deque<double> row1;
	do
	{
		row1 = cindeq_d(str, index);
		s = (row1.size() > s) ? row1.size() : s;
		if (!row1.empty())to_T.push_back(row1);
		row1.clear();
	} while (index == 0);
	m = to_T.size();

	int length = 0;
	std::vector<std::vector<double>> opt;
	for (int j = 0; j != s; j++)
	{
		std::vector<double> temp;
		for (int i = 0; i != m; i++)
		{
			if (to_T[i].size() != s || to_T.size() != m)
			{
				std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
				std::cerr << "Illeagal input!" << std::endl;
				std::cout << "\n=================================================================\n" << std::endl;
				return;
			}
			else
			{
				temp.push_back(to_T[i][j]);
				length = max(length, cal_length(to_T[i][j]));
			}
		}
		opt.push_back(temp);
	}
	std::cout << "\n-----------------------------------------------------------------\n" << std::endl;
	std::cout << "The transposed matrix is:" << std::endl;
	std::cout << "┌" << std::setw(m * (length + 1) + 2) << "┐" << std::endl;
	for (auto c1 : opt)
	{
		std::cout << "│";
		for (auto c2 : c1)
		{
			std::cout << std::setw(length + 1) << c2;
		}
		std::cout << "│" << std::endl;
	}
	std::cout << "└" << std::setw(m * (length + 1) + 2) << "┘" << std::endl;
	std::cout << "\n=================================================================\n" << std::endl;
}

#endif // !_TRANSPOSE_

分析

ALL RIGHTS RESERVED © 2020 Teddy van Jerry
欢迎转载，转载请注明出处。

See also

Teddy van Jerry 的导航页

Teddy van Jerry
关注
专栏目录
关于matlab的简介,Matlab 简介
weixin_42351362的博客
03-19 1428
&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbspMatlab(Matrix Laboratory)的中文名叫矩阵实验室，是一款著名的科学计算软件，也指这个软件中使用的编程语言．这里仅介绍最基本的 Matlab 功能和语法，且仅介绍本书使用到的功能．界面介绍图 1：Matlab 的 IDE 界面Matlab 的编程界面(图...
【C++ 程序】 TVJ Complex Calculator (v 2.2) 复数计算器
Teddy van Jerry的博客
12-28 940
这是一个用 Visual C++ 做的控制台界面复数计算器程序，支持多种复数有关运算以及混合运算。
【C++ 程序】 TVJ Matrix Laboratory (v 1.0)
Teddy van Jerry的博客
11-15 314
这是一个用 Visual C++做的关于线性代数（尤其是与矩阵相关的计算）的小软件。 产品版本：1.0 文件版本：1.0.2.9 大小：117 KB 语言：英语 版权：Teddy van Jerry
matlab矩阵代数计算,Matlab 原来是 Matrix Laboratory( 矩阵实验室)的缩写，主要用来处理矩阵等代数运算，后来发展为通用科技计算、图视交互系统和程序语言。...
weixin_42400518的博客
03-16 569
MatlabMatrix Laboratory()Matlab2070Cleve Moler Fortran1983Cleve MolerJohn Little C1984 Cleve MolerJohn LittleMathWorksMMatlabCtrl-p Ctrl-n Ctrl-b Ctrl-fCtrl+ Ctrl-rCtrl+ Ctrl-lHomeCtrl-aEndCtrl-eEscCt...
matlab_矩阵和数组
战士小小白的博客
12-13 210
官方： MATLAB是“matrix laboratory”的缩写形式。MATLAB® 主要用于处理整个的矩阵和数组，而其他编程语言大多逐个处理数值。 所有 MATLAB 变量都是多维数组，与数据类型无关。矩阵是指通常用来进行线性代数运算的二维数组。 数组创建 要创建一维数组，每个元素可以用逗号或者空格隔开，这种数组为行向量数组 如果要创建一个两行三列（2×3）的矩阵，可以使用分号来控制 也可以使用函数来创建矩阵，示例如下 矩阵和数组运算 matlab支持单一运算符或...
【MATLAB速成】知识点总结（通俗易懂，学不会来打我）
最新发布
道阻且长，行则将至。
05-30 4361
MATLAB的中文名称是（矩阵实验室），英文全称是，是一种以（矩阵计算）为基础的交互式程序语言。它是MathWorks公司推出的一套高性能的数值分析计算软件。组成主要包含两部分：核心部分和可选的功能项。
TVJ Matrix Laboratory (v 1.1)
11-17
这是 Teddy van Jerry 自己编写的小软件，在一定程度上可以替代 Matlab（目前已开发出五个与矩阵有关的功能，是 v 1.0 的升级版），源代码见我的博客 ...
TVJ Matrix Laboratory (v 1.0)
11-16
这是 Teddy van Jerry 自己编写的小软件，在一定程度上可以替代 Matlab（目前已开发出四个与矩阵有关的功能），源代码见我的博客 https://blog.csdn.net/weixin_50012998/article/details/109705109。
【C++ 程序】 tvj::Polygon类 （多边形类）
Teddy van Jerry的博客
01-04 2525
代码 Polygon.h /* * Project: Polygon Class * File: Polygon.h * ------------------ * * @author: Teddy van Jerry * * @version: 2021/01/03 * - initial version */ /////////////////////////////////////////////////// // NOTE: // The class name Poly
TVJ Complex Calculator (v 2.2)
12-29
这是一个用 Visual C++ 做的控制台界面复数计算器程序，支持多种复数有关运算以及混合运算。（设计：Teddy van Jerry）（程序内含帮助的链接）（在2.1版本上修复了bug，并在 simple test 中添加了内容）
Laboratory.rar
05-27
后台采用技术： SSM框架(SpringMVC + Spring + Mybatis) 前台采用技术： div + css + easyui框架
matlab入门（适合初学者）
热门推荐
cnds123的专栏
08-15 4万+
matlab入门 MATLAB 是“matrix laboratory”的缩写形式。MATLAB® 主要用于处理整个的矩阵和数组，而其他编程语言大多逐个处理数值。矩阵是指通常用来进行线性代数运算的二维数组。 MATLAB 是美国MathWorks公司出品的商业数学软件，用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分。...
MATLAB基础知识（01）
twg666的博客
02-12 4102
MATLAB是矩阵实验室（Matrix Laboratory）的简称，是一种用于算法开发、数据可视化、数据分析及数值计算的高级技术计算语言和交互式环境。MATLAB的应用范围非常广，包括信号和图像处理、通信、控制系统设计、测试和测量、财务建模和分析，以及计算生物学等众多应用领域。
c++矩阵转置_线性代数中的向量矩阵
weixin_39541767的博客
11-22 1079
目录前言符号约定向量的基本性质 【定义，基向量，线性相关/无关*，向量点积】矩阵的基本性质 【转置，广播，线性变换】矩阵基本运算 【矩阵相乘，矩阵点积】行列式 【概念，性质，右手法则，行列式计算】逆矩阵 【线性方程组，列空间与秩】特征分解和迹* 【特征值，迹的性质】函数与向量 【函数与向量的联系，矩阵求导】注：带 * 需要重点去看一、前言首先很感谢 Zsank 这位同学...
基于MATLAB的数字图像处理仿真软件
matlab1998_vx的博客
02-13 1672
1 引言1.1MATLAB介绍MATLAB是矩阵实验室（Matrix Laboratory）的简称，是美国MathWorks公司出品的商业数学软件，用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分。 MATLAB是由美国mathworks公司发布的主要面对科学计算、可视化以及交互式程序设计的高科技计算环境。它将数值分析、矩...
c语言矩阵转置再编写主函数,实现矩阵的输入与转置后矩阵的输出,用C语言编写一个矩阵转置的函数,矩阵的行数和列数在程序中由用户输入，请问怎么写，非常感谢...
weixin_36296983的博客
05-20 1403
满意答案gbwag2015.10.14采纳率：42%等级：9已帮助：667人我的代码逻辑是：矩阵行指针初值指向每行首地址，迭代依次取所有行指针指向值组成新行，所有行指针自增。最终组合新的矩阵。#include#includeint**getList(introw,intclo);//获取矩阵地址空间voidsetNum(int**nList,intn);//填写数值void...
编写C语言程序实现矩阵的转置
AndrewYZWang的博客
03-24 1万+
**#include <stdio.h> #include <conio.h> #include <stdlib.h>void fun (int array[3][3]) { int i,j,temp[3][3]; for(i=0;i<3;i++) { for(j=0;j<3;j++) { temp[i][j]=array[j][i];
【C++ 程序】 小游戏汇编
Teddy van Jerry的博客
11-07 1万+
用 C++ 编写小游戏是在获得乐趣的同时学习到 C++ 的实用技能。 控制台界面 【C++ 程序】 井字棋游戏（人 VS 人） 【C++ 程序】 井字棋游戏（人 VS Lv1电脑） 【C++ 程序】 井字棋游戏（人 VS Lv2电脑） 【C++ 程序】 井字棋游戏（人 VS Lv3电脑） 【C++ 程序】 井字棋游戏（人 VS Lv3电脑）（战绩统计版） 【C++ 程序】 五子棋游戏（人 VS 人） 【C++ 程序】 五子棋游戏（人 VS Lv1电脑）（思路及框架，内容待填充） 【C++ 程序】 移动迷
【C++ 程序】 井字棋游戏（人 VS 人）
Teddy van Jerry的博客
08-31 5896
本来有一个现成的程序，只不过是老版 C++/C 的，复制进 Visual Studio 2019 会报错： 然后修改了仍然不太好用，于是决定自己写一个，耗时1.5小时。 以下是程序：（分析见程序下面）： 程序 //This program is a simple tic-tac-toe game. #include <iostream> #include <string> #include <cstddef> #include <stdexcept> us
2021春季数据结构课程-单链表合并与排序报告
forward_list的功能，如迭代器支持，可以在GitHub（https://github.com/Teddy-van-Jerry/TVJ_Forward_List）或CSDN博客（https://blog.csdn.net/weixin_50012998/article/details/115029881）上找到代码版本v1.1更新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值