JAVA APPLE在DSP學習網頁上的應用

逢逢逢逢甲甲甲甲大大大大學學學學

自動控制工程學系專題製作自動控制工程學系專題製作自動控制工程學系專題製作自動控制工程學系專題製作

專專專專題題題題論論論論文文文文

JAVA APPLET在在在在DSP學習網頁上的應用學習網頁上的應用學習網頁上的應用學習網頁上的應用

Applying Java Applet on

Interactive and Learning

Website of DSP

指導教授指導教授指導教授指導教授：：：：劉益瑞劉益瑞劉益瑞劉益瑞老師老師老師老師

學學學學生生生生：：：：廖廷淙廖廷淙廖廷淙廖廷淙

羅冠昕羅冠昕羅冠昕羅冠昕

丁怡傑丁怡傑丁怡傑丁怡傑

中華民國九十六中華民國九十六中華民國九十六中華民國九十六年六年六年六年六月月月月

逢逢逢逢甲甲甲甲大大大大學學學學

自動控制工程學系專題製作自動控制工程學系專題製作自動控制工程學系專題製作自動控制工程學系專題製作

專專專專題題題題論論論論文文文文

JAVA APPLET在在在在DSP學習網頁上的應用學習網頁上的應用學習網頁上的應用學習網頁上的應用

Applying Java Applet on

Interactive and Learning

Website of DSP

學生學生學生學生：：：：廖廷淙廖廷淙廖廷淙廖廷淙丁怡傑丁怡傑丁怡傑丁怡傑羅冠昕羅冠昕羅冠昕羅冠昕

經專題口試合格特此證明經專題口試合格特此證明經專題口試合格特此證明經專題口試合格特此證明

評評評評審審審審委委委委員員員員指指指指導導導導教教教教授授授授

系系系系主主主主任任任任

考試日期考試日期考試日期考試日期：：：：中華民國九十六年元月二日中華民國九十六年元月二日中華民國九十六年元月二日中華民國九十六年元月二日

i

中文摘要中文摘要中文摘要中文摘要

數位訊號處理（DSP）是訊號經過數位化轉換後分析處理的研究。DSP 是

高度數學主題，多數教科書包含很多方程式，這是為了深入的理解 DSP 所必需

的。透過電腦程式輔助，能容易學會 DSP 的概念。這個專題的目的是利用 Java

Applet 以 DSP 基本概念為主題，建立一個簡單的 DSP 互動式網頁。

我們設計了三個題目在這個項目。第一個是三角函數的基本理論，用一個圓

弧的變化觀察各函數波形。第二個是傅立葉級數的原理，以正弦波與餘弦波的關

係模擬近似週期信號。最後一個，是用離散的取樣點重建還原成連續的訊號。

ii

Abstract

Digital signal processing (DSP) is the study of signals in a digital representation

and the processing methods of these signals. DSP is highly mathematical subject, and

the most textbooks contain a lot of equations. Therefore, it is necessary for a profound

understanding of DSP. Through the aid of computer program, it is easy to learn the

concepts of DSP. The purpose of this project is to build-up a simple DSP webpage for

the basic concepts of DSP by Java Applet.

We designed three topics in this project. The first one was basic theory of triangle

function which will help reader to understand the sinusoid wave by circular motion.

The second one was the principle of Fourier Series Approximation which will aid for

the relationship between any period signals with the N-harmonic signals. The last one

was Discrete-to-Continuous Conversion which will assist in reconstructing the

continuous signal from the sample point in discrete domain.

iii

感謝感謝感謝感謝

首先要感謝的是我們專題的指導老師-劉益瑞老師，在整個做專題的過中，

老師給我們很大的自由發揮的空間。從一開始的給我們很多大方向讓我們選擇，

在專題上遇到的困難老師也是站在指導的方面給我們對錯誤的改正想法，或是推

導公式也能夠一起討論破解，這樣的互動讓我們更能夠讓專題中的各個環及成功

的組合完成。

再來要感謝提供資料的學長-劉瑞福，在撰寫程式的過程中有很多的問題都

是學長經歷過的，所以我們可以在程式的撰寫上比較容易上手，也給我們很多選

擇專題的方向。

iv

目錄目錄目錄目錄

感謝…………………………………………………………………………………… i

中文摘要 …………………………………………………………………………… ii

Abstract……………………………………………………………………………… iii

目錄 ………………………………………………………………………………… iv

圖目錄…………………………………………………………………………………v

第一章前言 …………………………………………………………………………1

第二章程式語言與工具介紹 ………………………………………………………2

2.1 Java …………………………………………………………………………2

2.1.1 Java的創立………………………………………………………… 2

2.1.2 C#與 Java ……………………………………………………………3

2.1.3 位元碼………………………………………………………………4

2.1.4 Java的特性………………………………………………………… 5

2.1.5 Java的改革………………………………………………………… 9

2.2 Applet …………………………………………………………… 10

2.2.1 Applet的基本流程…………………………………………………10

2.2.2 Applet的基本架構…………………………………………………10

2.3 JBuilder2006………………………………………………………………11

第三章理論探討……………………………………………………………………13

3.1 摺積 Convolution ………………………………………………………13

3.2傅立業級數 Fourier series ………………………………………………13

3.3 Discrete-to-Continuous Conversion ………………………………………15

3.31 取樣定理 ………………………………………………………… 16

3.32 Zero-Order Square Pulse …………………………………………16

3.33 Triangular Pulse ………………………………………………… 18

v

3.34 3rd-Order Cubic Spline ………………………………………… 19

3.35 Ideal Pulse (sinc) ……………………………………………… 20

第四章程式架構與設計……………………………………………………………22

4.1 基礎實作練習：三角函數之定義 Demo………………………………… 22

4.11 三角函數之定義 Demo流程圖……………………………………22

4.12三角函數之定義Demo操作說明操作說明 ………………………22

4.2 摺積 Convolution Demo ………………………………………………… 24

4.21 摺積 Convolution Demo 流程圖 …………………………………24

4.22 摺積 Convolution Demo操作說明 ……………………………… 24

4.3 傅立業級數 Fourier series Demo ………………………………………26

4.31 傅立業級數 Fourier series Demo流程圖………………………… 26

4.32 傅立業級數 Fourier series Demo操作說明……………………… 27

4.4 Discrete-to-Continuous Conversion Demo ……………………………… 28

4.41 Discrete-to-Continuous Conversion Demo流程圖 ……………… 28

4.42 Discrete-to-Continuous Conversion Demo 操作說明…………… 28

第五章結論 ……………………………………………………………………… 31

5.1 討論……………………………………………………………………… 31

5.1.1 消除閃爍現象-雙重緩衝區的運作原理 …………………………31

5.2 結論……………………………………………………………………… 31

參考文獻 ……………………………………………………………………………32

附錄 A三角函數之定義 Demo 程式碼…………………………………………… 33

附錄B Java摺積Convolution程式碼……………………………………………… 37

附錄C Java傅立業級數 Fourier series程式碼 …………………………………… 42

附錄 D Java Discrete-to-Continuous Conversion程式碼………………………… 46

vi

圖目錄圖目錄圖目錄圖目錄

圖 2.1 於 Jbuilder2005中開啟新檔案圖……………………………………………11

圖 2.2 選擇 Web 中的 Applet ……………………………………………………… 12

圖 2.3攥寫程式碼於Source視窗……………………………………………………12

圖3.1 頻率250 ZH 週期0.04S方波之5階Fourier series ………………………… 14

圖 3.2 頻率 500HZ週期 0.02S鋸齒波之 5階 Fourier series ……………………… 15

圖 3.3 頻率 250HZ週期 0.04S鋸齒波之 5階 Fourier series ……………………… 15

圖 3.4輸入頻率 100HZ的 sin波作頻率 400的取樣 ……………………………… 16

圖 3.5 sTS 005.0= ， Zs Hf 200= 的方波 ………………………………………… 17

圖 3.6輸入頻率 100HZsin波作頻率 400取樣再對取樣點乘上方波 )(tx ……… 17

圖 3.7輸入頻率 100HZ的 sin波作頻率 400的取樣，用方波重建的結果 ……… 17

圖 3.8 sTS 005.0= ， Zs Hf 200= 的三角波 ……………………………………… 18

圖 3.9輸入頻率 100HZsin波作頻率 400取樣再對取樣點乘上三角波 )(tx …… 18

圖3.10輸入頻率100HZ的 sin波作頻率400的取樣用三角波重建的結果……… 19

圖 3.11 sTS 005.0= ， Zs Hf 200= 的 Cubica脈衝 ……………………………… 19

圖3.12輸入頻率100HZsin波作頻率400取樣再對取樣點乘上拋物線 )(tx …… 20

圖 3.13輸入頻率 100HZ的 sin波作頻率 400的取樣，用 Cubic重建的結果 … 20

圖 3.14 sTS 005.0= ， Zs Hf 200= 的 sinc脈衝 ………………………………… 21

圖 3.15輸入頻率 100HZ的 sin波作取樣頻率 400對取樣點作影響 7點 sinc(t) … 21

圖 3.16輸入頻率 100HZ的 sin波作頻率 400的取樣用 7點 sinc重建的結果…… 21

圖 4.1三角函數之定義Demo流程圖……………………………………………… 22

圖 4.2三角函數之定義Demo初始畫面…………………………………………… 22

圖 4.3 cos -236o………………………………………………………………………23

圖 4.4 sin -236o……………………………………………………………………… 23

圖 4.5 tan 328o ……………………………………………………………………… 23

vii

圖 4.6摺積 Convolution Demo流程圖 …………………………………………… 24

圖 4.7 新版本 Convolution DEMO 的初始畫面 ………………………………… 25

圖 4.8 舊版本 Convolution DEMO 的初始畫面 ………………………………… 25

圖 4.9 新版本 Convolution DEMO 計算摺積後的結果 ………………………… 26

圖 4.10傅立業級數 Fourier series Demo流程圖 ………………………………… 26

圖 4.11 Fourier series Demo的初始畫面……………………………………………27

圖 4.12 週期 0.002s 的鋸齒波初計算 4 階 Fourier series ………………………… 27

圖 4.13 Discrete-to-Continuous Conversion Demo流程圖………………………… 28

圖 4.14設定輸入波形的頻率 ………………………………………………………28

圖 4.15 設定取樣的頻率……………………………………………………………29

圖 4.16 triangular重建頻率 384HZ取樣頻率 833HZ的 sin波 …………………… 29

圖 4.17 cubic重建頻率 384HZ取樣頻率 263HZ得倒失真的 sin波圖 …………… 30

1

第一章第一章第一章第一章前言前言前言前言

網路近年來成為主流趨勢，大家都在網路上查詢資料，把以前只

能寫在課本上的資料也轉變成可以用電腦來模擬出來，利用軟體把文

字轉換成程式，再把這些程式作成互動式網頁，查詢的人可以透過網

頁直接點選程式，在網路上執行，不必下載，非常的便利。我們製作

有關數位信號處理教學的網站，提供大家有關學習數位信號處理的原

理與應用。

在我們醫工學程裡也有修過數位訊號處理，覺得在學習上，搭

配著軟體的應用，有大大的幫助。希望這個網站，可以帶給學習的人

更多的幫助，讓互動式網頁教學繼續發展下去。

2

第二章第二章第二章第二章程式語言與工程式語言與工程式語言與工程式語言與工具介紹具介紹具介紹具介紹

2.1 Java

2.1.1 Java 的創立的創立的創立的創立

JAVA 是在 1991 年由 James Gosling、Patrick Naughton、Chris Warth、Ed

Frank、與 Mike Sheridan 在 Sun Microsystem 公司構思而成。第一版的開發時間

為 18 個月。此語言最初稱為「Oak」，但在 1995 年更名為「Java」。從 1992 年秋

天開始實作 Oak，一直到 1995 年春天才公開發表 Java，在這段期間內，許多人

投入此語言的設計與發展。Bill Joy、Arthur van Hoff、Jonathan Payna、Frank Yelin

與 Tim Lindholm 都是 Oak 最初原型的主要貢獻者。

Java最初的原動力是為了尋求一個平台獨立(也就是與電腦內部結構無關)的

電腦語言，讓此語言所建立的軟體可嵌入於各種不同的消費性電子裝置，例如，

微波爐與遙控器。不同種類的裝置使不用不同形式的 CPU。若採用 C 與 C++(以

及其他大多數的語言)，則它們只能根據特定的目標來作設計。雖然能夠為每種

形式的 CPU 編譯 C++程式，但這樣必須要具備每種 CPU 的完整 C++編譯器才能

夠達成。這些編譯器相當昂貴且需要花費許多時間來建立程式。為了找尋一種既

簡單又合乎成本效率的解決方法，Gosling與其他人開始建立可移植、平台獨立

的語言。希望此種語法所產生的程式能夠在各種不同 CPU 上的不同環境下執

行。在他們努力下，最後創立了 Java。

第二個原動力就是 World Wide Web。由於World Wide Web 的出現，將 Java

推到電腦語言設計的前端，Web 同樣也需要可移植的程式。

大多數程式設計師在他們早期的職業生涯就已經知道可移植的程式非常難

懂。雖然在很久以前就已經開始尋找一種建立有效率、可移植(平台獨立)程式方

的方程式，總是更急迫的問題擠到後面去。此外，因為電腦世界已經分裂成

三個陣營:Internet、Macintosh、UNIX，大多數的程式設計師都只待在他們選定

的範圍裡，古老的移植程式需求度便因而降低。然而，隨著 Internet 包含各種不

3

同且分散的領域，其中有許多形式的電腦，、作業系統、以及 CPU。雖然許多

形式的平台都能連接 Internet。

在 1993 年，Java設計團隊的成員發覺，當企圖建立 Internet 的程式碼時，

也時常會碰上為嵌入式控制器建立程式時相同的移植問題。當初 Java所要解決

的小規模消費性電子裝置問題同樣也適用大規模的 Internet 程式設計。因此，Java

最初的原動力是渴望平台獨立的程式語言，但最終還是 Internet 引導 Java成功之

路。

2.1.2 C#與與與與 Java

所有受到 Java影響的語言中，最重要的是 C#。此語言是最近由 Microsoft

所創立，用來支援.NET Framework，C#和 Java的關係非常密切。舉例來說，這

兩種語言都延用 C++的語法風格，支援分散式程式設計、以及採用相同的物件模

型。當然，Java和 C#之間具有差異，但這兩個語言的整體「外觀」非常相似。

由 Java和 C#之間的「異花授粉」關係，就足以證實 Java提昇我們的思考模式和

使用電腦語言的方式。

Java的許多特性是由 C與 C++衍生而來。Java設計師明白若採用與 C 類似

的語法，和仿照 C++的物件導向功能，將使得他們的語言能夠吸引許多具有

C/C++經驗的程式設計師。除了表面的相似之外，Java也沿用一些幫助 C 與 C++

成功的其他性質。首先，Java是由一些具有實際工作經驗的程式設計師來設計、

測試與修改。此語言經過一些具有此種需求和具有經驗的人士規劃而成。因此，

Java也是程式設計師的語言。第二，Java具有內聚力(cohesion)和邏輯上的一致

性。第三，除了 Internet 環境所附加的限制外，Java給予程式設計師完整的控制

權。你的程式設計好壞與否，在程式中都會反映出來。換句話說，Java不是那種

會訓練你的語言。它是為專業程式設計師所設計的電腦語言。

因為 Java與 C++之間的相似性，容易將 Java想成是「C++的 Internet 版本」

。Java與 C++在實際應用與理論方面有著很大的差異。雖然 Java深受 C++的影

4

響是不可否認的，但它並不是 C++的加強版本。舉例來說，Java不論是往前或往

後都與 C++不相容。Java與 C++的相似程度很高。如果你是 C++的程式設計師，

學習 Java可能會覺得如魚得水。另一個重點:Java並不是為了取代 C++而設計

的。Java是為了解決某些問題而設計的。而 C++是為了解決另一些問題而設計的。

形成新電腦語言的原因有兩種:適應環境的變遷，以及在程式設計的技術上

精益求精。Java當時的環境變遷是因為 Internet 上的分散式環境需要平台獨立的

程式。然而，Java也具體地改變了程式的撰寫方式。

Java加強並提升 C++所使用的物件導向模型。因此，Java並不是孤立的語

言。它是屬於許多年前就已經開始發展且從未間斷過程中的一部份。僅僅根據此

事實就足以確保 Java在電腦語言歷史中的地位。Java對於 Internet 程式設計就如

同 C 對於系統程式設計:革新使它改變世界。

2.1.3 位元碼位元碼位元碼位元碼

允許 Java解決安全性與移植性問題的主要關鍵是 Java編譯器的輸出不是可

執行碼，而是位元碼。位元碼(bytecode)是一種高度最佳化的指令集，由一種稱

為 Java虛擬機器(java virtual machine，JVM)的 Java執行系統來執行。也就是說，

其標準形式中，JVM是位元碼的直譯器(interpreter for bytecode)。大多數的現代

語言都被設計成編譯，而不是直譯-因為效能的考量。由 Java直譯 Java程式解決

了跨越 Internet 下載程式的主要問題。原因如下。

將 Java程式轉譯成位元碼讓它很容易在各種不同的環境下執行。其理由相

當明顯:只需為每個平台實作 JVM。一旦某個系統具有 Java執行環境時，任何的

Java程式都可以在該系統上執行。雖然 JVM的細節會因為平台的不同而有所差

異，但所有的 JVM 都能直譯 Java位元碼。如果將 Java程式編譯成原生碼(native

code)，那麼一種程式需要有不同的版本以配合 Internet 上各種形式的 CPU。這當

然不是一種好方法。因此，位元碼的直譯機制是建立真正可移植程式的最快方法。

Java成是透過直譯的事實也讓它變得比較安全。因為每個 Java程式的執行

5

都是為 JVM 的控制之下，JVM 可以控制這些成是，並防止它產生一些影響系統

外環境的副作用。你將會看到，Java語言中也存在一些加強安全性的限制。

一般而言，直譯式程式的執行效率會比編譯成可執行碼的程式還慢。然而，

由於 Java，使得兩者之間的差異沒有那麼明顯。因為位元碼的使用，讓 Java執

行系統執行程式的速度比你預期中的還要快。

雖然 Java是設計成直譯，但 Java並沒有避免將位元碼編譯成原生碼。在這

方面，Sun 為位元碼提供 Just In Time(JIT)編譯器，在 Java2 中就包含此種編譯器。

當 JIT 編譯器成為 JVM 的一部份時，它可以及時將位元碼編譯成可執行碼，根

據當時的需求，一部份一部份地編譯。要將整個 Java程式立刻編譯成可執行碼

是不可能的，因為 Java必須進行許多在執行時期才能完成的檢查。在執行時，

JIT 會依據需求來編譯程式碼。然而，此種 Just In Time的方法仍然大大地提昇了

執行的效率。即使將位元碼動態地編譯成執行碼，移植性與安全性的特色仍然存

在，因為執行期時系統(進行編譯的部份)仍然是負責執行環境。無論你的 Java程

式是以傳統的方式進行直譯，或是進行即時編譯，他們功能仍然相同。

2.1.4 Java 的特性的特性的特性的特性

（一）簡單

Java的設計目的是要讓專業程式設計師很容易學習，而且使用起來很有效

率。假如你已經有一些程式設計的經驗你將會發現 Java很容易掌握。如果你已

經瞭解物件導向程式設計的基本概念，學習 Java的過程將會更容易。最重要的

是，如果你是個有經驗的 C++程式設計師，移到 Java只需要一些努力，因為 Java

繼承 C/C++的語法以及 C++的許多物件導向特色，大多數程式設計師在學習 Java

的過程中並不會遇到太多困難。而且，某些在 C++中複雜的概念已經從 Java中

移除，或是以較清楚、較簡明的方法來實作。

除了與 C/C++的類似性之外，Java有另一個性質，讓它更容易學習：它避免

令人驚訝的功能。在 Java中，能夠完成特定工作的方式只有少數幾種。

6

（二）安全

每當下載「正常的」程式時，都有感染病毒的危險。在 Java之前，大多數

的使用者並不會經常下載執行檔，若下載後，在執行前也會先進行病毒掃描。即

使如此，大多數的使用者仍然擔心他們的系統會感染病毒。除了病毒之外，還必

須防範另一種具備有惡意的程式。此種程式可以藉著搜尋你電腦檔案系統中的內

容來取的私人的資訊，例如信用卡號碼、銀行帳號以及密碼。Java藉著在網路應

用程式與你的電腦之間提供「防火牆」來排除這些憂慮。

當你使用 Java相容的瀏覽器時，你可以安全地下載 Java applet，無須擔心病

毒或具有惡意的程式。Java將 Java程式侷限在 Java執行環境下，並且不容許它

存取電腦的其他部分來達成這項保護。有信心地下載 applet，無須擔心會有其他

的傷害以及侵入的安全問題被認為是 Java最重要的部份。

（三）可移植

世界各地使用各種不同形式的電腦和作業系統-其中大部分都可以連接到

Internet。對於那些動態下載到 Internet 上各種平台的程式而言，你必須要有一些

方法來產生可以移植的執行碼。稍後你將會看到，用來確保安全性機制同樣也可

用來建立可移植的程式。Java對這兩個問題的解決方法確實很精簡，而且很有效

率。

（四）物件導向

雖然受到前輩的影響，Java的設計原理並不是要與其他任何語言的原始碼相

容。這讓 Java團隊能夠自由自在地設計。其結果是對物件有個清楚、合用、且

務實的方法。Java充分地參考最後幾十年中許多發展性物件軟體環境的觀念，並

設法在純粹主義派的「everything is object」與實用主義派「stay out of my way」

之間取得平衡。Java中的物件模型很簡單，且容易擴展。只有像整數這樣的簡單

型別才是以非物件的方式來處理。

（五）強健(robust)

Web 的多平台環境使得 Web 程式具有特殊的需求，因為 Web程式必須在各

7

種不同系統上確實地執行。因此，Java的設計中，建立強鍵程式的能力具有很高

的優先順序。為了貨的可靠性，Java在許多重要的地方都加以限制，強迫你在程

式發展過程中早點發現你的錯誤。同時，Java讓你不必擔心許多常見錯誤。因為

Java是個嚴格型別的語言，它在編譯時期會檢查你的程式碼。然而，在執行時期

也會檢查你的程式碼。事實上，通常在執行時期才會浮現的許多難以追蹤的錯誤

根本不可能在 Java中發生。Java主要的特色是，讓你能瞭解你所撰寫的程式在

不同情況下都會依照預期的方式來執行。

為了更瞭解 Java的強鍵程度，我們先探討程式失敗的兩個原因：記憶體管

理的過失與錯誤地處理例外情況(也就是執行時期的錯誤)。在傳統程式設計環境

裡，記憶體的管理有時是件困難且麻煩的工作。舉例來說，在 C/C++中，程式設

計師必須手動地配置與釋放所有的動態記憶體。這樣有時會產生問題，因為城市

設計師可能會忘記釋放先前配置的記憶體，或是更糟的情況，試著去釋放另外一

部分程式碼仍在使用的記憶體。Java能夠位你管理記憶體的配置與釋放已排除這

些問題(事實上，釋放記憶體的動作完全自動，因為 Java會為不用的物件進行垃

圾收集)。在傳統環境裡，例外情況通常是在像「除以零」或是「找不到檔案」

的處境下發生，它們必須以龐大、難懂的架構來管理。Java在這方面有提供物件

導向的例外處理。在撰寫良好的 Java程式裡，你的程式能夠-也應該-處理所有的

執行時期錯誤。

（六）多執行緒

Java的設計是為了能夠建立互動式的網路程式。為了達成此目標，Java支援

多執行緒的程式設計，讓你的程式能夠同步地執行許多動作。Java執行系統為同

步處理提供一套細緻且精密的解決之道，讓你能順利地建構互動式系統。Java

對多執行緒所採用的方式讓你能夠預期程式行為，並不像多重處理系統

(multitasking subsystem)那麼複雜。

（七）架構中立

Java設計者最主要的考量是程式碼的壽命與移植性。程式設計師所面臨的問

8

題是，你今天所寫的程式不保證明天還可以執行-即使是在相同的機器上。作業

系統的升級、處理器的升級、以及核心系統資源的更動都可以讓程式的功能失

常。Java程式設計師為了解決這種情況，在 Java語言以及 Java虛擬機器中作了

許多重要的決定。他們的目標是「write once；run anywhere，any time，forever.」

此目標已經達成ㄧ大部分。

（八）直譯與高效能

證如先前所描述，Java藉由將程式編譯成ㄧ種稱為 Java位元碼的中間碼以

達到跨平台的目標。在任何具有 Java虛擬機器的系統上都可直譯此種程式碼。

先前許多跨平台的解決之道都犧牲了執行效率。其他的直譯式系統，例如

BASIC、Tcl、與 PERL，都無法克服效率的不足。然而，Java是為了在低階的

CPU 上執行而設計的。如先前所解釋過，雖然 Java採用直譯的方式，但是 Java

位元碼謹慎的設計，讓它能夠輕易地直接轉換成原生機器碼，並利用 juet-in-time

編譯器可以達成很高效率。Java執行系統提供這項功能，而不會喪失平台獨立的

優點。「高效率且跨平台」已不再是神話。

（九）分散式

Java是為了 Internet 的分散式環境而設計的，因為它處理了 TCP/IP 通訊協

定。

透過 URL存取資源與存取檔案並沒有什麼差別。Java(Oak)的原來版本包括

一些內部網路訊息傳遞的功能。讓這兩個不同電腦上物件可以執行遠端的程序。

Java將這些介面放在一個稱為 Remote Method Invocation(RMI)的套件(package)

中。此功能將非平台層次的抽象性觀念引入用戶端/伺服器的程式設計中。

（十）動態

Java程式具有大量執行時期型別的資訊，因此在執行時期可利用這些資訊來

驗證和解析物件的存取過程。因此可以依照安全且方便的方式來動態連結程式

碼。這對 applet 環境的強鍵性是種很重要的，因為可能在執行系統上動態更新ㄧ

部份的位元碼。

9

2.1.5 Java 的改革的改革的改革的改革

Java最初的發表簡直可以說是件大革新，但不代表Java快速改革的時代已

經結束了。不同於其他的軟體系統只滿足於小規則的革新，Java持續以飛快的步

伐進行改革。在Java1.0發表後不久，Java設計者已經建立了Java1.1。Java1.1所新

增的功能比你所預期的還要大很多。Java1.1新增許多新的程式庫元件、重新定義

applet處理事件的方式、以及重新更動Java1.0函式庫中的許多功能。它也捨棄原

先Java1.0定義的許多功能。因此Java1.1不但新增了新的功能，同時也刪除一些

已經過時的功能。

Java下一個主要的版本為Java2，其中「2」代表「第二世代」。Java2是個

轉折點，代表此快速發展語言的「新時代」。Java2最初發表的版本為1. 2。因為

原先只涉及Java函式庫的版本，最後卻含括整個語言。隨著Java2到來，Sun將Java

產品重新包裝為J2SE(Java 2 Platform Standard Edition)，版本號碼也從此時開始套

用。

Java2支援許多新的功能，例如，Swing和Collections Framework，並加強Java

虛擬機器和許多程式設計工具。Java2也捨棄了一些功能。其中影響最大的為

Thred類別，其中suspend( )、resume( )、和stop( )方法都已經不在使用。

Java的下一個發表版本為J2SE 1.3。此版本將原先的Java2加以提昇。主要是

將現存的功能加以提昇，並使開發環境變得可靠。一般來說，用1.2版的程式和

1.3版的程式在原始碼等級是相容的。雖然1.3小部份的更新相較於先前的大革

新，可以說是小巫見大巫，不過這些更新仍然是很重要的。

J2SE1.4的發表進一步加強Java的功能。此版本包含許多重要的升級、提升、

和附加功能。舉例來說，它加入新的關鍵字assert、鏈狀例外情況(chained

exception)和channel-based I/O子系統。它也更改了Collections Framework、以及網

路相關的類別。另外，幾乎每個地方都存在少量的更動。若除去新加入的功能，

1.4版和之前的版本具有百分之百原始碼等級的相容性。Java目前最新的版本是

10

J2SE 5，它的改革完全不輸先前的版本。

2.2 Applet

Applet 是一個小型 Java應用程式，可以在 Applet Viewer(用來測試 Applet

的程式，包含在 J2SDK)或是 Web 瀏覽器內執行。當瀏覽器開啟 HTML網頁時，

如果網頁包含<Applet>標籤，瀏覽器就會自行下載指定的 Applet，並將執行結果

顯示於瀏覽器。Applet 原始檔的副檔名和一般 Java應用程式相同，都是.Java。

編譯過的 Applet 也是副檔名為.class 的類別檔，只不過這個類別檔必須執行於瀏

覽器。Java Applet 不僅可以包含美工特效，還可以加入背景音樂或是撥放影音動

畫。換言之，它的執行效能並不會受到網路連線速率的影響，執行時也不會佔用

網路頻寬。因此，Applet 的應用相當廣泛。

Applet 需部署在 Web 伺服器，執行前會經由網路下載到客戶端。只要客戶

端瀏覽器安裝適當的 JVM(Java Virtual Machine) ，就可以執行下載後的 Applet。

此外，Applet 是在一個安全機制下傳送與執行，它無法執行其他額外的工作，例

如:未經使用者同意卻擅自存取作業系統的檔案，或者將使用者資料傳送到網路

上其他電腦。

2.2.1 Applet 的基本運作流程的基本運作流程的基本運作流程的基本運作流程

(1)當瀏覽器嘗試開啟包含 Applet 的網頁時，會啟動 JVM。

(2)瀏覽器會將<Applet>標籤所定義的資訊傳送給 JVM類別載入(classloader)JVM

可藉此得知 Applet 執行過程中需要哪些 Java類別檔。

(3)在類別載入過程中會經過一個認證機制，目的是檢查欲載入的類別是否合

法。確認過類別的合法性之後，Applet 才會被執行。

2.2.1 Applet 的基本架構的基本架構的基本架構的基本架構

applet 類別由基本 4 個方法所組成─init( )、start( )、stop( )、destroy( )函式。

init( ) ─ Applet 開始啟動時，設定初值變數用途。

11

start( ) ─ 當前一步驟執行完成後，就緊接著執行，或當切換其他網頁時，再回

到本頁時就在執行一次。

stop( ) ─ 當切換其他網頁時，或關閉瀏覽器時，就會執行 stop( )來停止 Applet。

destroy( ) ─ 當 stop( )被呼叫時，applet 會暫停並且釋放使用 Applet 所佔用的記

憶體空間。

2.3 JBuilder2006

Borland Jbuilder是全球第一的跨平台 Java開發環境，可見建構符合業界標

準之 Java應用系統，開發 EJB、Web、XML以及資料庫等各類應用程式。藉由

JBuilder雙向、視覺化之設計工具，你可以快速開發各種 J2EE 應用程式，並部

署至多種應用程式伺服器。提供一個整體的開發環境，所有的編譯、編輯、執行、

除錯及線上說明，都建立在ㄧ個圖形式的使用者介面供程式設記者點選，所有可

以利用單一視窗來處理大多數的開發工作。

以 JBuilder2006 製作 Applet 作業流程：

(1)於 Jbuilder2006 中開啟新檔案

圖 2.1 於 Jbuilder2005中開啟新檔案

12

(2) 選擇 Web 中的 Applet

圖 2.2 選擇 Web 中的 Applet

(3) 自動進入 Source視窗，此視窗中攥寫程式碼，可看到 Applet 的基本架構

圖 2.3 攥寫程式碼於 Source視窗

13

第三章第三章第三章第三章理論探討理論探討理論探討理論探討

3.1 摺積摺積摺積摺積 Convolution

Convolution 就是一個各個單位分別相乘然後再累加起來的步驟，有限長的

向量做 Convolution 的動機來自於多項式的乘法，它是一種對兩個函數作移動平

均的觀念。在 DSP 裡，需定出兩組訊號, 其 Fourier係數作疊積產生出的新向量,

就是這兩個函數相乘後的 Fourier係數。式子如下：

∫∞

∞−

−= dvvtxvhty )()()( (3.1)

離散時間式子如下：

∑∞

−∞=

−=k

knxkhny ][][][ （3.2）

3.2 傅立業級數傅立業級數傅立業級數傅立業級數 Fourier series

任一週函數可以利用傅立葉級數分解成許多不同振幅大小，不同頻率高低

的正弦波與餘弦波。傅立葉級數主要是分析複雜種類的週期性函數，假如函數不

再是由簡單的週期性函數所組成，就必須用傅立業級數來逼近。傅立業級數於分

析週期性的圖形很重要的，當取樣值趨近於無窮大時，其圖形的描述有如原本的

圖形，利用此特性來描述圖形。

假設週期信號函數為 )(tf ，函數之週期為T ，即週即函數可表示為

)()( Ttftf ±= （3.3）

，則傅立葉級數可寫成：

∑∞

=

++=1

0 )cos(2

)(n

nnT

tnb

T

tna

atf

ππ （3.4）

∫=T

dttfT

a0

0 )(1

（3.5）

14

∫=T

n dtT

tntf

Ta

0

cos)(1 π

（3.6）

∫=T

n dtT

tntf

Tb

0

sin)(1 π

（3.7）

其中， 1≥n ， Tt ≤≤0 ，2

0a 為 )(tf 之初始值， na 、 nb 為傅立葉級數之係數。實

際上傅立業級數不可能取到無窮大，只能以近似來表示的三角多項式，以 N 次

為階數的近似傅立業方程式來逼近 )(tf ，所以又稱為三角傅立業級數。

傅立業級數可貴在於函數所鎖分解的正、餘弦函數具有正交性(orthogonality)

，即T

tnπsin ，

T

tnπcos 在週期T內成正交集合，因此適於頻譜的分析。

圖 3.1 頻率 250 ZH 週期 0.004S 方波之 5 階 Fourier series

15

圖 3.2 頻率 500HZ週期 0.002S 鋸齒波之 5 階 Fourier series

圖 3.3 頻率 250HZ週期 0.004S 鋸齒波之 5 階 Fourier series

3.3 Discrete-to-Continuous Conversion

ㄧ個時間訊號經過取樣之後，只能得到離散的數據。不轉換至頻率領域，在

時間領域用數學的方法利用的離散數據重建其訊號原來的波形。

16

圖 3.4 輸入頻率 100HZ的 sin 波作頻率 400 的取樣

3.3.1 取樣定理取樣定理取樣定理取樣定理

信號在取樣時常常會引起交疊 (aliasing) 的現象，而導致信號失真，亦即所

還原之信號並非原信號，為避免此一情形，信號在取樣時之取樣頻率必須不小於

有效取樣頻率，至於有效取樣頻率則需參照信號取樣定理的規定，信號取樣定理

又稱為 Nyquist 取樣定理，其內容為系統的有效取樣頻率 sf (effective Sampling

frequency) 必須滿足 02 ff c ≥ 的規定。在此 0f 為原信號之最大頻率，稱為 Nyquist

頻率，而 02 f 稱為 Nyquist rate。所以一類比信號其頻率成分沒有大於 0f 者，只要

取樣頻率 sf 大於 02 f ，那麼此一信號可依取樣定理來還原信號。

3.3.2 Zero-Order Square Pulse

對一個離散的取樣點乘上脈衝方波 )(tx ，做一個以本身為高度影響至前後一

個取樣點一半的距離。 )(tx 定義如下：

≤<

=

otherwise 0

2

1

2

1- 1

)(ss TtT

tx （3.8）

17

圖 3.5 sTS 005.0= ， Zs Hf 200= 的方波

圖 3.6 輸入頻率 100HZsin 波作頻率 400 取樣再對取樣點乘上方波 )(tx

圖 3.7 輸入頻率 100HZ 的 sin 波作頻率 400 的取樣，用方波重建的結果

18

3.3.3 Triangular Pulse

對一個離散的取樣點乘上脈衝三角波 )(tx ，做一個高度至下一個取樣點恰為

零的影響。 )(tx 定義如下：

otherwise 0

1)(

≤≤−−

=ss TtT

Ts

t

tx （3.9）

圖 3.8 sTS 005.0= ， Zs Hf 200= 的三角波

圖 3.9 輸入頻率 100HZsin 波作頻率 400 取樣再對取樣點乘上三角波 )(tx

19

圖 3.10 輸入頻率 100HZ的 sin 波作頻率 400 的取樣用三角波重建的結果

3.3.4 3rd-Order Cubic Spline

對一個離散的取樣點乘上脈衝三角波 )(tx ，做一個高度變化為拋物線至下兩個

取樣點的影響。 )(tx 的定義如下：

21 245.25.0

10 15.25.1)(

23

23

≤≤+−+−

≤≤+−=

tttt

ttttx （3.10）

圖 3.11 sTS 005.0= ， Zs Hf 200= 的 Cubica脈衝

20

圖 3.12 輸入頻率 100HZsin 波作頻率 400 取樣再對取樣點乘上拋物線 )(tx

圖 3.13 輸入頻率 100HZ的 sin 波作頻率 400 的取樣，用 Cubic重建的結果

3.3.5 Ideal Pulse (sinc)

一個方波經過 Fourier轉後的圖形為 sinc，所以對每個取樣點利用 sinc為脈衝

函數可以得到最理想的重建。其 )(tx 的定義如下：

∞<<∞−== t

tT

tTttx

s

s for

sin

)(sinc)(π

π

（3.11）

21

圖 3.14 sTS 005.0= ， Zs Hf 200= 的 sinc脈衝

圖 3.15 輸入頻率 100HZ的 sin 波作取樣頻率 400 對取樣點作影響 7 點 sinc(t)

圖 3.16 輸入頻率 100HZ的 sin 波作頻率 400 的取樣用 7 點 sinc重建的結果

22

第四章第四章第四章第四章程式架構與設計程式架構與設計程式架構與設計程式架構與設計

4.1 基礎基礎基礎基礎實作練習實作練習實作練習實作練習：：：：三角函數之定義三角函數之定義三角函數之定義三角函數之定義 Demo

4.1.1 三角函數之定義三角函數之定義三角函數之定義三角函數之定義 Demo 流程圖流程圖流程圖流程圖

圖 4.1 三角函數之定義 Demo 流程圖

4.1.2 三角函數之定義三角函數之定義三角函數之定義三角函數之定義 Demo 操作說明操作說明操作說明操作說明

（一）設定預計算的函數

（二）控制捲軸改變角度

圖 4.2 三角函數之定義 Demo 初始畫面

23

圖 4.3 cos -236o

圖 4.4 sin -236o

圖 4.5 tan 328o

24

4.2 摺積摺積摺積摺積 Convolution Demo

4.2.1 摺積摺積摺積摺積 Convolution Demo 流程圖流程圖流程圖流程圖

圖 4.6 摺積 Convolution Demo 流程圖

4.2.2 摺積摺積摺積摺積 Convolution Demo 操作說明操作說明操作說明操作說明

（一）新舊兩個版本程式的展現，基本的介面架構不變，開啟 Convolution

DEMO，預設 Input 與Ｓystem 信號分別為 Square與Ｄelta

（二）分別選取 Input 與 System 之信號

（三）點選 Display紐或是調整捲軸觀看 Convolution 過程

（四）點選 Display紐或是調整捲軸觀看 Convolution 過程

25

圖 4.7 新版本 Convolution DEMO的初始畫面

圖 4.8 舊版本 Convolution DEMO的初始畫面

26

（五）於右方觀看結果

圖 4.9 新版本 Convolution DEMO計算摺積後的結果

4.3 傅立業級數傅立業級數傅立業級數傅立業級數 Fourier series Demo

4.3.1 傅立業級數傅立業級數傅立業級數傅立業級數 Fourier series Demo 流程圖流程圖流程圖流程圖

圖 4.10 傅立業級數 Fourier series Demo 流程圖

27

4.3.2 傅立業級數傅立業級數傅立業級數傅立業級數 Fourier series Demo 操作說明操作說明操作說明操作說明

（一）選取 Input 訊號

（二）控制卷軸計算傅立業級數

圖 4.11 Fourier series Demo 的初始畫面

（三）觀察結果

圖 4.12 週期 0.002s 的鋸齒波初計算 4 階 Fourier series

28

4.4 Discrete-to-Continuous Conversion Demo

4.4.1 Discrete-to-Continuous Conversion Demo 流程圖流程圖流程圖流程圖

圖 4.13 Discrete-to-Continuous Conversion Demo 流程圖

4.4.2 Discrete-to-Continuous Conversion Demo 操作說明操作說明操作說明操作說明

（一）設定輸入波形的頻率

圖 4.14 設定輸入波形的頻率

29

（二）設定取樣點的頻率

圖 4.15 設定取樣的頻率

（三）選擇重建波形的數學方法

圖 4.16 triangular重建頻率 384HZ取樣頻率 833HZ的 sin 波

（四）觀察失真結果

30

圖 4.17 cubic重建頻率 384HZ取樣頻率 263HZ得倒失真的 sin 波

31

第五章第五章第五章第五章結論結論結論結論

5.1 討論討論討論討論

5.1.1 消除閃爍現象消除閃爍現象消除閃爍現象消除閃爍現象-雙重緩衝區的運作雙重緩衝區的運作雙重緩衝區的運作雙重緩衝區的運作原理原理原理原理

當 paint()方法被 repaint()呼叫時，applet 的畫面就會被完全清除一次。所以

在很短的時間內，感覺螢幕會閃爍。是因為重繪時，repaint()不是直接呼叫

paint()，而是先呼叫內定的 update()後，再來呼叫 paint()的。

雙重緩衝意指先將 paint()方法中的所有東西繪至一個幕後的影像記憶體

區。一直等到所有的東西繪製幕後的影像記憶體區後，這幕後的影像記憶體區才

一次複製到 applet 的螢幕上。

5.2 結論結論結論結論

本研究專題所發展的數位訊號教學網站，一方面可提供修習數位訊號處理

的學生獲知課程上的內容，另一方面經由我們在網路上蒐集整理後的不斷更新，

以最低的成本來共享教育研究資源。

瀏灠網頁已成為，日常生活中的習慣覽。未來，網頁的附加功能會越來越強

大，JAVA、FLASH 這種跨平台的工具會越來越蓬勃的發展，JAVA 在於內部程

式與介面設計的 FLASH 相輔相成、相互結合之下，必會有革命性的發展。

由於本網站架設課程上的範例，目前僅止於時域軸上的呈現，頻域軸尚未開

發，未來本站所有教學範例，可望朝此方向增修功能，或著將理論與日常生活結

合製作教學範例，讓網站更為活潑生動。

32

參考文獻參考文獻參考文獻參考文獻

[1] java 2 徹底研究/Herevert Schildt 原著賴俊安譯麥格羅希爾 2005

[2] 數位信號處理實務入門/林宸生邱創乾陳德請編著高立圖書 1996

[3] Signal Processing First/James H.McClellan Ronald W. Schafer Mark A Yoder

[4] Java 3D 電玩入門程式設計/彭勝陽編著文魁資訊 2003

[5] 訊號及憲性系統分析/Gordon E. CARLSON 著李世鴻譯五南圖書 2001

[6] JavaTM 2 教學手冊-JDK5 版/蔡明志陳彥仲譯碁峰資訊 2005

[7] JBuilder X 程式設計得心應手 / 洪國勝、張建原編著文魁資訊 200

[8] 網站：http://www.jhu.edu/~signals/

33

附錄附錄附錄附錄 A 三角函數之定義三角函數之定義三角函數之定義三角函數之定義 Demo 程式碼程式碼程式碼程式碼

package garbage;

import java.awt.*; import java.awt.event.*;

import java.applet.*;

import java.awt.Rectangle; import java.awt.geom.Arc2D;

import java.awt.geom.Line2D;

public class creat1 extends Applet {

boolean isStandalone = false;

BorderLayout borderLayout1 = new BorderLayout(); Scrollbar scrollbar1 = new Scrollbar();

TextField textField1 = new TextField();

Choice choice1 = new Choice();

double[] samples = new double[800];

int i, j, x; double a, d, d1, f, theta = (Math.PI / 180);

String b;

Image offscreen; Graphics drawoffscreen;

public void paint(Graphics g) {

g.setColor(Color.lightGray); Graphics2D g2D = (Graphics2D) g;

g.drawLine(5, 100, 115, 100);

g.drawLine(150, 100, 390, 100); g.drawLine(250, 45, 250, 150);

g.drawString("度", 245, 21);

g.drawLine(15, 100, 105, 100); g.drawLine(60, 45, 60, 150);

g.setColor(Color.BLUE);

if (b == "sin") { d = (double) Math.sin(a * theta);

Arc2D.Double arc = new Arc2D.Double(15, 55, 90, 90, 0, a, Arc2D.PIE);

g2D.draw(arc); Line2D.Double line1 = new Line2D.Double(60, 100 - (d * 45),250 + (a / 2.7), 100 - (d * 45));

g2D.draw(line1); for (i = 1; i < a; i++) {

j = i + 1;

d = (double) Math.sin(i * theta); d1 = (double) Math.sin(j * theta);

Line2D.Double line = new Line2D.Double(250 + (i / 2.7),100 - (d * 45), 250 + (j / 2.7), 100 - (d1 * 45));

g2D.draw(line); }

for (i = -1; i > a; i--) {

j = i - 1; d = (double) Math.sin(i * theta);

d1 = (double) Math.sin(j * theta);

Line2D.Double line = new Line2D.Double(250 + (i / 2.7),100 - (d * 45), 250 + (j / 2.7), 100 - (d1 * 45)); g2D.draw(line);

}

} if (b == "cos") {

d = (double) Math.cos(a * theta);

Arc2D.Double arc = new Arc2D.Double(15, 55, 90, 90, 0, a, Arc2D.PIE); g2D.draw(arc);

Line2D.Double line1 = new Line2D.Double(60, 100 - (d * 45),250 + (a / 2.7), 100 - (d * 45));


j = i + 1;

d = (double) Math.cos(i * theta); d1 = (double) Math.cos(j * theta);


g2D.draw(line); }

for (i = -1; i > a; i--) {

j = i - 1; d = (double) Math.cos(i * theta);

d1 = (double) Math.cos(j * theta);


34

}

} if (b == "tan") {

d = (double) Math.tan(a * theta);


Line2D.Double line1 = new Line2D.Double(60, 100 - (d * 45),250 + (a / 2.7), 100 - (d * 45));


j = i + 1;

d = (double) Math.tan(i * theta); d1 = (double) Math.tan(j * theta);


g2D.draw(line); }

for (i = -1; i > a; i--) {

j = i - 1; d = (double) Math.tan(i * theta);

d1 = (double) Math.tan(j * theta);


}

} if (b == "cot") {

d = 1 / (double) Math.tan(a * theta);


Line2D.Double line1 = new Line2D.Double(60, 100 - (d * 45),250 + (a / 2.7), 100 - (d * 45)); g2D.draw(line1);

for (i = 1; i < a; i++) {

j = i + 1; d = 1 / (double) Math.tan(i * theta);

d1 = 1 / (double) Math.tan(j * theta);


}

for (i = -1; i > a; i--) { j = i - 1;

d = 1 / (double) Math.tan(i * theta);

d1 = 1 / (double) Math.tan(j * theta); Line2D.Double line = new Line2D.Double(250 + (i / 2.7),100 - (d * 45), 250 + (j / 2.7), 100 - (d1 * 45));

g2D.draw(line);

} }

if (b == "sec") {

d = 1 / (double) Math.cos(a * theta); Arc2D.Double arc = new Arc2D.Double(15, 55, 90, 90, 0, a, Arc2D.PIE);

g2D.draw(arc);


for (i = 1; i < a; i++) {

j = i + 1; d = 1 / (double) Math.cos(i * theta);

d1 = 1 / (double) Math.cos(j * theta);


}

for (i = -1; i > a; i--) { j = i - 1;

d = 1 / (double) Math.cos(i * theta);

d1 = 1 / (double) Math.cos(j * theta); Line2D.Double line = new Line2D.Double(250 + (i / 2.7),100 - (d * 45), 250 + (j / 2.7), 100 - (d1 * 45));

g2D.draw(line);

} }

if (b == "csc") {

d = 1 / (double) Math.sin(a * theta); Arc2D.Double arc = new Arc2D.Double(15, 55, 90, 90, 0, a, Arc2D.PIE);

g2D.draw(arc);


for (i = 1; i < a; i++) {

j = i + 1; d = 1 / (double) Math.sin(i * theta);

d1 = 1 / (double) Math.sin(j * theta);

35


g2D.draw(line); }

for (i = -1; i > a; i--) {

j = i - 1; d = 1 / (double) Math.sin(i * theta);

d1 = 1 / (double) Math.sin(j * theta);


}

} }

//Get a parameter value

public String getParameter(String key, String def) { return isStandalone ? System.getProperty(key, def) :

(getParameter(key) != null ? getParameter(key) : def);

} //Construct the applet

public creat1() {}

//Initialize the applet public void init() {

try {

jbInit(); } catch (Exception e) {

e.printStackTrace();

} }

//Component initialization private void jbInit() throws Exception {

this.setLayout(null);

this.setBackground(Color.white); scrollbar1.setOrientation(0);

scrollbar1.setBounds(new Rectangle(70, 267, 199, 22));

scrollbar1.addAdjustmentListener(new creat1_scrollbar1_adjustmentAdapter(this)); textField1.setBounds(new Rectangle(279, 269, 47, 20));

textField1.addActionListener(new creat1_textField1_actionAdapter(this));

choice1.setBounds(new Rectangle(13, 268, 46, 26)); choice1.addItemListener(new creat1_choice1_itemAdapter(this));

this.addMouseMotionListener(new creat1_this_mouseMotionAdapter(this));

textField1.setText(" "); choice1.add("sin");

choice1.add("cos");

choice1.add("tan"); choice1.add("cot");

choice1.add("sec");

choice1.add("csc"); scrollbar1.setMinimum( -360);

scrollbar1.setVisibleAmount(1);

scrollbar1.setMaximum(361); this.add(choice1);

this.add(scrollbar1);

this.add(textField1); }

//Start the applet

public void start() {} public void update(Graphics g) {

if (offscreen == null) {

offscreen = createImage(this.getSize().width, this.getSize().height); drawoffscreen = offscreen.getGraphics();

}

drawoffscreen.setColor(getBackground()); drawoffscreen.fillRect(0, 0, this.getSize().width,

this.getSize().height);

drawoffscreen.setColor(getBackground()); paint(drawoffscreen);

g.drawImage(offscreen, 0, 0, this);

} //Stop the applet

public void stop() {}

//Destroy the applet public void destroy() {}

//Get Applet information

public String getAppletInfo() {return "Applet Information";} //Get parameter info

public String[][] getParameterInfo() {return null;}

36

public void textField1_actionPerformed(ActionEvent e) {}

public void scrollbar1_adjustmentValueChanged(AdjustmentEvent e) { a = scrollbar1.getValue();

textField1.setText(String.valueOf(a));

repaint();} public void choice1_itemStateChanged(ItemEvent e) {

b = choice1.getSelectedItem();

repaint();} public void button1_actionPerformed(ActionEvent e) {

f = Integer.parseInt(textField1.getText());

f = scrollbar1.getValue(); repaint();}

public void this_mouseDragged(MouseEvent e) {

x = e.getX(); repaint(); }

}

class creat1_this_mouseMotionAdapter extends MouseMotionAdapter { private creat1 adaptee;

creat1_this_mouseMotionAdapter(creat1 adaptee) {this.adaptee = adaptee;}

public void mouseDragged(MouseEvent e) {adaptee.this_mouseDragged(e);} }

class creat1_choice1_itemAdapter implements ItemListener {

private creat1 adaptee; creat1_choice1_itemAdapter(creat1 adaptee) {this.adaptee = adaptee;}

public void itemStateChanged(ItemEvent e) {adaptee.choice1_itemStateChanged(e);}

} class creat1_scrollbar1_adjustmentAdapter implements AdjustmentListener {

private creat1 adaptee; creat1_scrollbar1_adjustmentAdapter(creat1 adaptee) {this.adaptee = adaptee;}

public void adjustmentValueChanged(AdjustmentEvent e) {adaptee.scrollbar1_adjustmentValueChanged(e);}

} class creat1_textField1_actionAdapter implements ActionListener {

private creat1 adaptee;

creat1_textField1_actionAdapter(creat1 adaptee) {this.adaptee = adaptee;} public void actionPerformed(ActionEvent e) {adaptee.textField1_actionPerformed(e);}

}

37

附錄附錄附錄附錄 B 摺積摺積摺積摺積 Convolution 程式碼程式碼程式碼程式碼

package convo;

import java.awt.*;

import java.awt.event.*;


import java.awt.Rectangle;

public class Applet1 extends Applet implements Runnable {


BorderLayout borderLayout1 = new BorderLayout();

Button button1 = new Button();



int m[] = {0, 0, 0, 0, 3, 3, 3, -3, -3, -3, 0, 0, 0, 0, 0}; //初始圖形~方波

int n[] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //初始圖形~delta 波

int t[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //暫存器

int Square[] = {0, 0, 0, 0, 3, 3, 3, -3, -3, -3, 0, 0, 0, 0, 0}; //方波

int Delta[] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //delta 波

int Tria[] = {0, 0, 0, 0, 1, 3, 5, 3, 1, 0, 0, 0, 0, 0, 0}; //鋸齒波

int Step[] = {0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0}; //步階

int Noise[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //雜訊

int dshift[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3}; //步階平移

int Cos[] = {0, 0, 0, 0, 4, 3, 1, -1, -3, -4, -3, -1, 1, 3, 4}; //cos波

int ch = 15, ich = 14, ych = 29; //個波形元素 15個單位，摺積結果 29個單位

Image offscreen;

Graphics drawoffscreen;

int j, x = 0, y = 0, xx = 0;


public String getParameter(String key, String def) {

return isStandalone ? System.getProperty(key, def) :

(getParameter(key) != null ? getParameter(key) : def);}

//Construct the applet

public Applet1() {}

//Initialize the applet

public void init()

{

try {jbInit();}

catch (Exception e) {e.printStackTrace();}

}

//Component initialization

private void jbInit() throws Exception {

this.setBackground(Color.white);

this.addMouseMotionListener(new Applet1_this_mouseMotionAdapter(this));


button1.setLabel("Display");

button1.setBounds(new Rectangle(290, 22, 130, 53));

button1.addActionListener(new Applet1_button1_actionAdapter(this));

choice1.setBounds(new Rectangle(22, 23, 110, 22));

choice1.addItemListener(new Applet1_choice1_itemAdapter(this));

choice1.addHierarchyBoundsListener(new

Applet1_choice1_hierarchyBoundsAdapter(this));



choice2.addHierarchyBoundsListener(new

Applet1_choice2_hierarchyBoundsAdapter(this));

choice1.addItem("Square");

choice1.addItem("Step");

choice1.addItem("Step_shift");

38

choice1.addItem("Triangle");

choice1.addItem("Noise");

choice1.addItem("Cos");

choice2.addItem("Delta");

choice2.addItem("Square");

choice2.addItem("Step");

choice2.addItem("Triangle");

this.add(button1);

this.add(choice1);

this.add(choice2);}

//Start the applet

public void start() {}

//Stop the applet


//Destroy the applet

public void destroy() {}

public void run() {

Graphics g = getGraphics();

for (xx = 0; xx < 280; xx++) {

xx = xx;

repaint();

try {

Thread.sleep(20); //Display單位時間設置為 20毫秒

} catch (InterruptedException e) {}

}

xx = 0;

repaint();

}


g.setColor(Color.black);

g.drawLine(20, 90, 420, 90);

g.drawLine(20, 180, 420, 180);

g.drawLine(20, 290, 420, 290);

g.drawLine(20, 400, 420, 400); //

g.drawLine(220, 90, 220, 400);

g.drawLine(420, 90, 420, 400);

g.drawLine(20, 90, 20, 400);

g.drawLine(470, 250, 790, 250);

g.drawLine(560, 10, 560, 540);


g.drawLine(790, 10, 790, 540);

g.drawLine(470, 10, 470, 540);

g.drawLine(470, 10, 790, 10);

g.drawLine(470, 540, 790, 540);


g.drawLine(215, 155, 225, 155);

g.drawLine(217, 160, 223, 160);

g.drawLine(217, 165, 223, 165);

g.drawLine(217, 170, 223, 170);

g.drawLine(217, 175, 223, 175);

g.drawLine(215, 265, 225, 265);

g.drawLine(217, 270, 223, 270);

g.drawLine(217, 285, 223, 285);

g.drawLine(217, 275, 223, 275);

g.drawLine(217, 280, 223, 280);

g.drawString("h[n]", 240, 155);

g.drawString("x[n]", 40, 155);

g.setColor(Color.black); //

g.drawLine(558, 300, 562, 300);

g.drawLine(558, 350, 562, 350);

39

g.drawLine(558, 400, 562, 400);

g.drawLine(558, 450, 562, 450);

g.drawLine(558, 500, 562, 500);

g.drawLine(558, 200, 562, 200);

g.drawLine(558, 150, 562, 150);

g.drawLine(558, 100, 562, 100);

g.drawLine(558, 50, 562, 50);

g.drawString("x[n-k]and h[k]", 40, 265);

g.drawString("y[n]= x[k]h[n-k]", 660, 37);

g.drawString("Σ", 692, 38);

g.drawString("∞", 695, 24);

g.drawString(" 選取 [Input] 選取[System] 信號", 20, 17);

g.drawString("k=-∞", 687, 47);

g.drawString("5.0", 190, 155);

g.drawString("5.0", 190, 265);

g.drawString("40.0", 526, 47);

g.drawString("10.0", 523, 200);

g.drawString("-10.0", 520, 300);

g.drawString("Input", 95, 125);

g.drawString("System", 290, 125);

g.drawString("Covolution分解步驟", 110, 420);

g.setColor(Color.magenta);

g.drawOval(38 + x, 288, 4, 4);

g.drawOval(36 + x, 286, 8, 8);

g.drawString("控制點", 30 + x, 320);

for (int i = 0; i < ch; i++) {

g.setColor(Color.blue);

g.drawLine(i * 10 + 50, 180, i * 10 + 50, 180 - m[i] * 5);

if (m[i] != 0)

g.fillOval(i * 10 + 48, 178 - m[i] * 5, 4, 4); //繪出 input

g.setColor(Color.red);

g.drawLine(i * 10 + 270, 180, i * 10 + 270, 180 - n[i] * 5);

if (n[i] != 0)

g.fillRect(i * 10 + 268, 178 - n[i] * 5, 4, 4); //繪出 system


g.drawLine(i * 10 + 180, 290, i * 10 + 180, 290 - n[i] * 5);

if (n[i] != 0)

g.fillRect(i * 10 + 178, 288 - n[i] * 5, 4, 4); //繪出 system

}

int y[] = new int[29]; // 設置摺積結果，29個元素的陣列 y[]

for (int i = 0; i < ych; i++) { //ych=29

y[i] = 0;

}

for (int i = 0; i < ch; i++) { //ch=15

for (int j = 0; j < ch; j++) {

y[i + j] = y[i + j] + m[i] * n[j]; //得到摺積陣列 y[]所有的值}

}

for (int j = 0; j < ((x + xx) / 10); j++) {


g.drawLine(j * 10 + 480, 250, j * 10 + 480, 250 - y[j] * 5); //秀圖 3

if (y[j] != 0)

g.fillOval(j * 10 + 478, 248 - y[j] * 5, 4, 4);

}

//以下程式碼利用卷軸控制 input 陣列圖形的動向

for (int i = 0; i < ch; i++) { //將 input 元素前後置換

t[i] = m[ich - i]; } //置換後的新陣列暫存於 t[]

for (int j = 0; j < 30; j++) {

int temp = 0; //設 temp 為圖形像右移動的單位

40

temp = ((x + xx) / 10) * 10;

for (int i = 0; i < ch; i++) {


g.drawLine(i * 10 + temp + 30, 290, i * 10 + temp + 30, 290 - t[i] * 5);

if (t[i] != 0)

g.fillOval(i * 10 + temp + 28, 288 - t[i] * 5, 4, 4);}

}}

public void update(Graphics g) {


offscreen = createImage(this.getSize().width, this.getSize().height);

drawoffscreen = offscreen.getGraphics(); }

drawoffscreen.setColor(getBackground());

drawoffscreen.fillRect(0, 0, this.getSize().width, this.getSize().height);


paint(drawoffscreen);

g.drawImage(offscreen, 0, 0, this);}


public String getAppletInfo() {return "Applet Information";}

//Get parameter info


public void button1_actionPerformed(ActionEvent e) {

Thread th = new Thread(this);

th.start();

return;

}

public void choice1_ancestorMoved(HierarchyEvent e) {}


public void this_mouseDragged(MouseEvent e) {

y = e.getY();

if (280 < y) {

x = e.getX() - 39;

repaint();}}

public void choice1_itemStateChanged(ItemEvent e) {

String d;

d = choice1.getSelectedItem();

if (d == "Step_shift") { //選取平移步階信號做 input 信號

for (int i = 0; i < ch; i++) {m[i] = dshift[i];}}

if (d == "Cos") { //選取 COS 波做 input 信號

for (int i = 0; i < ch; i++) {m[i] = Cos[i];}}

if (d == "Square") { //選取方波做 input 信號

for (int i = 0; i < ch; i++) {m[i] = Square[i];}}

if (d == "Triangle") { //選取鋸齒波信號做 input 信號

for (int i = 0; i < ch; i++) {m[i] = Tria[i];}}

if (d == "Step") { //選取步階信號做 input 信號

for (int i = 0; i < ch; i++) {m[i] = Step[i];}}

if (d == "Noise") { //選取雜訊波做 input 信號

for (int i = 0; i < ch; i++) {

int temp = (int) ((Math.random() - 0.5) * 10); //製造亂數

Noise[i] = temp;

m[i] = Noise[i];}

}

for (int i = 0; i < ch; i++) {

t[i] = m[ich - i]; //將 input 陣列元素前後對換，暫存於 t[]}

repaint(); //重繪 paint()

}


repaint();

String d;

d = choice2.getSelectedItem();

41

if (d == "Square") { //選取方波做 SYSTEM 信號

for (int i = 0; i < ch; i++) {

n[i] = Square[i];}

}

if (d == "Delta") { //選取 delta 波做 SYSTEM 信號

for (int i = 0; i < ch; i++) {

n[i] = Delta[i];}

}

if (d == "Triangle") { //選取鋸齒波做 SYSTEM信號

for (int i = 0; i < ch; i++) {

n[i] = Tria[i];}

}

if (d == "Step") { //選取步接信號做 SYSTEM信號

for (int i = 0; i < ch; i++) {

n[i] = Step[i];}

}}}

class Applet1_this_mouseMotionAdapter extends MouseMotionAdapter {

private Applet1 adaptee;

Applet1_this_mouseMotionAdapter(Applet1 adaptee) {this.adaptee = adaptee;}

public void mouseDragged(MouseEvent e) {adaptee.this_mouseDragged(e);}

}

class Applet1_choice2_hierarchyBoundsAdapter extends HierarchyBoundsAdapter {


Applet1_choice2_hierarchyBoundsAdapter(Applet1 adaptee) {this.adaptee = adaptee;}

public void ancestorMoved(HierarchyEvent e) {adaptee.choice2_ancestorMoved(e);}

}





}

class Applet1_choice2_itemAdapter implements ItemListener {


Applet1_choice2_itemAdapter(Applet1 adaptee) {this.adaptee = adaptee;}


}





}

class Applet1_button1_actionAdapter implements ActionListener {


Applet1_button1_actionAdapter(Applet1 adaptee) {this.adaptee = adaptee;}

public void actionPerformed(ActionEvent e) {adaptee.button1_actionPerformed(e);}

}

42

附錄附錄附錄附錄 C 傅立業級數傅立業級數傅立業級數傅立業級數 Fourier series 程式碼程式碼程式碼程式碼

package untitled2;

import java.awt.*;





public class Applet1 extends Applet implements Runnable {



Scrollbar scrollbar1 = new Scrollbar();

Image offscreen;



double d1, d, x1, pi = Math.PI, theta = (Math.PI / 50);

double[][] y = new double[101][601];

double[][] y1 = new double[101][601];







int a, x, n, i;

String b;





}


public Applet1() {}


public void init() {

try {

jbInit();

} catch (Exception e) {

e.printStackTrace();

}

}





scrollbar1.setMaximum(110);

scrollbar1.setMinimum(0);

scrollbar1.setOrientation(0);


scrollbar1.addAdjustmentListener(new Applet1_scrollbar1_adjustmentAdapter(this));




this.add(choice1);

choice1.add("square wave");

choice1.add("sawtooth wave");

choice1.add("triangular wave");

}

public void run() {}

43


Graphics2D g2D = (Graphics2D) g;


g.drawString(" " + a, 245, 21);

g.setColor(Color.gray);

g.drawLine(0, 150, 400, 150);

g.drawLine(200, 0, 200, 300);

g.drawLine(50, 145, 50, 155);

g.drawLine(150, 145, 150, 155);

g.drawLine(350, 145, 350, 155);

g.drawLine(250, 145, 250, 155);

g.drawString("-0.002s", 40, 175);

g.drawString("-0.001s", 140, 175);

g.drawString("0s", 205, 175);

g.drawString("1", 205, 45);

g.drawLine(195, 50, 205, 50);

g.drawString("0.001s", 245, 175);

g.drawString("0.002s", 345, 175);

if (b == "square wave") {


g.drawLine(250, 150, 350, 150);

g.drawLine(0, 50, 50, 50);

g.drawLine(250, 50, 150, 50);

g.drawLine(350, 50, 450, 50);

g.drawLine(50, 150, 150, 150);

g.drawLine(50, 150, 50, 50);

g.drawLine(150, 150, 150, 50);

g.drawLine(250, 150, 250, 50);

g.drawLine(350, 150, 350, 50);

for (n = 1; n <= 100; n++) {

for (x = -200; x <= 400; x++) {

y[n][x +200] = 200 / pi / (2 * n - 1) *

((Math.sin((2 * n - 1) * 2 * pi * x / 200)));

y1[n][x +200] = 200 / pi / (2 * n - 1) *

((Math.sin((2 * n - 1) * 2 * pi * (x + 1) /200)));

}

}

for (n = 1; n <= 100; n++) {

for (x = 1; x <= 600; x++) {

y[n][x] = y[n][x] + y[n - 1][x];

y1[n][x] = y1[n][x] + y1[n - 1][x];}}

for (x = 1; x <= 600; x++) {

for (i = 1; i <= a; i++) {


Line2D.Double line = new Line2D.Double(x - 50, 100 - y[a][x],

(x + 1) - 50, 100 - y1[a][x]);

g2D.draw(line);

}

}

}

if (b == "sawtooth wave") {


g.drawLine( -50, 50, 50, 150);

g.drawLine(150, 50, 250, 150);

g.drawLine(50, 50, 150, 150);

g.drawLine(250, 50, 350, 150);

g.drawLine(350, 50, 450, 150);

g.drawLine(50, 50, 50, 150);

g.drawLine(150, 50, 150, 150);

g.drawLine(250, 50, 250, 150);

44

g.drawLine(350, 50, 350, 150);

for (n = 1; n <= 100; n++) {

for (x = -200; x <= 400; x++) {

y2[n][x + 200] = 100 * Math.cos(n * 2 * pi / 100) / (n * pi) *

Math.sin(n * 2 * pi * x / 100);

y3[n][x +200] = 100 * Math.cos(n * 2 * pi / 100) / (n * pi) *

Math.sin(n * 2 * pi * (x + 1) / 100);}

}

for (n = 1; n <= 100; n++) {

for (x = 1; x <= 600; x++) {

y2[n][x] = y2[n][x] + y2[n - 1][x];

y3[n][x] = y3[n][x] + y3[n - 1][x];}}

for (x = 1; x <= 600; x++) {

for (i = 1; i <= a; i++) {


Line2D.Double line = new Line2D.Double(x - 50,100 - y2[a][x],

(x + 1) - 50, 100 - y3[a][x]);

g2D.draw(line);

}

}

}

if (b == "triangular wave") {


g.drawLine(400, 50, 300, 150);

g.drawLine(200, 50, 300, 150);

g.drawLine(0, 50, 100, 150);

g.drawLine(200, 50, 100, 150);

for (n = 1; n <= 100; n++) {

for (x = -200; x <= 400; x++) {

y4[n][x +200] = ( -400 / (pi * pi)) * (Math.cos(((2 * n - 1) * 2 * pi * x) / 200))

/

((2 * n - 1) * (2 * n - 1));

y5[n][x +200] = ( -400 / (pi * pi)) *(Math.cos(((2 * n - 1) * 2 * pi * (x + 1)) /

200)) / ((2 * n - 1) * (2 * n - 1));

}

}

for (n = 1; n <= 100; n++) {

for (x = 1; x <= 600; x++) {

y4[n][x] = y4[n][x] + y4[n - 1][x];

y5[n][x] = y5[n][x] + y5[n - 1][x];

}

}

for (x = 1; x <= 600; x++) {

for (i = 1; i <= a; i++) {


Line2D.Double line = new Line2D.Double(x, 100 + y4[a][x],

(x + 1), 100 + y5[a][x]);

g2D.draw(line);

}

}

}

}

//Start the applet


//Stop the applet






45


drawoffscreen = offscreen.getGraphics();}


drawoffscreen.fillRect(0, 0, this.getSize().width,this.getSize().height);




}





public void scrollbar1_adjustmentValueChanged(AdjustmentEvent e) {

a = scrollbar1.getValue();

repaint();

}



repaint();}

}





}

class Applet1_scrollbar1_adjustmentAdapter implements AdjustmentListener {


Applet1_scrollbar1_adjustmentAdapter(Applet1 adaptee) {this.adaptee = adaptee;}

public void adjustmentValueChanged(AdjustmentEvent e) {

adaptee.scrollbar1_adjustmentValueChanged(e);}

}

46

附錄附錄附錄附錄 D Discrete-to-Continuous Conversion 程式碼程式碼程式碼程式碼

package last;

import java.awt.*;





import java.awt.geom.Ellipse2D;

public class Applet1 extends Applet {


Choice choice1 = new Choice(); //定義向下拉頁 1


Scrollbar scrollbar1 = new Scrollbar(); //定義軸 1

Scrollbar scrollbar2 = new Scrollbar(); //定義卷軸 2

Image offscreen; //定義圖片變數 offscreen


int i, j, k, l, a, v; //定義整數 a為取樣週期、v為 sin波週期、k為取樣頻率、l為 sin波頻率

double pi = Math.PI; //定義 pi=π

double d, d1, e, e1, f, f1, f2, f3, f4, f5; //定義浮點數

String b; //定義字形變數 b

double[][] sampley = new double[501][801]; //定義 501*801 的矩陣存放取樣點在 y軸的高度

int[][] samplex = new int[501][801]; //定義 501*801的矩陣存放取樣點在 t軸的長度

double[][] sampley1 = new double[501][801]; //501*801 矩陣存放下一個取樣點在 y軸的高度

int[][] samplex1 = new int[501][801]; //定義 501*801 的矩陣存放下一個取樣點在 t 軸的長度

double[][] y = new double[501][801];





double[] theta = new double[501]; //定義矩陣 theta 為 501*1 的矩陣存放角度大小





}


public Applet1() {}


g.setColor(Color.gray);

Graphics2D g2D = (Graphics2D) g;


g.drawString("fs=" + k + "Hz", 330, 18);

g.drawString("fo=" + l + "Hz", 330, 38);

Line2D.Double linex = new Line2D.Double(0, 150, 400, 150);

Line2D.Double liney = new Line2D.Double(50, 10, 50, 250);

g2D.draw(linex);

g2D.draw(liney);

g.drawLine(150, 145, 150, 155);

g.drawString("0.005s", 150, 167);

g.drawLine(250, 145, 250, 155);

g.drawString("0.01s", 250, 167);

g.drawLine(45, 50, 55, 50);



g.drawLine(45, 250, 55, 250);

g.drawString("-1", 36, 250);

47

g.setColor(Color.lightGray);

for (i = 1; i <= 500; i++) {theta[i] = (Math.PI / i);}

for (i = -20; i < 500; i++) {

d = (double) Math.sin((i - 40) * theta[v]) * 100;

d1 = (double) Math.sin((i - 39) * theta[v]) * 100;

Line2D.Double line = new Line2D.Double(10 + i, 150 - d, 10 + (i + 1),150 - d1);

g2D.draw(line);

}

for (i = 1; i <= 500; i++) {

for (j = -40; j <= 400; j++) {

samplex[i][j + 40] = (i * j - i);

sampley[i][j + 40] = Math.sin(((i * j - i)) * theta[v]) * 100;

samplex1[i][j + 40] = (i * (j + 1) - i);

sampley1[i][j + 40] = Math.sin(((i * (j + 1) - i)) * theta[v]) * 100;

}

}

for (i = 0; i <= 500; i++) {


Line2D.Double line = new Line2D.Double(50 + samplex[a][i],

150 - sampley[a][i], 50 + samplex[a][i], 150);

g2D.draw(line);

Ellipse2D.Double circle = new Ellipse2D.Double(47 + samplex[a][i],

147 - sampley[a][i], 6, 6);

g2D.draw(circle);

}

for (i = 1; i <= 500; i++) {

if (b == "Zero-order square pulse") {


Line2D.Double line4 = new Line2D.Double(50 + samplex[a][i] -((a + 1) / 2)

, 150 - sampley[a][i] ,50 + samplex[a][i] + ((a + 1) / 2), 150 - sampley[a][i]);

g2D.draw(line4);

Line2D.Double line2 = new Line2D.Double(50 + samplex[a][i] - ((a + 1) / 2)

, 150 - sampley[a][i], 50 + samplex[a][i] - ((a + 1) / 2) , 150);

g2D.draw(line2);

Line2D.Double line3 = new Line2D.Double(50 + samplex[a][i] + ((a + 1) / 2)

, 150 - sampley[a][i] ,50 + samplex1[a][i] - ((a + 1) / 2), 150);

g2D.draw(line3);

g.setColor(Color.green);

Line2D.Double line1 = new Line2D.Double(50 + samplex[a][i] - ((a + 1) / 2)

, 150 - sampley[a][i] ,50 + samplex[a][i] + ((a + 1) / 2) , 150 - sampley[a][i]);

g2D.draw(line1);

}

}

if (b == "triangular pulse") {

for (i = 1; i <= 42; i++) {


Line2D.Double line1 = new Line2D.Double(50 + samplex[a][i]

, 150 - sampley[a][i], 50 + samplex[a][i] + ((a + 1)) , 150);

g2D.draw(line1);


, 150 - sampley[a][i], 50 + samplex[a][i] - ((a + 1)), 150);

g2D.draw(line2);

}

for (i = 43; i <= 43; i++) {

g.setColor(Color.cyan);


, 150 - sampley[a][i], 50 + samplex[a][i] + ((a + 1)), 150);

g2D.draw(line1);



48

g2D.draw(line2);

}

for (i = 44; i <= 44; i++) {

g.setColor(Color.yellow);


, 150 - sampley[a][i], 50 + samplex[a][i] + ((a + 1)), 150);

g2D.draw(line1);



g2D.draw(line2);

}

for (i = 45; i <= 45; i++) {

g.setColor(Color.pink);



g2D.draw(line1);


, 150 - sampley[a][i] , 50 + samplex[a][i] - ((a + 1)) , 150);

g2D.draw(line2);

}

for (i = 46; i <= 500; i++) {

g.setColor(Color.GREEN);



g2D.draw(line1);



g2D.draw(line2);

}

for (i = 1; i <= 500; i++) {



, 150 - sampley[a][i], 50 + samplex1[a][i] , 150 - sampley1[a][i]);

g2D.draw(line3);

}

}

if (b == "sinc 7 point") {


for (i = 1; i <= 500; i++) {

for (j = 1; j <= 3 * a; j++) {

d = (double) Math.sin(j * pi / a) / (j * pi / a) *

sampley[a][i];

d1 = (double) Math.sin((j + 1) * pi / a) /

((j + 1) * pi / a) * sampley[a][i];

Line2D.Double line = new Line2D.Double(50 + j +samplex[a][i]

, 150 - d, 50 + (j + 1) + samplex[a][i], 150 - d1);

g2D.draw(line);

Line2D.Double line1 = new Line2D.Double(50 - j +samplex[a][i]

, 150 - d, 50 - (j + 1) + samplex[a][i], 150 - d1);

g2D.draw(line1);

}

}

for (i = 6; i <= 500; i++) {

for (j = 1; j <= a - 2; j++) {


e = (double)

+

Math.sin((2 * a + j) * pi / (a)) / ((2 * a + j) * pi / (a)) *

sampley[a][i - 2]

+

49

Math.sin((a + j) * pi / (a)) / ((a + j) * pi / (a)) *

sampley[a][i - 1]

+ Math.sin(j * pi / a) / (j * pi / a) * sampley[a][i]

+

Math.sin((a - j) * pi / a) / ((a - j) * pi / a) *

sampley[a][i + 1]

+

Math.sin((2 * a - j) * pi / a) / ((2 * a - j) * pi / a) *

sampley[a][i + 2]

+


sampley[a][i + 3];

e1 = (double)

+

Math.sin((2 * a + j + 1) * pi / (a)) /

((2 * a + j + 1) * pi / (a)) * sampley[a][i - 2]

+

Math.sin((a + j + 1) * pi / (a)) / ((a + j + 1) * pi / (a)) *

sampley[a][i - 1]

+

Math.sin((j + 1) * pi / a) / ((j + 1) * pi / a) *

sampley[a][i]

+

Math.sin((a - (j + 1)) * pi / a) /

((a - (j + 1)) * pi / a) * sampley[a][i + 1]

+

Math.sin((2 * a - (j + 1)) * pi / a) /

((2 * a - (j + 1)) * pi / a) * sampley[a][i + 2]

+

Math.sin((3 * a - (j + 1)) * pi / a) /

((3 * a - (j + 1)) * pi / a) * sampley[a][i + 3];

Line2D.Double line2 = new Line2D.Double(50 + j +

samplex[a][i], 150 - e, 50 + (j + 1) + samplex[a][i],150 - e1);

g2D.draw(line2);

}

}

}

if (b == "sinc 11 point") {


for (i = 1; i <= 500; i++) {

for (j = 1; j <= 4 * a; j++) {

d = (double) Math.sin(j * pi / a) / (j * pi / a) *

sampley[a][i];

d1 = (double) Math.sin((j + 1) * pi / a) /

((j + 1) * pi / a) * sampley[a][i];

Line2D.Double line = new Line2D.Double(50 + j +

samplex[a][i], 150 - d, 50 + (j + 1) + samplex[a][i], 150 - d1);

g2D.draw(line);

Line2D.Double line1 = new Line2D.Double(50 - j +samplex[a][i]

, 150 - d, 50 - (j + 1) + samplex[a][i], 150 - d1);

g2D.draw(line1);

}

}

for (i = 6; i <= 500; i++) {

for (j = 1; j <= a - 2; j++) {


e = (double)

+


50

sampley[a][i - 4]

+


sampley[a][i - 3]

+


sampley[a][i - 2]

+

Math.sin((a + j) * pi / (a)) / ((a + j) * pi / (a)) *

sampley[a][i - 1]

+ Math.sin(j * pi / a) / (j * pi / a) * sampley[a][i]

+

Math.sin((a - j) * pi / a) / ((a - j) * pi / a) *

sampley[a][i + 1]

+


sampley[a][i + 2]

+


sampley[a][i + 3]

+


sampley[a][i + 4]

+


sampley[a][i + 5]

;

e1 = (double)

+

Math.sin((4 * a + j + 1) * pi / (a)) /

((4 * a + j + 1) * pi / (a)) * sampley[a][i - 4]

+

Math.sin((3 * a + j + 1) * pi / (a)) /

((3 * a + j + 1) * pi / (a)) * sampley[a][i - 3]

+

Math.sin((2 * a + j + 1) * pi / (a)) /

((2 * a + j + 1) * pi / (a)) * sampley[a][i - 2]

+

Math.sin((a + j + 1) * pi / (a)) / ((a + j + 1) * pi / (a)) *

sampley[a][i - 1]

+

Math.sin((j + 1) * pi / a) / ((j + 1) * pi / a) *

sampley[a][i]

+

Math.sin((a - (j + 1)) * pi / a) /

((a - (j + 1)) * pi / a) * sampley[a][i + 1]

+

Math.sin((2 * a - (j + 1)) * pi / a) /

((2 * a - (j + 1)) * pi / a) * sampley[a][i + 2]

+

Math.sin((3 * a - (j + 1)) * pi / a) /

((3 * a - (j + 1)) * pi / a) * sampley[a][i + 3]

+

Math.sin((4 * a - (j + 1)) * pi / a) /

((4 * a - (j + 1)) * pi / a) * sampley[a][i + 4]

+

Math.sin((5 * a - (j + 1)) * pi / a) /

((5 * a - (j + 1)) * pi / a) * sampley[a][i + 5];


samplex[a][i], 150 - e, 50 + (j + 1) + samplex[a][i],

51

150 - e1);

g2D.draw(line2);

}

}

}

if (b == "3rd-order cubic spline") {

for (i = 1; i <= 42; i++) {


for (j = 0; j < a; j++) {

f = (1.5 * (Math.pow(j, 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(j, 2)) / Math.pow(a, 2) + 1) *sampley[a][i];

f1 = (1.5 * (Math.pow((j + 1), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow((j + 1), 2)) / Math.pow(a, 2) + 1) *sampley[a][i];


samplex[a][i], 150 - f, 50 + (j + 1) + samplex[a][i],150 - f1);

g2D.draw(line);

Line2D.Double line1 = new Line2D.Double(50 - j +

samplex[a][i], 150 - f, 50 - (j + 1) + samplex[a][i],150 - f1);

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {

f2 = ( -0.5 * (Math.pow(j, 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(j, 2)) / Math.pow(a, 2) -

4 * Math.pow(j, 1) / Math.pow(a, 1) + 2) *sampley[a][i];

f3 = ( -0.5 * (Math.pow((j + 1), 3)) / Math.pow(a, 3) +

2.5 * (Math.pow((j + 1), 2)) / Math.pow(a, 2) -

4 * Math.pow((j + 1), 1) / Math.pow(a, 1) + 2) *sampley[a][i];


samplex[a][i], 150 - f2,50 + (j + 1) + samplex[a][i],150 - f3);

g2D.draw(line1);

Line2D.Double line2 = new Line2D.Double(50 - j +samplex[a][i], 150 - f2,

50 - (j + 1) + samplex[a][i],150 - f3);

g2D.draw(line2);

}

}

for (i = 43; i <= 43; i++) {

for (j = 0; j < a; j++) {

g.setColor(Color.cyan);


2.5 * (Math.pow(j, 2)) / Math.pow(a, 2) + 1) *

sampley[a][i];


2.5 * (Math.pow((j + 1), 2)) / Math.pow(a, 2) + 1) *

sampley[a][i];


samplex[a][i], 150 - f, 50 + (j + 1) + samplex[a][i],

150 - f1);

g2D.draw(line);


samplex[a][i], 150 - f, 50 - (j + 1) + samplex[a][i],

150 - f1);

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {



4 * Math.pow(j, 1) / Math.pow(a, 1) + 2) *

sampley[a][i];


52


4 * Math.pow((j + 1), 1) / Math.pow(a, 1) + 2) *

sampley[a][i];



g2D.draw(line1);


samplex[a][i], 150 - f2,50 - (j + 1) + samplex[a][i],150 - f3);

g2D.draw(line2);

}

}

for (i = 44; i <= 44; i++) {

g.setColor(Color.yellow);

for (j = 0; j < a; j++) {



sampley[a][i];



sampley[a][i];


samplex[a][i], 150 - f, 50 + (j + 1) + samplex[a][i],150 - f1);

g2D.draw(line);


samplex[a][i], 150 - f, 50 - (j + 1) + samplex[a][i],150 - f1);

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {




sampley[a][i];




sampley[a][i];



g2D.draw(line1);


samplex[a][i], 150 - f2,50 - (j + 1) + samplex[a][i],150 - f3);

g2D.draw(line2);

}

}

for (i = 45; i <= 45; i++) {

g.setColor(Color.pink);

for (j = 0; j < a; j++) {



sampley[a][i];



sampley[a][i];



150 - f1);

g2D.draw(line);



150 - f1);

53

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {




sampley[a][i];




sampley[a][i];


samplex[a][i], 150 - f2,

50 + (j + 1) + samplex[a][i],

150 - f3);

g2D.draw(line1);



50 - (j + 1) + samplex[a][i],

150 - f3);

g2D.draw(line2);

}

}

for (i = 46; i <= 46; i++) {

g.setColor(Color.orange);

for (j = 0; j < a; j++) {



sampley[a][i];



sampley[a][i];



150 - f1);

g2D.draw(line);



150 - f1);

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {




sampley[a][i];




sampley[a][i];



50 + (j + 1) + samplex[a][i],

150 - f3);

g2D.draw(line1);



50 - (j + 1) + samplex[a][i],

150 - f3);

54

g2D.draw(line2);

}

}

for (i = 47; i <= 500; i++) {


for (j = 0; j < a; j++) {



sampley[a][i];



sampley[a][i];



150 - f1);

g2D.draw(line);



150 - f1);

g2D.draw(line1);

}

for (j = a; j < 2 * a; j++) {




sampley[a][i];




sampley[a][i];



50 + (j + 1) + samplex[a][i],

150 - f3);

g2D.draw(line1);



50 - (j + 1) + samplex[a][i],

150 - f3);

g2D.draw(line2);

}

}

for (i = 1; i <= 500; i++) {

for (j = 0; j < a; j++) {


f4 = +( -0.5 * (Math.pow(a + j, 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + j, 2)) / Math.pow(a, 2) -

4 * Math.pow(a + j, 1) / Math.pow(a, 1) + 2) *

sampley[a][i - 1]

+

(1.5 * (Math.pow(j, 3)) / Math.pow(a, 3) -


sampley[a][i]

+

(1.5 * (Math.pow((a - j), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(a - j, 2)) / Math.pow(a, 2) + 1) *

sampley[a][i + 1]

+

( -0.5 * (Math.pow(a + a - j, 3)) / Math.pow(a, 3) +

55

2.5 * (Math.pow(a + a - j, 2)) / Math.pow(a, 2) -

4 * Math.pow(a + a - j, 1) / Math.pow(a, 1) + 2) *

sampley[a][i + 2];

f5 = +( -0.5 * (Math.pow(a + (j + 1), 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + (j + 1), 2)) / Math.pow(a, 2) -

4 * Math.pow(a + (j + 1), 1) / Math.pow(a, 1) + 2) *

sampley[a][i - 1]

+

(1.5 * (Math.pow((j + 1), 3)) / Math.pow(a, 3) -


sampley[a][i]

+

(1.5 * (Math.pow(a - (j + 1), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(a - (j + 1), 2)) / Math.pow(a, 2) + 1) *

sampley[a][i + 1]

+

( -0.5 * (Math.pow(a + a - (j + 1), 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + a - (j + 1), 2)) / Math.pow(a, 2) -

4 * Math.pow(a + a - (j + 1), 1) / Math.pow(a, 1) + 2) *

sampley[a][i + 2];



50 + (j + 1) + samplex[a][i], 150 - f5);

g2D.draw(line);

}

for (j = 0; j < a; j++) {


f4 = +( -0.5 * (Math.pow(a + j, 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + j, 2)) / Math.pow(a, 2) -

4 * Math.pow(a + j, 1) / Math.pow(a, 1) + 2) *sampley[a][i - 1]

+

(1.5 * (Math.pow(j, 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(j, 2)) / Math.pow(a, 2) + 1) *sampley[a][i]

+

(1.5 * (Math.pow((a - j), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(a - j, 2)) / Math.pow(a, 2) + 1) *sampley[a][i + 1]

+

( -0.5 * (Math.pow(a + a - j, 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + a - j, 2)) / Math.pow(a, 2) -

4 * Math.pow(a + a - j, 1) / Math.pow(a, 1) + 2) *sampley[a][i + 2];

f5 = +( -0.5 * (Math.pow(a + (j + 1), 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + (j + 1), 2)) / Math.pow(a, 2) -

4 * Math.pow(a + (j + 1), 1) / Math.pow(a, 1) + 2) *sampley[a][i - 1]

+

(1.5 * (Math.pow((j + 1), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow((j + 1), 2)) / Math.pow(a, 2) + 1) *sampley[a][i]

+

(1.5 * (Math.pow(a - (j + 1), 3)) / Math.pow(a, 3) -

2.5 * (Math.pow(a - (j + 1), 2)) /Math.pow(a, 2) + 1)*sampley[a][i + 1]

+

( -0.5 * (Math.pow(a + a - (j + 1), 3)) / Math.pow(a, 3) +

2.5 * (Math.pow(a + a - (j + 1), 2)) / Math.pow(a, 2) -

4 * Math.pow(a + a - (j + 1), 1) / Math.pow(a, 1) + 2) *sampley[a][i + 2];

Line2D.Double line = new Line2D.Double(50 + j +samplex[a][i], 150 - f4,

50 + (j + 1) + samplex[a][i], 150 - f5);

g2D.draw(line);

}

}

}

56

if (a > v / 2) {


g.drawString("Alising", 40, 50);






}

}


public void init() {

try {jbInit();}

catch (Exception e) {e.printStackTrace();}

}







choice1.addHierarchyBoundsListener(new Applet1_choice1_hierarchyBoundsAdapter(this));






scrollbar2.setMinimum(1);




this.add(choice1);


this.add(scrollbar2, null);

choice1.add("sample");

choice1.add("Zero-order square pulse");

choice1.add("triangular pulse");

choice1.add("3rd-order cubic spline");

choice1.add("sinc 7 point");

choice1.add("sinc 11 point");

}

//Start the applet


//Stop the applet





drawoffscreen = offscreen.getGraphics();}


drawoffscreen.fillRect(0, 0, this.getSize().width,this.getSize().height);




}






57

public String[][] getParameterInfo() { return null;}

public void scrollbar1_adjustmentValueChanged(AdjustmentEvent e) {

a = e.getValue();

k = 10000 / a;

repaint();

}




repaint();

}

void scrollbar2_adjustmentValueChanged(AdjustmentEvent e) {

v = e.getValue();

l = 10000 / v;

repaint();

}

}





}





}

class Applet1_scrollbar1_adjustmentAdapter implements AdjustmentListener {private Applet1 adaptee;




}

class Applet1_scrollbar2_adjustmentAdapter implements java.awt.event.AdjustmentListener {

Applet1 adaptee;




}

Documents

JAVA APPLE在DSP學習網頁上的應用