Find out normal and trace in square matrix
Here given code implementation process.
/*
C Program
+ Find normal and trace of a matrix
*/
#include <stdio.h>
#include <math.h>
#define SIZE 3
void find_normal_trace(int matrix[][SIZE])
{
if(SIZE <=0 )
{
return;
}
int normal = 0;
//Calculate Normal
for (int i = 0; i < SIZE; ++i)
{
for (int j = 0; j < SIZE; ++j)
{
normal += matrix[i][j] * matrix[i][j];
}
}
printf(" Normal : %d\n",(int)sqrt(normal) );
//Calculate Trace
//This is sum of diagonal elements
int trace = matrix[0][0];
for (int i = 1; i < SIZE; ++i)
{
for (int j = 0; j < SIZE; ++j)
{
if(i == j )
{
//Calculate sum of diagonal elements
trace += matrix[i][j];
}
}
}
printf(" Trace : %d\n",trace );
}
void show_data(int matrix[][SIZE])
{
for (int i = 0; i < SIZE; ++i)
{
for (int j = 0; j < SIZE; ++j)
{
printf("%3d",matrix[i][j] );
}
printf("\n");
}
printf("\n");
}
int main(){
int matrix[][SIZE] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 3}
};
show_data(matrix);
find_normal_trace(matrix);
return 0;
}
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9/*
C++ Program
Find normal and trace of a matrix
*/
#include<iostream>
#include <math.h>
#define SIZE 3
using namespace std;
class MyMatrix {
public:
int size;
MyMatrix() {
//Get matrix size
//Assume that given matrix size is NXN
this->size = SIZE;
}
void find_normal_trace(int matrix[][SIZE]) {
if (this->size <= 0) {
return;
}
int normal = 0;
//Calculate Normal
for (int i = 0; i < this->size; ++i) {
for (int j = 0; j < this->size; ++j) {
normal += matrix[i][j] *matrix[i][j];
}
}
cout << " Normal : " << (int) sqrt(normal) << "\n";
//Calculate Trace
//This is sum of diagonal elements
int trace = matrix[0][0];
for (int i = 1; i < this->size; ++i) {
for (int j = 0; j < this->size; ++j) {
if (i == j) {
//Calculate sum of diagonal elements
trace += matrix[i][j];
}
}
}
cout << " Trace : " << trace << "\n";
}
void show_data(int matrix[][SIZE]) {
for (int i = 0; i < this->size; ++i) {
for (int j = 0; j < this->size; ++j) {
cout << " " << matrix[i][j];
}
cout << "\n";
}
cout << "\n";
}
};
int main() {
int matrix[][SIZE] = {
{
1,
2,
3
},
{
4,
5,
6
},
{
7,
8,
3
}
};
MyMatrix obj;
obj.show_data(matrix);
obj.find_normal_trace(matrix);
return 0;
}
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9/*
Java Program
Find normal and trace of a matrix
*/
public class MyMatrix {
public int size;
public MyMatrix(int [][]matrix)
{
//Get matrix size
//Assume that given matrix size is NXN
this.size = matrix.length;
}
public void find_normal_trace(int [][]matrix)
{
if(this.size <=0 )
{
return;
}
int normal = 0;
//Calculate Normal
for (int i = 0; i < this.size; ++i)
{
for (int j = 0; j < this.size; ++j)
{
normal += matrix[i][j] * matrix[i][j];
}
}
System.out.print(" Normal : "+(int)Math.sqrt(normal)+"\n" );
//Calculate Trace
//This is sum of diagonal elements
int trace = matrix[0][0];
for (int i = 1; i < this.size; ++i)
{
for (int j = 0; j < this.size; ++j)
{
if(i == j )
{
//Calculate sum of diagonal elements
trace += matrix[i][j];
}
}
}
System.out.print(" Trace : "+trace+"\n" );
}
public void show_data(int [][]matrix)
{
for (int i = 0; i < this.size; ++i)
{
for (int j = 0; j < this.size; ++j)
{
System.out.print(" "+matrix[i][j] );
}
System.out.print("\n");
}
System.out.print("\n");
}
public static void main(String[] args)
{
//Define matrix element
int [][]matrix =
{
{1, 2, 3},
{4, 5, 6},
{7, 8, 3}
};
MyMatrix obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.find_normal_trace(matrix);
}
}
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9/*
C# Program
Find normal and trace of a matrix
*/
using System;
public class MyMatrix {
int size;
MyMatrix(int[,] matrix) {
//Get matrix size
//Assume that given matrix size is NXN
this.size = matrix.GetLength(0);
}
public void find_normal_trace(int[,] matrix) {
if (this.size <= 0) {
return;
}
int normal = 0;
//Calculate Normal
for (int i = 0; i < this.size; ++i) {
for (int j = 0; j < this.size; ++j) {
normal += matrix[i,j] * matrix[i,j];
}
}
Console.Write(" Normal : " + (int) Math.Sqrt(normal) + "\n");
//Calculate Trace
//This is sum of diagonal elements
int trace = matrix[0,0];
for (int i = 1; i < this.size; ++i) {
for (int j = 0; j < this.size; ++j) {
if (i == j) {
//Calculate sum of diagonal elements
trace += matrix[i,j];
}
}
}
Console.Write(" Trace : " + trace + "\n");
}
public void show_data(int[,] matrix) {
for (int i = 0; i < this.size; ++i) {
for (int j = 0; j < this.size; ++j) {
Console.Write(" " + matrix[i,j]);
}
Console.Write("\n");
}
Console.Write("\n");
}
public static void Main(String[] args) {
int[,]
//Define matrix element
matrix = {
{
1,
2,
3
},
{
4,
5,
6
},
{
7,
8,
3
}
};
MyMatrix obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.find_normal_trace(matrix);
}
}
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9<?php
/*
Php Program
Find normal and trace of a matrix
*/
class MyMatrix {
public $size;
function __construct($matrix) {
//Get matrix size
//Assume that given matrix size is NXN
$this->size = count($matrix);
}
public function find_normal_trace($matrix) {
if ($this->size <= 0) {
return;
}
$normal = 0;
//Calculate Normal
for ($i = 0; $i < $this->size; ++$i) {
for ($j = 0; $j < $this->size; ++$j) {
$normal += $matrix[$i][$j] *$matrix[$i][$j];
}
}
echo(" Normal : ". intval(sqrt($normal)) ."\n");
//Calculate Trace
//This is sum of diagonal elements
$trace = $matrix[0][0];
for ($i = 1; $i < $this->size; ++$i) {
for ($j = 0; $j < $this->size; ++$j) {
if ($i == $j) {
//Calculate sum of diagonal elements
$trace += $matrix[$i][$j];
}
}
}
echo(" Trace : ". $trace ."\n");
}
public function show_data($matrix) {
for ($i = 0; $i < $this->size; ++$i) {
for ($j = 0; $j < $this->size; ++$j) {
echo(" ". $matrix[$i][$j]);
}
echo("\n");
}
echo("\n");
}
}
function main() {
//Define matrix element
$matrix = array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 3));
$obj = new MyMatrix($matrix);
$obj->show_data($matrix);
$obj->find_normal_trace($matrix);
}
main();
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9/*
Node Js Program
Find normal and trace of a matrix
*/
class MyMatrix {
;
constructor(matrix) {
//Get matrix size
//Assume that given matrix size is NXN
this.size = matrix.length;
}
find_normal_trace(matrix) {
if (this.size <= 0) {
return;
}
var normal = 0;
//Calculate Normal
for (var i = 0; i < this.size; ++i) {
for (var j = 0; j < this.size; ++j) {
normal += matrix[i][j] *matrix[i][j];
}
}
process.stdout.write(" Normal : " + parseInt(Math.sqrt(normal)) + "\n");
//Calculate Trace
//This is sum of diagonal elements
var trace = matrix[0][0];
for (var i = 1; i < this.size; ++i) {
for (var j = 0; j < this.size; ++j) {
if (i == j) {
//Calculate sum of diagonal elements
trace += matrix[i][j];
}
}
}
process.stdout.write(" Trace : " + trace + "\n");
}
show_data(matrix) {
for (var i = 0; i < this.size; ++i) {
for (var j = 0; j < this.size; ++j) {
process.stdout.write(" " + matrix[i][j]);
}
process.stdout.write("\n");
}
process.stdout.write("\n");
}
}
function main(args) {
//Define matrix element
var matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 3]
];
var obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.find_normal_trace(matrix);
}
main();
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9# Python 3 Program
# Find normal and trace of a matrix
import math
class MyMatrix :
def __init__(self, matrix) :
# Get matrix size
# Assume that given matrix size is NXN
self.size = len(matrix)
def find_normal_trace(self, matrix) :
if (self.size <= 0) :
return
normal = 0
# Calculate Normal
i = 0
while (i < self.size) :
j = 0
while (j < self.size) :
normal += matrix[i][j] * matrix[i][j]
j += 1
i += 1
print(" Normal : ", int(math.sqrt(normal)) ,"\n", end = "")
trace = matrix[0][0]
i = 1
while (i < self.size) :
j = 0
while (j < self.size) :
if (i == j) :
# Calculate sum of diagonal elements
trace += matrix[i][j]
j += 1
i += 1
print(" Trace : ", trace ,"\n", end = "")
def show_data(self, matrix) :
i = 0
while (i < self.size) :
j = 0
while (j < self.size) :
print(" ", matrix[i][j], end = "")
j += 1
print("\n", end = "")
i += 1
print("\n", end = "")
def main() :
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 3]
]
obj = MyMatrix(matrix)
obj.show_data(matrix)
obj.find_normal_trace(matrix)
if __name__ == "__main__":
main()
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9# Ruby Program
# Find normal and trace of a matrix
class MyMatrix
# Define the accessor and reader of class MyMatrix
attr_reader :size
attr_accessor :size
def initialize(matrix)
# Get matrix size
# Assume that given matrix size is NXN
self.size = matrix.length
end
def find_normal_trace(matrix)
if (self.size <= 0)
return
end
normal = 0
# Calculate Normal
i = 0
while (i < self.size)
j = 0
while (j < self.size)
normal += matrix[i][j] * matrix[i][j]
j += 1
end
i += 1
end
print(" Normal :", (Math.sqrt(normal)).to_i ,"\n")
trace = matrix[0][0]
i = 1
while (i < self.size)
j = 0
while (j < self.size)
if (i == j)
# Calculate sum of diagonal elements
trace += matrix[i][j]
end
j += 1
end
i += 1
end
print(" Trace :", trace ,"\n")
end
def show_data(matrix)
i = 0
while (i < self.size)
j = 0
while (j < self.size)
print(" ", matrix[i][j])
j += 1
end
print("\n")
i += 1
end
print("\n")
end
end
def main()
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 3]
]
obj = MyMatrix.new(matrix)
obj.show_data(matrix)
obj.find_normal_trace(matrix)
end
main()
Output
1 2 3
4 5 6
7 8 3
Normal :14
Trace :9
/*
Scala Program
Find normal and trace of a matrix
*/
class MyMatrix(var size: Int) {
;
def this(matrix: Array[Array[Int]]) {
//Get matrix size
//Assume that given matrix size is NXN
this(matrix.length);
}
def find_normal_trace(matrix: Array[Array[Int]]): Unit = {
if (this.size <= 0) {
return;
}
var normal: Int = 0;
//Calculate Normal
var i: Int = 0;
var j: Int = 0;
while (i < this.size) {
j = 0;
while (j < this.size) {
normal += matrix(i)(j) * matrix(i)(j);
j += 1;
}
i += 1;
}
print(" Normal : " + (Math.sqrt(normal)).toInt + "\n");
var trace: Int = matrix(0)(0);
i = 1;
while (i < this.size) {
j = 0;
while (j < this.size) {
if (i == j) {
//Calculate sum of diagonal elements
trace += matrix(i)(j);
}
j += 1;
}
i += 1;
}
print(" Trace : " + trace + "\n");
}
def show_data(matrix: Array[Array[Int]]): Unit = {
var i: Int = 0;
while (i < this.size) {
var j: Int = 0;
while (j < this.size) {
print(" " + matrix(i)(j));
j += 1;
}
print("\n");
i += 1;
}
print("\n");
}
}
object Main {
def main(args: Array[String]): Unit = {
val matrix: Array[Array[Int]] = Array(
Array(1, 2, 3),
Array(4, 5, 6),
Array(7, 8, 3));
val obj: MyMatrix = new MyMatrix(matrix);
obj.show_data(matrix);
obj.find_normal_trace(matrix);
}
}
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9/*
Swift Program
Find normal and trace of a matrix
*/
import Foundation
class MyMatrix {
var size: Int;
init(_ matrix: [
[Int]
]) {
//Get matrix size
//Assume that given matrix size is NXN
self.size = matrix.count;
}
func find_normal_trace(_ matrix: [
[Int]
]) {
if (self.size <= 0) {
return;
}
var normal: Int = 0;
//Calculate Normal
var i: Int = 0;
var j: Int = 0;
while (i < self.size) {
j = 0;
while (j < self.size) {
normal += matrix[i][j] * matrix[i][j];
j += 1;
}
i += 1;
}
print(" Normal : ", Int(sqrt(Double(normal))) ,"\n", terminator: "");
var trace: Int = matrix[0][0];
i = 1;
while (i < self.size) {
j = 0;
while (j < self.size) {
if (i == j) {
//Calculate sum of diagonal elements
trace += matrix[i][j];
}
j += 1;
}
i += 1;
}
print(" Trace : ", trace ,"\n", terminator: "");
}
func show_data(_ matrix: [
[Int]
]) {
var i: Int = 0;
while (i < self.size) {
var j: Int = 0;
while (j < self.size) {
print(" ", matrix[i][j], terminator: "");
j += 1;
}
print("\n", terminator: "");
i += 1;
}
print("\n", terminator: "");
}
}
func main() {
let matrix: [
[Int]
] = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 3]
];
let obj: MyMatrix = MyMatrix(matrix);
obj.show_data(matrix);
obj.find_normal_trace(matrix);
}
main();
Output
1 2 3
4 5 6
7 8 3
Normal : 14
Trace : 9
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment