Im planning to fetch RAM usage on server,i tried SNMP in PHP on my own pc but when i wanna get the percentage usage of RAM,that return is not the real RAM usage compare with system monitor on my pc.
i have read this solution below but still i didnt get right value
(Used – buffers – cached) / Total * 100 = % memory used
So you could get the following (expressed as Perl code):
my $memRealTotalOID = '.1.3.6.1.4.1.2021.4.5.0';
my $memRealAvailOID = '.1.3.6.1.4.1.2021.4.6.0';
my $memRealBuffersOID = '.1.3.6.1.4.1.2021.4.14.0';
my $memRealCachedOID = '.1.3.6.1.4.1.2021.4.15.0';
Memory Calculations my $memRealUsed = $memRealTotal - $memRealAvail;
Then you can alert on % RAM used:
my $realPercent = (($memRealUsed - $memRealBuffers - $memRealCached )/
$memRealTotal) * 100;
Here is my code and the result:
snmp_set_valueretrieval(SNMP_VALUE_PLAIN);
$memRealTotalOID = snmpget("127.0.0.1", "public", ".1.3.6.1.4.1.2021.4.5.0");
$memRealAvailOID = snmpget("127.0.0.1", "public", ".1.3.6.1.4.1.2021.4.6.0");
$memRealBuffersOID = snmpget("127.0.0.1", "public",'.1.3.6.1.4.1.2021.4.14.0');
$memRealCachedOID = snmpget("127.0.0.1", "public",'.1.3.6.1.4.1.2021.4.15.0');
$memRealUsed = $memRealTotalOID - $memRealAvailOID;
$realPercent = (($memRealUsed - $memRealBuffersOID - $memRealCachedOID) / $memRealTotalOID) * 100;
print_r($realPercent);
the current result is = 82.55542380
meanwhile system monitor is showing (89%):
Did i read wrong solution or wrong calculation?Any help pls
I have a golf league of 40 individuals. We all throw money in a pot and pay out the first 6 places based on final score.
If there were no ties the pay out would be simple but often we have, for example, 2 people tied for first place, 3 people tied for second, 1 person alone in third, etc. The variations seem endless.
I've been trying to automate the calculated payouts for each place using PHP but have not been successful. Any suggestions, help, or pointing in the right direction would be much appreciated. I noticed that someone else tried to ask a similar question on this site but was not successful in framing the question. I'll try to do a better job.
Here is some data I've been playing around with:
$playerNumber=40;
$totalPoints=100;
Payouts:
$pointsFirst=0.6*$totalPoints;
$pointsSecond=0.2*$totalPoints;
$pointsThird=0.15*$totalPoints;
$pointsFourth=0.03*$totalPoints;
$pointsFifth=0.02*$totalPoints;
$pointsSixth=0.01*$totalPoints;
For the example given above and to pay out six places, we would calculate the payouts as follows:
If two people are tied for first place, we add first and second place points and divide by two.
If three people are tied for second place, we add third, fourth and fifth place points and divide by three.
If one person is alone in third, this person would win sixth place points.
I can count the number of players who are in or tied for a certain place.
$countFirst=2;
$countSecond=3;
$countThird=1;
$countFourth=2;
$countFifth=1;
$countSixth=2;
In this example the player scores would be 72, 72, 73, 73, 73, 74, 75, 75, 76, 77, 77.
At first I thought this was an application for nested arrays. Then I thought perhaps using arrays, array slice, etc, may be a way to go. Each time I end up in the woods. I'm not seeing the logic.
I have used conditional statements for paying out three places but to pay out six places with this method puts me deep in the woods.
Example of payout to three places using conditional statements:
$pointsFirst=0.5*$totalPoints;
$pointsSecond=0.3*$totalPoints;
$pointsThird=0.2*$totalPoints;
if($countFirst>2) {
$ptsA=round($totalPoints/$countFirst,2);
}
elseif($countFirst==2) {
$ptsA=round(($pointsFirst+$pointsSecond)/2,2);
if($countSecond>1) {
$ptsB=round($pointsThird/$countSecond,2);
}
elseif($countSecond==1) {
$ptsB=round($pointsThird,2);
}
}
elseif($countFirst==1) {
$ptsA=round($pointsFirst,2);
if($countSecond>1) {
$ptsB=round(($pointsSecond+$pointsThird)/2,2);
}
elseif($countSecond==1) {
$ptsB=round($pointsSecond,2);
if($countThird>1) {
$ptsC=round($pointsThird/$countThird,2);
}
elseif($countThird==1) {
$ptsC=round($pointsThird,2);
}
}
}
I hope I have been clear in my request. I'll be glad to clarify anything. If anyone has any ideas on how to efficiently automate a payout calculation to six places I will be eternally grateful. Thank-you! Mike
Per request:
$scores=array();
$scores[0]=72;
$scores[1]=72;
$scores[2]=73;
$scores[3]=73;
$scores[4]=73;
$scores[5]=74;
$scores[6]=75;
$scores[7]=75;
$scores[8]=76;
$scores[9]=77;
$scores[10]=77;
$payout=array();
$payout[0]=0.6*$totalPoints;
$payout[1]=0.2*$totalPoints;
$payout[2]=0.15*$totalPoints;
$payout[3]=0.03*$totalPoints;
$payout[4]=0.02*$totalPoints;
$payout[5]=0.01*$totalPoints;
$countScores=array();
$countScores[0]=$countFirst;
$countScores[1]=$countSecond;
$countScores[2]=$countThird;
$countScores[3]=$countFourth;
$countScores[4]=$countFifth;
$countScores[5]=$countSixth;
First, there is a problem with your Payouts. If you add them up you get 1.01 not 1
0.6 (1st) + 0.2 (2nd ) + 0.15 (3rd) + 0.03 (4th) + 0.02 (5th) + 0.01 (6th) = 1.01
Second, it is easier if you make your Payouts and Counts into arrays -
change these -
$pointsFirst=0.6*$totalPoints;
$pointsSecond=0.2*$totalPoints;
$pointsThird=0.15*$totalPoints;
$pointsFourth=0.03*$totalPoints;
$pointsFifth=0.02*$totalPoints;
$pointsSixth=0.01*$totalPoints;
$countFirst=2;
$countSecond=3;
$countThird=1;
$countFourth=2;
$countFifth=1;
$countSixth=2;
to these
$payout=array();
$payout[0]=0.6*$totalPoints;
$payout[1]=0.2*$totalPoints;
$payout[2]=0.15*$totalPoints;
$payout[3]=0.03*$totalPoints;
$payout[4]=0.02*$totalPoints;
$payout[5]=0.01*$totalPoints;
$count=array();
$count[0]=2;
$count[1]=3;
$count[2]=1;
$count[3]=2;
$count[4]=1;
$count[5]=2;
Here is the start of one way to do it. Although I would eventually change this into a function so that I can use it again with different payouts, and number of places (see phpfiddle examples below)
I see this in 4 steps-
Step 1
// Add together the payments if there are ties - ie. 2 tied for first $payout[0]+$payout[1], etc
$payout_groups = array(); // start a payout array
$payout_groups_key = 0; // array key count
$payout_groups_count = 0; // array counter, use to match the $count array values
for($w=0;$w<count($payout);$w++){ //
if(array_key_exists($payout_groups_key,$payout_groups)){
$payout_groups[$payout_groups_key] += $payout[$w]; // if there are ties, add them together
}
else{
$payout_groups[$payout_groups_key] = $payout[$w]; // else set a new payout level
}
$payout_groups_count++; // increase the counter
if($payout_groups_count == $count[$payout_groups_key]){ // if we merged all the ties, set a new array key and restart the counter
$payout_groups_key++;
$payout_groups_count = 0;
}
}
Step 2
// basic counter to get how many placers/winners. This makes it possible to have ties for 6th (last) place
$x = 0;
$y = 0;
while($y < count($payout)){
$y += $count[$x]; // the $count array values until we reach the amount of places/payouts
$x++;
}
Step 3
// Create array for winnings per placing
$winnings = array(); // start an array
$placings_count = 0; //
$placings_counter = 0;
for($z=0;$z<$y;$z++){
$winnings[$z] = $payout_groups[$placings_count]/$count[$placings_count];
$placings_counter++;
if($placings_counter == $count[$placings_count]){
$placings_count++;
$placings_counter = 0;
}
}
Step 4
// Assign winnings to scorecard
$scoreboard = array();
for($t=0;$t<count($winnings);$t++){
$scoreboard[$t]['score'] = $scores[$t];
$scoreboard[$t]['payout'] = $winnings[$t];
}
You can see this using your defined values at - http://phpfiddle.org/main/code/a1g-qu0
Using the same code above, I changed the payout amounts, and increased it to 7th places - http://phpfiddle.org/main/code/uxi-qgt
Using, amongst other sources, various posts here on Stackoverflow, I'm trying to implement my own PHP classier to classify tweets into a positive, neutral and negative class. Before coding, I need to get the process straigt. My train-of-thought and an example are as follows:
p(class) * p(words|class)
Bayes theorem: p(class|words) = ------------------------- with
p(words)
assumption that p(words) is the same for every class leads to calculating
arg max p(class) * p(words|class) with
p(words|class) = p(word1|class) * p(word2|topic) * ... and
p(class) = #words in class / #words in total and
p(word, class) 1
p(word|class) = -------------- = p(word, class) * -------- =
p(class) p(class)
#times word occurs in class #words in total #times word occurs in class
--------------------------- * --------------- = ---------------------------
#words in total #words in class #words in class
Example:
------+----------------+-----------------+
class | words | #words in class |
------+----------------+-----------------+
pos | happy win nice | 3 |
neu | neutral middle | 2 |
neg | sad loose bad | 3 |
------+----------------+-----------------+
p(pos) = 3/8
p(neu) = 2/8
p(meg) = 3/8
Calculate: argmax(sad loose)
p(sad loose|pos) = p(sad|pos) * p(loose|pos) = (0+1)/3 * (0+1)/3 = 1/9
p(sad loose|neu) = p(sad|neu) * p(loose|neu) = (0+1)/3 * (0+1)/3 = 1/9
p(sad loose|neg) = p(sad|neg) * p(loose|neg) = 1/3 * 1/3 = 1/9
p(pos) * p(sad loose|pos) = 3/8 * 1/9 = 0.0416666667
p(neu) * p(sad loose|neu) = 2/8 * 1/9 = 0.0277777778
p(neg) * p(sad loose|neg) = 3/8 * 1/9 = 0.0416666667 <-- should be 100% neg!
As you can see, I have "trained" the classifier with a positive ("happy win nice"), a neutral ("neutral middle") and a negative ("sad loose bad") tweet. In order to prevent problems of having probabilities of zero because of one word missing in all classes, I'm using LaPlace (or ädd one") smoothing, see "(0+1)".
I basically have two questions:
Is this a correct blueprint for implementation? Is there room for improvement?
When classifying a tweet ("sad loose"), it is expected to be 100% in class "neg" because it only contains negative words. The LaPlace smoothing is however making things more complicated: class pos and neg have an equal probability. Is there a workaround for this?
There are two main elements to improve in your reasoning.
First, you should improve your smoothing method:
When applying Laplace smoothing, it should be applied to all measurements, not just to those with zero denominator.
In addition, Laplace smoothing for such cases is usually given by (c+1)/(N+V), where V is the vocabulary size (e.g., see in Wikipedia).
Therefore, using probability function you have defined (which might not be the most suitable, see below):
p(sad loose|pos) = (0+1)/(3+8) * (0+1)/(3+8) = 1/121
p(sad loose|neu) = (0+1)/(3+8) * (0+1)/(3+8) = 1/121
p(sad loose|neg) = (1+1)/(3+8) * (1+1)/(3+8) = 4/121 <-- would become argmax
In addition, a more common way of calculating the probability in the first place, would be by:
(number of tweets in class containing term c) / (total number of tweets in class)
For instance, in the limited trainset given above, and disregarding smoothing, p(sad|pos) = 0/1 = 0, and p(sad|neg) = 1/1 = 1. When the trainset size increases, the numbers would be more meaningful. e.g. if you had 10 tweets for the negative class, with 'sad' appearing in 4 of them, then p(sad|neg) would have been 4/10.
Regarding the actual number outputted by the Naive Bayes algorithm: you shouldn't expect the algorithm to assign actual probability to each class; rather, the category order is of more importance. Concretely, using the argmax would give you the algorithm's best guess for the class, but not the probability for it. Assigning probabilities to NB results is another story; for example, see an article discussing this issue.
Naive Bayes Algorithm with Laplacian Correction
Some Picture Links that show how the algorithm work
Data set example
Output
Output Cont.
import pandas as pd
#Calculate Frequency Of Each Value
def CountFrequency(my_list,my_list2,st,st2):
# Creating an empty dictionary
counter=0
for i in range(len(my_list)):
if (my_list[i]==st and my_list2[i]==st2):
counter=counter+1
return counter
#Reading headers From File
headers=pd.read_excel('data_set.xlsx').columns
#Reading From File
df = pd.read_excel('data_set.xlsx')
a=[]
for i in range(len(df.columns)):
a.append([])
for i in range(len(df.columns)):
for row in df.iterrows():
a[i].append(row[1][i])
#print(row[1][i])
#Calculate Table Info
result=[]
length=len(a[0])
tableInfo=sorted(set(a[-1]))
for i in range(len(tableInfo)):
result.append([])
for i in tableInfo :
print("P(",headers[-1],"=\"",i,"\") =", CountFrequency(a[-1],a[-1],i,i),"/",length,"=",CountFrequency(a[-1],a[-1],i,i)/length)
#Take User Input and Calculate Columns Info
for i in range(len(df.columns)-1):
print("Choose value for attribute ",headers[i],"that you want from list : ")
c=1
b=sorted(set(a[i]))
for j in b:
print(c,":",j)
c=c+1
choose=int(input("Enter Number Of Your Choice : "))
co=0
for k in tableInfo:
#Laplacian Correction
if CountFrequency(a[-1],a[i],k,b[choose-1])!=0:
print("P(",headers[i],"=\"",b[choose-1],"\"|",headers[-1],"=\"",k,"\") =", CountFrequency(a[-1],a[i],k,b[choose-1]),"/",CountFrequency(a[-1],a[-1],k,k),"=",CountFrequency(a[-1],a[i],k,b[choose-1])/CountFrequency(a[-1],a[-1],k,k))
result[co].append(CountFrequency(a[-1],a[i],k,b[choose-1])/CountFrequency(a[-1],a[-1],k,k))
else:
print("P(",headers[i],"=\"",b[choose-1],"\"|",headers[-1],"=\"",k,"\") =", CountFrequency(a[-1],a[i],k,b[choose-1])+1,"/",CountFrequency(a[-1],a[-1],k,k)+len(sorted(set(a[i]))),"=",((CountFrequency(a[-1],a[i],k,b[choose-1])+1)/(CountFrequency(a[-1],a[-1],k,k)+len(sorted(set(a[i])))))," With Laplacian correction ")
result[co].append(((CountFrequency(a[-1],a[i],k,b[choose-1])+1)/(CountFrequency(a[-1],a[-1],k,k)+len(sorted(set(a[i]))))))
co=co+1
#Calculate Final Result Laplacian Correction
finalResult=[1]*len(tableInfo)
for res in range(len(result)):
for i in range(len(result[res])):
finalResult[res]*=result[res][i]
#Print final result
print("#####################################################################")
print("#####################################################################")
print("#####################################################################")
mx=0
pos=0
for i in range(len(tableInfo)) :
print("P(X | ",headers[-1],"=\"",tableInfo[i],"\") =",finalResult[i]*(CountFrequency(a[-1],a[-1],tableInfo[i],tableInfo[i])/length))
if mx<finalResult[i]*(CountFrequency(a[-1],a[-1],tableInfo[i],tableInfo[i])/length):
mx=finalResult[i]*(CountFrequency(a[-1],a[-1],tableInfo[i],tableInfo[i])/length)
pos=i
print("ThereFore X belongs To Class (\"",headers[-1],"=",tableInfo[pos],"\")")
I am trying to do something that's quite complex (for me anyway) and I've got a point which has stopped me in my tracks.
In this project, you enter the weight of a box, and the percentage of materials held in that box. So for example, a box may have 10% of wood, 40% of plastic, and 50% of paper. The weights of the materials are held in the database as they dont change. So the value of 1% of wood is held in the database, as 1% of plastic and paper.
The controller should then take the percentage of material given, and then multiply it by the 1% value held in the database.
So far, this is my code:
foreach($wastestream as $ws) {
$genweight = $ws['Materialtype']['1pc'] * $ws['Valuegiven']['percent'];
}
And this gives the following values:
10% Wood = 97.5
40% Plastic = 100.4
50% Paper = 40.3
The problem I now have is that I have to add all of these variables together. So essentially what I want to do after it pumps out the values is to add them all up together, so:
97.5 + 100.4 + 40.3 = 238.2
What should I do?
Cheers!
I think I have misunderstood something, since it seems not complicated at all...
$total=0;
foreach($wastestream as $ws) {
$total += $ws['Materialtype']['1pc'] * $ws['Valuegiven']['percent'];
}
$total will hold the total value
Could you add the values as they are created?
$totalweight = 0;
foreach($wastestream as $ws) {
$genweight = $ws['Materialtype']['1pc'] * $ws['Valuegiven']['percent'];
$totalweight += $genweight;
}
I have a rectangular map, stored as multidimensional array (ie $map[row][col]) and I have to track down which squares are seen by a player, placed anywhere on this map.
Player visibility is circular with unknown radius (but given at run-time) and I only need integer solutions.
I know that circumference formula is
x^2 + y^2 <= r^2
but how can I store everything?
I need these values since then I can "reveal" map squares.
The best would be a multidimesional array (ie __$sol[x][y]__).
This is a piece of code that I'm using. It's not corrected since it assumes that vision is a square and not a circle.
Calculating the square
$this->vision_offsets_2 = array();
//visibility given as r^2
$mx = (int)(sqrt($this->viewradius2));
$mxArr = range($mx * -1, $mx + 1);
foreach ($mxArr as $d_row)
{
foreach ($mxArr as $d_col)
{
$this->vision_offsets_2[] = array($d_row, $d_col);
}
}
This is how I apply that
foreach($player as $bot)
{
foreach($visibility as $offset)
{
$vision_row = $offset[0] + $bot[0];
$vision_col = $offset[1] + $bot[1];
if(isset($map[$vision_row][$vision_col]))
{
if( $map[$vision_row][$vision_col] == UNSEEN) {
$map[$vision_row][$vision_col] = LAND; }
}
}
}
Here you can find the bot view: as you can see is a non perfect circle.
How can I track it? By the way, in this example radius^2 is 55, the orange circle is the player, brown squares are visible ones.
Structure
You're already referencing terrain in a grid. Store terrain objects in those grid values. Apply attributes to those objects. Check with something like
$map[$x][$y]->isVisible($player);
You'll need some methods in there for setting vision and tests for checking the user that is passed against a list of users who can see it. While you're at it, setup other related methods in those objects (I see references to land... isLand() and isWater() perhaps?).
You can even have vision cascade within objects such that you only need to move the position of a user and the object takes care of triggering off all the code to set nearby plots of land to visible.
Math
We are given circumference.
double diameter = circumference / 3.14159
double radius = diameter / 2 //Normally done in one step / variable
Now we must know the distance between two points to compare it. Let's use map[4][7] and map[3][9].
int x0 = 4;
int y0 = 7;
int x1 = 3;
int y1 = 9;
double distance = Math.sqrt(
Math.pow(x0 - x1, 2) +
Math.pow(y0 - y1, 2)
);
System.out.println(distance); //2.23606797749979
Test distance > radius.
Testing each square
Put the above in a method: visibleFrom(Square target)
radius should be a globally accessible static variable when comparing.
Your Square object should be able to hand over its coordinates.
target.getX()
target.getY()
Some optimizations can be had
Only checking things for circular distance when they're in the square.
Not checking anything for circular distance when purely along the x or y axis.
Figuring out the largest square that fits inside the circle and not checking boxes in that range for circular distance.
Remember that premature optimization and over optimization are pitfalls.
A function like this would tell you if a map square is visible (using the distance of the centers of the squares as a metric; if you want to define visibility in another manner, which you probably would, things get much more complicated):
function is_visible($mapX, $mapX, $playerX, $playerY, $r) {
return sqrt(pow($mapX - $playerX, 2) + pow($mapY - $playerY, 2)) <= $r;
}
You probably don't really need to store these values since you can easily calculate them on demand.
I think that Bresenham's circle drawing algorithm is what you're looking for.
I don't know exactly what you want, but here's some things that should help you along. As a warning these are untested, but the logic is sound.
//You mentioned circumference, this will find out the circumference but I don't
//think you actually need it.
$circumference_length = 2 * $visibility_range * 3.1415;
//Plug in the player and target coordinates and how far you can see, this will
//tell you if the player can see it. This can be optimized using your object
//and player Objects.
function canSee($player_x, $player_y, $vision_length, $target_x, $target_y){
$difference_x = $target_x - $player_x;
$difference_y = $target_y - $player_y;
$distance = sqrt((pow($difference_x,2) + pow($difference_y, 2));
if($vision < $distance){
return false;
} else {
return true;
}
}
Edit: In response to your clarification, you can use the above function to figure out if you should show the terrain objects or not.
foreach($player as $bot)
{
foreach($terrain_thing as $terrain)
{
//ASSUMING THAT [0] IS ALWAYS X AND [1] IS ALWAYS y, set a third variable
//to indicate visibility
$terrain["is_visible"] = canSee($bot[0], $bot[1], $visibility_range, $terrain[0], $terrain[1])
}
}