import java.util.*
public class demo2 {
private static int intercePosition = 0// 记录单个运算数据的长度
private static int[] intercePositionIndex = null// 记录“（”的下标
private static int[] intercePositionEnd = null// 记录“）”的下标
public static void main(String[] args) {
Scanner input = new Scanner(System.in)
do {
System.out.println("请输入你要计算的字符串(注意：只能输入数字和加，减，乘除符号输入完毕后,请直接回车):")
String numberString = input.next().trim()
// 判断输入的运算字符串是否符合规定
if (ispassString(numberString) == false) {
System.out.println("您输入的计算字符串有误,请正确输入!")
} else {
// 计算结果返回
System.out.println(interceResult(numberString))
}
} while (true)
}
// 判局困断是否有带括号的运算字符串存在
private static String interceResult(String str) {
String result = str
char[] numberString = str.toCharArray()// 1+2+(1*2+1-1*2+5)+2+(1+5+9+10-11)+1*5/2+3
/庆腊历/ 1+8-9+(1*8/2-5+(1+2+8))+4/5*8/3*2
int IndexStart = 0// 记录“（”的实际数量
int EndStart = 0// 记录“）”的实际数量
for (int i = 0i <numberString.lengthi++) {
if ('(' == numberString[i]) {
// 记录最后一个正括号的位置
IndexStart = i
}
if (')' == numberString[i]) {
// 记录反括号的最初始下标的位置
EndStart = i
// 截取最里面一个括号里的运算字符串
result = result.substring(IndexStart + 1, EndStart)
// 截取括号的运算字符串进行运算,生成新的运算字符串
result = str.substring(0, IndexStart)
+ interceptOperation(result, '*', '/')
+ str.substring(EndStart + 1, str.length())
// 回调执行，其它小括号的运算字符串
return interceResult(result)
}
if (i == numberString.length - 1)
if (EndStart == 0)
break
}
// 不存在括号了，再进行混合运算
result = interceptOperation(str, '*', '/')
return result
}
// 不带括号的四则运算
private static String interceptOperation(String operationNumber, char a,
char b) {
String mess = operationNumber
char[] stringOperation = mess.toCharArray()
// 循环遍历运算字符串，并做相应誉搜的运算
for (int i = 0i <stringOperation.lengthi++) {
// 判断运算符所在的索引
if (stringOperation[i] == a || stringOperation[i] == b) {
if (i != 0) {
// 运算符前的第一个数
double num1 = interceptNumIndex(mess.substring(0, i))
// 记录第一个数据的长度
int frontPosition = intercePosition
// 运算符前的第二个数
double num2 = interceptNumEnd(mess.substring(i + 1,
stringOperation.length))
// 记录第二个数据的长度
int backPosition = intercePosition
// 算完乘除，将结果替换到原来运算的位置，得到新的运算字符串
String IndexMess = mess.substring(0, i - frontPosition + 1)
String IndexResult = ""
// 判断是否运算到最后的结果了
if (IndexMess.indexOf('+') == -1
&&IndexMess.indexOf('*') == -1
&&IndexMess.indexOf('/') == -1
&&IndexMess.lastIndexOf('-') == -1)
IndexMess = ""
if (IndexMess != "")
IndexResult = IndexMess.lastIndexOf('-') == IndexMess
.length() - 1 ? IndexMess.substring(0, i
- frontPosition) : IndexMess
// 组装新的运算字符串
mess = IndexResult// mess.substring(0,i-frontPosition+1)
+ reslutString("" + stringOperation[i], num1, num2)
+ mess.substring(i + backPosition + 1)
// 0.111/1212/2/2/2/2/2/2/2
if (mess.lastIndexOf('-') == 0 &&mess.indexOf('+') == -1
&&mess.indexOf('*') == -1
&&mess.indexOf('/') == -1) {
break
}
// 回调，继续运算
return interceptOperation(mess, a, b)// 1+7-5+89/3+4-6*8/2+4-6
} else
continue
}
if (i == stringOperation.length - 1) {
// 递归出口，判断是否还有运算字符串在
if (mess.indexOf('+') != -1 || mess.indexOf('-') != -1)
return interceptOperation(mess, '+', '-')
break
}
}
return mess
}
// 截取第二个数
private static double interceptNumEnd(String str) {
double a = 0
int InrerceIndex = 0
char[] stringOperation = str.toCharArray()
boolean ispas = false// 记录是否为负数
for (int i = 0i <stringOperation.lengthi++) {
switch (stringOperation[i]) {
case '*':
case '/':
case '+':
case '-':
InrerceIndex = i
if (i != 0) // 判断该数是否为负数
ispas = true
break
default:
break
}
if (ispas)
break
}
// 判断此数据是否在运算字符串的最后一位
if (InrerceIndex == 0) {
a = Double.parseDouble(str)
intercePosition = str.length()
if (ispas)
intercePosition++
} else {
a = Double.parseDouble(str.substring(0, InrerceIndex))
// 记录数据的真实长度
intercePosition = str.substring(0, InrerceIndex).length()
}
return a
}
// 截取第一个数
private static double interceptNumIndex(String str) {
double a = 0// 记录数据
int InrerceIndex = 0// 记录运算符的位置
boolean temp = false// 记录数据前运算符的状态
char[] stringOperation = str.toCharArray()
for (int i = stringOperation.length - 1i >= 0i--) {
switch (stringOperation[i]) {
case '*':
case '/':
case '+':
case '-':
InrerceIndex = i
temp = true
break
default:
break
}
if (temp)
break
}
// 判断此数据是否在运算字符串的第一位
if (InrerceIndex == 0) {
a = Double.parseDouble(str)
intercePosition = str.length()
// if(temp)
// intercePosition++
} else {
a = Double.parseDouble(str.substring(InrerceIndex, str.length()))
// 记录数据的真实长度
intercePosition = str.substring(InrerceIndex, str.length())
.length()
}
return a
}
// 计算结果
private static double reslutString(String operation, double num1,
double num2) {
double sumResult = 0
if (operation.equals("*"))
sumResult = num1 * num2
if (operation.equals("-"))
sumResult = num1 - num2
if (operation.equals("/"))
sumResult = num1 / num2
if (operation.equals("+"))
sumResult = num1 + num2
return sumResult
}
// 判断是否正确输入运算方式
private static boolean ispassString(String messString) {
boolean ispass = false
boolean operationIspass = true// 记录被除数的状态
int ai = 0// 记录是否有运算符号的存在
char[] IsString = messString.toCharArray()
int num1 = 0
int num2 = 0
for (int i = 0i <IsString.lengthi++) {
// 记录有几对小括号的存在
if ('(' == IsString[i])
num1++
if (')' == IsString[i])
num2++
// 判断除数是否为零
if ('/' == IsString[i] &&IsString[i + 1] == '0')
operationIspass = false
// 判断是否输入了运算符合
if (IsString[i] == '+' || IsString[i] == '-' || IsString[i] == '*'
|| IsString[i] == '/')
ai++
if (i == IsString.length - 1)
if (ai == 0)
num2++
}
if (operationIspass)
if (num1 == num2)
ispass = true
return ispass
}
}
一、动态载荷的添加
通用程序控制中的外载荷为恒定载荷，对于材料在动态载荷作用下的破坏过程，所受的外载荷一般都是随着时间变化的载荷，例如三角波载荷等。通过对通用程序控制进行改进添加冲击三角波载荷，以适应对冲击问题的模拟。三角波孙汪载荷的示意图如图13-1所示。
图13-1 三角波载荷示意图
其中：Fmax为动态三角波冲击载荷的峰值；t1和t2分别为动态载荷的峰值时间和截止时间。
二、模型计算流程
岩石是一种典型的d脆性材料，在外力作用下，一般不会发生明显的塑性变形，因此可以不考虑材料的塑性变形。由于岩石的抗压强度远大于其抗拉强度，可以认为岩石在受压时，材料内部不会产生新的损伤，即不考虑体积压缩时的损伤累积。尽管在采用静态d性模型计算时，可以不考虑材料的损伤演化，但是由于在其他时步的计算过程中，产生的损伤是不会恢复的，所以在进行d性计算时，材料的d性模量将不同于最初的d性模量，变为损伤后的d性模量。根据以上的思路，可按照以下的计算流程来进行计算：
1.总体计算流程（针对单个块体）
（1）若块体单元损伤变量D为1，则不再对该单元进行计算而直接进入下一个单元的计算，否则进入（2）。
（2）计算体积应变εv，如果εv＜0即单元处于体积压缩状态，则进入（3），否则进入（4）。
（3）按照d性损伤模型，由应变计算应力，并且保持D值不变（不考虑体积压缩时的损伤积累），进入（5）。
（4）当岩石处于受拉状态时，材料的应力应变关系并不都是按照应力波衰减模型来计算的，而且还与应变变化率有一定的关系，仅当应变率大于10时，才能按照动态的应力波衰减模型，由应变计算应力值，进入（5）；而当应变率小于10时，按照岩石受压状态下的d性损伤模型来计算（高尔新等，1999），然后进入（5）。
（5）如果D＞1或D=1，则令D=1，并置当前所计算块体的压力和偏应力为零，进入下一步的计算。
在每一步的计算中需要对所有单元进行一一计算，并保存当前步的应力及应变计算结果以供下一步计算使用。
2.具体的计算模型和公式
第一步计算：
（1）由于对D值的计算需要用到D的变化率，因此本步计算中保持D值不变。
（2）应变变化率
岩石断裂与损伤
（3）体积应变
岩石断裂与损伤
（4）动态应力波衰减模型
σij=3K（1-D）εδij+2G（1-D）eij
即
岩石断裂与损伤
（5）d性损伤模型
岩石断裂与损伤
在以上各则激仔式中：E、G、K、μ分别为材料的d性模量、剪切模量、体积模量和泊松比。
第二步及其以后的计算：
（1）D值的计算：
岩石断裂与损伤
（2）应变变化率的计算：
岩石断裂与损伤
（3）体积应变的计算：
岩石断裂与损伤
应力波衰减模型与铅并d性损伤模型同第一步相同。
以上的讨论和建立的公式都是针对于平面应力问题而言的，如果要求解的问题属于平面应变问题，需要把以上方程式中的E换为，μ换为。
#include<stdio.h>void main()
{
int i,j,k,a=5,m[6][6]
i=1//初始化i的值为1
k=(a+1)/2//初始化k的值为(a+1)/2，即k=3
/*循环过程如下：
j=1, m[1][3]=1, k=4,i=5,a=5
j=2, m[5][4]=2, k=5,i=4,a=5
j=3, m[4][5]=3, k=1,i=3,a=5
j=4, m[3][1]=4, k=2,i=2,a=5
j=5, m[2][2]=5, k=2,i=3,a=5 执行第一个if语句，continue了
j=6, m[3][2]=6, k=3,i=2,a=5
j=7, m[2][3]=7, k=4,i=1,a=5
j=8, 枯闭握m[1][4]=8, k=5,i=5,a=5
j=9, m[5][5]=9, k=1,i=4,a=5
j=10,m[4][1]=10,k=1,i=5,a=5 执行第一个if语句，continue了
j=11,m[5][1]=11,k=2,i=4,a=5
j=12,m[4][2]=12,k=3,i=3,a=5
j=13,m[3][3]=13,k=4,i=2,a=5
j=14,m[2][4]=14,k=5,i=1,a=5
j=15,m[1][5]=15,k=5,i=2,a=5 执行第一个if语句，continue了
j=16,m[2][5]=16,k=1,i=1,a=5
j=17,m[1][1]=17,k=2,i=5,a=5
j=18,m[5][2]=18,k=3,i=4,a=5
j=19,m[4][3]=19,k=4,i=3,a=5
j=20,m[3][4]=20,k=4,i=4,a=5 执行第一个if语句，continue了
j=21,m[4][4]=21,k=5,i=3,a=5
j=22,m[3][5]=22,k=1,i=2,a=5
j=23,m[2][1]=23,k=2,i=1,a=5
j=24,m[1][2]=24,k=3,i=5,a=5
j=25,m[5][3]=25,k=3,i=4,a=5
j=26退出循环 */
for(j=1j<=a*aj++) //从1到25循环
{
m[i][k]=j //将循环的索引值j赋值给数组m的第i行第k列
if(j%a==0)
{
i=(i%a)+1
continue
}
k=(k%a)+1
i--
if(i==0)
i=a
}
/*执行结果为：
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
*/
for(i=1i<=ai++)//从1到5循环：控制行
{
for(j=1j<=aj++)//内层从1到5循环：控制列
printf("%4d",m[i][j])//以4位整数输出数组中第2行第2列的态猜值到数组最后的值
printf("\n")//行结束打印换行符 没庆
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）