spimB-2

.data
str1: .asciiz "Enter int-number:"
ans1: .asciiz "square:"
ans2: .asciiz "square root:"
Unsuitable_text: .asciiz "! The square root of a negative number does not exist !"
eol: .asciiz "\n"
.text
.globl main


main:
li $v0, 4
la $a0, str1
syscall

li $v0, 5
syscall
move $a1, $v0
mul $t0, $a1, $a1

li $v0, 4
la $a0, ans1
syscall
li $v0, 1
move $a0, $t0
syscall
li $v0, 4
la $a0, eol
syscall

bgt $zero, $a1, Unsuitable
jal sqrt
move $t1, $v0

li $v0, 4
la $a0, ans2
syscall
li $v0, 1
move $a0, $t1
syscall
li $v0, 4
la $a0, eol
syscall
j main


Unsuitable:
li $v0, 4
la $a0, Unsuitable_text
syscall
la $a0, eol
syscall
j main

sqrt:
move $v0, $zero
sqrt_loop:
mul $t0, $v0, $v0
bgt $t0, $a1, exit
addi $v0, $v0, 1
j sqrt_loop
exit:
addi $t1, $v0, -1
mul $t1, $t1, $t1
sub $t0, $a1, $t0 # $t0 > $a1 なので負の数
sub $t1, $a1, $t1 # $t1 < $a1 なので正の数
add $t2, $t0, $t1 # $t1の絶対値が小さければ負=>$v0 - 1がより近似解,$t0の絶対値が小さければ正=>$v0 - 0がより近似解
slti $t0, $t2, 0 # $t2が負ならば1、正ならば0を返す
sub $v0, $v0, $t0 # $v0と$v0 ー 1 の近似解が得られる
jr $ra

spimB-1

.data
open_bracket: .asciiz "["
close_bracket: .asciiz "] = "
str1: .asciiz "Enter int-number:"
str2: .asciiz "Print"
str3: .asciiz "Enter Array size:"
error: .asciiz "!negative number has entered!"
eol: .asciiz "\n"
.text
.globl main

main:
jal Enter
jal Sort
jal Print

Enter:

# "Enter Array size:"を表示
li $v0, 4
la $a0, str3
syscall

#配列のサイズを指定
li $v0, 5
syscall

bgt $v0, $zero, Enter_num

li $v0, 4
la $a0, error
syscall
la $a0, eol
syscall

j Enter

Enter_num:
move $s1, $v0
sll $a0, $v0, 2
li $v0, 9
syscall

move $s0, $v0
move $t0, $zero


Enter_loop:

#"Enter int-number:" を表示
li $v0, 4
la $a0, str1
syscall

# "[n]= "と出力して、入力された整数を格納
la $a0, open_bracket
syscall
li $v0, 1
move $a0, $t0
syscall
li $v0, 4
la $a0, close_bracket
syscall
li $v0, 5
syscall


sll $t1, $t0, 2 # $t0 * 4
add $t1, $t1, $s0 # ベースレジスタを追加
sw $v0, 0($t1)


addi $t0, $t0, 1 #オフセットを更新
bne $t0, $s1, Enter_loop #配列が埋まっていなければ入力を続ける

#改行
li $v0, 4
la $a0, eol

syscall

jr $ra


Print:
move $t0, $zero
li $v0, 4
la $a0, str2
syscall
la $a0, eol
syscall

Print_loop:
la $a0, open_bracket
syscall
li $v0, 1
move $a0, $t0
syscall
li $v0, 4
la $a0, close_bracket
syscall

sll $t1, $t0, 2
add $t1, $t1, $s0
li $v0, 1
lw $a0, 0($t1)
syscall
li $v0, 4
la $a0, eol
syscall

addi $t0, $t0, 1

bne $t0, $s1, Print_loop

la $a0, eol
syscall

jr $ra


Sort:
addi $sp, $sp, -20
sw $ra, 16($sp)
sw $s3, 12($sp)
sw $s2, 8($sp)
sw $s1, 4($sp)
sw $s0, 0($sp)

move $s2, $s0
move $s3, $s1

move $s0, $zero
for1tst:
slt $t0, $s0, $s3
beq $t0, $zero, exit1

addi $s1, $s0, -1
for2tst:
slti $t0, $s1, 0
bne $t0, $zero, exit2
sll $t1, $s1, 2
add $t2, $s2, $t1
lw $t3, 0($t2)
lw $t4, 4($t2)
slt $t0, $t4, $t3
beq $t0, $zero, exit2

move $a0, $s2
move $a1, $s1
jal swap

addi $s1, $s1, -1
j for2tst

exit2:
addi $s0, $s0, 1
j for1tst

exit1:
lw $s0, 0($sp)
lw $s1, 4($sp)
lw $s2, 8($sp)
lw $s3, 12($sp)
lw $ra, 16($sp)
addi $sp, $sp, 20

jr $ra


swap:
sll $t1, $a1, 2
add $t1, $a0, $t1

lw $t0, 0($t1) #
lw $t2, 4($t1) #

sw $t2, 0($t1) #
sw $t0, 4($t1) #

jr $ra

.data
buffer: .space 64
str1: .asciiz "Enter int-number:"
str2: .asciiz "Enter float-number:"
str3: .asciiz "Enter double-number:"
str4: .asciiz "Enter String:"
str5: .asciiz "Enter char:"
ans1: .asciiz "this number is =>"
ans2: .asciiz "this string is =>"
ans3: .asciiz "this char is =>"
eol: .asciiz "\n"
.text
.globl main
main: li $v0,4 # print_stringを格納
la $a0,str1 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,5 # read_int
syscall
move $t0,$v0 # 読み込んだ値を$t0に
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,1 # print_intを格納
move $a0,$t0 # 出力する整数を$a0に格納
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str2 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,6 # read_float
syscall
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,2 # print_floatを格納
mov.s $f12,$f0 # 出力する整数を$f12に格納、単精度
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str3 # asciizの文字列を格納
syscall
li $v0,7 # read_doubleを格納
syscall
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,3 # print_doubleを格納
mov.d $f12,$f0 # 出力する整数を$f12に格納、倍精度
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str4 # asciizの文字列を格納
syscall
li $v0,8 # read_string
la $a0,buffer # 文字サイズbufferを格納
li $a1,20 # Stringのための語長
move $t0,$a0 # $a0を$t0に格納
syscall
li $v0,4 # print_stringを格納
la $a0,ans2 # asciizの文字列を格納
syscall
la $a0,buffer # 語長を再読み込み
move $a0,$t0 # $a0を$t0に格納(読み込みのアドレス)
syscall

li $v0,4 # print_stringを格納
la $a0,str5 # asciizの文字列を格納
syscall
li $v0,12 # read_charを格納
syscall
move $t0,$v0 # 読み込んだ値を$t0に
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall
la $a0,ans3 # asciizの文字列を格納
syscall
li $v0,11 # print_charを格納
move $a0,$t0 # $a0を$t0に格納(読み込みのアドレス)
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall


jr $ra


実行結果例
Enter int-number:1
this number is =>1
Enter float-number:1.2345678
this number is =>1.23456776
Enter double-number:1.2345678
this number is =>1.23456779999999999
Enter String:hogehoge
this string is =>hogehoge
Enter char:!
this char is =>!

考察:int float double String charで読み込んだものをそのまま出力するプログラムを作成した。
   指定されたシステムコールの動作をすべて確認することには成功したが、疑問が残る部分もある。
   5つめに確認をしたchar型の読み込みと出力が1文字しか取ることができず、改行をする前に次の命令に移行してしまう。
   調べたところ、read_charのアウトプットには”$v0 = 文字(改行なし)をエコーする”とあった。
   うまく実行できなかった原因は、print_charのインプットが”$a0 = 文字(下位8ビット)”であるため1文字しか出力できないことかと推測したが、
   解決策はみつからなかった。あるいは、自分が情報をうまく探すことができていないだけでこのchar型ではこれで正しく実行できているのかもしれない。
   1文字は正しく動作しているため大きく間違っているということはないが、より理解を深める必要があるように感じた。
   その他4つについては、String型で語長の設定にとまどった程度で課題スライドと参考資料をもとに作成することができた。

spim

.data
buffer: .space 64
str1: .asciiz "Enter int-number:"
str2: .asciiz "Enter float-number:"
str3: .asciiz "Enter double-number:"
str4: .asciiz "Enter String:"
str5: .asciiz "Enter char:"
ans1: .asciiz "this number is =>"
ans2: .asciiz "this string is =>"
ans3: .asciiz "this char is =>"
eol: .asciiz "\n"
.text
.globl main
main: li $v0,4 # print_stringを格納
la $a0,str1 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,5 # read_int
syscall
move $t0,$v0 # 読み込んだ値を$t0に
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,1 # print_intを格納
move $a0,$t0 # 出力する整数を$a0に格納
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str2 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,6 # read_float
syscall
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,2 # print_floatを格納
mov.s $f12,$f0 # 出力する整数を$f12に格納
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str3 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,7 # read_double
syscall
li $v0,4 # print_stringを格納
la $a0,ans1 # asciizの文字列を格納
syscall
li $v0,3 # print_doubleを格納
la $f0,$f1
mov.s $f12,$f0 # 出力する整数を$f12に格納
syscall
li $v0,4 # print_stringを格納
la $a0,eol # 改行
syscall

li $v0,4 # print_stringを格納
la $a0,str4 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,8 # read_string
la $a0,buffer # 文字サイズbufferを格納
li $a1,20 # Stringのための語長
move $t0,$a0 # $a0を$t0に格納
syscall
li $v0,4 # print_stringを格納
la $a0,ans2 # asciizの文字列を格納
syscall
la $a0,buffer # 語長を再読み込み
move $a0,$t0 # $a0を$t0に格納(読み込みのアドレス)
syscall

li $v0,4 # print_stringを格納
la $a0,str5 # asciizの文字列を格納
syscall # 文字列の出力
li $v0,12 # read_char
syscall

move $t0,$v0 # 読み込んだ値を$t0に
li $v0,4 # print_stringを格納
la $a0,ans3 # asciizの文字列を格納
syscall
li $v0,11 # print_charを格納
move $a0,$t0 # $a0を$t0に格納(読み込みのアドレス)
syscall


jr $ra

a

import java.util.*;
import java.io.*;

public class WUGraph {
int numOfNodes;
ArrayList<Edge> list = new ArrayList<Edge>(); //隣接ノード、重さ//

class Edge implements Comparable<Edge> {
private int to; // 辺番号//
private int weight; //重さ//
private int nodeU, nodeV; //両端ノード//
Edge(int to,int nodeU, int nodeV ,int weight) {this.to = to; this.weight = weight; this.nodeU = nodeU; this.nodeV = nodeV;}
int To() { return to;}
int NodeU() { return nodeU;}
int NodeV() { return nodeV;}
int Weight() { return weight;}
@Override
public int compareTo(Edge e) {
return this.weight - e.weight;
}
}

ArrayList<Edge> getSortedEdges(){
ArrayList<Edge> al = new ArrayList<>(list);
Collections.sort(al);
return al;
}


void LoadGraph(String filename){
try{
Scanner scan = new Scanner(new File(filename));

String Line = scan.nextLine();
String r = Line.split(",",2); //頂点数、 辺の数//

numOfNodes = Integer.parseInt(r[0]);

for(int i = 0; i < Integer.parseInt(r[1]); i++){
String line = scan.nextLine();
String s = line.split(":",0);
String[] t = s[1].split(",",3);

Edge e = new Edge(Integer.parseInt(s[0]),Integer.parseInt(t[0]), Integer.parseInt(t[1]),Integer.parseInt(t[2]));
list.add(e);

}
} catch (java.io.FileNotFoundException e){
System.out.println(e);
System.exit(0);
}
}

ArrayList<Edge> getMST() {
ArrayList<Edge> mst = new ArrayList<Edge>();
ArrayList<Edge> selst = getSortedEdges();
UnionFind uf = new UnionFind(numOfNodes);
for (Edge e : selst) {
if (uf.unite(e.nodeU, e.nodeV)) {
mst.add(e);
}
}
return mst;
}

int getMSTcost() {
ArrayList<Edge> edges= getMST();
int cost = 0;
for (int i = 0; i < edges.size(); i++)
cost = cost + edges.get(i).Weight();
return cost;
}

void printGraph(){
ArrayList<Edge> edges= getMST();
System.out.println(getMSTcost());
System.out.println(numOfNodes + "," + edges.size());
for (int j = 0; j < edges.size() ; j++) {
System.out.println(edges.get(j).To() + ":" + edges.get(j).NodeU() + "," + edges.get(j).NodeV() + "," + edges.get(j).Weight());
}
}
}

kadai2

import java.util.*;
class Dijkstra extends Graph{

int slowDijkstra(int start) {
 double D = new double[nodes.size()]; //頂点ごとへの最短距離//
 int Search = new int [nodes.size()];
 int
tree = new int [nodes.size()];
 int remain = nodes.size() - 1; // ループ回数 //
 for (int i = 0; i < nodes.size() ;i++) {
 D[i] = Double.MAX_VALUE; Search[i] = 1; tree[i] = -1;
 }
  D[start] = 0; Search[start] = 0; tree[start] = start;
 while(remain != 0) {
 int u = 0;  // u:node 軽い//
 double min =  Double.MAX_VALUE;
 for (int j = 0; j < D.length; j++) {  
 if ( min > D[j] && Search[j] == 1)  {
 u = j; min = D[j]; 
  }
 }
 Search[u] = 0;
 for(int k = 0; k < nodes.get(u).Num(); k++) {
 if *1;
 tree[list.get(nodes.get(u).Pointer() + k).To()] = u;
   }
  }
   remain--;
   }
  return tree;
  }
int getShortestPath(int start, int end) {
 ArrayList<Integer> path = new ArrayList<Integer>();
 int tree
= slowDijkstra(start);
 path.add(end);
 while( end != start) {
 path.add(tree[end]);
 end = tree[end];
 }
 int Path = new int [path.size()];
 for (int l = 0; l < path.size(); l++) {
 Path[l] = path.get( (path.size()-1) - l);
 }
 return Path;
 }
}

class DijkstraTester {
public static void main (String args){
 int Tree;
 Dijkstra d = new Dijkstra();
 d.LoadGraph("graph001.txt");
 Tree = d.slowDijkstra(2);
 System.out.print(Tree[0]);
 for (int m = 1; m < Tree.length; m++)
 System.out.print("," + Tree[m]);
 System.out.println();
 int Path = d.getShortestPath(0,4);
 System.out.print(Path[0]);
 for (int n = 1; n < Path.length; n++)
 System.out.print(" " + Path[n]);
  }
 }
 
 
 
 
 
 
 
 
 
 
 
 
import java.util.*;
import java.io.*;
public class Graph {
 int num = 0;
  ArrayList<Edge> list = new ArrayList<Edge>();  //隣接ノード、重さ//
  ArrayList<Node> nodes = new ArrayList<Node>();  //ノード番号、隣接数、先頭オフセット//
 class Edge {
  private int to; private double weight;
  Edge(int to, double weight) {this.to = to; this.weight = weight;}
  int To() { return to;}
  double Weight() { return weight;}
 }
 class Node {
  int id; int Num; int pointer;
  Node (int id,int Num, int pointer) {this.id = id; this.Num = Num; this.pointer = pointer;}
  int Num() {return this.Num;}
  int Id(){ return this.id;}
  int Pointer() { return this.pointer;}
  }

 void LoadGraph(String filename){
 try{
  Scanner scan = new Scanner(new File(filename));
  int pointer = 0;
 while(true){
 if( !scan.hasNextLine()) {
   break;
 }
 String line = scan.nextLine();
 String s = line.split(":",0);
 if (s.length != 1){
 String t = s[1].split(",",0);
 for (int i = 0; i < t.length; i++) {
 String[] u = t[i].split("@",2);
 Edge e = new Edge(Integer.parseInt(u[0]), Double.parseDouble(u[1]));
 list.add(e);
  }
 
 Node n = new Node(Integer.parseInt(s[0]), t.length, pointer);
 nodes.add(n);
 num ++; //ノード数//
 pointer = pointer + t.length ;
  }
 else {
  Node n = new Node(Integer.parseInt(s[0]),0 , pointer);
 nodes.add(n);
 num ++; //ノード数//
 }
 }
 } catch (java.io.FileNotFoundException e){
  System.out.println(e);
  System.exit(0);
  }
 }

 void printGraph(){
 for (int j = 0; j < num ; j++) {
 System.out.print(nodes.get(j).Id() + ":");
 for (int k = 0; k < nodes.get(j).Num(); k++) {
 System.out.print(list.get(nodes.get(j).Pointer() + k).To() + "@" + list.get(nodes.get(j).Pointer()+k).Weight());
 if (k < nodes.get(j).Num() - 1)
 System.out.print(",");
   }
 System.out.println();
  }
 }
}
 
 

*1:D[list.get(nodes.get(u).Pointer() + k).To()] > ( D[u] + list.get(nodes.get(u).Pointer() + k).Weight()))) {
 D[list.get(nodes.get(u).Pointer() + k).To()] =
   ( D[u] + list.get(nodes.get(u).Pointer() + k).Weight(

kadai1

 

import java.util.*;
import java.io.*;
public class Graph {
 int num = 0;
  ArrayList<Edge> list = new ArrayList<Edge>();  //隣接ノード、重さ//
  ArrayList<Node> nodes = new ArrayList<Node>();  //ノード番号、隣接数、先頭オフセット//
 class Edge {
  private int to; private double weight;
  Edge(int to, double weight) {this.to = to; this.weight = weight;}
  int To() { return to;}
  double Weight() { return weight;}
 }
 class Node {
  int id; int Num; int pointer;
  Node (int id,int Num, int pointer) {this.id = id; this.Num = Num; this.pointer = pointer;}
  int Num() {return this.Num;}
  int Id(){ return this.id;}
  int Pointer() { return this.pointer;}
  }

 void LoadGraph(String filename){
 try{
  Scanner scan = new Scanner(new File(filename));
  int pointer = 0;
 while(true){
 if( !scan.hasNextLine()) {
   break;
 }
 String line = scan.nextLine();
 String s = line.split(":",0);
 if (s.length != 1){
 String t = s[1].split(",",0);
 for (int i = 0; i < t.length; i++) {
 String u = t[i].split("@",2);
 Edge e = new Edge(Integer.parseInt(u[0]), Double.parseDouble(u[1]));
 list.add(e);
  }
 
 Node n = new Node(Integer.parseInt(s[0]), t.length, pointer);
 nodes.add(n);
 num ++; //ノード数//
 pointer = pointer + t.length ;
  }
 else {
  Node n = new Node(Integer.parseInt(s[0]),0 , pointer);
 nodes.add(n);
 num ++; //ノード数//
 }
 }
 } catch (java.io.FileNotFoundException e){
  System.out.println(e);
  System.exit(0);
  }
 }

 void printGraph(){
 for (int j = 0; j < num ; j++) {
 System.out.print(nodes.get(j).Id() + ":");
 for (int k = 0; k < nodes.get(j).Num(); k++) {
 System.out.print(list.get(nodes.get(j).Pointer() + k).To() + "@" + list.get(nodes.get(j).Pointer()+k).Weight());
 if (k < nodes.get(j).Num() - 1)
 System.out.print(",");
   }
 System.out.println();
  }
 }
}
 
 
 
 
 
 
import java.util.*;
import java.io.*;
class GraphTester {
 public static void main (String args){
 Graph g = new Graph();
 g.LoadGraph("graph001.txt");
 g.printGraph();
 }
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0:1@2.0,3@6.0,4@1.0
1:6@3.0
2:
3:6@2.0
4:5@2.0
5:3@1.0,2@2.0
6:2@4.0