Trending December 2023 # How Can We Implement Logistic Regression? # Suggested January 2024 # Top 16 Popular

You are reading the article How Can We Implement Logistic Regression? updated in December 2023 on the website We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested January 2024 How Can We Implement Logistic Regression?

This article was published as a part of the Data Science Blogathon


In this article, we will be learning about how we can implement logistic regression by writing Python code. You must be wondering what is logistic regression and what is the theory behind it? What python packages are involved while implementing logistic regression? You must be coming up with many more questions but I will try to answer as many as questions possible. Well, you have chosen the right article. So let’s begin our journey for logistic regression.

Topics to be covered in this article:

Introduction to Logistic Regression

How can we implement it?

Train your dataset

Sigmoid function

Calculating probability and making predictions

Calculating the cost

Reducting the cost using Gradient Descent

Testing you model

Predicting the values

Introduction to logistic regression

Now we proceed to see how this algorithm can be implemented.

How can we implement it?

This algorithm can be implemented in two ways. The first way is to write your own functions i.e. you code your own sigmoid function, cost function, gradient function, etc. instead of using some library. The second way is,  of course as I mentioned, to use the Scikit-Learn library. The Scikit-Learn library makes our life easier and pretty good. All functions are already built-in, you just need to call those functions by passing the required parameters into it. However, if you are learning logistic regression for the first time, then I would suggest you write your own code instead of using the sci-kit-learn library. It does not mean that the mentioned library is not useful, I only want to make you learn the core concepts of this algorithm.

Train your dataset

Before you start working on a project, it is important for us to visualize the dataset. Once we have visualized your dataset, then we will move to the major part of the project. After visualization, we will train our dataset. The training process includes calculating the probability and the cost, and then reduce the cost on the available dataset. The given dataset helps us to train our model so that accurate predictions could be made. Once the model is trained, we check our accuracy on the validation set (this is the part of the dataset, usually we use 80% of our dataset as a training set and the rest 20% as a validation set.) A validation set is required to measure the accuracy of our trained model i.e. how our model will behave when it is exposed to similar unseen data. We compare the results of a validation set with their actual labels mentioned in the dataset.

So let’s visualize our data.

First load the data from the CSV file.

loan= pd.read_csv("loan_test.csv")

Then, have a look at the dataset with the following command:

The above image is an output of some dataset that aims to predict loan eligibility.

Of course, I recommend everyone who is learning ML and want to pursue a career in Data Science to learn plotting graphs using the Matplotlib library. It is going to be useful. Trust me!

By plotting your data on a graph, we can visualize the importance as well as the distribution of a particular factor.

Now in the next section, we’ll learn to make predictions using the sigmoid function.

Making predictions and implementing sigmoid function

(Image source: Google search)

Calculating probability and making predictions

Now you can clearly imagine what is sigmoid function from the above graph. The y-axis is the sigmoid function and the x-axis is the dot product of theta vector and X vector.

Now we’ll write a code for it:

def calc_sigmoid(z): p=1/(1+ np.exp(-z)) p=np.minimum(p, 0.9999) p = np.maximum(p, 0.0001) return p

This is a sigmoid function that accepts a parameter z which is a dot product from the following function:

def calc_pred_func(theta,x):,np.transpose(x)) return calc_sigmoid(y)

The above function returns a probability value between [0,1].

Calculating the cost

Now the most important part is to reduce the cost of the predictions we made. So you must be wondering what is cost? It is the error in the calculations made from the existing labels. So we have to reduce our costs gradually. First, we calculate it using the given function:

def calc_error(y_pred, y_label): len_label=len(y_label) cost= (-y_label*np.log(y_pred) - (1-y_label)*np.log(1-y_pred)).sum()/len_label return cost

Now, we will work to reduce our cost using gradient descent

Reducing the cost using Gradient Descent

Just to tell you about the gradient descent, the graph looks like this for this technique:

Image source: google search

Now we will implement the gradient descent technique:

def gradient_descent(y_pred,y_label,x, learning_rate, theta): len_label=len(y_label) J= (-(,(y_label-y_pred)))/len_label) theta-= learning_rate*J #print("theta_0 shape: ",np.shape(theta),np.shape(J)) return theta Training Your Model: def train(y_label,x, learning_rate, theta, iterations): list_cost=[] for i in range(iterations): y_pred=calc_pred_func(theta,x) theta=gradient_descent(y_pred,y_label,x, learning_rate, theta) if i%100==0: print("n iteration",i) print("y_label:",y_pred) print("theta:",theta) cost=calc_error(y_pred, y_label) list_cost.append(cost) print("final cost list: ",list_cost) return theta,list_cost,y_pred

We will call the train function to call all functions above and you’ll see the following graph when you plot costs per iterations:

We can see the graph declining i.e. the cost is reducing.

Testing your model

Now we will test our model on the validation set:

def classify(y_test): return np.around(y_test) def predict(x_test,theta):,np.transpose(x_test)) #print(y_test) p=calc_sigmoid(y_test) print(p) return p #for calculating accuracy based on validation set ''' Description of variables: x_test:numpy array (no. of rows in dataset, no. of features/columns) z_test: is added as column in x_test for the purpose of theta_0 y_label_test: actual labels y_test= numpy array of probability (note: these are probabilities NOT classes) y_test_pred_labels= numpy array of classes based of probability (note: here it is classes NOT probability) ''' x_test=loan.iloc[500:, 1:10].values x_rows_test, x_columns_test= x_test.shape z_test = np.ones((x_rows_test,1), dtype=float) x_test=np.append(x_test,z_test,axis=1) y_label_test=loan.loc[500:,"Status_New" ].values y_label_test=y_label_test.astype(float) x_test=x_test.astype(float) y_test=predict(x_test,theta) y_test_pred_labels=classify(y_test)

This will make a prediction on the validation set and you will get your output as the label 0 or 1.

I hope you enjoyed my article. This was all about its implementation.

About the Author:

Hi! I am Sarvagya Agrawal. I am pursuing B.Tech. from the Netaji Subhas University Of Technology. ML is my passion and feels proud to contribute to the community of ML learners through this platform. Feel free to contact me by visiting my website:

The media shown in this article are not owned by Analytics Vidhya and is used at the Author’s discretion.


You're reading How Can We Implement Logistic Regression?

Naive Bayes Vs Logistic Regression

Difference Between Naive Bayes vs Logistic Regression

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

Head to Head Comparison Between Naive Bayes vs Logistic Regression (Infographics)

Key Difference Between Naive Bayes vs Logistic Regression

Let us discuss some of the major key differences between Naive Bayes vs Logistic Regression:

When we have correlated features for both Naive Bayes and logistic regression, correlation happens with labels by making predictions so that when the labels are repeating, there are more chances for making the repetitive features the prominent ones in the Naive Bayes algorithm. This will not happen in Logistic regression as the repeating features are counted less number times making it compensate with the repetition. There is no optimization in Naïve Bayes making it to calculate the entries of features directly. But we cannot add different features for the same problem here.

Naive bayes calculates directly from the features aiming in more perfection but gives poor results if the features are more. It does not consider the calibrations and if there are dependency in the features, it will consider that and add into the feature making it more prominent. If the feature is giving negative impact, this will give poor results. This is not a problem in Logistic regression as calibration of the features happen on time when the features are added more number of times giving exact results. Naïve bayes individually counts the classes and gives result based on the more number of feature count in a particular class. The classes are separated in Logistic regression making it to identify the prominent feature based on calibration.

Naive Bayes is mostly used to classify text data. For example, to identify whether the mailbox has spam, this algorithm can be used to find spam emails based on some terms within the mail. Email text is taken as input where there are no dependent features to be considered. Linear combination of inputs is considered to give binary output where features to be dependent or independent is not considered as a point to classify the data.

The error is higher in Naive Bayes making it a grave mistake if the classification is done on a small amount of data and if there are dependent features which were ignored while doing the algorithmic calculation. Hence, Naïve Bayes is not a go-to solution always for any classification problems. The error is less in Logistic regression where we can find the answers easily for dependent or independent features with large data.

Training data is directly taken into consideration while making assumptions in Logistic regression. Training data is not considered directly but a small sample is taken in Naïve Bayes classification. Logistic regression discriminates the target value for any input values given and can be considered as a discriminative classifier. All the attributes are accounted for in the Naive Bayes algorithm.

Naive Bayes vs Logistic Regression Comparison Table

Naive Bayes Classification Logistic Regression

Classification method based on Bayes theorem where the probability of a feature is calculated with the given attributes and independence of each feature is considered to be prominent to calculate the predominant feature within the classification. This gives the name Naive to the Bayes classification. Probability of a sample is considered from a class and linear classification is done on the same based on the probability. This is by far finding the decision boundary between two or more classes and their samples so that the classes can be separated based on their behavior.

This is a discriminative model where probability is calculated directly by mapping A to B or B to A so that we can know whether B has occurred at a certain interval of time owing to A.

All the features are considered to be independent so that classification happens in a generated manner. If any of the features are correlated, the classification will not happen in an expected way. The features are split in a linear fashion so that even if the features are correlated, due to linear classification, logistic regression works in favor of data analysis and gives better results than Naive Bayes.

When the total data considered is small or the sample data is less, we can do better classification based on the number of features helping in good probabilities of the data even before the data analysis. This helps indirectly in forming the forecasting in markets helping the analysts to get the prominent feature. Less data is not in favor of Logistic regression as the result will be a more generalized model with the available features. Overfitting will be reduced with the help of regression techniques but the result will not be as expected and analysis will not help in understanding the data.

Naive Bayes has a higher bias and low variance. Results are analyzed to know the data generation making it easier to predict with less variables and less data. Naive bayes give a faster solution for few training sets while considering independent features. Logistic regression has low bias and higher variance. Functional form indirect manner is used to predict the probability with categorical and continuous variables making the result set to be categorical. When there are more classes, multi-class logistic regression is used for data analysis.


Both the classifiers work in a similar fashion but the assumptions considered along with the number of features differ. We can do both the classifications on the same data and check the output and know the way how data performs with both the classification. These are the two most common statistic models used in machine learning.

Recommended Articles

This is a guide to Naive Bayes vs Logistic Regression. Here we discuss key differences with infographics and comparison table respectively. You may also have a look at the following articles to learn more –

Learn How We Can Use The Xmlagg Function?

Introduction to Oracle XMLAGG

We can use the XMLAGG function in the oracle database to aggregate the collection of fragments of XML. This function returns the value which will be an aggregated document in XML and if any of the arguments that are passed to this function evaluate to NULL then the argument is skipped or dropped out from the final result. This function behaves in the same way as that of SYS_XMLAGG. But there is only one difference between SYS_XMLAGG and XMLAGG which is that the XMLAGG function does not accept the XMLFORMAT object for the purpose of formatting the result though it returns the collection of the nodes as the result. One more difference is that the resultant of XMLAGG is not enclosed in the element tags as in the case of SYS_XMLAGG. The number literals mentioned in the ORDER BY clause are not interpreted by the oracle database as column positions as in other cases but they are referred to as number literals themselves.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

The syntax of the XMLAGG function is as shown below –

The syntax can also be understood from the following figure –

As the XMLAGG function returns the result in a single row or cell to wrap around all the element tags inside a single parent tag we can optionally make the use of XML_ELEMENT which will help to get all the result enclosed in a new parent tag or inside a single element which is created by it. When the strings are to be aggregated then we can use the “.extract(‘//text()’)” which will keep the string together in XML and the rtrim() function can be used along with it to get rid of the trailing commas or spaces. When instead of strings we are about to aggregate the CLOB values using XMLAGG function then we can make the use of xmlparse which will accept the XML text and will transform it into a datatype of XMLTYPE. The use of the ORDER BY clause is completely optional in nature and can be used to order the values of XML elements that are being concatenated by using the XMLAGG function.

Examples of Oracle XMLAGG

Let us take the example of the customer data of a particular brand having multiple stores and multiple departments in each of the stores. The table is created and the data is inserted in it which can be done by using the following query –


There are in all 14 different customers data being inserted into the customer’s table that is created using the INSERT INTO statements whose contents are as shown below –

GROUP BY department_id;

The XML element used in the above statement will lead to the creation of a new xml element called customer data. We can give any name to this xml element being created which will contain the concatenated value of the f_name, l_name, and the comma between each of the concatenated values. The use of XMLAGG, in this case, gives rise to the creation of the XML snippet which is the aggregation of the customer data XML elements. The use of rtrim() removes all the spaces and the trailing commas while.extract helps to keep the string together as a single unit. The execution of the above query will give the following output along with all the grouped result set according to the departments of the store as shown below –

In XML format, the output of the execution of the above query will be as follows along with all the grouped result set according to the departments of the store –

We can even make use of the XMLAGG function along with the CLOB datatype values rather than the string values by using the XMLPARSE which takes the specified XML values as text and further converts them to XMLTYPE data type.

GROUP BY department_id;

The execution of the above query will give the following output along with all the grouped result set according to the departments of the store but without the commas between the aggregated values as shown below –

In XML format, the output of the execution of the above query will be as follows along with all the grouped result set according to the departments of the store –

We can even use the JSON_ARRAYAGG instead of the XMLAGG function for the oracle database versions which are more than 18c or later. We can use the JSON_ARRAYAGG instead of the XMLAGG function in the above query in the following way which generates similar results with a little difference of the square brackets for each group.

GROUP BY department_id;

The execution of the above query will give the following output along with all the grouped result set according to the departments of the store as shown below –

In XML format, the output of the execution of the above query will be as follows along with all the grouped result set according to the departments of the store –


We can use the XMLAGG function in the oracle database management system for aggregating multiple strings or XML fragments to be represented as a concatenated XML element as a single unit. Mostly, strings are aggregated to generate a comma-separated concatenated string which is the collection of all the minor strings. The XMLAGG function works similar to that of SYS_XMLAGG with some minor differences in formatting. In the versions of oracle higher than 18 c, we can also use the JSON_ARRAYAGG function as an alternative to XMLAGG for aggregating multiple values and representing them in a single row or cell. The ORDER BY and GROUP BY statements are mostly used along with the XMLAGG function to get the grouped concatenated result which is properly ordered.

Recommended Articles

This is a guide to Oracle XMLAGG. Here we discuss How we can use the XMLAGG function in the oracle database management system. You may also have a look at the following articles to learn more –

How To Implement Autofill In Your Android Apps

How does autofill work?

Providing hints for autofill

If your app uses standard Views, then by default it should work with any autofill service that uses heuristics to determine the type of data that each View expects. However, not all autofill services use these kind of heuristics; some rely on the View itself to declare the type of data that it expects.

To ensure your app can communicate with the Autofill Framework regardless of the autofill service that the user has installed on their device, you’ll need to add an “android:autofillHints” attribute to every View that’s capable of sending and receiving autofill data.

Let’s take a look at how you’d update a project to provide autofill hints. Create a new project that targets Android Oreo, and then create a basic login screen consisting of two EditTexts that accept a username and a password:

android:layout_width=”match_parent” android:layout_height=”match_parent” <TextView android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:textSize=”30sp” android:text=”Login” app:layout_constraintBottom_toBottomOf=”parent” app:layout_constraintHorizontal_bias=”0.462″ app:layout_constraintLeft_toLeftOf=”parent” app:layout_constraintRight_toRightOf=”parent” app:layout_constraintTop_toTopOf=”parent” <EditText android:id=”@+id/username” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:hint=”Enter Name” app:layout_constraintBottom_toTopOf=”@+id/password” app:layout_constraintEnd_toEndOf=”parent” app:layout_constraintHorizontal_bias=”0.056″ app:layout_constraintStart_toStartOf=”parent” app:layout_constraintTop_toTopOf=”parent” <EditText android:id=”@+id/password” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:layout_marginBottom=”324dp” android:hint=”Password” android:inputType=”textPassword” app:layout_constraintBottom_toBottomOf=”parent” app:layout_constraintEnd_toEndOf=”parent” app:layout_constraintHorizontal_bias=”0.054″

The Username EditText expects a username, so add android:autofillHints=”username”

The Password EditText expects a password, so we need to add android:autofillHints=”password”

Later in this article we’ll be covering different ways of optimizing your app for autofill, but since this is enough to provide basic autofill support, let’s look at how you’d put this updated application to the test.

Testing your app with autofill

Build and install Google’s Autofill Framework sample project

Android Studio will now import the Autofill Framework app as a new project. If Android Studio prompts you to upgrade your Gradle plugin, select ‘Update.’

At the time of writing, this project still uses the Java 8.0 support provided by the deprecated Jack compiler, so open the module-level build.gradle file and remove the following:


jackOptions { enabled true }

If you look at the Manifest, you’ll see that this project has two launcher Activities:


<application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:supportsRtl="true" <activity android:name=".app.MainActivity" <activity ... ... ... <activity android:name=".multidatasetservice.settings.SettingsActivity" android:exported="true" android:label="@string/settings_name" Activate Android Oreo’s Autofill

Autofill is disabled by default; to enable it, you’ll need to specify the autofill service that you want to use:

Open your device’s ‘Settings’ app.

Select ‘Multi-Dataset Autofill Service,’ which is Google’s autofill service application.

Supply some data

If we’re going to test our app’s ability to receive data from an autofill service, then the autofill service is going to need some data that it can supply to this application.

There’s an easy way to feed data to an autofill service:

Load any other application that expects the data in question – in this instance, that’s any application where we can enter a username and password.

Enter this data into the application.

When prompted, save this data to the autofill service.

Switch to the application that you want to test.

Select the View that you want to test, and then see whether autofill kicks in and offers to complete this View for you.

Conveniently, the Autofill Sample app contains a login Activity that expects a username and password combo:

Launch the Autofill Sample app.

Select ‘Sample Login Using EditTexts.’

Enter a fake username and password. Note that a quirk of this Activity is that the username and password must be exactly the same for it to accept your input, so if you use “testing” as your username, then you’ll also have to use “testing” as your password. Also be aware that Google’s autofill service stores its data in SharedPreferences, so anyone with root access to your device can potentially see this data.

Launch the login screen application we created earlier in this tutorial.

Tap the ‘username’ View. At this point the autofill picker should appear.

Select the dataset you want to use, and all Views present in this dataset will be autofilled, so the username and password Views should be autofilled simultaneously.

Optimizing your app for autofill

While this is enough to implement basic autofill functionality in your app, there’s some additional steps you can take to ensure your application is providing the best possible autofill experience.

In this final section I’m going to look at several ways that you can optimize your app for autofill.

Is a View important, or unimportant?

“auto.” Android is free to decide whether this View is important for autofill – essentially, this is the system’s default behavior.

“yes.” This View and all of its child Views are important for autofill.

“no.” This View is unimportant for autofill. Occasionally, you may be able to improve the user experience by marking certain Views as unimportant, for example if your app includes a CAPTCHA, then focusing on this field could trigger the autofill picker menu, which is just unnecessary onscreen clutter, distracting the user from what they’re trying to accomplish. In this scenario, you can improve the user experience by marking this View as android:importantForAutofill=“no.”

“noExcludeDescendants.” The View and all of its children are unimportant for autofill.

“yesExcludeDescendants.” The View is important for autofill, but all of its child Views are unimportant.

Alternatively, you can use the setImportantForAutofill method, which accepts the following:






For example:


.setImportantForAutofill(View.IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS); Force an autofill request

Most of the time, the autofill lifecycle is started automatically in response to notifyViewEntered(View), which is called when the user enters a View that supports autofill. However, sometimes you may want to trigger an autofill request in response to user action, for example if the user long-presses a field.

You can force an autofill request using requestAutofill(), for example:


public void eventHandler(View view) { AutofillManager afm = context.getSystemService(AutofillManager.class); if (afm != null) { afm.requestAutofill(); } } Check whether autofill is enabled

You may decide to offer additional features when autofill is enabled, for example an ‘Autofill’ item in your app’s contextual overflow menu. However, since it’s never a good idea to mislead users by offering features that your app can’t currently deliver, you should always check whether autofill is currently enabled and then adjust your application accordingly, for example removing ‘Autofill’ from your context menu if autofill is disabled.

You can check whether autofill is available, by calling the isEnabled() method of the AutofillManager object:


if (getSystemService(android.view.autofill.AutofillManager.class).isEnabled()) { Sharing data between your website and application

Open the Android project that you want to associate with your website.

Enter the domain that you want to associate with your application.

Enter your app’s signing config, or select a keystore file. Note that if you use a debug config or keystore, then eventually you’ll need to generate and upload a new Digital Asset Links file that uses your app’s release key.

Wrapping Up

Compressed Work Schedules And How To Implement Them

What is a compressed work schedule?

A compressed work schedule is when a full-time employee works a traditional workweek, generally consisting of 35 to 40 hours, in fewer than five days. A compressed work schedule is a flexible option that allows employees to work more efficiently and gain a better work-life balance without sacrificing a full-time salary and benefits.

There are various ways to set up a compressed work schedule, with one of the most common being the 4/10 work schedule. In the 4/10 schedule, employees work 10 hours per day Monday through Thursday to earn the day off each Friday. 

Another alternative is the 9/80 schedule. This is when, over a two-week period, an employee works nine hours per day for eight days and eight hours per day for one day to accumulate one day off every two weeks. While there are various ways to make a compressed schedule, these are some of the most common and attainable schedules used.


According to a study by Robert Half, 66% of employees would prefer a compressed work schedule, but only 17% of employers offer that as an option.

2. There can be greater morale and productivity.

An extra day off can boost employees’ morale and lead them to be more driven and productive in their work, with fewer interruptions. They will feel more motivated and empowered to do better in their roles, knowing they have control over their personal time and don’t need to worry that important tasks are falling by the wayside. Employers also benefit, as employees are less likely to take time off for personal reasons, which should result in better attendance at work.

3. There’s more time for family and passions.

By working a shorter week, employees can organize their schedules to suit their lives. This gives them extra time to spend however they choose, whether that’s relaxing, spending time with family or taking care of personal matters. With the flexibility of a compressed work schedule, employees can get an additional scheduled day off without losing their full-time income and employee benefits.

A compressed workweek can be a great draw to attract and retain talent and can help improve company morale due to its flexibility. Employees want to have more personal time and not feel stuck in a job with no improvement or options in sight. The efficiency of a compressed workweek gives that additional personal time to employees while also increasing productivity when they are in the office. It also allows businesses to broaden their hours of operation by having employees in the office on an extended schedule, rather than all employees working the same hours.

Did You Know?

A compressed workweek is a form of flextime. Other flextime examples are remote work and job-sharing.

What are the drawbacks of compressed work schedules?

Compressed work schedules aren’t suitable for every employee and business. Here are some drawbacks.

1. Longer workdays may be a hard adjustment.

While compressed work schedules offer some great benefits, they can also be challenging to adjust to if you’re used to a standard eight-hour workday. Longer workdays can be more efficient, but without the proper management, they can come at a toll both mentally and physically.

If an employee isn’t used to working a compressed schedule, it can be hard to push through the extended hours while their 9-to-5 co-workers head out for the day. The longer workweeks can drag on and lead to a lack of motivation if the employee doesn’t manage their time right.

For some, the long shifts, lack of supervision and absence of co-workers during certain work hours can make it hard to push through the day, causing them to slack off and be unproductive.

“Some employees … are able to maintain consistently strong work for an entire 10-hour shift, [while] others may check out mentally after hour six or seven, meaning you get fewer useful work hours from them under a compressed schedule,” said Matt Erhard, managing partner at recruiting firm Summit Search Group. “It all comes down to knowing your team, their work style and the type of work they do when you’re deciding whether compressed schedules can work for your team.”

2. There’s potential for burnout.

If an employee is overwhelmed and feels the work will never end, they should step back and take a break to reset with some personal time. By not addressing these feelings, employees will exhaust themselves and head toward burnout, severely hindering their work and demeanor.

By finding ways to prepare for this adjustment mentally and maximizing their out-of-office time, employees can avoid burnout and keep the momentum going to maintain a compressed work schedule.


To help employees avoid burnout on a compressed schedule, allow them to set boundaries and schedule breaks into their workday, regardless of how long it is.

3. There are potential child care and scheduling issues.

Although a compressed schedule can be very beneficial to some, certain employees may find it to be more of an inconvenience. While a compressed schedule gives employees extra personal time and opens up their calendar, it also requires them to work hours that may be inconvenient for coordinating with others.

Scheduling conflicts can often arise when using public transportation, when getting to places such as the bank or DMV that run on strict schedules, or when dropping off or picking up children from school or daycare.

With a compressed workweek, extended hours can cause an employee’s daily availability to be out of sync with other businesses that operate on a 9-to-5 basis. With issues like child care, this could force employees to find alternative solutions, which can mean added expenses.

How do you plan a compressed work schedule?

If you’re considering implementing a compressed work schedule, consider these best practices.

1. Ask the right questions to ensure the plan is solid.

When planning and implementing a compressed work schedule, you need to ask the right questions to avoid issues once an employee’s schedule changes.

You should also consider the customer to ensure this new schedule does not interfere with current business demands, and whether the workload will still be healthy during extended hours. A compressed work schedule may be OK for an overworked employee in the short term, but it could negatively affect them in the long run.


The best employee scheduling software can help you manage schedules across multiple locations and gauge when you’ll need more workers to cover a busy shift.

2. Get employee buy-in.

To keep staff motivated, it’s important to get your employees’ buy-in so that everybody is on the same page and supportive of any changes being implemented. After all, the employees will be most affected by the change.

You must consider what’s right for the company if employees are divided on using a compressed work schedule. If a small minority doesn’t want it, will the policy change, or is it an elective schedule shift? Be sure not to force longer hours on an employee who can’t or doesn’t want to change the agreed-upon schedule in their contract.

3. Communicate with employees.

To ensure a compressed schedule works for all parties, you should openly communicate with your employees on a compressed schedule and monitor the arrangement to see if it’s going smoothly. Giving employees the chance to be open, preferably in a one-on-one setting, will help them see you’re on their side and that they’ll have the support to get through any issues or challenges that arise.

Make sure your whole team is aware of any compressed schedules being implemented. The schedule change could affect the entire team because of some employees’ differing hours and availability. It’s essential to keep everyone’s needs in mind and help the entire team adjust to the new schedule.

Watch for signs that a compressed work schedule arrangement is negatively affecting your employees, including symptoms of overwork and expressed lack of support. It’s critical to ensure all your employees’ needs are being addressed.

How to implement a successful compressed work schedule

Follow these best practices to implement a compressed work schedule.

1. Check your local labor laws.

Labor laws may come into play in certain states, particularly overtime pay laws. For example, California labor laws say a compressed workweek with shifts longer than 10 hours may mean some employees must be compensated for overtime.

Check your state’s rules and regulations regarding overtime and the legal limits for how many hours an employee can work per day to ensure you don’t violate any labor laws.

Did You Know?

In California, employers that wish to implement a compressed workweek must put it to a vote and receive at least two-thirds approval from all affected employees via secret ballot.

2. Use a time and attendance system to keep track of schedules.

To prevent staffing issues due to specific employees’ compressed work schedules and ensure adequate coverage, keep a close eye on your whole team’s hours. The best time and attendance systems allow you to manage schedules, create attendance policies, and change employee timecards as needed if there are last-minute adjustments.

3. Ask for employee feedback.

To make sure a compressed work schedule is beneficial for all parties, request feedback regularly from your employees to see if they can recommend any improvements to the arrangement. Keep track of this feedback and implement suggested changes as often as possible.

4. Modify and remain flexible.

Both employers and employees will need to adjust to compressed work schedules. As an employer, you should remain flexible and open to change to make sure this plan is working for everyone. Keep an open mind and be willing to try different things to figure out the plan that suits each employee best. Don’t be afraid of trial and error or going back to a standard schedule if the schedule shift doesn’t work.

Examples To Implement Mysql Mod()

Introduction to MySQL MOD()

MySQL MOD() function allows us to divide a literal number with another numeric expression to return the remainder of it. The MOD() takes numeric values as arguments for the function to execute and produce the result. The arguments can be said as dividend and divisor as in Maths which works on the fractional numeric values to output the special remainder. If the divisor or, say, the second parameter of the MySQL MOD() function is set to 0 (zero), the result will be NULL. This function can be used safely with BIGINT data type values, but mainly it is used for fractional parts to perform the division and show the remainder after calculating logically.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others


The following syntax code introduces the structure to apply the Math function MOD() in MySQL:

MOD(a,b) a MOD b a % b

We have the above three syntaxes to use the MOD() function within the queries in MySQL.

Here, the ‘a’ and ‘b’ parameters are the required numeric values that can be either fractional part or BIGINT data type values with the help of the MOD() function’s division process. After the completion of the command query then, the return value is the remainder balanced within numbers as in Maths calculation problems.

Also, we can define the first argument value (a) as dividends and the other one-second argument (b) as the divisor for the MOD() calculation to produce the result of the division.

Thus, with the literal numbers, the MOD() function returns the remains of the division, and if the divisor is zero like MOD(dividend,0), the result will be NULL.

How does MySQL MOD() Function work?

As per the syntax above, dividing a numeric expression by another literal number will result in the remainder of this MOD() function in MySQL.

This performs the same work as Modulus calculation is calculated in Maths that we do manually using logic and basic concepts. In addition, we also use SELECT query statement to supplement the MOD() function used in MySQL, so we use the MOD() function as:


Code: Let us take a query using the MOD() function for MySQL to illustrate the function syntaxes that can be executed in three forms-

SELECT MOD(152, 3);


SELECT 152 % 3;




Explanation: As you can see that the results show the remainder of each query form that is executed on the server. So, like this, the Math function implements the logic to produce the modulus process result.

Examples of implementing MOD() function in MySQL

Let us illustrate the MySQLMOD() function with the help of the following examples and show executions results generated simultaneously:

1. Some Simple Examples Using MySQL MOD() function

Code #1



It can be noticed that MySQL permits to use of the modulus operator, i.e., %, which can be considered as the synonym for this MOD() function to give the result also like this:

Code #2

SELECT 21 % 2;


Also, look at the results gained using the MOD() function that accepts fractional elements to return the remainder of the division process. The query for this is as follows:

Code #3

SELECT MOD(15.8, 3);


By utilizing both a dividend and divisor with fractional values, the following code demonstrates how to obtain the result:

SELECT MOD(8.452, 2.14);


The result of the remainder is also with fractional values. Also, view the below query with a divisor in fractional value only:

Code #5

SELECT 25 MOD 2.3;


2. Using MOD() function for zero divisor value

Suppose we have set the divisor as zero and dividend like any literal numeric expression; then the MOD() function applied to it will produce the following result as a reminder:

Code #1



You can view that the remainder of the above query with a 0 divisor value is NULL when executed on the MySQL server.

Let us try out the result of the MOD() function in MySQL when we set zero value for dividend and non-zero or, say, any literal number for divisor using the succeeding query:

Code #2

SELECT 0 % 5;

So, do remember that if we divide the 0 value with any numeric expression, mathematically, it will give the result zero, just the opposite if we reverse the statement values when the divisor is zero. If the dividend is non-zero, then the output will be NULL.

3. Using MOD() function on Database Table fields

Supposing we have created a table named ‘Books’ where we will implement the MOD() function in MySQL. To accomplish this, you can utilize the following code for table creation, which includes the fields BookID, BookName, Language, and Price:


Let us enter some data records in the table Books with the following SQL query:

Code #1

INSERT INTO TABLE (BookID, BookName, Language, Price) VALUES('101','Algebraic Maths','English','2057');

And so on.

Output: View the table here:

Now, we will use MySQLMOD() query on the table column ‘Price’ to check whether the values are even or odd:

Code #2

SELECT BookID, BookName, Language, Price, IF (MOD(Price,2), 'Odd_Price','Even_Price') AS Odd_Even_Prices FROM Books GROUP BY BookID ORDER BY BookID;


In this illustration:

In this case, we utilize the price column to fetch its values for performing the MOD() operation, specifically on numeric values.

When we apply the MOD() function, the values in the Price column will undergo division by 2 as the divisor, resulting in the retrieval of the remainder. The query will evaluate odd or even according to the results produced in zero or one.

At last, we have applied the IF() function that, when executed, will show Odd and Even prices string based on the result of the MOD() operation.


MySQL provides the MOD() function, which actively evaluates the given values and generates the remainder after dividing the specified arguments.

The MySQL MOD() thus implements a modulo operation on calling the function to provide the remainder of two numeric values passed in the function by the division method.

Recommended Articles

We hope that this EDUCBA information on “MySQL MOD()” was beneficial to you. You can view EDUCBA’s recommended articles for more information.

Update the detailed information about How Can We Implement Logistic Regression? on the website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!