皮革 床上用品 英语培训 优盘 油画 游戏机 有线电视 幼教 刻录 口吃 口罩 快餐 矿泉水 篮球鞋 浪潮 理财 粮食 猎头 猎头公司 旅游景点 玫瑰 美容院 棉花 民办大学 钱币 桥梁 情报 求职招聘 人才交流 软件公司 扫描 扫描仪 山水 商务网 商行 商业 上海房产 上海租房 上市 少儿英语 设计公司 民歌 玉器 服装辅料 元件 民谣 社保 社会保障 民族音乐 园艺 市场研究 灯箱 远程控制 明信片 社会调查 申请邮箱 牡丹 云南旅游 灯饰 保健食品 生日贺卡 生物工程 在线歌曲 霓虹灯 失眠 农药 造价 花店 农业网 实习 实验 暖通 招生简章 搬家 真空泵厂 世界杯 支原体 直销 试剂 室内装修 喷雾器 职业 盆景 书刊 屏幕 制药厂 卡片 数码照相机 奇石 卡特 痔疮 中草药 开发 棋牌 数字 开发区 考试中心 汽车销售 水环式真空泵 科普 科研 中国律师 展览会 税务师 招聘信息 招商引资 学校管理 思培 塑料包装 学英语 找工作 眼科 泰克 贴纸相 演唱会 植物 制药 药物流产 质量 质量管理 投资公司 智能 中国纺织网 液压 外语学院 一点通 医疗保健 网上商城 玩具出租 网上银行 医疗保险 中国旅行社 保洁 北京翻译 北京翻译公司 中国旅游 网上赚钱 稳压 抑郁症 背景音乐 音像 污水 主页空间 标牌 标志设计 自动化 印刷厂 无线网络 租赁 博士 应聘 无形资产评估 英汉翻译 步进电机 物资 仙人掌 彩信 先锋 纤维 饮食 现代 产品 香格里拉 邮件 成功 邮局 销售 邮票 协会 游记 传真 传真机 信息咨询 运动 姓名学 增高 打折 档案管理 点歌 电工 电力公司 电脑配件 电子信箱 电子邮件 调制解调器 高速公路 工程造价 工业设计 古董 骨科 管理制度 广告策划 规章制度 过滤 汉译英 汉英翻译 汉英互译 合同范本 合作 衡器 交流 交通安全 近视 经营 景点 开关电源 考勤 空压机近视 拉手 辣椒 礼品公司 礼仪 流产 取名 认证 润滑 三菱 设计在线 摄像 深呼吸 生日 石油 事务所 流星雨 互联网 对外贸易 外贸 花语 鼠标 美发 画廊 二胡 环球 美媚 数据 密码 换外汇 会计师事务所 密码破解 水果 水晶 免费MP3下载 绘画 法硕 惠普打印机 法语翻译 台球 机电机电 翻译英文 基金 民办高校 天文 铁道 计量 计数器 奶牛 听力 通信 技术 配件 投资 托福 皮肤 加密 粉碎 外贸公司 平安 家政 富士 家政服务 网吧 网校 维修 无线 无线电 武术 舞蹈 舞曲 系统 下载音乐 相册 项目 效果图 鞋业 心理咨询 信息管理 信箱 诚信 出租 处理 导游 电路 电气 电台 电梯 电子图书 电子邮箱 儿歌 二手 高校招生 工程 工具 公路 公司法 供求 供求信息 古筝 观赏鱼 国画 国际金融 国际旅行社 国家标准 海报 海运 航班 航空 航空公司 合金 合同法 行政管理 户外运动 护理 安防 熊猫 压缩 安全 化工网 案例 翻译社 黄金 婚庆 饭店 办公 阳光 养老保险 防盗 计算机考试 养殖 保温 防辐射 移动通信 房屋 房屋出租 保险公司 手机大全 手机之家 纺织网 交通管理 分析 标志 诺基亚手机 标准 风水 解密 经理人 服装学院 彩屏手机 妇科 九寨沟 餐饮 策划 就业 局域网 俱乐部

皮革 床上用品 英语培训 优盘 油画 游戏机 有线电视 幼教 刻录 口吃 口罩 快餐 矿泉水 篮球鞋 浪潮 理财 粮食 猎头 猎头公司 旅游景点 玫瑰 美容院 棉花 民办大学 钱币 桥梁 情报 求职招聘 人才交流 软件公司 扫描 扫描仪 山水 商务网 商行 商业 上海房产 上海租房 上市 少儿英语 设计公司 民歌 玉器 服装辅料 元件 民谣 社保 社会保障 民族音乐 园艺 市场研究 灯箱 远程控制 明信片 社会调查 申请邮箱 牡丹 云南旅游 灯饰 保健食品 生日贺卡 生物工程 在线歌曲 霓虹灯 失眠 农药 造价 花店 农业网 实习 实验 暖通 招生简章 搬家 真空泵厂 世界杯 支原体 直销 试剂 室内装修 喷雾器 职业 盆景 书刊 屏幕 制药厂 卡片 数码照相机 奇石 卡特 痔疮 中草药 开发 棋牌 数字 开发区 考试中心 汽车销售 水环式真空泵 科普 科研 中国律师 展览会 税务师 招聘信息 招商引资 学校管理 思培 塑料包装 学英语 找工作 眼科 泰克 贴纸相 演唱会 植物 制药 药物流产 质量 质量管理 投资公司 智能 中国纺织网 液压 外语学院 一点通 医疗保健 网上商城 玩具出租 网上银行 医疗保险 中国旅行社 保洁 北京翻译 北京翻译公司 中国旅游 网上赚钱 稳压 抑郁症 背景音乐 音像 污水 主页空间 标牌 标志设计 自动化 印刷厂 无线网络 租赁 博士 应聘 无形资产评估 英汉翻译 步进电机 物资 仙人掌 彩信 先锋 纤维 饮食 现代 产品 香格里拉 邮件 成功 邮局 销售 邮票 协会 游记 传真 传真机 信息咨询 运动 姓名学 增高 打折 档案管理 点歌 电工 电力公司 电脑配件 电子信箱 电子邮件 调制解调器 高速公路 工程造价 工业设计 古董 骨科 管理制度 广告策划 规章制度 过滤 汉译英 汉英翻译 汉英互译 合同范本 合作 衡器 交流 交通安全 近视 经营 景点 开关电源 考勤 空压机近视 拉手 辣椒 礼品公司 礼仪 流产 取名 认证 润滑 三菱 设计在线 摄像 深呼吸 生日 石油 事务所 流星雨 互联网 对外贸易 外贸 花语 鼠标 美发 画廊 二胡 环球 美媚 数据 密码 换外汇 会计师事务所 密码破解 水果 水晶 免费MP3下载 绘画 法硕 惠普打印机 法语翻译 台球 机电机电 翻译英文 基金 民办高校 天文 铁道 计量 计数器 奶牛 听力 通信 技术 配件 投资 托福 皮肤 加密 粉碎 外贸公司 平安 家政 富士 家政服务 网吧 网校 维修 无线 无线电 武术 舞蹈 舞曲 系统 下载音乐 相册 项目 效果图 鞋业 心理咨询 信息管理 信箱 诚信 出租 处理 导游 电路 电气 电台 电梯 电子图书 电子邮箱 儿歌 二手 高校招生 工程 工具 公路 公司法 供求 供求信息 古筝 观赏鱼 国画 国际金融 国际旅行社 国家标准 海报 海运 航班 航空 航空公司 合金 合同法 行政管理 户外运动 护理 安防 熊猫 压缩 安全 化工网 案例 翻译社 黄金 婚庆 饭店 办公 阳光 养老保险 防盗 计算机考试 养殖 保温 防辐射 移动通信 房屋 房屋出租 保险公司 手机大全 手机之家 纺织网 交通管理 分析 标志 诺基亚手机 标准 风水 解密 经理人 服装学院 彩屏手机 妇科 九寨沟 餐饮 策划 就业 局域网 俱乐部

This is an unusual use of the JCSP library. Normally the CSP processes are defined, created and then started. In this case, we spawn new processes as needed while the other processes are running.

See "Squinting at Power Series" and "Power Series, Power Serious".

/* Please try the NoviceExamples? before these examples

/* Please try the NoviceExamples? before these examples

let int MAX = 10; let ArrayList? processes = new ArrayList?();

let ArrayList? m = new ArrayList?();

let a = new Rational(num: 1, den: 5); print( deriv( a * ones() ));

par( processes.toArray ).run;

void stopProcesses(){ for (each : m) each.stop; m.clear; }

let count = 5;

println(""); println("=== derivatives ==="); let d = derivative(ones()); print(d, count); stopProcesses();

println(""); println("=== integrals ==="); let i = integral(ones()); print(i, count); stopProcesses();

println(""); println("=== 1 / (1-x)**2 ==="); let o = split(ones()); print(o[0]*o[1], count);

class PowerSeries? { One2OneChannel chan = new One2OneChannel();

Rational read() = cast(chan.read); void write(Rational a) = chan.write(a);

PowerSeries? ones(){ void->void b(PowerSeries? P){ void a(){ while(true) P.write( RationalOne?() ); } return a; } return managedPS(b);

PowerSeries? `+`(PowerSeries? F, PowerSeries? G){ let P = new PowerSeries?(); void a(){ while(true) P.write(F.read + G.read); } processes.add( seq(a) ); return P;

PowerSeries? `*`(PowerSeries? F, PowerSeries? G){ void->void b(PowerSeries? P){ void a(){ let f = F.read; let g = G.read; let FF = split(F); let GG = split(G); P.write(f * g); let fG = f * GG[0]; let gF = g * FF[0]; let xFG = xmul(FF[1] * GG[1]);

while(true) P.write(fG.read + gF.read + xFG.read); } return a; } return managedPS(b);

PowerSeries? `+`(Rational c, PowerSeries? F){ let P = new PowerSeries?(); void a(){ while(true) P.write(c + F.read); } processes.add( seq(a) ); return P; }

PowerSeries? `-`(PowerSeries? F, PowerSeries? G){ let P = new PowerSeries?(); void a(){ while(true) P.write(F.read - G.read); } processes.add( seq(a) ); return P;

PowerSeries?[] split(PowerSeries? F){ let P0 = new PowerSeries?(channel: One2OneChannel.create(new InfiniteBuffer?())); let P1 = new PowerSeries?(channel: One2OneChannel.create(new InfiniteBuffer?()));

let pm = new ProcessManager?( new Delta2(F.channel,P0.channel,P1.channel) ); m.add(pm); pm.start; return [P0,P1];

let P = new PowerSeries?();

void->void b(PowerSeries? P){

processes.add( seq(a) ); return P;

return a; } return managedPS(b);

void print(PowerSeries? F){

PowerSeries? xmul(PowerSeries? F){ void->void b(PowerSeries? P){ void a(){ P.write(RationalZero?()); while(true) P.write(F.read); } return a; } return managedPS(b); }

void print(PowerSeries? F, int n){

while(count<MAX){ println(F.read);

println("Value\t\tThreads"); while(count<n){ println(F.read + "\t\t" + Thread.activeCount());

System.exit(0);

processes.add( seq(a) );

seq(a).run;

PowerSeries? ones(){ let P = new PowerSeries?(); void a(){ while(true)P.write( new Rational(num: 1, den: 1) ); } processes.add( seq(a) ); return P;

PowerSeries? derivative(PowerSeries? F){ void->void b(PowerSeries? P){ void a(){ var f = F.read; var n = 1; while(true){ f = F.read; P.write( new Rational(num: n*f.num, den: f.den) ); n++; } } return a; } return managedPS(b);

PowerSeries? deriv(PowerSeries? F){ let P = new PowerSeries?();

PowerSeries? integral(PowerSeries? F){ void->void b(PowerSeries? P){

P.write( new Rational(num: n*f.num, den: f.den) );

P.write( new Rational(num: f.num, den: f.den*n) );

return a; } return managedPS(b); }

processes.add( seq(a) );

class PowerSeries? { One2OneChannel channel = new One2OneChannel();

Rational read() = cast(channel.read); void write(Rational a) = channel.write(a); }

PowerSeries? managedPS(PowerSeries?->(void->void) f){ let P = new PowerSeries?(); let a = f(P); let pm = new ProcessManager?( seq(a) ); m.add(pm); pm.start;

See "Squinting at Power Series" (1989)

Experimental use of the "Communicating Sequential Processes for Java TM (JCSP)" library.

See "Squinting at Power Series"

Experimental use of the "Communicating Sequential Processes for Java TM (JCSP)" library.

and "Power Series, Power Serious" http://citeseer.nj.nec.com/mcilroy98power.html

>java -cp jcspclasses.jar;power.jar power.fun

>java -cp "jcspclasses.jar;power.jar" power.fun

1. /5
2. /5
3. /5
4. /5
5. /5
6. /5
7. /5
8. /5
9. /5
10. /5*/

= derivatives = Value Threads

1. 3
2. 3
3. 3
4. 3
5. 3

= integrals = Value Threads

1. 3
2. /2 3
3. /3 3
4. /4 3
5. /5 3

= 1 / (1-x)**2 = Value Threads

1. 7
2. 15
3. 19
4. 27
5. 27

if (gcd = 1 || gcd = denominator){

if (gcd == 1){

}

toString(Rational a) = a.num + "/" + a.den;

toString(){ if (den == 1) return num.toString; else return num + "/" + den; } }

Rational `-`(Rational a, Rational b){ if (a.den == b.den) return new Rational(num: a.num - b.num, den: a.den); else return new Rational(

num

(a.num * b.den) - (b.num * a.den),

den

a.den * b.den );

Rational RationalOne?() = new Rational(num: 1, den: 1); Rational RationalZero?() = new Rational(num: 0, den: 1);

let d = split( deriv( ones()) ); print( add(d[0],d[1]) );

let a = new Rational(num: 1, den: 5); print( deriv( a * ones() ));

par( processes.toArray );

par( processes.toArray ).run;

One2OneChannel ones(){ let out = new One2OneChannel();

class PowerSeries? { One2OneChannel chan = new One2OneChannel();

void a(){ while(true) out.write( new Rational(num: 1, den: 1) );

Rational read() = cast(chan.read); void write(Rational a) = chan.write(a);

PowerSeries? `+`(PowerSeries? F, PowerSeries? G){ let P = new PowerSeries?(); void a(){ while(true) P.write(F.read + G.read); }

return out;

return P;

One2OneChannel deriv(One2OneChannel in){ let out = new One2OneChannel();

void a(){ in.read; var n = 1; while(true){ let Rational r = cast(in.read); out.write( new Rational(num: n*r.num, den: r.den) ); n++; }

PowerSeries? `+`(Rational c, PowerSeries? F){ let P = new PowerSeries?(); void a(){ while(true) P.write(c + F.read); } processes.add( seq(a) ); return P;

PowerSeries? `-`(PowerSeries? F, PowerSeries? G){ let P = new PowerSeries?(); void a(){ while(true) P.write(F.read - G.read); }

return out;

return P;

One2OneChannel[] split(One2OneChannel in){ let out1 = One2OneChannel.create( new InfiniteBuffer?() ); let out2 = One2OneChannel.create( new InfiniteBuffer?() );

processes.add( new Delta2(in,out1,out2) ); return [out1,out2];

PowerSeries? `*`(Rational c, PowerSeries? F){ let P = new PowerSeries?(); void a(){ while(true) P.write(c * F.read); } processes.add( seq(a) ); return P;

One2OneChannel add(One2OneChannel f, One2OneChannel g){ let out = new One2OneChannel();

void print(PowerSeries? F){

var Rational rf; var Rational rg; while(true){ rf = cast(f.read); rg = cast(g.read); out.write( rf + rg );

var count = 0; while(count<MAX){ println(F.read); count++; } System.exit(0);

processes.add( seq(a) );

PowerSeries? ones(){ let P = new PowerSeries?(); void a(){ while(true)P.write( new Rational(num: 1, den: 1) ); }

return out;

return P;

void print(One2OneChannel in){

PowerSeries? deriv(PowerSeries? F){ let P = new PowerSeries?();

var count = 0; while(count<MAX){ let Rational r = cast( in.read ); println(r); count++;

var f = F.read; var n = 1; while(true){ f = F.read; P.write( new Rational(num: n*f.num, den: f.den) ); n++;

System.exit(0);

return P;

1. /1
2. /1
3. /1
4. /1
5. /1
6. /1
7. /1
8. /1
9. /1
10. /1

1. /5
2. /5
3. /5
4. /5
5. /5
6. /5
7. /5
8. /5
9. /5
10. /5*/

let One2OneChannelInt done = new One2OneChannelInt();

let m = new ProcessManager?( par( processes.toArray ));

m.start; done.read; m.stop;

par( processes.toArray );

done.write(0);

System.exit(0);

let One2OneChannelInt done = new One2OneChannelInt();

par( processes.toArray ).run;

let m = new ProcessManager?( par( processes.toArray ));

m.start; done.read; m.stop;

System.exit(0);

done.write(0);

%META:TOPICINFO{author="IsaacGouy" date="1077746460" format="1.0" version="1.1"}% %META:TOPICPARENT{name="CodeExamples"}%

/* Please try the NoviceExamples before these examples
To compile:
   nicec --classpath "jcspclasses.jar;nice-csp.jar" --sourcepath .. -a power.jar power
To run:
   java -cp "jcspclasses.jar;power.jar" power.fun
*/

import nice.csp;
import nice.csp.util;
import jcsp.plugNplay.* (!);

let int MAX = 10;
let ArrayList<CSProcess> processes = new ArrayList();

void main(String[] args){   
   let d = split( deriv( ones()) );
   print( add(d[0],d[1]) );

   par( processes.toArray ).run;
}


One2OneChannel ones(){ 
   let out = new One2OneChannel();

   void a(){
      while(true)
         out.write( new Rational(num: 1, den: 1) );
   } 

   processes.add( seq(a) );
   return out;
}


One2OneChannel deriv(One2OneChannel in){
   let out = new One2OneChannel();

   void a(){
      in.read;
      var n = 1;
      while(true){
         let Rational r = cast(in.read);      
         out.write( new Rational(num: n*r.num, den: r.den) );
         n++;
      }
   } 

   processes.add( seq(a) );
   return out;
}


One2OneChannel[] split(One2OneChannel in){ 
   let out1 = One2OneChannel.create( new InfiniteBuffer() );
   let out2 = One2OneChannel.create( new InfiniteBuffer() );

   processes.add( new Delta2(in,out1,out2) );
   return [out1,out2];
}


One2OneChannel add(One2OneChannel f, One2OneChannel g){
   let out = new One2OneChannel();

   void a(){
      var Rational rf;
      var Rational rg;
      while(true){
         rf = cast(f.read);
         rg = cast(g.read);      
         out.write( rf + rg );
      }
   } 

   processes.add( seq(a) );
   return out;
}


void print(One2OneChannel in){

   void a(){
      var count = 0;
      while(count<MAX){
         let Rational r = cast( in.read );
         println(r);
         count++;
      }
      System.exit(0);
   } 

   processes.add( seq(a) );
}

/* Notes - language
See "Squinting at Power Series" (1989)
http://citeseer.nj.nec.com/mcilroy89squinting.html

Experimental use of the "Communicating Sequential Processes for Java TM (JCSP)" library.

   >java -cp "jcspclasses.jar;power.jar" power.fun
   2/1
   4/1
   6/1
   8/1
   10/1
   12/1
   14/1
   16/1
   18/1
   20/1
*/

public class Rational {
   long num; // dividend
   long den; // divisor
   
   {
      let denominator = abs(den); 
      var numerator = num;
      if (den<0) numerator = -numerator;
      
      let gcd = numerator.gcd(denominator);
      if (gcd == 1 || gcd == denominator){
         num = numerator;
         den = denominator;
      }
      else {
         num = numerator/gcd;
         den = denominator/gcd;
      }      
   }
}

toString(Rational a) = a.num + "/" + a.den;

Rational `+`(Rational a, Rational b){
   if (a.den == b.den)
      return new Rational(num: a.num + b.num, den: a.den);
   else
      return new Rational(
         num: (a.num * b.den) + (b.num * a.den), 
         den: a.den * b.den
         );      
}   
   
Rational `-`(Rational a, Rational b){
   if (a.den == b.den)
      return new Rational(num: a.num - b.num, den: a.den);
   else
      return new Rational(
         num: (a.num * b.den) - (b.num * a.den), 
         den: a.den * b.den
         );      
}  

Rational `*`(Rational a, Rational b) =
  new Rational(num: a.num * b.num, den: a.den * b.den);