源碼怎麼求值
❶ 表達式求值的C語言源代碼
一個用C#編寫的簡單的數學表達式解析器，實現了C語言里的幾乎所有運算符和幾乎所有數學庫函數，並且實現了定義自變數的功能。程序沒有運用中綴表達式、後綴表達式和前綴表達式的思想，而只是運用循環的方法從左到右掃描表達式。進入下載網址http://hi..com/%C9%B9%D1%A7%CD%F8/album/item/d6b05d9b9fa707bfc8eaf448.html後，右擊軟體運行界面的圖片，點擊「目標另存為...」。將擴展名改為rar，然後可以用Winrar打開。
❷ 計算機源碼，反碼，補碼之間怎麼計算
1、正整數的原碼、反碼、補碼完全一樣，即符號位固定為0，數值位相同。
2、負整數的符號位固定為1，由原碼變為補碼時，規則如下：原碼符號位1不變，整數的每一位二進制數位求反，得到反碼；反碼符號位1不變，反碼數值位最低位加1，得到補碼。
3、例如正整數的原碼為01110110，則反碼和補碼也為01110110；負整數的原碼為11110110，反碼為10001001，補碼為11110111。
拓展資料：
1、反碼是數值存儲的一種，多應用於系統環境設置，如linux平台的目錄和文件的默認許可權的設置umask，就是使用反碼原理。在計算機內，定點數有3種表示法:原碼、反碼和補碼。
2、在計算機系統中，數值一律用補碼來表示（存儲）。 主要原因：使用補碼，可以將符號位和其它位統一處理；同時，減法也可按加法來處理。另外，兩個用補 碼表示的數相加時，如果最高位（符號位）有進位，則進位被舍棄。
❸ 一個數的原碼，反碼，補碼怎麼算
計算機中的存儲系統都是用2進制儲存的,對我們輸入的每一個信息它都會自動轉變成二進制的形式,而二進制在存儲的時候就會用到原碼,反碼和補碼例如:輸入25原碼是:0000000000011001反碼: 1111111111100110 補碼: 1111111111100111
數值在計算機中表示形式為機器數,計算機只能識別0和1,使用的是二進制,而在日常生活中人們使用的是十進制,"正如亞里士多德早就指出的那樣,今天十進制的廣泛採用,只不過我們絕大多數人生來具有10個手指頭這個解剖學事實的結果.盡管在歷史上手指計數(5,10進制)的實踐要比二或三進制計數出現的晚. "(摘自<<數學發展史>>有空大家可以看看哦~,很有意思的).為了能方便的與二進制轉換,就使用了十六進制(2 4)和八進制(23).下面進入正題.
數值有正負之分,計算機就用一個數的最高位存放符號(0為正,1為負).這就是機器數的原碼了.假設機器能處理的位數為8.即字長為1byte,原碼能表示數值的范圍為
(-127~-0 +0~127)共256個.
有了數值的表示方法就可以對數進行算術運算.但是很快就發現用帶符號位的原碼進行乘除運算時結果正確,而在加減運算的時候就出現了問題,如下: 假設字長為8bits
( 1 ) 10- ( 1 )10 = ( 1 )10 + ( -1 )10 = ( 0 )10
(00000001)原 + (10000001)原 = (10000010)原 = ( -2 ) 顯然不正確.
因為在兩個整數的加法運算中是沒有問題的,於是就發現問題出現在帶符號位的負數身上,對除符號位外的其餘各位逐位取反就產生了反碼.反碼的取值空間和原碼相同且一一對應. 下面是反碼的減法運算:
( 1 )10 - ( 1 ) 10= ( 1 ) 10+ ( -1 ) 10= ( 0 )10
(00000001) 反+ (11111110)反 = (11111111)反 = ( -0 ) 有問題.
( 1 )10 - ( 2)10 = ( 1 )10 + ( -2 )10 = ( -1 )10
(00000001) 反+ (11111101)反 = (11111110)反 = ( -1 ) 正確
問題出現在(+0)和(-0)上,在人們的計算概念中零是沒有正負之分的.(印度人首先將零作為標記並放入運算之中,包含有零號的印度數學和十進制計數對人類文明的貢獻極大).
於是就引入了補碼概念. 負數的補碼就是對反碼加一,而正數不變,正數的原碼反碼補碼是一樣的.在補碼中用(-128)代替了(-0),所以補碼的表示範圍為:
(-128~0~127)共256個.
注意:(-128)沒有相對應的原碼和反碼, (-128) = (10000000) 補碼的加減運算如下:
( 1 ) 10- ( 1 ) 10= ( 1 )10 + ( -1 )10 = ( 0 )10
(00000001)補 + (11111111)補 = (00000000)補 = ( 0 ) 正確
( 1 ) 10- ( 2) 10= ( 1 )10 + ( -2 )10 = ( -1 )10
(00000001) 補+ (11111110) 補= (11111111)補 = ( -1 ) 正確
所以補碼的設計目的是:
⑴使符號位能與有效值部分一起參加運算,從而簡化運算規則.
⑵使減法運算轉換為加法運算,進一步簡化計算機中運算器的線路設計
所有這些轉換都是在計算機的最底層進行的，而在我們使用的匯編、C等其他高級語言中使用的都是原碼
❹ 計算機中補碼為10111010，怎麼計算求源碼
源碼→補碼：除符號位外各位取反再+1，那反之，知道補碼求源碼，只需符號位外各位-1再取反嘍。以此題為例，10111010-1=10111001，再取反得11000110，所以源碼即使11000110。
❺ C語言求值#include <stdio.h> void main__1__{ int a[8]={1,0,1,0,1,0,1,0},i; for(i=2;i<8;i++)
源代碼及編譯如下：
❻ 經傳主力凈買額指標公式源碼是什麼意思怎麼計算
主力凈買額的指標公式是：主力凈買額=主力凈買+跟風凈買；主力凈買額指的是主力和跟風資金參與市場的資金情況，正數表示凈流入，負數則表示凈流出。並且數值是以億作為單位。源碼就是股票分析指標在股票軟體中的函數表達式，而且這個指標在一般的收費軟體都有的，不需要公式，因為只有公式，沒有數據支持也是沒有用的。
股票技術指標
股票技術指標是相對於基本分析而言的，著重於對一般經濟情況以及各個公司的經營管理狀況、行業動態等因素進行分析，衡量股價高低的指標。而技術分析則是透過圖表或技術指標的記錄，研究市場行為反應，以推測價格的變動趨勢。其依據的技術指標的主要內容是由股價、成交量或漲跌指數等數據計算而來。
股票技術指標是屬於統計學的范疇，一切以數據來論證股票趨向、買賣等。指標主要分為了3大類：1，屬於趨向類的技術指標，2，屬於強弱的技術指標，3，屬於隨機買入的技術指標。
基本分析的目的是為了判斷股票現行股價的價位是否合理並描繪出它長遠的發展空間，而技術分析主要是預測短期內股價漲跌的趨勢。通過基本分析我們可以了解應購買何種股票，而技術分析則讓我們把握具體購買的時機。大多數成功的股票投資者都是把兩種分析方法結合起來加以運用。
股價技術分析和基本分析都認為股價是由供求關系所決定。基本分析主要是根據對影響供需關系種種因素的分析來預測股價走勢，而技術分析則是根據股價本身的變化來預測股價走勢。技術分析的基本觀點是：所有股票的實際供需量及其背後起引導作用的因素，包括股票市場上每個人對茫然的希望、擔心、恐懼等等，都集中反映在股票的價格和交易量上。
❼ 計算機源碼，反碼，補碼之間怎麼計算
轉換方法：
如果是正數或零，則首位為 0，補碼＝原碼＝反碼。
否則，首位為 1，數值位取反加一，即可實現「補碼與原碼」互換。
例如：
對 1111 1001 取反，為 1000 0110，再加一，得：1000 0111。
對 1000 0111 取反，為 1111 1000，再加一，得：1111 1001。
這說明，補碼 ←→ 原碼，方法是相同的。
❽ 易語言怎麼從源碼中獲取到某控制項元素的值
正則表達式或者文本中間
你給的那段代碼，裡面沒有值啊
如果要取DIV裡面的內容
可以用正則表達式
<divid="times"style="font-size:50px;text-align:center">(.*?)</div>
❾ C++ 後綴表達式求值的源代碼。要簡單明了的 不要任何修飾
我不知道C#語言你能不能看得懂，這里是我用C#語言實現的代碼，其實數據結構哪種語言都可以實現，主要的是看它的演算法思想
namespace JiSuanQi
{
class JiSuan
{
public char[] a;
public string[] aa;
public char a1;
public char a2;
public int top = -1;
public string s = "";
public string s1 = "";
public int totalnum = 0;
public JiSuan(string s)
{
this.s = s;
}
public void JiSuanQi()
{
aa = new string[20];
a=new char[20];
}
public void ZhongChuo() /*對輸入的中綴表達式的判斷*/
{
for(int i=0;i<s.Length;i++)
{
char cha=s[i];
switch(cha)
{
case '+':
YuanSu(cha,1);
break;
case '-':
YuanSu(cha, 1);
break;
case '*':
YuanSu(cha, 2);
break;
case '/':
YuanSu(cha, 2);
break;
case '(':
Push(cha);
break;
case ')':
YuanSu1();
break;
default:
s1 += cha;
break;
}
}
for (int i = 0; i < a.Length;i++ )
{
if(i==0)
{
a2 = a[i];
char cha2 = a2;
char cha1 = a1;
int num;
if (PanDuan(cha2) == 2)
{
for (int j = 0; j < s1.Length; j++)
{
char ss = s1[j];
if (ss == cha1)
{
s1 = s1.Remove(j,1);
num = 1;
break;
}
}
YuanSu(cha1, 1);
YuanSu1();
break;
}
else
{
YuanSu1();
break;
}
}
}
}
public void Jisuan()
{
for (int i = 0; i < s1.Length; i++)
{
char cha = s1[i];
int num1;
int num2;
if (cha != '+' && cha != '-' && cha != '*' && cha != '/')
{
Push1(cha.ToString());
}
switch (cha)
{
case '+':
num1 = int.Parse(Pop1().ToString());
num2 = int.Parse(Pop1().ToString());
int total0 = num2 + num1;
totalnum = total0;
Push1(total0.ToString());
break;
case '-':
num1 = int.Parse(Pop1().ToString());
num2 = int.Parse(Pop1().ToString());
int total = num2 - num1;
totalnum = total;
Push1(total.ToString());
break;
case '*':
num1 = int.Parse(Pop1().ToString());
num2 = int.Parse(Pop1().ToString());
int total1=num2 * num1;
totalnum = total1;
Push1(total1.ToString());
break;
case '/':
num1 = int.Parse(Pop1().ToString());
num2 = int.Parse(Pop1().ToString());
int total2 = num2 / num1;
totalnum = total2;
Push1(total2.ToString());
break;
default:
break;
}
}
}
public int PanDuan(char cha)
{
int num2;
if (a[0] == '+' || a[0] == '-')
{
num2 = 1;
}
else
{
num2 = 2;
}
return num2;
}
public void YuanSu(char car,int num) /*判斷運算符的優先順序*/
{
while(top!=-1)
{
char ar=Pop();
if (ar == '(')
{
Push(ar);
break;
}
else
{
int num2;
if (ar == '+' || ar == '-')
{
num2 = 1;
}
else
{
num2 = 2;
}
if (num > num2)
{
Push(ar);
break;
}
else
{
s1+=ar;
}
}
}
Push(car);
}
public void YuanSu1() /*讀出寨中剩餘的運算符並拼接到字元串*/
{
while(top!=-1)
{
char cha = Pop();
if(cha!='(')
{
s1 = s1 + cha;
}
}
}
public void Push(char shuzi) /*用數組模擬實現寨的進入*/
{
if(top==0)
{
a1 = a[top];
}
top += 1;
a[top] = shuzi;
// return a[top].ToString();
}
public char Pop() /*用數組模擬實現寨的輸出*/
{
char cha = a[top];
top -= 1;
return cha;
}
public void Push1(string shuzi)
{
top += 1;
aa[top] = shuzi;
}
public string Pop1()
{
string number=aa[top];
top -= 1;
return number;
}
public string ZiFu(string zifu)
{
return zifu;
}
}
class Program
{
static void Main(string[] args)
{
JiSuan js = new JiSuan(Console.ReadLine());
js.JiSuanQi();
js.ZhongChuo();
js.Jisuan();
Console.WriteLine("計算結果："+js.totalnum+" 後輟表達式："+js.s1);
}
}
}
我們來舉個例子3+（4*5）
在這個程序里，我們是先把中輟表達式轉換成後綴表達式的，轉換的方法名是ZhongChuo() ，轉換後的表達式為345*+，那程序又是如何實現轉換的呢？在ZhongChuo()中判斷+，-，*，/,(,)當遇到數字時，我們就把數字寫入定義的寨中，而當遇到運算符時，由於運算符有優先順序，所以我們就要對運算符進行相應的判斷，這里，我們就需要主意寨的思想，當遇到運算級低的運算符時，就將它寫入寨中，如果運算符高，就直接寫入定義的字元串，具體代碼實現看YuanSu（）這個方法(C++里叫函數)
最後要記得把寨里的運算符全部寫出並拼接到字元串里就可以得到後綴表達式了，希望我的回答你能看得懂
❿ 怎樣用java寫出逆波蘭表達式求值部分的源代碼（提供代碼框架）
下面的代碼是用來計算表達式的，看看是不是你要的
public class OPNode {
char op;// 運算符號
int level;// 優先順序
//設置優先順序
public OPNode(String op) {
this.op = op.charAt(0);
if (op.equals("+") || op.equals("-")) {
this.level = 1;
} else if (op.equals("*") || op.equals("/")) {
this.level = 2;
} else if (op.equals("(")) {
this.level = -3;
} else {
this.level = -1;
}
}
}
//主類
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class OPText {
public static void main(String[] args) {
String expression = "2+2+(8-2)/3";// 要計算的表達式
List list = new LinkedList();
//正則式
Pattern entryOfExpression = Pattern
.compile("[0-9]+(\\.[0-9]+)?|\\(|\\)|\\+|-|\\*|/");
Deque stack = new LinkedList();//棧
Matcher m = entryOfExpression.matcher(expression);
while (m.find()) {
//提取語素
String nodeString = expression.substring(m.start(), m.end());
if (nodeString.matches("[0-9].*")) {
list.add(Double.valueOf(nodeString));//如果是數字直接送入列表
} else {
OPNode opn = new OPNode(nodeString);//如果是運算符
int peekLevel = (stack.peek() == null) ? 0 : ((OPNode) stack
.peek()).level;
if (opn.level >=peekLevel) {
stack.push(opn);//新的運算符比舊的優先順序別高則入棧
} else {
if (opn.level == -1) {
OPNode temp = (OPNode) stack.pop();
while (temp.level != -3) {//如果為"("則一直出棧一直到")"
list.add(temp);
System.out.println(nodeString);
temp = (OPNode) stack.pop();
}
} else if (opn.level == -3) {
stack.push(opn);
} else {//如果新運算符比棧頂運算符底則一直出棧
OPNode temp = (OPNode) stack.pop();
while (temp.level > opn.level) {
list.add(temp);
if (stack.isEmpty()) {
break;
}
temp = (OPNode) stack.pop();
}
stack.push(opn);
}
}
}
}
OPNode temp = null;
while (!stack.isEmpty()) {
temp = (OPNode) stack.pop();
list.add(temp);
}//後續表達式計算
stack.clear();
for (Object o : list) {
if (o instanceof Double) {
stack.push(o);//為數字入棧
} else {
double op2 = ((Double) stack.pop()).doubleValue();
double op1 = ((Double) stack.pop()).doubleValue();
switch (((OPNode) o).op) {
case '+':
stack.push(op1 + op2);
break;
case '-':
stack.push(op1 - op2);
break;
case '*':
stack.push(op1 * op2);
break;
case '/':
stack.push(op1 / op2);
break;
}
}
}
System.out.println("結果為:" + stack.pop());
}
}
呃，太晚了，沒心思去改了
明天再說